/**
 * Copyright 2005-2016 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.rice.kns.maintenance;

import org.apache.commons.beanutils.PropertyUtils;
import org.apache.commons.lang.StringUtils;
import org.kuali.rice.core.api.CoreApiServiceLocator;
import org.kuali.rice.core.api.encryption.EncryptionService;
import org.kuali.rice.core.web.format.FormatException;
import org.kuali.rice.kim.api.identity.PersonService;
import org.kuali.rice.kim.api.services.KimApiServiceLocator;
import org.kuali.rice.kns.datadictionary.MaintainableCollectionDefinition;
import org.kuali.rice.kns.datadictionary.MaintainableFieldDefinition;
import org.kuali.rice.kns.datadictionary.MaintainableItemDefinition;
import org.kuali.rice.kns.datadictionary.MaintainableSectionDefinition;
import org.kuali.rice.kns.document.MaintenanceDocument;
import org.kuali.rice.kns.document.authorization.FieldRestriction;
import org.kuali.rice.kns.document.authorization.MaintenanceDocumentPresentationController;
import org.kuali.rice.kns.document.authorization.MaintenanceDocumentRestrictions;
import org.kuali.rice.kns.lookup.LookupUtils;
import org.kuali.rice.kns.service.BusinessObjectAuthorizationService;
import org.kuali.rice.kns.service.BusinessObjectDictionaryService;
import org.kuali.rice.kns.service.BusinessObjectMetaDataService;
import org.kuali.rice.kns.service.DocumentHelperService;
import org.kuali.rice.kns.service.KNSServiceLocator;
import org.kuali.rice.kns.service.MaintenanceDocumentDictionaryService;
import org.kuali.rice.kns.util.FieldUtils;
import org.kuali.rice.kns.util.InactiveRecordsHidingUtils;
import org.kuali.rice.kns.util.MaintenanceUtils;
import org.kuali.rice.kns.web.ui.Section;
import org.kuali.rice.kns.web.ui.SectionBridge;
import org.kuali.rice.krad.bo.BusinessObject;
import org.kuali.rice.krad.bo.DataObjectRelationship;
import org.kuali.rice.krad.bo.PersistableBusinessObject;
import org.kuali.rice.krad.datadictionary.AttributeSecurity;
import org.kuali.rice.krad.datadictionary.exception.UnknownBusinessClassAttributeException;
import org.kuali.rice.krad.maintenance.MaintainableImpl;
import org.kuali.rice.krad.service.DataDictionaryService;
import org.kuali.rice.krad.service.KRADServiceLocator;
import org.kuali.rice.krad.service.KRADServiceLocatorWeb;
import org.kuali.rice.krad.service.ModuleService;
import org.kuali.rice.krad.service.PersistenceStructureService;
import org.kuali.rice.krad.util.GlobalVariables;
import org.kuali.rice.krad.util.KRADConstants;
import org.kuali.rice.krad.util.KRADPropertyConstants;
import org.kuali.rice.krad.util.MessageMap;
import org.kuali.rice.krad.util.ObjectUtils;
import org.kuali.rice.krad.valuefinder.ValueFinder;

import java.beans.PropertyDescriptor;
import java.lang.reflect.InvocationTargetException;
import java.security.GeneralSecurityException;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

/**
 * Base Maintainable class to hold things common to all maintainables.
 */
@Deprecated
public class KualiMaintainableImpl extends MaintainableImpl implements Maintainable {
        private static final long serialVersionUID = 4814145799502207182L;

        private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(KualiMaintainableImpl.class);

        protected PersistableBusinessObject businessObject;

        protected Map<String, PersistableBusinessObject> newCollectionLines = new HashMap<String, PersistableBusinessObject>();
        protected Map<String, Boolean> inactiveRecordDisplay = new HashMap<String, Boolean>();

    // TODO: rename once 'newCollectionLines' is removed
    protected Set<String> newCollectionLineNames = new HashSet<String>();

        protected transient BusinessObjectDictionaryService businessObjectDictionaryService;
        protected transient PersonService personService;
        protected transient BusinessObjectMetaDataService businessObjectMetaDataService;
        protected transient BusinessObjectAuthorizationService businessObjectAuthorizationService;
        protected transient DocumentHelperService documentHelperService;
    protected transient MaintenanceDocumentDictionaryService maintenanceDocumentDictionaryService;

        /**
         * Default empty constructor
         */
        public KualiMaintainableImpl() {
        super();
        }

        /**
         * Constructor which initializes the business object to be maintained.
         *
         * @param businessObject
         */
        public KualiMaintainableImpl(PersistableBusinessObject businessObject) {
                super();
                this.businessObject = businessObject;
                super.setDataObject(businessObject);
        }

        /**
         * @see Maintainable#populateBusinessObject(java.util.Map,
         *      org.kuali.rice.krad.maintenance.MaintenanceDocument, String)
         */
        @SuppressWarnings("unchecked")
        public Map populateBusinessObject(Map<String, String> fieldValues, MaintenanceDocument maintenanceDocument,
                        String methodToCall) {
                fieldValues = decryptEncryptedData(fieldValues, maintenanceDocument, methodToCall);
                Map newFieldValues = null;
                newFieldValues = getPersonService().resolvePrincipalNamesToPrincipalIds(getBusinessObject(), fieldValues);

                Map cachedValues = FieldUtils.populateBusinessObjectFromMap(getBusinessObject(), newFieldValues);
                performForceUpperCase(newFieldValues);

                return cachedValues;
        }

        /**
         * Special hidden parameters are set on the maintenance jsp starting with a
         * prefix that tells us which fields have been encrypted. This field finds
         * the those parameters in the map, whose value gives us the property name
         * that has an encrypted value. We then need to decrypt the value in the Map
         * before the business object is populated.
         * 
         * @param fieldValues
         *            - possibly with encrypted values
         * @return Map fieldValues - with no encrypted values
         */
        protected Map<String, String> decryptEncryptedData(Map<String, String> fieldValues,
                        MaintenanceDocument maintenanceDocument, String methodToCall) {
                try {
                        MaintenanceDocumentRestrictions auths = KNSServiceLocator.getBusinessObjectAuthorizationService()
                                        .getMaintenanceDocumentRestrictions(maintenanceDocument,
                                                        GlobalVariables.getUserSession().getPerson());
                        for (Iterator<String> iter = fieldValues.keySet().iterator(); iter.hasNext();) {
                                String fieldName = iter.next();
                                String fieldValue = (String) fieldValues.get(fieldName);

                                if (fieldValue != null && !"".equals(fieldValue)
                                                && fieldValue.endsWith(EncryptionService.ENCRYPTION_POST_PREFIX)) {
                                        if (shouldFieldBeEncrypted(maintenanceDocument, fieldName, auths, methodToCall)) {
                                                String encryptedValue = fieldValue;

                                                // take off the postfix
                                                encryptedValue = StringUtils.stripEnd(encryptedValue, EncryptionService.ENCRYPTION_POST_PREFIX);
                        if(CoreApiServiceLocator.getEncryptionService().isEnabled()) {
                            String decryptedValue = getEncryptionService().decrypt(encryptedValue);

                                                    fieldValues.put(fieldName, decryptedValue);
                        }
                                        }
                                        else
                                                throw new RuntimeException("The field value for field name " + fieldName
                                                                + " should not be encrypted.");
                                }
                                else if (fieldValue != null && !"".equals(fieldValue)
                                    && auths.hasRestriction(fieldName)
                                    && shouldFieldBeEncrypted(maintenanceDocument, fieldName, auths, methodToCall))
                                            throw new RuntimeException("The field value for field name " + fieldName + " should be encrypted.");
                        }
                }
                catch (GeneralSecurityException e) {
                        throw new RuntimeException("Unable to decrypt secure data: " + e.getMessage());
                }

                return fieldValues;
        }

