Coverage Report

Coverage Report - org.kuali.rice.kew.rule.web.WebRuleResponsibility

Classes in this File

Line Coverage

Branch Coverage

Complexity

WebRuleResponsibility

0/220

0/72

WebRuleResponsibility$DelegationRulesProxy

0/13

0/8

 /*
  * Copyright 2005-2008 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.kew.rule.web;
 
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
 import java.util.Iterator;
 import java.util.List;
 
 import org.apache.commons.beanutils.PropertyUtils;
 import org.apache.commons.lang.ClassUtils;
 import org.apache.struts.action.ActionErrors;
 import org.apache.struts.action.ActionMessage;
 import org.kuali.rice.kew.rule.RuleBaseValues;
 import org.kuali.rice.kew.rule.RuleDelegation;
 import org.kuali.rice.kew.rule.RuleExtension;
 import org.kuali.rice.kew.rule.RuleExtensionValue;
 import org.kuali.rice.kew.rule.RuleResponsibility;
 import org.kuali.rice.kew.rule.service.RuleService;
 import org.kuali.rice.kew.service.KEWServiceLocator;
 import org.kuali.rice.kew.util.KEWConstants;
 import org.kuali.rice.kew.util.Utilities;
 import org.kuali.rice.kim.bo.Group;
 import org.kuali.rice.kim.bo.entity.KimPrincipal;
 import org.kuali.rice.kim.service.KIMServiceLocator;
 import org.kuali.rice.kns.util.KNSConstants;
 
 
 /**
  * A decorator around a {@link RuleResponsibility} object which provides some
  * convienance functions for interacting with the bean from the web-tier.
  * This helps to alleviate some of the weaknesses of JSTL.
  *
  * @author Kuali Rice Team (rice.collab@kuali.org)
  */
 public class WebRuleResponsibility extends RuleResponsibility {
 
         private static final long serialVersionUID = -8422695726158274189L;
 
         private static final String DISPLAY_INLINE = "display:inline";
 
         private static final String DISPLAY_NONE = "display:none";
 
         private String reviewer;
 
         private String reviewerStyle = "";
 
         private String personLookupStyle = "";
 
         private String workgroupLookupStyle = "";
 
         private String roleReviewer;
 
         private String roleAreaStyle = "";
 
         private boolean delegationRulesMaterialized = false;
 
         private boolean showDelegations = false;
 
         private int numberOfDelegations;
 
         private int index = 0;
 
         private boolean hasDelegateRuleTemplate = false;
 
         /**
          * "reviewerId added to support links to workgroup report or user report
          */
 
         private String reviewerId;
 
         public String getReviewerId() {
                 return reviewerId;
         }
 
         public void setReviewerId(String reviewerId) {
                 this.reviewerId = reviewerId;
         }
 
         public WebRuleResponsibility() {
                 setRuleResponsibilityType(KEWConstants.RULE_RESPONSIBILITY_WORKFLOW_ID);
                 setApprovePolicy(KEWConstants.APPROVE_POLICY_FIRST_APPROVE);
         }
 
         public void initialize() throws Exception {
                 if (getDelegationRules().size() <= Integer.parseInt(Utilities.getKNSParameterValue(KEWConstants.KEW_NAMESPACE, KNSConstants.DetailTypes.RULE_DETAIL_TYPE, KEWConstants.RULE_DELEGATE_LIMIT))) {
                         showDelegations = true;
                 }
                 setNumberOfDelegations(getDelegationRules().size());
                 if (delegationRulesMaterialized) {
                         for (Iterator iterator = getDelegationRules().iterator(); iterator.hasNext();) {
                                 RuleDelegation ruleDelegation = (RuleDelegation) iterator.next();
                                 WebRuleBaseValues webRule = (WebRuleBaseValues) ruleDelegation.getDelegationRuleBaseValues();
                                 webRule.initialize();
                         }
                 }
                 establishRequiredState();
         }
 
         private void loadWebValues() throws Exception {
                 if (!Utilities.isEmpty(getRuleResponsibilityName())) {
                         if (KEWConstants.RULE_RESPONSIBILITY_WORKFLOW_ID.equals(getRuleResponsibilityType())) {
                                 // setReviewer(getUserService().getWorkflowUser(new
                                 // WorkflowUserId(getRuleResponsibilityName())).getAuthenticationUserId().getAuthenticationId());
                                 KimPrincipal principal = KEWServiceLocator.getIdentityHelperService().getPrincipal(getRuleResponsibilityName());
                                 setReviewer(principal.getPrincipalName());
                                 setReviewerId(principal.getPrincipalId());
                         } else if (KEWConstants.RULE_RESPONSIBILITY_GROUP_ID.equals(getRuleResponsibilityType())) {
                                 // setReviewer(getWorkgroupService().getWorkgroup(new
                                 // WorkflowGroupId(new
                                 // Long(getRuleResponsibilityName()))).getGroupNameId().getNameId());
                                 Group group = KIMServiceLocator.getIdentityManagementService().
                           getGroup(getRuleResponsibilityName());
                                 setReviewer(group.getGroupName());
                                 setReviewerId(group.getGroupId());
                         } else if (KEWConstants.RULE_RESPONSIBILITY_ROLE_ID.equals(getRuleResponsibilityType())) {
                                 setRoleReviewer(getRuleResponsibilityName());
                                 setReviewer(getResolvedRoleName());
                         }
                 }
         }
 
         private void injectWebMembers() throws Exception {
         DelegationRulesProxy delegationRulesProxy = new DelegationRulesProxy(getDelegationRules());
         Class delegationRulesClass = getDelegationRules().getClass();
         //System.err.println("delegation rules class: "+ delegationRulesClass);
         Class[] delegationRulesInterfaces = new Class[0]; // = delegationRulesClass.getInterfaces();
         List<Class> delegationRulesInterfaceList = (List<Class>) ClassUtils.getAllInterfaces(delegationRulesClass);
         delegationRulesInterfaces = delegationRulesInterfaceList.toArray(delegationRulesInterfaces);
         ClassLoader delegationRulesClassLoader = getDelegationRules().getClass().getClassLoader();
         Object o = Proxy.newProxyInstance(delegationRulesClassLoader, delegationRulesInterfaces, delegationRulesProxy);
         //setDelegationRules((List) o);
 
                 if (Integer.parseInt(Utilities.getKNSParameterValue(KEWConstants.KEW_NAMESPACE, KNSConstants.DetailTypes.RULE_DETAIL_TYPE, KEWConstants.RULE_DELEGATE_LIMIT)) > getDelegationRules().size() || showDelegations) {
                         for (Iterator iterator = getDelegationRules().iterator(); iterator.hasNext();) {
                                 RuleDelegation ruleDelegation = (RuleDelegation) iterator.next();
                                 WebRuleBaseValues webRule = new WebRuleBaseValues();
                                 webRule.load(ruleDelegation.getDelegationRuleBaseValues());
                                 webRule.edit(ruleDelegation.getDelegationRuleBaseValues());
                                 ruleDelegation.setDelegationRuleBaseValues(webRule);
                         }
                 }
         }
 
         public RuleDelegation addNewDelegation() {
                 RuleDelegation ruleDelegation = new RuleDelegation();
                 ruleDelegation.setDelegationRuleBaseValues(new WebRuleBaseValues());
                 ruleDelegation.setDelegationType(KEWConstants.DELEGATION_PRIMARY);
                 ruleDelegation.getDelegationRuleBaseValues().setDelegateRule(Boolean.TRUE);
                 ruleDelegation.getDelegationRuleBaseValues().setDocTypeName(getRuleBaseValues().getDocTypeName());
                 getDelegationRules().add(ruleDelegation);
                 showDelegations = true;
                 return ruleDelegation;
         }
 
         public String getReviewer() {
                 return reviewer;
         }
 
         public void setReviewer(String reviewer) {
                 this.reviewer = reviewer;
         }
 
         public void setWorkgroupId(String workgroupId) {
             Group workgroup = KIMServiceLocator.getIdentityManagementService().getGroup(workgroupId);
                 //Workgroup workgroup = getWorkgroupService().getWorkgroup(new WorkflowGroupId(workgroupId));
                 if (workgroup != null) {
                         setReviewer(workgroup.getGroupName());
                 } else {
                         setReviewer("");
                 }
         }
 
         public String getPersonLookupStyle() {
                 return personLookupStyle;
         }
 
         public void setPersonLookupStyle(String personLookupStyle) {
                 this.personLookupStyle = personLookupStyle;
         }
 
         public String getReviewerStyle() {
                 return reviewerStyle;
         }
 
         public void setReviewerStyle(String reviewerStyle) {
                 this.reviewerStyle = reviewerStyle;
         }
 
         public String getRoleAreaStyle() {
                 return roleAreaStyle;
         }
 
         public void setRoleAreaStyle(String roleAreaLookupStyle) {
                 this.roleAreaStyle = roleAreaLookupStyle;
         }
 
         public String getWorkgroupLookupStyle() {
                 return workgroupLookupStyle;
         }
 
         public void setWorkgroupLookupStyle(String workgroupLookupStyle) {
                 this.workgroupLookupStyle = workgroupLookupStyle;
         }
 
         public RuleDelegation getDelegationRule(int index) {
                 while (getDelegationRules().size() <= index) {
                         addNewDelegation();
                 }
                 return (RuleDelegation) getDelegationRules().get(index);
         }
 
         public int getNumberOfDelegations() {
                 return numberOfDelegations;
         }
 
         public void setNumberOfDelegations(int numberOfDelegations) {
                 this.numberOfDelegations = numberOfDelegations;
         }
 
         public boolean isDelegationRulesMaterialized() {
                 return delegationRulesMaterialized;
         }
 
         public void setDelegationRulesMaterialized(boolean isDelegationRulesMaterialized) {
                 this.delegationRulesMaterialized = isDelegationRulesMaterialized;
         }
 
         public String getRoleReviewer() {
                 return roleReviewer;
         }
 
         public void setRoleReviewer(String roleReviewer) {
                 this.roleReviewer = roleReviewer;
         }
 
         public int getIndex() {
                 return index;
         }
 
         public void setIndex(int index) {
                 this.index = index;
         }
 
         public boolean isShowDelegations() {
                 return showDelegations;
         }
 
         public void setShowDelegations(boolean showDelegations) {
                 this.showDelegations = showDelegations;
         }
 
         public void establishRequiredState() throws Exception {
                 if (KEWConstants.RULE_RESPONSIBILITY_WORKFLOW_ID.equals(getRuleResponsibilityType())) {
                         reviewerStyle = DISPLAY_INLINE;
                         personLookupStyle = DISPLAY_INLINE;
                         workgroupLookupStyle = DISPLAY_NONE;
                         roleAreaStyle = DISPLAY_NONE;
                 }
                 if (KEWConstants.RULE_RESPONSIBILITY_GROUP_ID.equals(getRuleResponsibilityType())) {
                         reviewerStyle = DISPLAY_INLINE;
                         personLookupStyle = DISPLAY_NONE;
                         workgroupLookupStyle = DISPLAY_INLINE;
                         roleAreaStyle = DISPLAY_NONE;
                 }
                 if (KEWConstants.RULE_RESPONSIBILITY_ROLE_ID.equals(getRuleResponsibilityType())) {
                         reviewerStyle = DISPLAY_NONE;
                         personLookupStyle = DISPLAY_NONE;
                         workgroupLookupStyle = DISPLAY_NONE;
                         roleAreaStyle = DISPLAY_INLINE;
                 }
                 loadWebValues();
                 if (delegationRulesMaterialized) {
                         for (Iterator iterator = getDelegationRules().iterator(); iterator.hasNext();) {
                                 RuleDelegation delegation = (RuleDelegation) iterator.next();
                                 ((WebRuleBaseValues) delegation.getDelegationRuleBaseValues()).establishRequiredState();
                         }
                 }
         }
 
         public void validateResponsibility(String keyPrefix, ActionErrors errors) {
                 if (KEWConstants.RULE_RESPONSIBILITY_WORKFLOW_ID.equals(getRuleResponsibilityType())) {
                         boolean invalidUser = Utilities.isEmpty(getReviewer());
                         if (!invalidUser)
                         {
                                 //chb: 10Jan2009: not using KEW IdentityHelperService b/c we want to deal w/ exception here
                                 KimPrincipal principal = KIMServiceLocator.getIdentityManagementService().getPrincipalByPrincipalName(getReviewer());
                                 if( principal != null)
                                 {
                                         setRuleResponsibilityName(principal.getPrincipalId());
                                 }
                                 else
                                 {
                                         invalidUser = true;
                                 }
                         }
                         if (invalidUser) {
                                 errors.add(keyPrefix + "reviewer", new ActionMessage("routetemplate.ruleservice.user.invalid"));
                         }
                 } else if (KEWConstants.RULE_RESPONSIBILITY_GROUP_ID.equals(getRuleResponsibilityType())) {
                         boolean invalidWorkgroup = Utilities.isEmpty(getReviewer());
                         ;
                         if (!invalidWorkgroup) {
                             Group workgroup = KIMServiceLocator.getIdentityManagementService().getGroup(getReviewerId());
                                 if (workgroup == null) {
                                         invalidWorkgroup = true;
                                 } else {
                                         setRuleResponsibilityName(workgroup.getGroupId());
                                 }
                         } else {
                                 errors.add(keyPrefix + "reviewer", new ActionMessage("routetemplate.ruleservice.workgroup.invalid"));
                         }
 
                 } else if (KEWConstants.RULE_RESPONSIBILITY_ROLE_ID.equals(getRuleResponsibilityType())) {
                         setRuleResponsibilityName(getRoleReviewer());
                 }
 
                 int delIndex = 0;
                 for (Iterator respIterator = getDelegationRules().iterator(); respIterator.hasNext();) {
                         String delPrefix = keyPrefix + "delegationRule[" + delIndex + "].delegationRuleBaseValues.";
                         RuleDelegation ruleDelegation = (RuleDelegation) respIterator.next();
                         ((WebRuleBaseValues) ruleDelegation.getDelegationRuleBaseValues()).validateRule(delPrefix, errors);
                 }
         }
 
         public void edit(RuleResponsibility ruleResponsibility) throws Exception {
                 load(ruleResponsibility);
                 initialize();
         }
 
         public void load(RuleResponsibility ruleResponsibility) throws Exception {
                 PropertyUtils.copyProperties(this, ruleResponsibility);
                 injectWebMembers();
         }
 
         public void loadDelegations() throws Exception {
                 fetchDelegations();
 
                 for (Iterator iterator = getDelegationRules().iterator(); iterator.hasNext();) {
                         RuleDelegation ruleDelegation = (RuleDelegation) iterator.next();
                         WebRuleBaseValues webRule = new WebRuleBaseValues();
                         webRule.edit(ruleDelegation.getDelegationRuleBaseValues());
                         ruleDelegation.setDelegationRuleBaseValues(webRule);
                 }
                 delegationRulesMaterialized = true;
                 populatePreviousVersionIds();
         }
 
         public void populatePreviousVersionIds() {
                 if (delegationRulesMaterialized) {
                         for (Iterator iterator = getDelegationRules().iterator(); iterator.hasNext();) {
                                 RuleDelegation delegation = (RuleDelegation) iterator.next();
                                 ((WebRuleBaseValues) delegation.getDelegationRuleBaseValues()).populatePreviousVersionIds();
                         }
                 }
         }
 
         private void fetchDelegations() {
                 if (getRuleResponsibilityKey() != null) {
                         RuleResponsibility responsibility = getRuleService().findByRuleResponsibilityId(getRuleResponsibilityKey());
                         if (responsibility == null) {
                                 return;
                         }
                         getDelegationRules().addAll(responsibility.getDelegationRules());
                 }
         }
 
         public void prepareHiddenDelegationsForRoute() {
                 if (showDelegations) {
                         return;
                 }
 
                 fetchDelegations();
 
                 for (Iterator iter = getDelegationRules().iterator(); iter.hasNext();) {
                         RuleDelegation delegation = (RuleDelegation) iter.next();
                         delegation.setDelegateRuleId(null);
                         delegation.setVersionNumber(null);
                         delegation.setRuleDelegationId(null);
                         //delegation.setRuleResponsibility(this);
                         delegation.setResponsibilityId(null);
 
                         RuleBaseValues rule = delegation.getDelegationRuleBaseValues();
                         rule.setVersionNumber(null);
                         rule.setPreviousVersionId(rule.getRuleBaseValuesId());
                         rule.setRouteHeaderId(null);
                         rule.setRuleBaseValuesId(null);
 
                         for (Iterator iterator = rule.getResponsibilities().iterator(); iterator.hasNext();) {
                                 RuleResponsibility responsibility = (RuleResponsibility) iterator.next();
                                 responsibility.setVersionNumber(null);
                                 responsibility.setRuleBaseValuesId(null);
                                 responsibility.setRuleBaseValues(rule);
                                 responsibility.setRuleResponsibilityKey(null);
                         }
 
                         for (Iterator iterator = rule.getRuleExtensions().iterator(); iterator.hasNext();) {
                                 RuleExtension extension = (RuleExtension) iterator.next();
                                 extension.setLockVerNbr(null);
                                 extension.setRuleBaseValues(rule);
                                 extension.setRuleBaseValuesId(null);
                                 extension.setRuleExtensionId(null);
 
                                 for (Iterator iter2 = extension.getExtensionValues().iterator(); iter2.hasNext();) {
                                         RuleExtensionValue value = (RuleExtensionValue) iter2.next();
                                         value.setExtension(extension);
                                         value.setLockVerNbr(null);
                                         value.setRuleExtensionId(null);
                                         value.setRuleExtensionValueId(null);
                                 }
                         }
                 }
         }
 
         public boolean isHasDelegateRuleTemplate() {
                 return hasDelegateRuleTemplate;
         }
 
         public void setHasDelegateRuleTemplate(boolean hasDelegateRuleTemplate) {
                 this.hasDelegateRuleTemplate = hasDelegateRuleTemplate;
         }
 
         private RuleService getRuleService() {
                 return (RuleService) KEWServiceLocator.getService(KEWServiceLocator.RULE_SERVICE);
         }
 
         /**
          * Just a little dynamic proxy to keep us from establishing required state
          * on the delegation rules if they haven't been materialized from the
          * database yet (they are currenty proxied by OJB)
          *
  * @author Kuali Rice Team (rice.collab@kuali.org)
          */
         private class DelegationRulesProxy implements InvocationHandler, java.io.Serializable {
 
                 private static final long serialVersionUID = 7046323200221509473L;
 
                 private List delegationRules;
 
                 public DelegationRulesProxy(List delegationRules) {
                         this.delegationRules = delegationRules;
                 }
 
                 public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {
                         if (!delegationRulesMaterialized && !m.getName().equals("isEmpty") && !m.getName().equals("size")) {
                                 for (Iterator iterator = delegationRules.iterator(); iterator.hasNext();) {
                                         RuleDelegation ruleDelegation = (RuleDelegation) iterator.next();
                                         WebRuleBaseValues webRule = new WebRuleBaseValues();
                                         webRule.load(ruleDelegation.getDelegationRuleBaseValues());
                                         webRule.establishRequiredState();
                                         ruleDelegation.setDelegationRuleBaseValues(webRule);
                                 }
                                 delegationRulesMaterialized = true;
 
                         }
                         return m.invoke(delegationRules, args);
                 }
 
         }
 
 }

