/*
    * Copyright 2006 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.coa.document.validation.impl;
  
  import java.sql.Date;
  import java.sql.Timestamp;
  import java.util.Calendar;
  import java.util.HashMap;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  
  import org.apache.commons.lang.StringUtils;
  import org.apache.commons.lang.time.DateUtils;
  import org.kuali.ole.coa.businessobject.Account;
  import org.kuali.ole.coa.businessobject.Organization;
  import org.kuali.ole.coa.service.OrganizationService;
  import org.kuali.ole.sys.OLEConstants;
  import org.kuali.ole.sys.OLEKeyConstants;
  import org.kuali.ole.sys.OLEPropertyConstants;
  import org.kuali.ole.sys.context.SpringContext;
  import org.kuali.ole.sys.identity.OleKimAttributes;
  import org.kuali.rice.core.api.parameter.ParameterEvaluatorService;
  import org.kuali.rice.coreservice.framework.parameter.ParameterService;
  import org.kuali.rice.kim.api.KimConstants;
  import org.kuali.rice.kim.api.identity.Person;
  import org.kuali.rice.kim.api.services.IdentityManagementService;
  import org.kuali.rice.kns.document.MaintenanceDocument;
  import org.kuali.rice.kns.maintenance.rules.MaintenanceDocumentRuleBase;
  import org.kuali.rice.krad.util.GlobalVariables;
  import org.kuali.rice.krad.util.ObjectUtils;
  
  /**
   * This class implements the business rules specific to the {@link Org} Maintenance Document.
   */
  public class OrgRule extends MaintenanceDocumentRuleBase {
  
      protected static org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(OrgRule.class);
  
  
      protected static OrganizationService orgService;
  
      protected Organization oldOrg;
      protected Organization newOrg;
      protected boolean isHrmsOrgActivated;
  
      /**
       * Constructs a OrgRule and pseudo-injects services
       */
      public OrgRule() {
          super();
  
          // Pseudo-inject some services.
          //
          // This approach is being used to make it simpler to convert the Rule classes
          // to spring-managed with these services injected by Spring at some later date.
          // When this happens, just remove these calls to the setters with
          // SpringContext, and configure the bean defs for spring.
          if (orgService == null) {
              orgService = SpringContext.getBean(OrganizationService.class);
          }
      }
  
      /**
       * This performs the following checks on document approve:
       * <ul>
       * <li>{@link OrgRule#checkExistenceAndActive()}</li>
       * <li>{@link OrgRule#checkOrgClosureRules(MaintenanceDocument)}</li>
       * <li>{@link OrgRule#checkSimpleRules(MaintenanceDocument)}</li>
       * <li>{@link OrgRule#checkDefaultAccountNumber(MaintenanceDocument)}</li>
       * </ul>
       * This rule fails on rule failure
       *
       * @see org.kuali.rice.kns.maintenance.rules.MaintenanceDocumentRuleBase#processCustomApproveDocumentBusinessRules(org.kuali.rice.kns.document.MaintenanceDocument)
       */
      @Override
      protected boolean processCustomApproveDocumentBusinessRules(MaintenanceDocument document) {
  
          boolean success = true;
  
          LOG.debug("Entering processCustomApproveDocumentBusinessRules()");
  
          // determine whether HRMS ORG is activated in this app instance
          isHrmsOrgActivated = isHrmsOrgActivated();
  
          // check that all sub-objects whose keys are specified have matching objects in the db
         success &= checkExistenceAndActive();
 
         success &= checkOrgClosureRules(document);
 
         // check that end date is greater than begin date and Reports To Chart/Org should not be same as this Chart/Org
         success &= checkSimpleRules(document);
 
         // check that defaultAccount is present unless
         // ( (orgType = U or C) and ( document is a "create new" ))
 
         //Code changes for JIRA OLE2344 don't check default account number as account no is made optional
         //success &= checkDefaultAccountNumber(document);
 
         return success;
     }
 
     /**
      * This performs the following checks on document route:
      * <ul>
      * <li>{@link OrgRule#checkExistenceAndActive()}</li>
      * <li>{@link OrgRule#checkOrgClosureRules(MaintenanceDocument)}</li>
      * <li>{@link OrgRule#checkSimpleRules(MaintenanceDocument)}</li>
      * <li>{@link OrgRule#checkDefaultAccountNumber(MaintenanceDocument)}</li>
      * </ul>
      * This rule fails on rule failure
      *
      * @see org.kuali.rice.kns.maintenance.rules.MaintenanceDocumentRuleBase#processCustomRouteDocumentBusinessRules(org.kuali.rice.kns.document.MaintenanceDocument)
      */
     @Override
     protected boolean processCustomRouteDocumentBusinessRules(MaintenanceDocument document) {
 
         boolean success = true;
 
         LOG.debug("Entering processCustomRouteDocumentBusinessRules()");
 
         // determine whether HRMS ORG is activated in this app instance
         isHrmsOrgActivated = isHrmsOrgActivated();
 
         // check that all sub-objects whose keys are specified have matching objects in the db
         success &= checkExistenceAndActive();
 
         // check that end date is greater than begin date and Reports To Chart/Org should not be same as this Chart/Org
         success &= checkSimpleRules(document);
 
         // check that defaultAccount is present unless
         // ( (orgType = U or C) and ( document is a "create new" ))
 
         //Code changes for JIRA OLE2344 don't check default account number as account no is made optional
         //success &= checkDefaultAccountNumber(document);
 
         success &= checkOrgClosureRules(document);
 
         return success;
     }
 
     /**
      * This performs the following checks on document save:
      * <ul>
      * <li>{@link OrgRule#checkExistenceAndActive()}</li>
      * <li>{@link OrgRule#checkOrgClosureRules(MaintenanceDocument)}</li>
      * <li>{@link OrgRule#checkSimpleRules(MaintenanceDocument)}</li>
      * <li>{@link OrgRule#checkDefaultAccountNumber(MaintenanceDocument)}</li>
      * </ul>
      * This rule does not fail on rule failure
      *
      * @see org.kuali.rice.kns.maintenance.rules.MaintenanceDocumentRuleBase#processCustomSaveDocumentBusinessRules(org.kuali.rice.kns.document.MaintenanceDocument)
      */
     @Override
     protected boolean processCustomSaveDocumentBusinessRules(MaintenanceDocument document) {
 
         LOG.debug("Entering processCustomSaveDocumentBusinessRules()");
 
         // determine whether HRMS ORG is activated in this app instance
         isHrmsOrgActivated = isHrmsOrgActivated();
 
         // check that all sub-objects whose keys are specified have matching objects in the db
         checkExistenceAndActive();
 
         checkOrgClosureRules(document);
 
         // check that end date is greater than begin date and Reports To Chart/Org should not be same as this Chart/Org
         checkSimpleRules(document);
 
         // check that defaultAccount is present unless
         // ( (orgType = U or C) and ( document is a "create new" ))
 
         //Code changes for JIRA OLE2344 don't check default account number as account no is made optional
         //checkDefaultAccountNumber(document);
 
         return true;
     }
 
     /**
      * This checks to see if the org is active
      *
      * @return true if the org is inactive or false otherwise
      */
     protected boolean checkExistenceAndActive() {
 
         LOG.debug("Entering checkExistenceAndActive()");
         boolean success = true;
 
         // shortcut out with no enforcement if this org is closed
         if (!newOrg.isActive()) {
             return success;
         }
 
         // Disabling plant attribute checking
 //        success &= checkPlantAttributes();
 
         return success;
     }
 
     /**
      * This checks to see if a user is authorized for plant fields modification. If not then it returns true (without activating
      * fields). If the org does not have to report to itself then it checks to see if the plant fields have been filled out
      * correctly and fails if they haven't
      *
      * @return false if user can edit plant fields but they have not been filled out correctly
      */
     protected boolean checkPlantAttributes() {
 
         boolean success = true;
 
         /*
          * KULCOA-1132 - exit if the user is not a member of the plant maintainer work group.
          */
 
         // get user
         Person user = GlobalVariables.getUserSession().getPerson();
 
         // if not authroized to edit plant fields, exit with true
         if (isPlantAuthorized(user) == false) {
             return true;
         }
 
         // relax this edit for
         if (!getOrgMustReportToSelf(newOrg)) {
             // require Org Plant ChartCode
             success &= checkEmptyBOField("organizationPlantChartCode", newOrg.getOrganizationPlantChartCode(), "Organization Plant Chart of Accounts Code");
 
             // require Org Plant AccountNumber
             success &= checkEmptyBOField("organizationPlantAccountNumber", newOrg.getOrganizationPlantAccountNumber(), "Organization Plant Account Number");
 
             // require Campus Plant ChartCode
             success &= checkEmptyBOField("campusPlantChartCode", newOrg.getCampusPlantChartCode(), "Campus Plant Chart of Accounts Code");
 
             // require Org Plant ChartCode
             success &= checkEmptyBOField("campusPlantAccountNumber", newOrg.getCampusPlantAccountNumber(), "Campus Plant Account Number");
 
             // validate Org Plant Account
             success &= getDictionaryValidationService().validateReferenceExistsAndIsActive(newOrg, "organizationPlantAccount", MAINTAINABLE_ERROR_PREFIX + "organizationPlantAccountNumber", "Organization Plant Account");
 
             // validate Campus Plant Account
             success &= getDictionaryValidationService().validateReferenceExistsAndIsActive(newOrg, "campusPlantAccount", MAINTAINABLE_ERROR_PREFIX + "campusPlantAccountNumber", "Campus Plant Account");
         }
 
         return success;
     }
 
     /**
      * This method enforces the business rules surrounding when an Org becomes closed/inactive. If we are editing and switching the
      * org to inactive or if it is a new doc and it is marked as inactive then we assume we are closing the org. If we are not then
      * we return true. If we are then we return false if there are still active accounts tied to the org
      *
      * @param document
      * @return false if trying to close org but it still has accounts that are active linked to it
      */
     protected boolean checkOrgClosureRules(MaintenanceDocument document) {
 
         boolean success = true;
         boolean orgBeingClosed = false;
         boolean checkForChildObjects = true;
 
         // if its an edit, and its being closed
         if (document.isEdit()) {
             if (oldOrg.isActive() && !newOrg.isActive()) {
                 orgBeingClosed = true;
             }
         }
 
         // if its new, and is being created as closed
         if (document.isNew()) {
             if (!newOrg.isActive()) {
                 orgBeingClosed = true;
                 // Since it's new, we don't need to check for accounts and orgs
                 checkForChildObjects = false;
             }
         }
 
         // if the org isnt being closed, stop processing here
         if (!orgBeingClosed) {
             return success;
         }
 
         // FROM HERE ON WE'RE ASSUMING THE ORG IS BEING CLOSED
 
         // do not allow the org to be closed while there are active accounts tied
         // to this org
         if (checkForChildObjects) {
             List childAccounts = orgService.getActiveAccountsByOrg(newOrg.getChartOfAccountsCode(),
                     newOrg.getOrganizationCode());
             if (childAccounts.size() > 0) {
 
                 // get the first three accounts on the list for display
                 StringBuffer childAccountList = new StringBuffer();
                 int count = 0;
                 String delim = "";
                 for (Iterator iter = childAccounts.iterator(); iter.hasNext();) {
                     Account account = (Account) iter.next();
                     childAccountList
                             .append(delim + account.getChartOfAccountsCode() + "-" + account.getAccountNumber());
                     count++;
                     if (count >= 1) {
                         delim = ", ";
                     }
                     if (count >= 3) {
                         break;
                     }
                 }
                 if (childAccounts.size() > count) {
                     childAccountList.append(", ... (" + (childAccounts.size() - count) + " more)");
                 }
 
                 putGlobalError(OLEKeyConstants.ERROR_DOCUMENT_ORGMAINT_OPEN_CHILD_ACCOUNTS_ON_ORG_CLOSURE,
                         childAccountList.toString());
                 success &= false;
             }
 
             // do not allow this org to be closed while there are still active orgs
             // that have this org as their reportsToOrg
             List childOrgs = orgService.getActiveChildOrgs(newOrg.getChartOfAccountsCode(),
                     newOrg.getOrganizationCode());
             if (childOrgs.size() > 0) {
 
                 // get the first three orgs on the list for display
                 StringBuffer childOrgsList = new StringBuffer();
                 int count = 0;
                 String delim = "";
                 for (Iterator iter = childOrgs.iterator(); iter.hasNext();) {
                     Organization org = (Organization) iter.next();
                     childOrgsList.append(delim + org.getChartOfAccountsCode() + "-" + org.getOrganizationCode());
                     count++;
                     if (count >= 1) {
                         delim = ", ";
                     }
                     if (count >= 3) {
                         break;
                     }
                 }
                 if (childOrgs.size() > count) {
                     childOrgsList.append(", ... (" + (childOrgs.size() - count) + " more)");
                 }
 
                 putGlobalError(OLEKeyConstants.ERROR_DOCUMENT_ORGMAINT_OPEN_CHILD_ORGS_ON_ORG_CLOSURE,
                         childOrgsList.toString());
                 success &= false;
             }
         }
 
         // if org is being closed, end-date must be valid and present
         if (ObjectUtils.isNull(newOrg.getOrganizationEndDate())) {
             success &= false;
             putFieldError("organizationEndDate", OLEKeyConstants.ERROR_DOCUMENT_ORGMAINT_END_DATE_REQUIRED_ON_ORG_CLOSURE);
         }
         return success;
 
     }
 
     /**
      * This checks to see if the org is active and if it the HRMS org is active
      *
      * @param document
      * @return true if either the org is inactive or isHrmsOrgActivated is false
      */
     protected boolean checkHrmsOrgRules(MaintenanceDocument document) {
 
         boolean success = true;
 
         // shortcut out with no enforcement if this org is closed
         if (!newOrg.isActive()) {
             return success;
         }
 
         // short circuit and fail if HRMSOrg is turned off
         if (!isHrmsOrgActivated) {
             return success;
         }
 
         // if the system has a HRMS Org record attached to this org record, then prompt the
         // user to fill out the HRMS Org info
 
         // HRMS Org Campus == Org Campus
         // HRMS Org campus code must be the same as Org campus code
 
 
         // if the
         return success;
     }
 
     /**
      * This checks our {@link Parameter} rules to see if this org needs to report to itself
      *
      * @param organization
      * @return true if it does
      */
     protected boolean getOrgMustReportToSelf(Organization organization) {
         return /*REFACTORME*/SpringContext.getBean(ParameterEvaluatorService.class).getParameterEvaluator(Organization.class, OLEConstants.ChartApcParms.ORG_MUST_REPORT_TO_SELF_ORG_TYPES, organization.getOrganizationTypeCode()).evaluationSucceeds();
     }
 
     /**
      * This checks the following conditions:
      * <ul>
      * <li>begin date must be greater than or equal to end date</li>
      * <li>start date must be greater than or equal to today if new Document</li>
      * <li>Reports To Chart/Org should not be same as this Chart/Org</li>
      * </ul>
      *
      * @param document
      * @return true if it passes all the rules, false otherwise
      */
     protected boolean checkSimpleRules(MaintenanceDocument document) {
 
         boolean success = true;
         String lastReportsToChartOfAccountsCode;
         String lastReportsToOrganizationCode;
         boolean continueSearch;
         Organization tempOrg;
         Integer loopCount;
         Integer maxLoopCount = 40;
 
         // begin date must be greater than or equal to end date
         if ((ObjectUtils.isNotNull(newOrg.getOrganizationBeginDate()) && (ObjectUtils.isNotNull(newOrg.getOrganizationEndDate())))) {
 
             Date beginDate = newOrg.getOrganizationBeginDate();
             Date endDate = newOrg.getOrganizationEndDate();
 
             if (endDate.before(beginDate)) {
                 putFieldError("organizationEndDate", OLEKeyConstants.ERROR_DOCUMENT_ORGMAINT_END_DATE_GREATER_THAN_BEGIN_DATE);
                 success &= false;
             }
         }
 
         // start date must be greater than or equal to today if new Document
         if ((ObjectUtils.isNotNull(newOrg.getOrganizationBeginDate()) && (document.isNew()))) {
             Timestamp today = getDateTimeService().getCurrentTimestamp();
             today.setTime(DateUtils.truncate(today, Calendar.DAY_OF_MONTH).getTime());
             if (newOrg.getOrganizationBeginDate().before(today)) {
                 putFieldError("organizationBeginDate", OLEKeyConstants.ERROR_DOCUMENT_ORGMAINT_STARTDATE_IN_PAST);
                 success &= false;
             }
         }
 
         // Reports To Chart/Org should not be same as this Chart/Org
         // However, allow special case where organization type is listed in the business rules
         if (ObjectUtils.isNotNull(newOrg.getReportsToChartOfAccountsCode()) && ObjectUtils.isNotNull(newOrg.getReportsToOrganizationCode()) && ObjectUtils.isNotNull(newOrg.getChartOfAccountsCode()) && ObjectUtils.isNotNull(newOrg.getOrganizationCode())) {
             if (!getOrgMustReportToSelf(newOrg)) {
 
                 if ((newOrg.getReportsToChartOfAccountsCode().equals(newOrg.getChartOfAccountsCode())) && (newOrg.getReportsToOrganizationCode().equals(newOrg.getOrganizationCode()))) {
                     putFieldError("reportsToOrganizationCode", OLEKeyConstants.ERROR_DOCUMENT_ORGMAINT_REPORTING_ORG_CANNOT_BE_SAME_ORG);
                     success = false;
                 }
                 else {
                     // Don't allow a circular reference on Reports to Chart/Org
                     // terminate the search when a top-level org is found
                     lastReportsToChartOfAccountsCode = newOrg.getReportsToChartOfAccountsCode();
                     lastReportsToOrganizationCode = newOrg.getReportsToOrganizationCode();
                     continueSearch = true;
                     loopCount = 0;
                     do {
                         tempOrg = orgService.getByPrimaryId(lastReportsToChartOfAccountsCode, lastReportsToOrganizationCode);
                         loopCount++;
                         ;
                         if (ObjectUtils.isNull(tempOrg)) {
                             continueSearch = false;
                             // if a null is returned on the first iteration, then the reports-to org does not exist
                             // fail the validation
                             if (loopCount == 1) {
                                 putFieldError("reportsToOrganizationCode", OLEKeyConstants.ERROR_DOCUMENT_ORGMAINT_REPORTING_ORG_MUST_EXIST);
                                 success = false;
                             }
                         }
                         else {
                             // on the first iteration, check whether the reports-to organization is active
                             if (loopCount == 1 && !tempOrg.isActive()) {
                                 putFieldError("reportsToOrganizationCode", OLEKeyConstants.ERROR_DOCUMENT_ORGMAINT_REPORTING_ORG_MUST_EXIST);
                                 success = false;
                                 continueSearch = false;
                             }
                             else {
                                 // LOG.info("Found Org = " + lastReportsToChartOfAccountsCode + "/" +
                                 // lastReportsToOrganizationCode);
                                 lastReportsToChartOfAccountsCode = tempOrg.getReportsToChartOfAccountsCode();
                                 lastReportsToOrganizationCode = tempOrg.getReportsToOrganizationCode();
 
                                 if ((tempOrg.getReportsToChartOfAccountsCode().equals(newOrg.getChartOfAccountsCode())) && (tempOrg.getReportsToOrganizationCode().equals(newOrg.getOrganizationCode()))) {
                                     putFieldError("reportsToOrganizationCode", OLEKeyConstants.ERROR_DOCUMENT_ORGMAINT_REPORTING_ORG_CANNOT_BE_CIRCULAR_REF_TO_SAME_ORG);
                                     success = false;
                                     continueSearch = false;
                                 }
                             }
                         }
                         if (loopCount > maxLoopCount) {
                             continueSearch = false;
                         }
                         // stop the search if we reach an org that must report to itself
                         if (continueSearch && /*REFACTORME*/SpringContext.getBean(ParameterEvaluatorService.class).getParameterEvaluator(Organization.class, OLEConstants.ChartApcParms.ORG_MUST_REPORT_TO_SELF_ORG_TYPES, tempOrg.getOrganizationTypeCode()).evaluationSucceeds()) {
                             continueSearch = false;
                         }
 
                     } while (continueSearch == true);
                 } // end else (checking for circular ref)
             }
             else { // org must report to self (university level organization)
                 if (!(newOrg.getReportsToChartOfAccountsCode().equals(newOrg.getChartOfAccountsCode()) && newOrg.getReportsToOrganizationCode().equals(newOrg.getOrganizationCode()))) {
                     putFieldError("reportsToOrganizationCode", OLEKeyConstants.ERROR_DOCUMENT_ORGMAINT_REPORTING_ORG_MUST_BE_SAME_ORG);
                     success = false;
                 }
                 // org must be the only one of that type
                 String topLevelOrgTypeCode = SpringContext.getBean(ParameterService.class).getParameterValueAsString(Organization.class, OLEConstants.ChartApcParms.ORG_MUST_REPORT_TO_SELF_ORG_TYPES);
                 List<Organization> topLevelOrgs = orgService.getActiveOrgsByType(topLevelOrgTypeCode);
                 if (!topLevelOrgs.isEmpty()) {
                     // is the new org in the topLevelOrgs list? If not, then there's an error; if so, we're editing the top level
                     // org
                     if (!topLevelOrgs.contains(newOrg)) {
                         putFieldError("organizationTypeCode", OLEKeyConstants.ERROR_DOCUMENT_ORGMAINT_ONLY_ONE_TOP_LEVEL_ORG, topLevelOrgs.get(0).getChartOfAccountsCode() + "-" + topLevelOrgs.get(0).getOrganizationCode());
                         success = false;
                     }
                 }
             }
         }
 
 
         return success;
     }
 
 
     /**
      * This checks that defaultAccount is present unless ( (orgType = U or C) and ( document is a "create new" or "edit" ))
      *
      * @param document
      * @return false if missing default account number and it is not an exempt type code
      */
     protected boolean checkDefaultAccountNumber(MaintenanceDocument document) {
 
         boolean success = true;
         boolean exemptOrganizationTypeCode = false;
         boolean missingDefaultAccountNumber = StringUtils.isBlank(newOrg.getOrganizationDefaultAccountNumber());
 
         if (ObjectUtils.isNotNull(newOrg.getOrganizationTypeCode())) {
             String organizationTypeCode = newOrg.getOrganizationTypeCode();
             if (/*REFACTORME*/SpringContext.getBean(ParameterEvaluatorService.class).getParameterEvaluator(Organization.class, OLEConstants.ChartApcParms.DEFAULT_ACCOUNT_NOT_REQUIRED_ORG_TYPES, newOrg.getOrganizationTypeCode()).evaluationSucceeds()) {
                 exemptOrganizationTypeCode = true;
             }
         }
 
         if (missingDefaultAccountNumber && (!exemptOrganizationTypeCode || (!document.isNew() && !document.isEdit()))) {
             putFieldError("organizationDefaultAccountNumber", OLEKeyConstants.ERROR_DOCUMENT_ORGMAINT_DEFAULT_ACCOUNT_NUMBER_REQUIRED);
             success &= false;
         }
 
         return success;
     }
 
     /**
      * This method compares an old and new value, and determines if they've changed. If the old was null/blank, and the new is not,
      * return true. If the old had a value, and the new is null/blank, return true. If both old and new had a value, and the values
      * are different (excluding trailing or leading whitespaces, and excluding case changes), return true. If none of the above,
      * return false.
      *
      * @param oldValue - Old value to test.
      * @param newValue - New value to test.
      * @return true or false, based on the algorithm described above.
      */
     protected boolean fieldsHaveChanged(String oldValue, String newValue) {
 
         // if old was null/blank and new is not
         if (StringUtils.isBlank(oldValue) && StringUtils.isNotBlank(newValue)) {
             return true;
         }
 
         // if old had a value, but new is null/blank
         if (StringUtils.isNotBlank(oldValue) && StringUtils.isBlank(newValue)) {
             return true;
         }
 
         // at this point, we know that we had a value before, and we have a
         // value now, so we need to test whether this value has changed
         if (oldValue != null && newValue != null) {
             if (!oldValue.trim().equalsIgnoreCase(newValue.trim())) {
                 return true;
             }
         }
 
         // if we've made it to here, then no changes have happened to the values
         return false;
     }
 
     /**
      * This method looks up in the ParameterService whether ther HRMS Org system is turned on.
      *
      * @return true or false depending on the app configuration
      */
     protected boolean isHrmsOrgActivated() {
         return SpringContext.getBean(ParameterService.class).getParameterValueAsBoolean(Organization.class, OLEConstants.ChartApcParms.APC_HRMS_ACTIVE_KEY);
     }
 
     /**
      * This method sets the convenience objects like newOrg and oldOrg, so you have short and easy handles to the new and old
      * objects contained in the maintenance document. It also calls the BusinessObjectBase.refresh(), which will attempt to load all
      * sub-objects from the DB by their primary keys, if available.
      *
      * @param document - the maintenanceDocument being evaluated
      */
     @Override
     public void setupConvenienceObjects() {
 
         // setup oldAccount convenience objects, make sure all possible sub-objects are populated
         oldOrg = (Organization) super.getOldBo();
 
         // setup newAccount convenience objects, make sure all possible sub-objects are populated
         newOrg = (Organization) super.getNewBo();
     }
 
     /**
      * This method tests whether the specified user is part of the group that grants authorization to the Plant fields.
      *
      * @param user - the user to test
      * @return true if user is part of the group, false otherwise
      */
     protected boolean isPlantAuthorized(Person user) {
         String principalId = user.getPrincipalId();
         String namespaceCode = OLEConstants.ParameterNamespaces.KNS;
         String permissionTemplateName = KimConstants.PermissionTemplateNames.MODIFY_FIELD;
 
         Map<String,String> roleQualifiers = new HashMap<String,String>();
         roleQualifiers.put(OleKimAttributes.CHART_OF_ACCOUNTS_CODE, newOrg.getChartOfAccountsCode());
 
         Map<String,String> permissionDetails = new HashMap<String,String>();
         permissionDetails.put(KimConstants.AttributeConstants.COMPONENT_NAME, Organization.class.getSimpleName());
         permissionDetails.put(KimConstants.AttributeConstants.PROPERTY_NAME, OLEPropertyConstants.ORGANIZATION_PLANT_CHART_CODE);
 
         IdentityManagementService identityManagementService = SpringContext.getBean(IdentityManagementService.class);
         Boolean isAuthorized = identityManagementService.isAuthorizedByTemplateName(principalId, namespaceCode, permissionTemplateName, permissionDetails, roleQualifiers);
         if (!isAuthorized) {
             if(LOG.isDebugEnabled()) {
                 LOG.debug("User '" + user.getPrincipalName() + "' has no access to the Plant Chart.");
             }
             return false;
         }
 
         permissionDetails.put(KimConstants.AttributeConstants.PROPERTY_NAME, OLEPropertyConstants.ORGANIZATION_PLANT_ACCOUNT_NUMBER);
         isAuthorized = identityManagementService.isAuthorizedByTemplateName(principalId, namespaceCode, permissionTemplateName, permissionDetails, roleQualifiers);
         if (!isAuthorized) {
             if(LOG.isDebugEnabled()) {
                 LOG.debug("User '" + user.getPrincipalName() + "' has no access to the Plant account.");
             }
             return false;
         }
 
         if(LOG.isDebugEnabled()) {
             LOG.debug("User '" + user.getPrincipalName() + "' has access to the Plant fields.");
         }
         return true;
     }
 }