        /**
         * Determines whether the field in a request should be encrypted. This base
         * implementation does not work for properties of collection elements.
         * 
         * This base implementation will only return true if the maintenance
         * document is being refreshed after a lookup (i.e. methodToCall is
         * "refresh") and the data dictionary-based attribute security definition
         * has any restriction defined, whether the user would be authorized to view
         * the field. This assumes that only fields returned from a lookup should be
         * encrypted in a request. If the user otherwise has no permissions to
         * view/edit the field, then a request parameter will not be sent back to
         * the server for population.
         * 
         * @param maintenanceDocument
         * @param fieldName
         * @param auths
         * @param methodToCall
         * @return
         */
        protected boolean shouldFieldBeEncrypted(MaintenanceDocument maintenanceDocument, String fieldName,
                        MaintenanceDocumentRestrictions auths, String methodToCall) {
                if ("refresh".equals(methodToCall) && fieldName != null) {
                        fieldName = fieldName.replaceAll("\\[[0-9]*+\\]", "");
                        fieldName = fieldName.replaceAll("^add\\.", "");
                        Map<String, AttributeSecurity> fieldNameToAttributeSecurityMap = MaintenanceUtils
                                        .retrievePropertyPathToAttributeSecurityMappings(getDocumentTypeName());
                        AttributeSecurity attributeSecurity = fieldNameToAttributeSecurityMap.get(fieldName);
                        return attributeSecurity != null && attributeSecurity.hasRestrictionThatRemovesValueFromUI();
                }
                else {
                        return false;
                }
        }

        /**
         * Calls method to get all the core sections for the business object defined
         * in the data dictionary. Then determines if the bo has custom attributes,
         * if so builds a custom attribute section and adds to the section list.
         * 
         * @return List of org.kuali.ui.Section objects
         */
        public List getSections(MaintenanceDocument document, Maintainable oldMaintainable) {
                List<Section> sections = new ArrayList<Section>();
                sections.addAll(getCoreSections(document, oldMaintainable));

                return sections;
        }

        /**
         * Gets list of maintenance sections built from the data dictionary. If the
         * section contains maintenance fields, construct Row/Field UI objects and
         * place under Section UI. If section contains a maintenance collection,
         * call method to build a Section UI which contains rows of Container
         * Fields.
         * 
         * @return List of org.kuali.ui.Section objects
         */
        public List<Section> getCoreSections(MaintenanceDocument document, Maintainable oldMaintainable) {
                List<Section> sections = new ArrayList<Section>();
                MaintenanceDocumentRestrictions maintenanceRestrictions = KNSServiceLocator
                                .getBusinessObjectAuthorizationService().getMaintenanceDocumentRestrictions(document,
                                                GlobalVariables.getUserSession().getPerson());

                MaintenanceDocumentPresentationController maintenanceDocumentPresentationController = (MaintenanceDocumentPresentationController) getDocumentHelperService()
                                .getDocumentPresentationController(document);
                Set<String> conditionallyRequiredFields = maintenanceDocumentPresentationController
                                .getConditionallyRequiredPropertyNames(document);

                List<MaintainableSectionDefinition> sectionDefinitions = getMaintenanceDocumentDictionaryService()
                                .getMaintainableSections(getDocumentTypeName());
                try {
                        // iterate through section definitions and create Section UI object
                        for (Iterator iter = sectionDefinitions.iterator(); iter.hasNext();) {
                                MaintainableSectionDefinition maintSectionDef = (MaintainableSectionDefinition) iter.next();

                                List<String> displayedFieldNames = new ArrayList<String>();
                                if (!maintenanceRestrictions.isHiddenSectionId(maintSectionDef.getId())) {

                                        for (Iterator iter2 = maintSectionDef.getMaintainableItems().iterator(); iter2.hasNext();) {
                                                MaintainableItemDefinition item = (MaintainableItemDefinition) iter2.next();
                                                if (item instanceof MaintainableFieldDefinition) {
                                                        displayedFieldNames.add(((MaintainableFieldDefinition) item).getName());
                                                }
                                        }

                                        Section section = SectionBridge
                            .toSection(maintSectionDef, getBusinessObject(), this, oldMaintainable,
                                    getMaintenanceAction(), displayedFieldNames, conditionallyRequiredFields);
                                        if (maintenanceRestrictions.isReadOnlySectionId(maintSectionDef.getId())) {
                                                section.setReadOnly(true);
                                        }

                                        // add to section list
                                        sections.add(section);
                                }

                        }

                }
                catch (InstantiationException e) {
                        LOG.error("Unable to create instance of object class" + e.getMessage());
                        throw new RuntimeException("Unable to create instance of object class" + e.getMessage());
                }
                catch (IllegalAccessException e) {
                        LOG.error("Unable to create instance of object class" + e.getMessage());
                        throw new RuntimeException("Unable to create instance of object class" + e.getMessage());
                }

                return sections;
        }


    /**
         * 
         * @see Maintainable#saveBusinessObject()
         */
        public void saveBusinessObject() {
                getBusinessObjectService().linkAndSave(businessObject);
        }

    /**
     * delegate this call to KNS' {@link org.kuali.rice.kns.maintenance.Maintainable#saveBusinessObject()} in order
     * to support KNS maintainables.
     */
    @Override
    public void saveDataObject() {
        saveBusinessObject();
    }

    /**
         * Retrieves title for maintenance document from data dictionary
         */
        public String getMaintainableTitle() {
                return getMaintenanceDocumentDictionaryService().getMaintenanceLabel(getDocumentTypeName());
        }

    @Override
    public void setupNewFromExisting(MaintenanceDocument document, Map<String, String[]> parameters) {
    }

        public boolean isBoNotesEnabled() {
        return getDataObjectMetaDataService().areNotesSupported(getDataObjectClass());
        }

    /**
     * Overriding to call old (KNS) name of the method
     */
    @Override
    public boolean isNotesEnabled() {
        return isBoNotesEnabled();
    }

    /**
         * @see Maintainable#refresh(java.lang.String,
         *      java.util.Map) Impls will be needed if custom action is needed on
         *      refresh.
         */
        public void refresh(String refreshCaller, Map fieldValues, MaintenanceDocument document) {
                String referencesToRefresh = (String) fieldValues.get(KRADConstants.REFERENCES_TO_REFRESH);
                refreshReferences(referencesToRefresh);
        }