1		/*
2		* Copyright 2005-2008 The Kuali Foundation
3		*
4		*
5		* Licensed under the Educational Community License, Version 2.0 (the "License");
6		* you may not use this file except in compliance with the License.
7		* You may obtain a copy of the License at
8		*
9		* http://www.opensource.org/licenses/ecl2.php
10		*
11		* Unless required by applicable law or agreed to in writing, software
12		* distributed under the License is distributed on an "AS IS" BASIS,
13		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14		* See the License for the specific language governing permissions and
15		* limitations under the License.
16		*/
17		package org.kuali.rice.kew.rule.web;
18
19		import java.lang.reflect.InvocationHandler;
20		import java.lang.reflect.Method;
21		import java.lang.reflect.Proxy;
22		import java.util.Iterator;
23		import java.util.List;
24
25		import org.apache.commons.beanutils.PropertyUtils;
26		import org.apache.commons.lang.ClassUtils;
27		import org.apache.struts.action.ActionErrors;
28		import org.apache.struts.action.ActionMessage;
29		import org.kuali.rice.kew.rule.RuleBaseValues;
30		import org.kuali.rice.kew.rule.RuleDelegation;
31		import org.kuali.rice.kew.rule.RuleExtension;
32		import org.kuali.rice.kew.rule.RuleExtensionValue;
33		import org.kuali.rice.kew.rule.RuleResponsibility;
34		import org.kuali.rice.kew.rule.service.RuleService;
35		import org.kuali.rice.kew.service.KEWServiceLocator;
36		import org.kuali.rice.kew.util.KEWConstants;
37		import org.kuali.rice.kew.util.Utilities;
38		import org.kuali.rice.kim.bo.Group;
39		import org.kuali.rice.kim.bo.entity.KimPrincipal;
40		import org.kuali.rice.kim.service.KIMServiceLocator;
41		import org.kuali.rice.kns.util.KNSConstants;
42
43
44		/**
45		* A decorator around a {@link RuleResponsibility} object which provides some
46		* convienance functions for interacting with the bean from the web-tier.
47		* This helps to alleviate some of the weaknesses of JSTL.
48		*
49		* @author Kuali Rice Team (rice.collab@kuali.org)
50		*/
51	0	public class WebRuleResponsibility extends RuleResponsibility {
52
53		private static final long serialVersionUID = -8422695726158274189L;
54
55		private static final String DISPLAY_INLINE = "display:inline";
56
57		private static final String DISPLAY_NONE = "display:none";
58
59		private String reviewer;
60
61	0	private String reviewerStyle = "";
62
63	0	private String personLookupStyle = "";
64
65	0	private String workgroupLookupStyle = "";
66
67		private String roleReviewer;
68
69	0	private String roleAreaStyle = "";
70
71	0	private boolean delegationRulesMaterialized = false;
72
73	0	private boolean showDelegations = false;
74
75		private int numberOfDelegations;
76
77	0	private int index = 0;
78
79	0	private boolean hasDelegateRuleTemplate = false;
80
81		/**
82		* "reviewerId added to support links to workgroup report or user report
83		*/
84
85		private String reviewerId;
86
87		public String getReviewerId() {
88	0	return reviewerId;
89		}
90
91		public void setReviewerId(String reviewerId) {
92	0	this.reviewerId = reviewerId;
93	0	}
94
95	0	public WebRuleResponsibility() {
96	0	setRuleResponsibilityType(KEWConstants.RULE_RESPONSIBILITY_WORKFLOW_ID);
97	0	setApprovePolicy(KEWConstants.APPROVE_POLICY_FIRST_APPROVE);
98	0	}
99
100		public void initialize() throws Exception {
101	0	if (getDelegationRules().size() <= Integer.parseInt(Utilities.getKNSParameterValue(KEWConstants.KEW_NAMESPACE, KNSConstants.DetailTypes.RULE_DETAIL_TYPE, KEWConstants.RULE_DELEGATE_LIMIT))) {
102	0	showDelegations = true;
103		}
104	0	setNumberOfDelegations(getDelegationRules().size());
105	0	if (delegationRulesMaterialized) {
106	0	for (Iterator iterator = getDelegationRules().iterator(); iterator.hasNext();) {
107	0	RuleDelegation ruleDelegation = (RuleDelegation) iterator.next();
108	0	WebRuleBaseValues webRule = (WebRuleBaseValues) ruleDelegation.getDelegationRuleBaseValues();
109	0	webRule.initialize();
110	0	}
111		}
112	0	establishRequiredState();
113	0	}
114
115		private void loadWebValues() throws Exception {
116	0	if (!Utilities.isEmpty(getRuleResponsibilityName())) {
117	0	if (KEWConstants.RULE_RESPONSIBILITY_WORKFLOW_ID.equals(getRuleResponsibilityType())) {
118		// setReviewer(getUserService().getWorkflowUser(new
119		// WorkflowUserId(getRuleResponsibilityName())).getAuthenticationUserId().getAuthenticationId());
120	0	KimPrincipal principal = KEWServiceLocator.getIdentityHelperService().getPrincipal(getRuleResponsibilityName());
121	0	setReviewer(principal.getPrincipalName());
122	0	setReviewerId(principal.getPrincipalId());
123	0	} else if (KEWConstants.RULE_RESPONSIBILITY_GROUP_ID.equals(getRuleResponsibilityType())) {
124		// setReviewer(getWorkgroupService().getWorkgroup(new
125		// WorkflowGroupId(new
126		// Long(getRuleResponsibilityName()))).getGroupNameId().getNameId());
127	0	Group group = KIMServiceLocator.getIdentityManagementService().
128		getGroup(getRuleResponsibilityName());
129	0	setReviewer(group.getGroupName());
130	0	setReviewerId(group.getGroupId());
131	0	} else if (KEWConstants.RULE_RESPONSIBILITY_ROLE_ID.equals(getRuleResponsibilityType())) {
132	0	setRoleReviewer(getRuleResponsibilityName());
133	0	setReviewer(getResolvedRoleName());
134		}
135		}
136	0	}
137
138		private void injectWebMembers() throws Exception {
139	0	DelegationRulesProxy delegationRulesProxy = new DelegationRulesProxy(getDelegationRules());
140	0	Class delegationRulesClass = getDelegationRules().getClass();
141		//System.err.println("delegation rules class: "+ delegationRulesClass);
142	0	Class[] delegationRulesInterfaces = new Class[0]; // = delegationRulesClass.getInterfaces();
143	0	List<Class> delegationRulesInterfaceList = (List<Class>) ClassUtils.getAllInterfaces(delegationRulesClass);
144	0	delegationRulesInterfaces = delegationRulesInterfaceList.toArray(delegationRulesInterfaces);
145	0	ClassLoader delegationRulesClassLoader = getDelegationRules().getClass().getClassLoader();
146	0	Object o = Proxy.newProxyInstance(delegationRulesClassLoader, delegationRulesInterfaces, delegationRulesProxy);
147		//setDelegationRules((List) o);
148
149	0	if (Integer.parseInt(Utilities.getKNSParameterValue(KEWConstants.KEW_NAMESPACE, KNSConstants.DetailTypes.RULE_DETAIL_TYPE, KEWConstants.RULE_DELEGATE_LIMIT)) > getDelegationRules().size() \|\| showDelegations) {
150	0	for (Iterator iterator = getDelegationRules().iterator(); iterator.hasNext();) {
151	0	RuleDelegation ruleDelegation = (RuleDelegation) iterator.next();
152	0	WebRuleBaseValues webRule = new WebRuleBaseValues();
153	0	webRule.load(ruleDelegation.getDelegationRuleBaseValues());
154	0	webRule.edit(ruleDelegation.getDelegationRuleBaseValues());
155	0	ruleDelegation.setDelegationRuleBaseValues(webRule);
156	0	}
157		}
158	0	}
159
160		public RuleDelegation addNewDelegation() {
161	0	RuleDelegation ruleDelegation = new RuleDelegation();
162	0	ruleDelegation.setDelegationRuleBaseValues(new WebRuleBaseValues());
163	0	ruleDelegation.setDelegationType(KEWConstants.DELEGATION_PRIMARY);
164	0	ruleDelegation.getDelegationRuleBaseValues().setDelegateRule(Boolean.TRUE);
165	0	ruleDelegation.getDelegationRuleBaseValues().setDocTypeName(getRuleBaseValues().getDocTypeName());
166	0	getDelegationRules().add(ruleDelegation);
167	0	showDelegations = true;
168	0	return ruleDelegation;
169		}
170
171		public String getReviewer() {
172	0	return reviewer;
173		}
174
175		public void setReviewer(String reviewer) {
176	0	this.reviewer = reviewer;
177	0	}
178
179		public void setWorkgroupId(String workgroupId) {
180	0	Group workgroup = KIMServiceLocator.getIdentityManagementService().getGroup(workgroupId);
181		//Workgroup workgroup = getWorkgroupService().getWorkgroup(new WorkflowGroupId(workgroupId));
182	0	if (workgroup != null) {
183	0	setReviewer(workgroup.getGroupName());
184		} else {
185	0	setReviewer("");
186		}
187	0	}
188
189		public String getPersonLookupStyle() {
190	0	return personLookupStyle;
191		}
192
193		public void setPersonLookupStyle(String personLookupStyle) {
194	0	this.personLookupStyle = personLookupStyle;
195	0	}
196
197		public String getReviewerStyle() {
198	0	return reviewerStyle;
199		}
200
201		public void setReviewerStyle(String reviewerStyle) {
202	0	this.reviewerStyle = reviewerStyle;
203	0	}
204
205		public String getRoleAreaStyle() {
206	0	return roleAreaStyle;
207		}
208
209		public void setRoleAreaStyle(String roleAreaLookupStyle) {
210	0	this.roleAreaStyle = roleAreaLookupStyle;
211	0	}
212
213		public String getWorkgroupLookupStyle() {
214	0	return workgroupLookupStyle;
215		}
216
217		public void setWorkgroupLookupStyle(String workgroupLookupStyle) {
218	0	this.workgroupLookupStyle = workgroupLookupStyle;
219	0	}
220
221		public RuleDelegation getDelegationRule(int index) {
222	0	while (getDelegationRules().size() <= index) {
223	0	addNewDelegation();
224		}
225	0	return (RuleDelegation) getDelegationRules().get(index);
226		}
227
228		public int getNumberOfDelegations() {
229	0	return numberOfDelegations;
230		}
231
232		public void setNumberOfDelegations(int numberOfDelegations) {
233	0	this.numberOfDelegations = numberOfDelegations;
234	0	}
235
236		public boolean isDelegationRulesMaterialized() {
237	0	return delegationRulesMaterialized;
238		}
239
240		public void setDelegationRulesMaterialized(boolean isDelegationRulesMaterialized) {
241	0	this.delegationRulesMaterialized = isDelegationRulesMaterialized;
242	0	}
243
244		public String getRoleReviewer() {
245	0	return roleReviewer;
246		}
247
248		public void setRoleReviewer(String roleReviewer) {
249	0	this.roleReviewer = roleReviewer;
250	0	}
251
252		public int getIndex() {
253	0	return index;
254		}
255
256		public void setIndex(int index) {
257	0	this.index = index;
258	0	}
259
260		public boolean isShowDelegations() {
261	0	return showDelegations;
262		}
263
264		public void setShowDelegations(boolean showDelegations) {
265	0	this.showDelegations = showDelegations;
266	0	}
267
268		public void establishRequiredState() throws Exception {
269	0	if (KEWConstants.RULE_RESPONSIBILITY_WORKFLOW_ID.equals(getRuleResponsibilityType())) {
270	0	reviewerStyle = DISPLAY_INLINE;
271	0	personLookupStyle = DISPLAY_INLINE;
272	0	workgroupLookupStyle = DISPLAY_NONE;
273	0	roleAreaStyle = DISPLAY_NONE;
274		}
275	0	if (KEWConstants.RULE_RESPONSIBILITY_GROUP_ID.equals(getRuleResponsibilityType())) {
276	0	reviewerStyle = DISPLAY_INLINE;
277	0	personLookupStyle = DISPLAY_NONE;
278	0	workgroupLookupStyle = DISPLAY_INLINE;
279	0	roleAreaStyle = DISPLAY_NONE;
280		}
281	0	if (KEWConstants.RULE_RESPONSIBILITY_ROLE_ID.equals(getRuleResponsibilityType())) {
282	0	reviewerStyle = DISPLAY_NONE;
283	0	personLookupStyle = DISPLAY_NONE;
284	0	workgroupLookupStyle = DISPLAY_NONE;
285	0	roleAreaStyle = DISPLAY_INLINE;
286		}
287	0	loadWebValues();
288	0	if (delegationRulesMaterialized) {
289	0	for (Iterator iterator = getDelegationRules().iterator(); iterator.hasNext();) {
290	0	RuleDelegation delegation = (RuleDelegation) iterator.next();
291	0	((WebRuleBaseValues) delegation.getDelegationRuleBaseValues()).establishRequiredState();
292	0	}
293		}
294	0	}
295
296		public void validateResponsibility(String keyPrefix, ActionErrors errors) {
297	0	if (KEWConstants.RULE_RESPONSIBILITY_WORKFLOW_ID.equals(getRuleResponsibilityType())) {
298	0	boolean invalidUser = Utilities.isEmpty(getReviewer());
299	0	if (!invalidUser)
300		{
301		//chb: 10Jan2009: not using KEW IdentityHelperService b/c we want to deal w/ exception here
302	0	KimPrincipal principal = KIMServiceLocator.getIdentityManagementService().getPrincipalByPrincipalName(getReviewer());
303	0	if( principal != null)
304		{
305	0	setRuleResponsibilityName(principal.getPrincipalId());
306		}
307		else
308		{
309	0	invalidUser = true;
310		}
311		}
312	0	if (invalidUser) {
313	0	errors.add(keyPrefix + "reviewer", new ActionMessage("routetemplate.ruleservice.user.invalid"));
314		}
315	0	} else if (KEWConstants.RULE_RESPONSIBILITY_GROUP_ID.equals(getRuleResponsibilityType())) {
316	0	boolean invalidWorkgroup = Utilities.isEmpty(getReviewer());
317		;
318	0	if (!invalidWorkgroup) {
319	0	Group workgroup = KIMServiceLocator.getIdentityManagementService().getGroup(getReviewerId());
320	0	if (workgroup == null) {
321	0	invalidWorkgroup = true;
322		} else {
323	0	setRuleResponsibilityName(workgroup.getGroupId());
324		}
325	0	} else {
326	0	errors.add(keyPrefix + "reviewer", new ActionMessage("routetemplate.ruleservice.workgroup.invalid"));
327		}
328
329	0	} else if (KEWConstants.RULE_RESPONSIBILITY_ROLE_ID.equals(getRuleResponsibilityType())) {
330	0	setRuleResponsibilityName(getRoleReviewer());
331		}
332
333	0	int delIndex = 0;
334	0	for (Iterator respIterator = getDelegationRules().iterator(); respIterator.hasNext();) {
335	0	String delPrefix = keyPrefix + "delegationRule[" + delIndex + "].delegationRuleBaseValues.";
336	0	RuleDelegation ruleDelegation = (RuleDelegation) respIterator.next();
337	0	((WebRuleBaseValues) ruleDelegation.getDelegationRuleBaseValues()).validateRule(delPrefix, errors);
338	0	}
339	0	}
340
341		public void edit(RuleResponsibility ruleResponsibility) throws Exception {
342	0	load(ruleResponsibility);
343	0	initialize();
344	0	}
345
346		public void load(RuleResponsibility ruleResponsibility) throws Exception {
347	0	PropertyUtils.copyProperties(this, ruleResponsibility);
348	0	injectWebMembers();
349	0	}
350
351		public void loadDelegations() throws Exception {
352	0	fetchDelegations();
353
354	0	for (Iterator iterator = getDelegationRules().iterator(); iterator.hasNext();) {
355	0	RuleDelegation ruleDelegation = (RuleDelegation) iterator.next();
356	0	WebRuleBaseValues webRule = new WebRuleBaseValues();
357	0	webRule.edit(ruleDelegation.getDelegationRuleBaseValues());
358	0	ruleDelegation.setDelegationRuleBaseValues(webRule);
359	0	}
360	0	delegationRulesMaterialized = true;
361	0	populatePreviousVersionIds();
362	0	}
363
364		public void populatePreviousVersionIds() {
365	0	if (delegationRulesMaterialized) {
366	0	for (Iterator iterator = getDelegationRules().iterator(); iterator.hasNext();) {
367	0	RuleDelegation delegation = (RuleDelegation) iterator.next();
368	0	((WebRuleBaseValues) delegation.getDelegationRuleBaseValues()).populatePreviousVersionIds();
369	0	}
370		}
371	0	}
372
373		private void fetchDelegations() {
374	0	if (getRuleResponsibilityKey() != null) {
375	0	RuleResponsibility responsibility = getRuleService().findByRuleResponsibilityId(getRuleResponsibilityKey());
376	0	if (responsibility == null) {
377	0	return;
378		}
379	0	getDelegationRules().addAll(responsibility.getDelegationRules());
380		}
381	0	}
382
383		public void prepareHiddenDelegationsForRoute() {
384	0	if (showDelegations) {
385	0	return;
386		}
387
388	0	fetchDelegations();
389
390	0	for (Iterator iter = getDelegationRules().iterator(); iter.hasNext();) {
391	0	RuleDelegation delegation = (RuleDelegation) iter.next();
392	0	delegation.setDelegateRuleId(null);
393	0	delegation.setVersionNumber(null);
394	0	delegation.setRuleDelegationId(null);
395		//delegation.setRuleResponsibility(this);
396	0	delegation.setResponsibilityId(null);
397
398	0	RuleBaseValues rule = delegation.getDelegationRuleBaseValues();
399	0	rule.setVersionNumber(null);
400	0	rule.setPreviousVersionId(rule.getRuleBaseValuesId());
401	0	rule.setRouteHeaderId(null);
402	0	rule.setRuleBaseValuesId(null);
403
404	0	for (Iterator iterator = rule.getResponsibilities().iterator(); iterator.hasNext();) {
405	0	RuleResponsibility responsibility = (RuleResponsibility) iterator.next();
406	0	responsibility.setVersionNumber(null);
407	0	responsibility.setRuleBaseValuesId(null);
408	0	responsibility.setRuleBaseValues(rule);
409	0	responsibility.setRuleResponsibilityKey(null);
410	0	}
411
412	0	for (Iterator iterator = rule.getRuleExtensions().iterator(); iterator.hasNext();) {
413	0	RuleExtension extension = (RuleExtension) iterator.next();
414	0	extension.setLockVerNbr(null);
415	0	extension.setRuleBaseValues(rule);
416	0	extension.setRuleBaseValuesId(null);
417	0	extension.setRuleExtensionId(null);
418
419	0	for (Iterator iter2 = extension.getExtensionValues().iterator(); iter2.hasNext();) {
420	0	RuleExtensionValue value = (RuleExtensionValue) iter2.next();
421	0	value.setExtension(extension);
422	0	value.setLockVerNbr(null);
423	0	value.setRuleExtensionId(null);
424	0	value.setRuleExtensionValueId(null);
425	0	}
426	0	}
427	0	}
428	0	}
429
430		public boolean isHasDelegateRuleTemplate() {
431	0	return hasDelegateRuleTemplate;
432		}
433
434		public void setHasDelegateRuleTemplate(boolean hasDelegateRuleTemplate) {
435	0	this.hasDelegateRuleTemplate = hasDelegateRuleTemplate;
436	0	}
437
438		private RuleService getRuleService() {
439	0	return (RuleService) KEWServiceLocator.getService(KEWServiceLocator.RULE_SERVICE);
440		}
441
442		/**
443		* Just a little dynamic proxy to keep us from establishing required state
444		* on the delegation rules if they haven't been materialized from the
445		* database yet (they are currenty proxied by OJB)
446		*
447		* @author Kuali Rice Team (rice.collab@kuali.org)
448		*/
449		private class DelegationRulesProxy implements InvocationHandler, java.io.Serializable {
450
451		private static final long serialVersionUID = 7046323200221509473L;
452
453		private List delegationRules;
454
455	0	public DelegationRulesProxy(List delegationRules) {
456	0	this.delegationRules = delegationRules;
457	0	}
458
459		public Object invoke(Object proxy, Method m, Object[] args) throws Throwable {
460	0	if (!delegationRulesMaterialized && !m.getName().equals("isEmpty") && !m.getName().equals("size")) {
461	0	for (Iterator iterator = delegationRules.iterator(); iterator.hasNext();) {
462	0	RuleDelegation ruleDelegation = (RuleDelegation) iterator.next();
463	0	WebRuleBaseValues webRule = new WebRuleBaseValues();
464	0	webRule.load(ruleDelegation.getDelegationRuleBaseValues());
465	0	webRule.establishRequiredState();
466	0	ruleDelegation.setDelegationRuleBaseValues(webRule);
467	0	}
468	0	delegationRulesMaterialized = true;
469
470		}
471	0	return m.invoke(delegationRules, args);
472		}
473
474		}
475
476		}