001/**
002 * Copyright 2005-2016 The Kuali Foundation
003 *
004 * Licensed under the Educational Community License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.opensource.org/licenses/ecl2.php
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016package org.kuali.rice.kew.document;
017
018import java.util.Collections;
019import java.util.List;
020import java.util.Map;
021
022import org.kuali.rice.core.api.exception.RiceRuntimeException;
023import org.kuali.rice.kew.api.KEWPropertyConstants;
024import org.kuali.rice.kew.rule.RuleBaseValues;
025import org.kuali.rice.kew.rule.RuleResponsibilityBo;
026import org.kuali.rice.kew.rule.bo.RuleTemplateBo;
027import org.kuali.rice.kew.rule.web.WebRuleUtils;
028import org.kuali.rice.kew.service.KEWServiceLocator;
029import org.kuali.rice.kns.maintenance.KualiMaintainableImpl;
030import org.kuali.rice.kns.web.ui.Section;
031import org.kuali.rice.krad.bo.PersistableBusinessObject;
032import org.kuali.rice.kns.document.MaintenanceDocument;
033import org.kuali.rice.krad.maintenance.MaintenanceLock;
034import org.kuali.rice.kns.maintenance.Maintainable;
035
036/**
037 * This class is the maintainable implementation for Routing Rules 
038 * in KEW (represented by the {@link RuleBaseValues} business object). 
039 * 
040 * @author Kuali Rice Team (rice.collab@kuali.org)
041 *
042 */
043public class RoutingRuleMaintainable extends KualiMaintainableImpl {
044
045        private static final long serialVersionUID = -5920808902137192662L;
046    
047        /**
048         * Override the getSections method on this maintainable so that the Section Containing the various Rule Attributes
049         * can be dynamically generated based on the RuleTemplate which is selected.
050         */
051        @Override
052        public List getSections(MaintenanceDocument document, Maintainable oldMaintainable) {
053                List<Section> sections = super.getSections(document, oldMaintainable);
054                return WebRuleUtils.customizeSections(getThisRule(), sections, false);
055                
056        }
057        
058        /**
059         * On creation of a new rule document, we must validate that a rule template and document type are set. 
060         */
061        @Override
062        public void processAfterNew(MaintenanceDocument document,
063                        Map<String, String[]> parameters) {
064                WebRuleUtils.validateRuleTemplateAndDocumentType(getOldRule(document), getNewRule(document), parameters);
065                WebRuleUtils.establishDefaultRuleValues(getNewRule(document));
066                getNewRule(document).setDocumentId(document.getDocumentHeader().getDocumentNumber());
067        }
068        
069        /**
070         * This is a hack to get around the fact that when a document is first created, this value is
071         * true which causes issues if you want to be able to initialize fields on  the document using
072         * request parameters.  See SectionBridge.toSection for the "if" block where it populates
073         * Field.propertyValue to see why this causes problems
074         */
075        @Override
076        public void setGenerateBlankRequiredValues(String docTypeName) {                
077                
078        }
079                        
080    /**
081     * A complete override of the implementation for saving a Rule
082     */
083    @Override
084    public void saveBusinessObject() {
085        WebRuleUtils.clearKeysForSave(getThisRule());
086        WebRuleUtils.translateResponsibilitiesForSave(getThisRule());
087        WebRuleUtils.translateFieldValuesForSave(getThisRule());
088        KEWServiceLocator.getRuleService().makeCurrent(getThisRule(), true);
089    }
090
091    @Override
092    public void processAfterCopy(MaintenanceDocument document, Map<String, String[]> parameters) {
093        WebRuleUtils.processRuleForCopy(document.getDocumentNumber(), getOldRule(document), getNewRule(document));
094        super.processAfterCopy(document, parameters);
095    }
096    
097        @Override
098        public void processAfterEdit(MaintenanceDocument document,
099                        Map<String, String[]> parameters) {
100                if (!getOldRule(document).getCurrentInd()) {
101                        throw new RiceRuntimeException("Cannot edit a non-current version of a rule.");
102                }
103                WebRuleUtils.populateForCopyOrEdit(getOldRule(document), getNewRule(document));
104                
105                getNewRule(document).setPreviousRuleId(getOldRule(document).getId());
106
107                getNewRule(document).setDocumentId(document.getDocumentHeader().getDocumentNumber());
108                super.processAfterEdit(document, parameters);
109        }
110
111        /**
112         * Returns the new RuleBaseValues business object.
113         */
114        protected RuleBaseValues getNewRule(MaintenanceDocument document) {
115                return (RuleBaseValues)document.getNewMaintainableObject().getBusinessObject();
116        }
117        
118        /**
119         * Returns the old RuleBaseValues business object.
120         */
121        protected RuleBaseValues getOldRule(MaintenanceDocument document) {
122                return (RuleBaseValues)document.getOldMaintainableObject().getBusinessObject();
123        }
124        
125        /**
126         * Returns the RuleBaseValues business object associated with this Maintainable.
127         */
128        protected RuleBaseValues getThisRule() {
129                return (RuleBaseValues)getBusinessObject();
130        }
131
132        /**
133         * Overridden implementation of maintenance locks.  The default locking for Routing Rules
134         * is based on previous version (can't route more than one rule based off the same 
135         * previous verison).  However, for the first version of a rule, the previous version id
136         * will be null.
137         * 
138         * So for a new Route Rule maintenance document we don't want any locks generated.
139         * 
140         * TODO can we just let the locking key be the primary key? (ruleBaseValuesId)
141         */
142        @Override
143        public List<MaintenanceLock> generateMaintenanceLocks() {
144                if (getThisRule().getPreviousRuleId() == null) {
145                        return Collections.emptyList();
146                }
147                return super.generateMaintenanceLocks();
148        }
149
150        @Override
151        public String getDocumentTitle(MaintenanceDocument document) {
152                StringBuffer title = new StringBuffer();
153        RuleBaseValues rule = getThisRule();
154        if (rule.getPreviousRuleId() != null) {
155            title.append("Editing Rule '").append(rule.getDescription()).append("'");
156        } else {
157            title.append("Adding Rule '").append(rule.getDescription()).append("'");
158        }
159        return title.toString();
160        }
161
162        /**
163         * This overridden method ...
164         *
165         * @see org.kuali.rice.krad.maintenance.KualiMaintainableImpl#prepareForSave()
166         */
167        @Override
168        public void prepareForSave() {
169                super.prepareForSave();
170                WebRuleUtils.translateResponsibilitiesForSave(getThisRule());
171        }
172
173    /**
174         * @see org.kuali.rice.krad.maintenance.KualiMaintainableImpl#setNewCollectionLineDefaultValues(java.lang.String, org.kuali.rice.krad.bo.PersistableBusinessObject)
175         */
176        @Override
177        protected void setNewCollectionLineDefaultValues(String collectionName,
178                        PersistableBusinessObject addLine) {
179                super.setNewCollectionLineDefaultValues(collectionName, addLine);
180                if (KEWPropertyConstants.RESP_SECTION_NAME_SET.contains(collectionName)) {
181                        RuleTemplateBo ruleTemplate = getThisRule().getRuleTemplate();
182                        if(ruleTemplate.getDefaultActionRequestValue() != null && ruleTemplate.getDefaultActionRequestValue().getValue() != null){
183                                ((RuleResponsibilityBo) addLine).setActionRequestedCd(ruleTemplate.getDefaultActionRequestValue().getValue());
184                }
185                }
186        }
187        
188}