        protected void refreshReferences(String referencesToRefresh) {
                PersistenceStructureService persistenceStructureService = getPersistenceStructureService();
                if (StringUtils.isNotBlank(referencesToRefresh)) {
                        String[] references = StringUtils.split(referencesToRefresh, KRADConstants.REFERENCES_TO_REFRESH_SEPARATOR);
                        for (String reference : references) {
                                if (StringUtils.isNotBlank(reference)) {
                                        if (reference.startsWith(KRADConstants.ADD_PREFIX + ".")) {
                                                // add one for the period
                                                reference = reference.substring(KRADConstants.ADD_PREFIX.length() + 1);

                                                String boToRefreshName = StringUtils.substringBeforeLast(reference, ".");
                                                String propertyToRefresh = StringUtils.substringAfterLast(reference, ".");
                                                if (StringUtils.isNotBlank(propertyToRefresh)) {
                                                        PersistableBusinessObject addlineBO = getNewCollectionLine(boToRefreshName);
                                                        Class addlineBOClass = addlineBO.getClass();
                                                        if (LOG.isDebugEnabled()) {
                                                                LOG.debug("Refresh this \"new\"/add object for the collections:  " + reference);
                                                        }
                                                        if (persistenceStructureService.hasReference(addlineBOClass, propertyToRefresh)
                                                                        || persistenceStructureService.hasCollection(addlineBOClass, propertyToRefresh)) {
                                                                addlineBO.refreshReferenceObject(propertyToRefresh);
                                                        }
                                                        else {
                                                                if (getDataDictionaryService().hasRelationship(addlineBOClass.getName(),
                                                                                propertyToRefresh)) {
                                                                        // a DD mapping, try to go straight to the
                                                                        // object and refresh it there
                                                                        Object possibleBO = ObjectUtils.getPropertyValue(addlineBO, propertyToRefresh);
                                                                        if (possibleBO != null && possibleBO instanceof PersistableBusinessObject) {
                                                                                ((PersistableBusinessObject) possibleBO).refresh();
                                                                        }
                                                                }
                                                        }
                                                }
                                                else {
                                                        LOG.error("Error: unable to refresh this \"new\"/add object for the collections:  "
                                                                        + reference);
                                                }
                                        }
                                        else if (ObjectUtils.isNestedAttribute(reference)) {
                                                Object nestedObject = ObjectUtils.getNestedValue(getBusinessObject(),
                                                                ObjectUtils.getNestedAttributePrefix(reference));
                        if (nestedObject == null) {
                            LOG.warn("Unable to refresh ReferenceToRefresh (" + reference + ")  was found to be null");
                        }
                        else {
                            if (nestedObject instanceof Collection) {
                                // do nothing, probably because it's not really a
                                // collection reference but a relationship defined
                                // in the DD for a collections lookup
                                // this part will need to be rewritten when the DD
                                // supports true collection references
                            }
                            else if (nestedObject instanceof PersistableBusinessObject) {
                                String propertyToRefresh = ObjectUtils.getNestedAttributePrimitive(reference);
                                if (persistenceStructureService.hasReference(nestedObject.getClass(), propertyToRefresh)
                                        || persistenceStructureService.hasCollection(nestedObject.getClass(),
                                                propertyToRefresh)) {
                                    if (LOG.isDebugEnabled()) {
                                        LOG.debug("Refeshing " + ObjectUtils.getNestedAttributePrefix(reference) + " "
                                                + ObjectUtils.getNestedAttributePrimitive(reference));
                                    }
                                    ((PersistableBusinessObject) nestedObject).refreshReferenceObject(propertyToRefresh);
                                }
                                else {
                                    // a DD mapping, try to go straight to the
                                    // object and refresh it there
                                    Object possibleBO = ObjectUtils.getPropertyValue(nestedObject, propertyToRefresh);
                                    if (possibleBO != null && possibleBO instanceof PersistableBusinessObject) {
                                        if (getDataDictionaryService().hasRelationship(possibleBO.getClass().getName(),
                                                propertyToRefresh)) {
                                            ((PersistableBusinessObject) possibleBO).refresh();
                                        }
                                    }
                                }
                            }
                            else {
                                LOG.warn("Expected that a referenceToRefresh ("
                                        + reference
                                        + ")  would be a PersistableBusinessObject or Collection, but instead, it was of class "
                                        + nestedObject.getClass().getName());
                            }
                        }
                                        }
                                        else {
                                                if (LOG.isDebugEnabled()) {
                                                        LOG.debug("Refreshing " + reference);
                                                }
                                                if (persistenceStructureService.hasReference(getDataObjectClass(), reference)
                                                                || persistenceStructureService.hasCollection(getDataObjectClass(), reference)) {
                                                        getBusinessObject().refreshReferenceObject(reference);
                                                }
                                                else {
                                                        if (getDataDictionaryService().hasRelationship(getBusinessObject().getClass().getName(),
                                                                        reference)) {
                                                                // a DD mapping, try to go straight to the
                                                                // object and refresh it there
                                                                Object possibleRelationship = ObjectUtils.getPropertyValue(getBusinessObject(),
                                                                                reference);
                                                                if (possibleRelationship != null) {
                                                                        if (possibleRelationship instanceof PersistableBusinessObject) {
                                                                                ((PersistableBusinessObject) possibleRelationship).refresh();
                                                                        }
                                                                        else if (possibleRelationship instanceof Collection) {
                                                                                // do nothing, probably because it's not
                                                                                // really a collection reference but a
                                                                                // relationship defined in the DD for a
                                                                                // collections lookup
                                                                                // this part will need to be rewritten
                                                                                // when the DD supports true collection
                                                                                // references
                                                                        }
                                                                        else {
                                                                                LOG.warn("Expected that a referenceToRefresh ("
                                                                                                + reference
                                                                                                + ")  would be a PersistableBusinessObject or Collection, but instead, it was of class "
                                                                                                + possibleRelationship.getClass().getName());
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                }
        }

        public void addMultipleValueLookupResults(MaintenanceDocument document, String collectionName,
                        Collection<PersistableBusinessObject> rawValues, boolean needsBlank, PersistableBusinessObject bo) {
                Collection maintCollection = (Collection) ObjectUtils.getPropertyValue(bo, collectionName);
                String docTypeName = document.getDocumentHeader().getWorkflowDocument().getDocumentTypeName();

                List<String> duplicateIdentifierFieldsFromDataDictionary = getDuplicateIdentifierFieldsFromDataDictionary(
                                docTypeName, collectionName);

                List<String> existingIdentifierList = getMultiValueIdentifierList(maintCollection,
                                duplicateIdentifierFieldsFromDataDictionary);

                Class collectionClass = getMaintenanceDocumentDictionaryService().getCollectionBusinessObjectClass(docTypeName,
                                collectionName);

                List<MaintainableSectionDefinition> sections = getMaintenanceDocumentDictionaryService()
                                .getMaintainableSections(docTypeName);
                Map<String, String> template = MaintenanceUtils.generateMultipleValueLookupBOTemplate(sections, collectionName);
                try {
                        for (PersistableBusinessObject nextBo : rawValues) {
                                PersistableBusinessObject templatedBo;
                                if (needsBlank) {
                                        templatedBo = (PersistableBusinessObject) collectionClass.newInstance();
                                }
                                else {
                                        // templatedBo = (PersistableBusinessObject)
                                        // ObjectUtils.createHybridBusinessObject(collectionClass,
                                        // nextBo, template);
                                        try {
                                                ModuleService moduleService = KRADServiceLocatorWeb.getKualiModuleService()
                                                                .getResponsibleModuleService(collectionClass);
                                                if (moduleService != null && moduleService.isExternalizable(collectionClass))
                                                        templatedBo = (PersistableBusinessObject) moduleService
                                                                        .createNewObjectFromExternalizableClass(collectionClass);
                                                else
                                                        templatedBo = (PersistableBusinessObject) collectionClass.newInstance();
                                        }
                                        catch (Exception e) {
                                                throw new RuntimeException("Cannot instantiate " + collectionClass.getName(), e);
                                        }
                                        // first set the default values specified in the DD
                                        setNewCollectionLineDefaultValues(collectionName, templatedBo);
                                        // then set the values from the multiple value lookup result
                                        ObjectUtils.createHybridBusinessObject(templatedBo, nextBo, template);

                                        prepareBusinessObjectForAdditionFromMultipleValueLookup(collectionName, templatedBo);
                                }
                                templatedBo.setNewCollectionRecord(true);

                                if (!hasBusinessObjectExisted(templatedBo, existingIdentifierList,
                                                duplicateIdentifierFieldsFromDataDictionary)) {
                                        maintCollection.add(templatedBo);

                                }
                        }
                }
                catch (Exception e) {
                        LOG.error("Unable to add multiple value lookup results " + e.getMessage());
                        throw new RuntimeException("Unable to add multiple value lookup results " + e.getMessage());
                }
        }

        /**
         * This method is to retrieve a List of fields which are specified in the
         * maintenance document data dictionary as the
         * duplicateIdentificationFields. This List is used to determine whether the
         * new entry being added to the collection is a duplicate entry and if so,
         * we should not add the new entry to the existing collection
         * 
         * @param docTypeName
         * @param collectionName
         */
        public List<String> getDuplicateIdentifierFieldsFromDataDictionary(String docTypeName, String collectionName) {
                List<String> duplicateIdentifierFieldNames = new ArrayList<String>();
                MaintainableCollectionDefinition collDef = getMaintenanceDocumentDictionaryService().getMaintainableCollection(
                                docTypeName, collectionName);
                Collection<MaintainableFieldDefinition> fieldDef = collDef.getDuplicateIdentificationFields();
                for (MaintainableFieldDefinition eachFieldDef : fieldDef) {
                        duplicateIdentifierFieldNames.add(eachFieldDef.getName());
                }
                return duplicateIdentifierFieldNames;
        }

        public List<String> getMultiValueIdentifierList(Collection maintCollection, List<String> duplicateIdentifierFields) {
                List<String> identifierList = new ArrayList<String>();
                for (PersistableBusinessObject bo : (Collection<PersistableBusinessObject>) maintCollection) {
                        String uniqueIdentifier = new String();
                        for (String identifierField : duplicateIdentifierFields) {
                                uniqueIdentifier = uniqueIdentifier + identifierField + "-"
                                                + ObjectUtils.getPropertyValue(bo, identifierField);
                        }
                        if (StringUtils.isNotEmpty(uniqueIdentifier)) {
                                identifierList.add(uniqueIdentifier);
                        }
                }
                return identifierList;
        }

        public boolean hasBusinessObjectExisted(BusinessObject bo, List<String> existingIdentifierList,
                        List<String> duplicateIdentifierFields) {
                String uniqueIdentifier = new String();
                for (String identifierField : duplicateIdentifierFields) {
                        uniqueIdentifier = uniqueIdentifier + identifierField + "-"
                                        + ObjectUtils.getPropertyValue(bo, identifierField);
                }
                if (existingIdentifierList.contains(uniqueIdentifier)) {
                        return true;
                }
                else {
                        return false;
                }
        }

        public void prepareBusinessObjectForAdditionFromMultipleValueLookup(String collectionName, BusinessObject bo) {
                // default implementation does nothing
        }

        /**
         * Set the new collection records back to true so they can be deleted (copy
         * should act like new)
         * 
         * @see KualiMaintainableImpl#processAfterCopy()
         */
        public void processAfterCopy(MaintenanceDocument document, Map<String, String[]> parameters) {
                try {
                        ObjectUtils.setObjectPropertyDeep(businessObject, KRADPropertyConstants.NEW_COLLECTION_RECORD,
                                        boolean.class, true, 2);
                } catch (Exception e) {
                        LOG.error("unable to set newCollectionRecord property: " + e.getMessage(), e);
                        throw new RuntimeException("unable to set newCollectionRecord property: " + e.getMessage(), e);
                }
        }

    @Override
    public void processAfterEdit(MaintenanceDocument document, Map<String, String[]> requestParameters) {

    }

    @Override
    public void processAfterNew(MaintenanceDocument document, Map<String, String[]> requestParameters) {

    }

    @Override
    public void processAfterPost(MaintenanceDocument document, Map<String, String[]> requestParameters) {

    }

    @Override
    public void setDataObject(Object object) {
        super.setDataObject(object);
        
        if(object instanceof PersistableBusinessObject) {
            this.businessObject = (PersistableBusinessObject)object;
        }
    }

    @Override
    public String getDocumentTitle(MaintenanceDocument document) {
        return super.getDocumentTitle((org.kuali.rice.krad.maintenance.MaintenanceDocument) document);
    }

    /**
     * @return Returns the instance of the business object being maintained.
     */
    public PersistableBusinessObject getBusinessObject() {
        return businessObject;
    }

    /**
     * @param businessObject
     *            Sets the instance of a business object that will be
     *            maintained.
     */
    public void setBusinessObject(PersistableBusinessObject businessObject) {
        this.businessObject = businessObject;
        setDataObject(businessObject);
    }

        /**
         * @return Returns the boClass.
         */
        public Class getBoClass() {
                return super.getDataObjectClass();
        }

        /**
         * @param boClass
         *            The boClass to set.
         */
        public void setBoClass(Class boClass) {
                setDataObjectClass(boClass);
        }

        /**
         * 
         * @see Maintainable#setGenerateDefaultValues()
         */
        public void setGenerateDefaultValues(String docTypeName) {
                List<MaintainableSectionDefinition> sectionDefinitions = getMaintenanceDocumentDictionaryService()
                                .getMaintainableSections(docTypeName);
                Map defaultValues = new HashMap();

                try {
                        // iterate through section definitions
                        for (Iterator iter = sectionDefinitions.iterator(); iter.hasNext();) {

                                MaintainableSectionDefinition maintSectionDef = (MaintainableSectionDefinition) iter.next();
                                Collection maintItems = maintSectionDef.getMaintainableItems();
                                for (Iterator iterator = maintItems.iterator(); iterator.hasNext();) {
                                        MaintainableItemDefinition item = (MaintainableItemDefinition) iterator.next();

                                        if (item instanceof MaintainableFieldDefinition) {
                                                MaintainableFieldDefinition maintainableFieldDefinition = (MaintainableFieldDefinition) item;

                                                String defaultValue = maintainableFieldDefinition.getDefaultValue();
                                                if (defaultValue != null) {
                                                        if (defaultValue.equals("true")) {
                                                                defaultValue = "Yes";
                                                        }
                                                        else if (defaultValue.equals("false")) {
                                                                defaultValue = "No";
                                                        }
                                                }

                                                Class defaultValueFinderClass = maintainableFieldDefinition.getDefaultValueFinderClass();
                                                if (defaultValueFinderClass != null) {
                                                        defaultValue = ((ValueFinder) defaultValueFinderClass.newInstance()).getValue();

                                                }
                                                if (defaultValue != null) {
                                                        defaultValues.put(item.getName(), defaultValue);
                                                }
                                        }
                                }
                        }
                        Map cachedValues = FieldUtils.populateBusinessObjectFromMap(getBusinessObject(), defaultValues);
                }
                catch (Exception e) {
                        LOG.error("Unable to set default value " + e.getMessage(), e);
                        throw new RuntimeException("Unable to set default value" + e.getMessage(), e);
                }

        }

        /**
         * 
         * @see Maintainable#setGenerateBlankRequiredValues()
         */
        public void setGenerateBlankRequiredValues(String docTypeName) {
                try {
                        List<MaintainableSectionDefinition> sectionDefinitions = getMaintenanceDocumentDictionaryService()
                                        .getMaintainableSections(docTypeName);
                        Map<String, String> defaultValues = new HashMap<String, String>();

                        for (MaintainableSectionDefinition maintSectionDef : sectionDefinitions) {
                                for (MaintainableItemDefinition item : maintSectionDef.getMaintainableItems()) {
                                        if (item instanceof MaintainableFieldDefinition) {
                                                MaintainableFieldDefinition maintainableFieldDefinition = (MaintainableFieldDefinition) item;
                                                if (maintainableFieldDefinition.isRequired()
                                                                && maintainableFieldDefinition.isUnconditionallyReadOnly()) {
                                                        Object currPropVal = ObjectUtils.getPropertyValue(this.getBusinessObject(), item.getName());
                                                        if (currPropVal == null
                                                                        || (currPropVal instanceof String && StringUtils.isBlank((String) currPropVal))) {
                                                                Class<? extends ValueFinder> defaultValueFinderClass = maintainableFieldDefinition
                                                                                .getDefaultValueFinderClass();
                                                                if (defaultValueFinderClass != null) {
                                                                        String defaultValue = defaultValueFinderClass.newInstance().getValue();
                                                                        if (defaultValue != null) {
                                                                                defaultValues.put(item.getName(), defaultValue);
                                                                        }
                                                                }
                                                        }
                                                }
                                        }
                                }
                        }
                        FieldUtils.populateBusinessObjectFromMap(getBusinessObject(), defaultValues);
                }
                catch (Exception e) {
                        LOG.error("Unable to set blank required value " + e.getMessage(), e);
                        throw new RuntimeException("Unable to set blank required value" + e.getMessage(), e);
                }
        }

        @Deprecated
        public void processAfterAddLine(String colName, Class colClass) {
        }

        /**
         * @see Maintainable#processBeforeAddLine(java.lang.String,
         *      java.lang.Class, org.kuali.rice.krad.bo.BusinessObject)
         */
        public void processBeforeAddLine(String colName, Class colClass, BusinessObject addBO) {
        }

        /**
         * @see Maintainable#getShowInactiveRecords(java.lang.String)
         */
        public boolean getShowInactiveRecords(String collectionName) {
                return InactiveRecordsHidingUtils.getShowInactiveRecords(inactiveRecordDisplay, collectionName);
        }

        /**
         * @see Maintainable#setShowInactiveRecords(java.lang.String,
         *      boolean)
         */
        public void setShowInactiveRecords(String collectionName, boolean showInactive) {
                InactiveRecordsHidingUtils.setShowInactiveRecords(inactiveRecordDisplay, collectionName, showInactive);
        }

        /**
         * @return the inactiveRecordDisplay
         */
        public Map<String, Boolean> getInactiveRecordDisplay() {
                return inactiveRecordDisplay;
        }

        public void addNewLineToCollection(String collectionName) {

                if (LOG.isDebugEnabled()) {
                        LOG.debug("addNewLineToCollection( " + collectionName + " )");
                }
                // get the new line from the map
                PersistableBusinessObject addLine = newCollectionLines.get(collectionName);
                if (addLine != null) {
                        // mark the isNewCollectionRecord so the option to delete this line
                        // will be presented
                        addLine.setNewCollectionRecord(true);

                        // if we add back add button on sub collection of an "add line" we
                        // may need extra logic here

                        // get the collection from the business object
                        Collection maintCollection = (Collection) ObjectUtils.getPropertyValue(getBusinessObject(), collectionName);
                        // add the line to the collection
                        maintCollection.add(addLine);
                        // refresh parent object since attributes could of changed prior to
                        // user clicking add

                        String referencesToRefresh = LookupUtils
                                        .convertReferencesToSelectCollectionToString(getAllRefreshableReferences(getBusinessObject()
                                                        .getClass()));
                        if (LOG.isInfoEnabled()) {
                                LOG.info("References to refresh for adding line to collection " + collectionName + ": "
                                                + referencesToRefresh);
                        }
                        refreshReferences(referencesToRefresh);
                }

                initNewCollectionLine(collectionName);

        }

        public PersistableBusinessObject getNewCollectionLine(String collectionName) {
                if (LOG.isDebugEnabled()) {
                        // LOG.debug( this + ") getNewCollectionLine( " + collectionName +
                        // ")", new Exception( "tracing exception") );
                        LOG.debug("newCollectionLines: " + newCollectionLines);
                }
                PersistableBusinessObject addLine = newCollectionLines.get(collectionName);
                if (addLine == null) {
                        addLine = initNewCollectionLine(collectionName);
                }
                return addLine;
        }

        public PersistableBusinessObject initNewCollectionLine(String collectionName) {
                if (LOG.isDebugEnabled()) {
                        LOG.debug("initNewCollectionLine( " + collectionName + " )");
                }
                // try to get the object from the map
                // BusinessObject addLine = newCollectionLines.get( collectionName );
                // if ( addLine == null ) {
                // if not there, instantiate a new one
                PersistableBusinessObject addLine;
                try {
                        addLine = (PersistableBusinessObject) getMaintenanceDocumentDictionaryService()
                                        .getCollectionBusinessObjectClass(getDocumentTypeName(), collectionName).newInstance();
                }
                catch (Exception ex) {
                        LOG.error("unable to instantiate new collection line", ex);
                        throw new RuntimeException("unable to instantiate new collection line", ex);
                }
                // and add it to the map
                newCollectionLines.put(collectionName, addLine);
                // }
                // set its values to the defaults
                setNewCollectionLineDefaultValues(collectionName, addLine);
                return addLine;
        }

        /**
         * 
         * @see Maintainable#populateNewCollectionLines(java.util.Map)
         */
        public Map<String, String> populateNewCollectionLines(Map<String, String> fieldValues,
                        MaintenanceDocument maintenanceDocument, String methodToCall) {
                if (LOG.isDebugEnabled()) {
                        LOG.debug("populateNewCollectionLines: " + fieldValues);
                }
                fieldValues = decryptEncryptedData(fieldValues, maintenanceDocument, methodToCall);

                Map<String, String> cachedValues = new HashMap<String, String>();

                // loop over all collections with an enabled add line
                List<MaintainableCollectionDefinition> collections = getMaintenanceDocumentDictionaryService()
                                .getMaintainableCollections(getDocumentTypeName());

                for (MaintainableCollectionDefinition coll : collections) {
                        // get the collection name
                        String collName = coll.getName();
                        if (LOG.isDebugEnabled()) {
                                LOG.debug("checking for collection: " + collName);
                        }
                        // build a map for that collection
                        Map<String, String> collectionValues = new HashMap<String, String>();
                        Map<String, String> subCollectionValues = new HashMap<String, String>();
                        // loop over the collection, extracting entries with a matching
                        // prefix
                        for (Map.Entry<String, String> entry : fieldValues.entrySet()) {
                                String key = entry.getKey();
                                if (key.startsWith(collName)) {
                                        String subStrKey = key.substring(collName.length() + 1);
                                        // check for subcoll w/ '[', set collName to propername and
                                        // put in correct name for collection values (i.e. strip
                                        // '*[x].')
                                        if (key.contains("[")) {

                                                // collName = StringUtils.substringBeforeLast(key,"[");

                                                // need the whole thing if subcollection
                                                subCollectionValues.put(key, entry.getValue());
                                        }
                                        else {
                                                collectionValues.put(subStrKey, entry.getValue());
                                        }
                                }
                        }
                        // send those values to the business object
                        if (LOG.isDebugEnabled()) {
                                LOG.debug("values for collection: " + collectionValues);
                        }
                        cachedValues.putAll(FieldUtils.populateBusinessObjectFromMap(getNewCollectionLine(collName),
                                        collectionValues, KRADConstants.MAINTENANCE_ADD_PREFIX + collName + "."));
                        performFieldForceUpperCase(getNewCollectionLine(collName), collectionValues);

                        cachedValues.putAll(populateNewSubCollectionLines(coll, subCollectionValues));
                }

                // cachedValues.putAll( FieldUtils.populateBusinessObjectFromMap( ))
                return cachedValues;
        }

        /*
         * Yes, I think this could be merged with the above code - I'm leaving it
         * separate until I figure out of there are any issues which would reqire
         * that it be separated.
         */
        protected Map populateNewSubCollectionLines(MaintainableCollectionDefinition parentCollection, Map fieldValues) {
                if (LOG.isDebugEnabled()) {
                        LOG.debug("populateNewSubCollectionLines: " + fieldValues);
                }
                Map cachedValues = new HashMap();

                for (MaintainableCollectionDefinition coll : parentCollection.getMaintainableCollections()) {
                        // get the collection name
                        String collName = coll.getName();

                        if (LOG.isDebugEnabled()) {
                                LOG.debug("checking for sub collection: " + collName);
                        }
                        Map<String, String> parents = new HashMap<String, String>();
                        // get parents from list
                        for (Object entry : fieldValues.entrySet()) {
                                String key = (String) ((Map.Entry) entry).getKey();
                                if (key.contains(collName)) {
                                        parents.put(StringUtils.substringBefore(key, "."), "");
                                }
                        }

                        for (String parent : parents.keySet()) {
                                // build a map for that collection
                                Map<String, Object> collectionValues = new HashMap<String, Object>();
                                // loop over the collection, extracting entries with a matching
                                // prefix
                                for (Object entry : fieldValues.entrySet()) {
                                        String key = (String) ((Map.Entry) entry).getKey();
                                        if (key.contains(parent)) {
                                                String substr = StringUtils.substringAfterLast(key, ".");
                                                collectionValues.put(substr, ((Map.Entry) entry).getValue());
                                        }
                                }
                                // send those values to the business object
                                if (LOG.isDebugEnabled()) {
                                        LOG.debug("values for sub collection: " + collectionValues);
                                }
                                GlobalVariables.getMessageMap().addToErrorPath(
                                                KRADConstants.MAINTENANCE_ADD_PREFIX + parent + "." + collName);
                                cachedValues.putAll(FieldUtils.populateBusinessObjectFromMap(getNewCollectionLine(parent + "."
                                                + collName), collectionValues, KRADConstants.MAINTENANCE_ADD_PREFIX + parent + "." + collName
                                                + "."));
                                performFieldForceUpperCase(getNewCollectionLine(parent + "." + collName), collectionValues);
                                GlobalVariables.getMessageMap().removeFromErrorPath(
                                                KRADConstants.MAINTENANCE_ADD_PREFIX + parent + "." + collName);
                        }

                        cachedValues.putAll(populateNewSubCollectionLines(coll, fieldValues));
                }

                return cachedValues;
        }

        public Collection<String> getAffectedReferencesFromLookup(BusinessObject baseBO, String attributeName,
                        String collectionPrefix) {
                PersistenceStructureService pss = getPersistenceStructureService();
                String nestedBOPrefix = "";
                if (ObjectUtils.isNestedAttribute(attributeName)) {
                        // if we're performing a lookup on a nested attribute, we need to
                        // use the nested BO all the way down the chain
                        nestedBOPrefix = ObjectUtils.getNestedAttributePrefix(attributeName);

                        // renormalize the base BO so that the attribute name is not nested
                        // anymore
                        Class reference = ObjectUtils.getPropertyType(baseBO, nestedBOPrefix, pss);
                        if (!(PersistableBusinessObject.class.isAssignableFrom(reference))) {
                                return new ArrayList<String>();
                        }

                        try {
                                baseBO = (PersistableBusinessObject) reference.newInstance();
                        }
                        catch (InstantiationException e) {
                                LOG.error(e);
                        }
                        catch (IllegalAccessException e) {
                                LOG.error(e);
                        }
                        attributeName = ObjectUtils.getNestedAttributePrimitive(attributeName);
                }

                if (baseBO == null) {
                        return new ArrayList<String>();
                }

                Map<String, Class> referenceNameToClassFromPSS = LookupUtils.getPrimitiveReference(baseBO, attributeName);
                if (referenceNameToClassFromPSS.size() > 1) {
                        LOG.error("LookupUtils.getPrimitiveReference return results should only have at most one element");
                }

                BusinessObjectMetaDataService businessObjectMetaDataService = getBusinessObjectMetaDataService();
                DataObjectRelationship relationship = businessObjectMetaDataService.getBusinessObjectRelationship(baseBO,
                                attributeName);
                if (relationship == null) {
                        return new ArrayList<String>();
                }

                Map<String, String> fkToPkMappings = relationship.getParentToChildReferences();

                Collection<String> affectedReferences = generateAllAffectedReferences(baseBO.getClass(), fkToPkMappings,
                                nestedBOPrefix, collectionPrefix);
                if (LOG.isDebugEnabled()) {
                        LOG.debug("References affected by a lookup on BO attribute \"" + collectionPrefix + nestedBOPrefix + "."
                                        + attributeName + ": " + affectedReferences);
                }

                return affectedReferences;
        }

        protected boolean isRelationshipRefreshable(Class boClass, String relationshipName) {
                if (getPersistenceStructureService().isPersistable(boClass)) {
                        if (getPersistenceStructureService().hasCollection(boClass, relationshipName)) {
                                return !getPersistenceStructureService().isCollectionUpdatable(boClass, relationshipName);
                        }
                        else if (getPersistenceStructureService().hasReference(boClass, relationshipName)) {
                                return !getPersistenceStructureService().isReferenceUpdatable(boClass, relationshipName);
                        }
                        // else, assume that the relationship is defined in the DD
                }

                return true;
        }

        protected Collection<String> generateAllAffectedReferences(Class boClass, Map<String, String> fkToPkMappings,
                        String nestedBOPrefix, String collectionPrefix) {
                Set<String> allAffectedReferences = new HashSet<String>();
                DataDictionaryService dataDictionaryService = getDataDictionaryService();
                PersistenceStructureService pss = getPersistenceStructureService();

                collectionPrefix = StringUtils.isBlank(collectionPrefix) ? "" : collectionPrefix;

                // retrieve the attributes that are affected by a lookup on
                // attributeName.
                Collection<String> attributeReferenceFKAttributes = fkToPkMappings.keySet();

                // a lookup on an attribute may cause other attributes to be updated
                // (e.g. account code lookup would also affect chart code)
                // build a list of all affected FK values via mapKeyFields above, and
                // for each FK, see if there are any non-updatable references with that
                // FK

                // deal with regular simple references (<reference-descriptor>s in OJB)
                for (String fkAttribute : attributeReferenceFKAttributes) {
                        for (String affectedReference : pss.getReferencesForForeignKey(boClass, fkAttribute).keySet()) {
                                if (isRelationshipRefreshable(boClass, affectedReference)) {
                                        if (StringUtils.isBlank(nestedBOPrefix)) {
                                                allAffectedReferences.add(collectionPrefix + affectedReference);
                                        }
                                        else {
                                                allAffectedReferences.add(collectionPrefix + nestedBOPrefix + "." + affectedReference);
                                        }
                                }
                        }
                }

                // now with collection references (<collection-descriptor>s in OJB)
                for (String collectionName : pss.listCollectionObjectTypes(boClass).keySet()) {
                        if (isRelationshipRefreshable(boClass, collectionName)) {
                                Map<String, String> keyMappingsForCollection = pss.getInverseForeignKeysForCollection(boClass,
                                                collectionName);
                                for (String collectionForeignKey : keyMappingsForCollection.keySet()) {
                                        if (attributeReferenceFKAttributes.contains(collectionForeignKey)) {
                                                if (StringUtils.isBlank(nestedBOPrefix)) {
                                                        allAffectedReferences.add(collectionPrefix + collectionName);
                                                }
                                                else {
                                                        allAffectedReferences.add(collectionPrefix + nestedBOPrefix + "." + collectionName);
                                                }
                                        }
                                }
                        }
                }

                // now use the DD to compute more affected references
                List<String> ddDefinedRelationships = dataDictionaryService.getRelationshipNames(boClass.getName());
                for (String ddRelationship : ddDefinedRelationships) {
                        // note that this map is PK (key/target) => FK (value/source)
                        Map<String, String> referencePKtoFKmappings = dataDictionaryService.getRelationshipAttributeMap(
                                        boClass.getName(), ddRelationship);
                        for (String sourceAttribute : referencePKtoFKmappings.values()) {
                                // the sourceAttribute is the FK pointing to the target
                                // attribute (PK)
                                if (attributeReferenceFKAttributes.contains(sourceAttribute)) {
                                        for (String affectedReference : dataDictionaryService.getRelationshipEntriesForSourceAttribute(
                                                        boClass.getName(), sourceAttribute)) {
                                                if (isRelationshipRefreshable(boClass, ddRelationship)) {
                                                        if (StringUtils.isBlank(nestedBOPrefix)) {
                                                                allAffectedReferences.add(affectedReference);
                                                        }
                                                        else {
                                                                allAffectedReferences.add(nestedBOPrefix + "." + affectedReference);
                                                        }
                                                }
                                        }
                                }
                        }
                }
                return allAffectedReferences;
        }

        protected Collection<String> getAllRefreshableReferences(Class boClass) {
                HashSet<String> references = new HashSet<String>();
                for (String referenceName : getPersistenceStructureService().listReferenceObjectFields(boClass).keySet()) {
                        if (isRelationshipRefreshable(boClass, referenceName)) {
                                references.add(referenceName);
                        }
                }
                for (String collectionName : getPersistenceStructureService().listCollectionObjectTypes(boClass).keySet()) {
                        if (isRelationshipRefreshable(boClass, collectionName)) {
                                references.add(collectionName);
                        }
                }
                for (String relationshipName : getDataDictionaryService().getRelationshipNames(boClass.getName())) {
                        if (isRelationshipRefreshable(boClass, relationshipName)) {
                                references.add(relationshipName);
                        }
                }
                return references;
        }

        protected void setNewCollectionLineDefaultValues(String collectionName, PersistableBusinessObject addLine) {
                PropertyDescriptor[] descriptors = PropertyUtils.getPropertyDescriptors(addLine);
                for (int i = 0; i < descriptors.length; ++i) {
                        PropertyDescriptor propertyDescriptor = descriptors[i];

                        String fieldName = propertyDescriptor.getName();
                        Class propertyType = propertyDescriptor.getPropertyType();
                        String value = getMaintenanceDocumentDictionaryService().getCollectionFieldDefaultValue(getDocumentTypeName(),
                                        collectionName, fieldName);

                        if (value != null) {
                                try {
                                        ObjectUtils.setObjectProperty(addLine, fieldName, propertyType, value);
                                }
                                catch (Exception ex) {
                                        LOG.error("Unable to set default property of collection object: " + "\nobject: " + addLine
                                                        + "\nfieldName=" + fieldName + "\npropertyType=" + propertyType + "\nvalue=" + value, ex);
                                }
                        }

                }
        }

        /**
         * @see Maintainable#clearBusinessObjectOfRestrictedValues(org.kuali.rice.kns.document.authorization.MaintenanceDocumentRestrictions)
         */
        public void clearBusinessObjectOfRestrictedValues(MaintenanceDocumentRestrictions maintenanceDocumentRestrictions) {
                List<MaintainableSectionDefinition> sections = getMaintenanceDocumentDictionaryService()
                                .getMaintainableSections(getDocumentTypeName());
                for (MaintainableSectionDefinition sectionDefinition : sections) {
                        for (MaintainableItemDefinition itemDefinition : sectionDefinition.getMaintainableItems()) {
                                if (itemDefinition instanceof MaintainableFieldDefinition) {
                                        clearFieldRestrictedValues("", businessObject, (MaintainableFieldDefinition) itemDefinition,
                                                        maintenanceDocumentRestrictions);
                                }
                                else if (itemDefinition instanceof MaintainableCollectionDefinition) {
                                        clearCollectionRestrictedValues("", businessObject,
                                                        (MaintainableCollectionDefinition) itemDefinition, maintenanceDocumentRestrictions);
                                }
                        }
                }
        }

        protected void clearCollectionRestrictedValues(String fieldNamePrefix, BusinessObject businessObject,
                        MaintainableCollectionDefinition collectionDefinition,
                        MaintenanceDocumentRestrictions maintenanceDocumentRestrictions) {
                String collectionName = fieldNamePrefix + collectionDefinition.getName();
                Collection<BusinessObject> collection = (Collection<BusinessObject>) ObjectUtils.getPropertyValue(
                                businessObject, collectionDefinition.getName());

                if (collection != null) {
                        int i = 0;
                        // even though it's technically a Collection, we're going to index
                        // it like a list
                        for (BusinessObject collectionItem : collection) {
                                String collectionItemNamePrefix = collectionName + "[" + i + "].";
                                for (MaintainableCollectionDefinition subCollectionDefinition : collectionDefinition
                                                .getMaintainableCollections()) {
                                        clearCollectionRestrictedValues(collectionItemNamePrefix, collectionItem, subCollectionDefinition,
                                                        maintenanceDocumentRestrictions);
                                }
                                for (MaintainableFieldDefinition fieldDefinition : collectionDefinition.getMaintainableFields()) {
                                        clearFieldRestrictedValues(collectionItemNamePrefix, collectionItem, fieldDefinition,
                                                        maintenanceDocumentRestrictions);
                                }
                                i++;
                        }
                }
        }

        protected void clearFieldRestrictedValues(String fieldNamePrefix, BusinessObject businessObject,
                        MaintainableFieldDefinition fieldDefinition, MaintenanceDocumentRestrictions maintenanceDocumentRestrictions) {
                String fieldName = fieldNamePrefix + fieldDefinition.getName();

                FieldRestriction fieldRestriction = maintenanceDocumentRestrictions.getFieldRestriction(fieldName);
                if (fieldRestriction.isRestricted()) {
                        String defaultValue = null;
                        if (StringUtils.isNotBlank(fieldDefinition.getDefaultValue())) {
                                defaultValue = fieldDefinition.getDefaultValue();
                        }
                        else if (fieldDefinition.getDefaultValueFinderClass() != null) {
                                try {
                                        defaultValue = ((ValueFinder) fieldDefinition.getDefaultValueFinderClass().newInstance())
                                                        .getValue();
                                }
                                catch (Exception e) {
                                        defaultValue = null;
                                        LOG.error("Error trying to instantiate ValueFinder or to determine ValueFinder for doc type: "
                                                        + getDocumentTypeName() + " field name " + fieldDefinition.getName() + " with field prefix: "
                                                        + fieldNamePrefix, e);
                                }
                        }
                        try {
                                ObjectUtils.setObjectProperty(businessObject, fieldDefinition.getName(), defaultValue);
                        }
                        catch (Exception e) {
                                // throw an exception, because we don't want users to be able to
                                // see the restricted value
                                LOG.error("Unable to clear maintenance document values for field name: " + fieldName
                                                + " default value: " + defaultValue, e);
                                throw new RuntimeException("Unable to clear maintenance document values for field name: " + fieldName,
                                                e);
                        }
                }
        }

        protected void performForceUpperCase(Map fieldValues) {
                List<MaintainableSectionDefinition> sections = getMaintenanceDocumentDictionaryService()
                                .getMaintainableSections(getDocumentTypeName());
                for (MaintainableSectionDefinition sectionDefinition : sections) {
                        for (MaintainableItemDefinition itemDefinition : sectionDefinition.getMaintainableItems()) {
                                if (itemDefinition instanceof MaintainableFieldDefinition) {
                                        performFieldForceUpperCase("", businessObject, (MaintainableFieldDefinition) itemDefinition,
                                                        fieldValues);
                                }
                                else if (itemDefinition instanceof MaintainableCollectionDefinition) {
                                        performCollectionForceUpperCase("", businessObject,
                                                        (MaintainableCollectionDefinition) itemDefinition, fieldValues);

                                }
                        }
                }
        }

        protected void performFieldForceUpperCase(String fieldNamePrefix, BusinessObject bo,
                        MaintainableFieldDefinition fieldDefinition, Map fieldValues) {
                MessageMap errorMap = GlobalVariables.getMessageMap();
                String fieldName = fieldDefinition.getName();
                String mapKey = fieldNamePrefix + fieldName;
                if (fieldValues != null && fieldValues.get(mapKey) != null) {
                        if (PropertyUtils.isWriteable(bo, fieldName) && ObjectUtils.getNestedValue(bo, fieldName) != null) {

                                try {
                                        Class type = ObjectUtils.easyGetPropertyType(bo, fieldName);
                                        // convert to upperCase based on data dictionary
                                        Class businessObjectClass = bo.getClass();
                                        boolean upperCase = false;
                                        try {
                                                upperCase = getDataDictionaryService().getAttributeForceUppercase(businessObjectClass,
                                                                fieldName);
                                        }
                                        catch (UnknownBusinessClassAttributeException t) {
                                                boolean catchme = true;
                                                // throw t;
                                        }

                                        Object fieldValue = ObjectUtils.getNestedValue(bo, fieldName);

                                        if (upperCase && fieldValue instanceof String) {
                                                fieldValue = ((String) fieldValue).toUpperCase();
                                        }
                                        ObjectUtils.setObjectProperty(bo, fieldName, type, fieldValue);
                                }
                                catch (FormatException e) {
                                        errorMap.putError(fieldName, e.getErrorKey(), e.getErrorArgs());
                                }
                                catch (IllegalAccessException e) {
                                        LOG.error("unable to populate business object" + e.getMessage());
                                        throw new RuntimeException(e.getMessage(), e);
                                }
                                catch (InvocationTargetException e) {
                                        LOG.error("unable to populate business object" + e.getMessage());
                                        throw new RuntimeException(e.getMessage(), e);
                                }
                                catch (NoSuchMethodException e) {
                                        LOG.error("unable to populate business object" + e.getMessage());
                                        throw new RuntimeException(e.getMessage(), e);
                                }
                        }
                }
        }

        protected void performCollectionForceUpperCase(String fieldNamePrefix, BusinessObject bo,
                        MaintainableCollectionDefinition collectionDefinition, Map fieldValues) {
                String collectionName = fieldNamePrefix + collectionDefinition.getName();
                Collection<BusinessObject> collection = (Collection<BusinessObject>) ObjectUtils.getPropertyValue(bo,
                                collectionDefinition.getName());
                if (collection != null) {
                        int i = 0;
                        // even though it's technically a Collection, we're going to index
                        // it like a list
                        for (BusinessObject collectionItem : collection) {
                                String collectionItemNamePrefix = collectionName + "[" + i + "].";
                                // String collectionItemNamePrefix = "";
                                for (MaintainableFieldDefinition fieldDefinition : collectionDefinition.getMaintainableFields()) {
                                        performFieldForceUpperCase(collectionItemNamePrefix, collectionItem, fieldDefinition, fieldValues);
                                }
                                for (MaintainableCollectionDefinition subCollectionDefinition : collectionDefinition
                                                .getMaintainableCollections()) {
                                        performCollectionForceUpperCase(collectionItemNamePrefix, collectionItem, subCollectionDefinition,
                                                        fieldValues);
                                }
                                i++;
                        }
                }
        }

        protected void performFieldForceUpperCase(BusinessObject bo, Map fieldValues) {
                MessageMap errorMap = GlobalVariables.getMessageMap();

                try {
                        for (Iterator iter = fieldValues.keySet().iterator(); iter.hasNext();) {
                                String propertyName = (String) iter.next();

                                if (PropertyUtils.isWriteable(bo, propertyName) && fieldValues.get(propertyName) != null) {
                                        // if the field propertyName is a valid property on the bo
                                        // class
                                        Class type = ObjectUtils.easyGetPropertyType(bo, propertyName);
                                        try {
                                                // Keep the convert to upperCase logic here. It will be
                                                // used in populateNewCollectionLines,
                                                // populateNewSubCollectionLines
                                                // convert to upperCase based on data dictionary
                                                Class businessObjectClass = bo.getClass();
                                                boolean upperCase = false;
                                                try {
                                                        upperCase = getDataDictionaryService().getAttributeForceUppercase(businessObjectClass,
                                                                        propertyName);
                                                }
                                                catch (UnknownBusinessClassAttributeException t) {
                                                        boolean catchme = true;
                                                        // throw t;
                                                }

                                                Object fieldValue = fieldValues.get(propertyName);

                                                if (upperCase && fieldValue instanceof String) {
                                                        fieldValue = ((String) fieldValue).toUpperCase();
                                                }
                                                ObjectUtils.setObjectProperty(bo, propertyName, type, fieldValue);
                                        }
                                        catch (FormatException e) {
                                                errorMap.putError(propertyName, e.getErrorKey(), e.getErrorArgs());
                                        }
                                }
                        }
                }
                catch (IllegalAccessException e) {
                        LOG.error("unable to populate business object" + e.getMessage());
                        throw new RuntimeException(e.getMessage(), e);
                }
                catch (InvocationTargetException e) {
                        LOG.error("unable to populate business object" + e.getMessage());
                        throw new RuntimeException(e.getMessage(), e);
                }
                catch (NoSuchMethodException e) {
                        LOG.error("unable to populate business object" + e.getMessage());
                        throw new RuntimeException(e.getMessage(), e);
                }

        }

        /**
         * By default a maintainable is not external
         * 
         * @see Maintainable#isExternalBusinessObject()
         */
        public boolean isExternalBusinessObject() {
                return false;
        }

        /**
         * @see Maintainable#getExternalBusinessObject()
         */
        public void prepareBusinessObject(BusinessObject businessObject) {
                // Do nothing by default
        }

        // 3070
        public void deleteBusinessObject() {
                if (businessObject == null)
                        return;

                KRADServiceLocator.getBusinessObjectService().delete(businessObject);
                businessObject = null;
        }

        public boolean isOldBusinessObjectInDocument() {
                return super.isOldDataObjectInDocument();
        }

        protected BusinessObjectDictionaryService getBusinessObjectDictionaryService() {
                if (businessObjectDictionaryService == null) {
                        businessObjectDictionaryService = KNSServiceLocator.getBusinessObjectDictionaryService();
                }
                return businessObjectDictionaryService;
        }

        protected PersonService getPersonService() {
                if (personService == null) {
                        personService = KimApiServiceLocator.getPersonService();
                }
                return personService;
        }

        protected BusinessObjectMetaDataService getBusinessObjectMetaDataService() {
                if (businessObjectMetaDataService == null) {
                        businessObjectMetaDataService = KNSServiceLocator.getBusinessObjectMetaDataService();
                }
                return businessObjectMetaDataService;
        }

        protected BusinessObjectAuthorizationService getBusinessObjectAuthorizationService() {
                if (businessObjectAuthorizationService == null) {
                        businessObjectAuthorizationService = KNSServiceLocator.getBusinessObjectAuthorizationService();
                }
                return businessObjectAuthorizationService;
        }

        protected DocumentHelperService getDocumentHelperService() {
                if (documentHelperService == null) {
                        documentHelperService = KNSServiceLocator.getDocumentHelperService();
                }
                return documentHelperService;
        }

        public void setBusinessObjectDictionaryService(BusinessObjectDictionaryService businessObjectDictionaryService) {
                this.businessObjectDictionaryService = businessObjectDictionaryService;
        }

        public void setPersonService(PersonService personService) {
                this.personService = personService;
        }

        public void setBusinessObjectMetaDataService(BusinessObjectMetaDataService businessObjectMetaDataService) {
                this.businessObjectMetaDataService = businessObjectMetaDataService;
        }

        public void setBusinessObjectAuthorizationService(
                        BusinessObjectAuthorizationService businessObjectAuthorizationService) {
                this.businessObjectAuthorizationService = businessObjectAuthorizationService;
        }

        public void setDocumentHelperService(DocumentHelperService documentHelperService) {
                this.documentHelperService = documentHelperService;
        }

    public MaintenanceDocumentDictionaryService getMaintenanceDocumentDictionaryService() {
        if (maintenanceDocumentDictionaryService == null) {
            this.maintenanceDocumentDictionaryService = KNSServiceLocator.getMaintenanceDocumentDictionaryService();
        }
        return maintenanceDocumentDictionaryService;
    }

    public void setMaintenanceDocumentDictionaryService(
            MaintenanceDocumentDictionaryService maintenanceDocumentDictionaryService) {
        this.maintenanceDocumentDictionaryService = maintenanceDocumentDictionaryService;
    }
}