Java tutorial
/* * Copyright 2008-2009 The Kuali Foundation * * Licensed under the Educational Community License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.opensource.org/licenses/ecl2.php * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.kuali.ole.sys.batch.dataaccess.impl; import java.util.ArrayList; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import org.apache.commons.beanutils.PropertyUtils; import org.apache.log4j.Logger; import org.apache.ojb.broker.core.proxy.ProxyHelper; import org.apache.ojb.broker.query.Criteria; import org.kuali.ole.sys.OLEConstants; import org.kuali.ole.sys.OLEPropertyConstants; import org.kuali.ole.sys.batch.dataaccess.FiscalYearMaker; import org.kuali.ole.sys.businessobject.FiscalYearBasedBusinessObject; import org.kuali.ole.sys.businessobject.SystemOptions; import org.kuali.rice.core.api.mo.common.active.MutableInactivatable; import org.kuali.rice.core.framework.persistence.ojb.dao.PlatformAwareDaoBaseOjb; import org.kuali.rice.krad.bo.PersistableBusinessObject; import org.kuali.rice.krad.service.BusinessObjectService; import org.kuali.rice.krad.service.PersistenceStructureService; import org.kuali.rice.krad.util.ObjectUtils; /** * Default implementation of fiscal year maker process for an entity. This implementation can be used for a table in the fiscal year * maker process by defining a spring bean and setting the businessObjectClass property. */ public class FiscalYearMakerImpl extends PlatformAwareDaoBaseOjb implements FiscalYearMaker { private static final Logger LOG = org.apache.log4j.Logger.getLogger(FiscalYearMakerImpl.class); protected static final Long ONE = new Long(1); protected PersistenceStructureService persistenceStructureService; protected BusinessObjectService businessObjectService; protected Class<? extends FiscalYearBasedBusinessObject> businessObjectClass; protected Set<Class<? extends FiscalYearBasedBusinessObject>> parentClasses; protected boolean fiscalYearOneBehind; protected boolean fiscalYearOneAhead; protected boolean twoYearCopy; protected boolean carryForwardInactive; protected boolean allowOverrideTargetYear; protected Boolean hasExtension = null; protected List<String> primaryKeyPropertyNames = null; protected List<String> propertyNames = null; @SuppressWarnings("rawtypes") protected Map<String, Class> referenceObjects = null; @SuppressWarnings("rawtypes") protected Map<String, Class> collectionObjects = null; protected Map<String, Map<String, String>> referenceForeignKeys = new HashMap<String, Map<String, String>>(); /** * Constructs a FiscalYearMakerImpl.java. */ public FiscalYearMakerImpl() { fiscalYearOneBehind = false; fiscalYearOneAhead = false; twoYearCopy = false; carryForwardInactive = false; allowOverrideTargetYear = true; parentClasses = new HashSet<Class<? extends FiscalYearBasedBusinessObject>>(); } protected boolean hasExtension() { if (hasExtension == null) { hasExtension = persistenceStructureService.hasReference(businessObjectClass, OLEPropertyConstants.EXTENSION); } return hasExtension.booleanValue(); } @Override public List<String> getPrimaryKeyPropertyNames() { if (primaryKeyPropertyNames == null) { primaryKeyPropertyNames = persistenceStructureService.listPrimaryKeyFieldNames(businessObjectClass); } return primaryKeyPropertyNames; } @Override public List<String> getPropertyNames() { if (propertyNames == null) { propertyNames = persistenceStructureService.listFieldNames(businessObjectClass); } return propertyNames; } @Override @SuppressWarnings("rawtypes") public Map<String, Class> getReferenceObjectProperties() { if (referenceObjects == null) { referenceObjects = persistenceStructureService.listReferenceObjectFields(businessObjectClass); } return referenceObjects; } @Override @SuppressWarnings("rawtypes") public Map<String, Class> getCollectionProperties() { if (collectionObjects == null) { collectionObjects = persistenceStructureService.listCollectionObjectTypes(businessObjectClass); } return collectionObjects; } @Override public Map<String, String> getForeignKeyMappings(String referenceName) { if (!referenceForeignKeys.containsKey(referenceName)) { referenceForeignKeys.put(referenceName, persistenceStructureService.getForeignKeysForReference(businessObjectClass, referenceName)); } return referenceForeignKeys.get(referenceName); } /** * Sets fiscal year field up one, resets version number and assigns a new Guid for the object id * * @see org.kuali.ole.coa.dataaccess.FiscalYearMaker#changeForNewYear(java.lang.Integer, * org.kuali.rice.krad.bo.PersistableBusinessObject) */ @Override public void changeForNewYear(Integer baseFiscalYear, FiscalYearBasedBusinessObject currentRecord) { if (LOG.isDebugEnabled()) { LOG.debug("starting changeForNewYear() for bo class " + businessObjectClass.getName()); } try { // increment fiscal year by 1 Integer newFiscalYear = currentRecord.getUniversityFiscalYear() + 1; // update extension, must be done before updating main record so we can retrieve the extension record by reference updateExtensionRecord(newFiscalYear, currentRecord); // update main record fields currentRecord.setUniversityFiscalYear(newFiscalYear); currentRecord.setVersionNumber(ONE); currentRecord.setObjectId(java.util.UUID.randomUUID().toString()); } catch (Exception e) { String msg = String.format("Failed to set properties for class %s due to %s", businessObjectClass.getName(), e.getMessage()); LOG.error(msg); throw new RuntimeException(msg, e); } } /** * Determines if an extension record is mapped up and exists for the current record. If so then updates the version number, * object id, and clears the primary keys so they will be relinked when storing the main record * * @param newFiscalYear fiscal year to set * @param currentRecord main record with possible extension reference */ protected void updateExtensionRecord(Integer newFiscalYear, PersistableBusinessObject currentRecord) throws Exception { // check if reference is mapped up if (!hasExtension()) { return; } // try to retrieve extension record currentRecord.refreshReferenceObject(OLEPropertyConstants.EXTENSION); PersistableBusinessObject extension = currentRecord.getExtension(); // if found then update fields if (ObjectUtils.isNotNull(extension)) { extension = (PersistableBusinessObject) ProxyHelper.getRealObject(extension); extension.setVersionNumber(ONE); extension.setObjectId(java.util.UUID.randomUUID().toString()); // since this could be a new object (no extension object present on the source record) // we need to set the keys // But...we only need to do this if this was a truly new object, which we can tell by checking // the fiscal year field if (((FiscalYearBasedBusinessObject) extension).getUniversityFiscalYear() == null) { for (String pkField : getPrimaryKeyPropertyNames()) { PropertyUtils.setSimpleProperty(extension, pkField, PropertyUtils.getSimpleProperty(currentRecord, pkField)); } } ((FiscalYearBasedBusinessObject) extension).setUniversityFiscalYear(newFiscalYear); } } /** * @see org.kuali.rice.core.api.mo.common.active.MutableInactivatable * @see org.kuali.ole.coa.dataaccess.FiscalYearMaker#createSelectionCriteria(java.lang.Integer) */ @Override public Criteria createNextYearSelectionCriteria(Integer baseFiscalYear) { if (LOG.isDebugEnabled()) { LOG.debug("starting createNextYearSelectionCriteria() for bo class " + businessObjectClass.getName()); } Criteria criteria = new Criteria(); addYearCriteria(criteria, baseFiscalYear + 1, twoYearCopy); return criteria; } /** * Selects records for the given base year or base year minus one if this is a lagging copy. If this is a two year copy base * year plus one records will be selected as well. In addition will only select active records if the business object class * implements the MutableInactivatable interface and has the active property. * * @see org.kuali.rice.core.api.mo.common.active.MutableInactivatable * @see org.kuali.ole.coa.dataaccess.FiscalYearMaker#createSelectionCriteria(java.lang.Integer) */ @Override public Criteria createSelectionCriteria(Integer baseFiscalYear) { if (LOG.isDebugEnabled()) { LOG.debug("starting createSelectionCriteria() for bo class " + businessObjectClass.getName()); } Criteria criteria = new Criteria(); addYearCriteria(criteria, baseFiscalYear, false); // add active criteria if the business object class supports the inactivateable interface List<String> fields = getPropertyNames(); if (MutableInactivatable.class.isAssignableFrom(businessObjectClass) && fields.contains(OLEPropertyConstants.ACTIVE) && !carryForwardInactive) { criteria.addEqualTo(OLEPropertyConstants.ACTIVE, OLEConstants.ACTIVE_INDICATOR); } return criteria; } /** * Selects records to delete for base year + 1 (or base year for lagging, and base year + 2 for two year) * * @see org.kuali.ole.coa.batch.dataaccess.FiscalYearMakerHelper#createDeleteCriteria(java.lang.Integer) */ @Override public Criteria createDeleteCriteria(Integer baseFiscalYear) { if (LOG.isDebugEnabled()) { LOG.debug("starting createDeleteCriteria() for bo class " + businessObjectClass.getName()); } Criteria criteria = new Criteria(); addYearCriteria(criteria, baseFiscalYear + 1, twoYearCopy); return criteria; } /** * Adds fiscal year criteria based on the configuration (copy two years, lagging, or normal) * * @param criteria OJB Criteria object * @param baseFiscalYear Fiscal year for critiera * @param createTwoYears indicates whether two years of fiscal year criteria should be added */ protected void addYearCriteria(Criteria criteria, Integer baseFiscalYear, boolean createTwoYears) { if (fiscalYearOneBehind) { baseFiscalYear = baseFiscalYear - 1; } else if (fiscalYearOneAhead) { baseFiscalYear = baseFiscalYear + 1; } if (createTwoYears) { List<Integer> copyYears = new ArrayList<Integer>(); copyYears.add(baseFiscalYear); copyYears.add(baseFiscalYear + 1); criteria.addIn(OLEPropertyConstants.UNIVERSITY_FISCAL_YEAR, copyYears); } else { criteria.addEqualTo(OLEPropertyConstants.UNIVERSITY_FISCAL_YEAR, baseFiscalYear); } } /** * Default implementation does nothing * * @see org.kuali.ole.coa.batch.dataaccess.FiscalYearMakerHelper#performCustomProcessing(java.lang.Integer) */ @Override public void performCustomProcessing(Integer baseFiscalYear, boolean firstCopyYear) { } /** * Default to doing both normal FYM process and custom * * @see org.kuali.ole.coa.batch.dataaccess.FiscalYearMakerHelper#doCustomProcessingOnly() */ @Override public boolean doCustomProcessingOnly() { return false; } /** * @see org.kuali.ole.coa.dataaccess.FiscalYearMaker#getBusinessObjectClass() */ @Override public Class<? extends FiscalYearBasedBusinessObject> getBusinessObjectClass() { return businessObjectClass; } /** * <code>Options</code> is the parent for univFiscalYear which all our copy objects should have. Added to list here by default. * * @see org.kuali.ole.coa.batch.dataaccess.FiscalYearMakerHelper#getParentClasses() * @see org.kuali.ole.sys.businessobject.Options */ @Override public Set<Class<? extends FiscalYearBasedBusinessObject>> getParentClasses() { if (!businessObjectClass.equals(SystemOptions.class) && !parentClasses.contains(SystemOptions.class)) { parentClasses.add(SystemOptions.class); } return parentClasses; } /** * Sets the businessObjectClass attribute value. * * @param businessObjectClass The businessObjectClass to set. */ public void setBusinessObjectClass(Class<? extends FiscalYearBasedBusinessObject> businessObjectClass) { this.businessObjectClass = businessObjectClass; } /** * Sets the parentClasses attribute value. * * @param parentClasses The parentClasses to set. */ public void setParentClasses(Set<Class<? extends FiscalYearBasedBusinessObject>> parentClasses) { this.parentClasses = parentClasses; } /** * Gets the fiscalYearOneBehind attribute. * * @return Returns the fiscalYearOneBehind. */ public boolean isFiscalYearOneBehind() { return fiscalYearOneBehind; } /** * Sets the fiscalYearOneBehind attribute value. * * @param fiscalYearOneBehind The fiscalYearOneBehind to set. */ public void setFiscalYearOneBehind(boolean fiscalYearOneBehind) { this.fiscalYearOneBehind = fiscalYearOneBehind; } /** * Gets the fiscalYearOneAhead attribute. * * @return Returns the fiscalYearOneAhead. */ public boolean isFiscalYearOneAhead() { return fiscalYearOneAhead; } /** * Sets the fiscalYearOneAhead attribute value. * * @param fiscalYearOneAhead The fiscalYearOneAhead to set. */ public void setFiscalYearOneAhead(boolean fiscalYearOneAhead) { this.fiscalYearOneAhead = fiscalYearOneAhead; } /** * Gets the twoYearCopy attribute. * * @return Returns the twoYearCopy. */ @Override public boolean isTwoYearCopy() { return twoYearCopy; } /** * Sets the twoYearCopy attribute value. * * @param twoYearCopy The twoYearCopy to set. */ public void setTwoYearCopy(boolean twoYearCopy) { this.twoYearCopy = twoYearCopy; } /** * Gets the carryForwardInactive attribute. * * @return Returns the carryForwardInactive. */ public boolean isCarryForwardInactive() { return carryForwardInactive; } /** * Sets the carryForwardInactive attribute value. * * @param carryForwardInactive The carryForwardInactive to set. */ public void setCarryForwardInactive(boolean carryForwardInactive) { this.carryForwardInactive = carryForwardInactive; } /** * Sets the persistenceStructureService attribute value. * * @param persistenceStructureService The persistenceStructureService to set. */ public void setPersistenceStructureService(PersistenceStructureService persistenceStructureService) { this.persistenceStructureService = persistenceStructureService; } /** * Gets the allowOverrideTargetYear attribute. * * @return Returns the allowOverrideTargetYear. */ @Override public boolean isAllowOverrideTargetYear() { return allowOverrideTargetYear; } /** * Sets the allowOverrideTargetYear attribute value. * * @param allowOverrideTargetYear The allowOverrideTargetYear to set. */ public void setAllowOverrideTargetYear(boolean allowOverrideTargetYear) { this.allowOverrideTargetYear = allowOverrideTargetYear; } public void setBusinessObjectService(BusinessObjectService businessObjectService) { this.businessObjectService = businessObjectService; } }