Coverage Report

Coverage Report - org.kuali.rice.kew.rule.dao.impl.RuleDelegationDAOOjbImpl

Classes in this File

0/144

0/98

 /*
  * Copyright 2005-2007 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.dao.impl;
 
 import org.apache.commons.lang.StringUtils;
 import org.apache.ojb.broker.query.Criteria;
 import org.apache.ojb.broker.query.QueryByCriteria;
 import org.apache.ojb.broker.query.QueryFactory;
 import org.apache.ojb.broker.query.ReportQueryByCriteria;
 import org.kuali.rice.core.exception.RiceRuntimeException;
 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.RuleResponsibility;
 import org.kuali.rice.kew.rule.dao.RuleDelegationDAO;
 import org.kuali.rice.kew.util.KEWConstants;
 import org.kuali.rice.kew.util.Utilities;
 import org.kuali.rice.kim.bo.entity.KimPrincipal;
 import org.kuali.rice.kim.service.KIMServiceLocator;
 import org.springmodules.orm.ojb.support.PersistenceBrokerDaoSupport;
 
 import java.util.*;
 
 
 public class RuleDelegationDAOOjbImpl extends PersistenceBrokerDaoSupport implements RuleDelegationDAO {
 
     public List findByDelegateRuleId(Long ruleId) {
         Criteria crit = new Criteria();
         crit.addEqualTo("delegateRuleId", ruleId);
         return (List) this.getPersistenceBrokerTemplate().getCollectionByQuery(new QueryByCriteria(RuleDelegation.class, crit));
     }
 
     public void save(RuleDelegation ruleDelegation) {
             this.getPersistenceBrokerTemplate().store(ruleDelegation);
     }
     public List findAllCurrentRuleDelegations(){
         Criteria crit = new Criteria();
         crit.addEqualTo("delegationRuleBaseValues.currentInd", true);
         return (List) this.getPersistenceBrokerTemplate().getCollectionByQuery(new QueryByCriteria(RuleDelegation.class, crit));
     }
 
     public RuleDelegation findByRuleDelegationId(Long ruleDelegationId){
         Criteria crit = new Criteria();
         crit.addEqualTo("ruleDelegationId", ruleDelegationId);
         return (RuleDelegation) this.getPersistenceBrokerTemplate().getObjectByQuery(new QueryByCriteria(RuleDelegation.class, crit));
 
     }
     public void delete(Long ruleDelegationId){
             this.getPersistenceBrokerTemplate().delete(findByRuleDelegationId(ruleDelegationId));
     }
 
     public List<RuleDelegation> findByResponsibilityIdWithCurrentRule(Long responsibilityId) {
             Criteria crit = new Criteria();
             crit.addEqualTo("responsibilityId", responsibilityId);
             crit.addEqualTo("delegationRuleBaseValues.currentInd", true);
             Collection delegations = getPersistenceBrokerTemplate().getCollectionByQuery(new QueryByCriteria(RuleDelegation.class, crit));
             return new ArrayList<RuleDelegation>(delegations);
     }
 
     /**
      * This overridden method ...
      *
      * @see org.kuali.rice.kew.rule.dao.RuleDelegationDAO#search(java.lang.String, java.lang.Long, java.lang.Long, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.Boolean, java.util.Map, java.lang.String)
      */
     public List<RuleDelegation> search(String parentRuleBaseVaueId, String parentResponsibilityId, String docTypeName, Long ruleId,
             Long ruleTemplateId, String ruleDescription, String workgroupId,
             String principalId, String delegationType, Boolean activeInd,
             Map extensionValues, String workflowIdDirective) {
         Criteria crit = new Criteria(); //getSearchCriteria(docTypeName, ruleTemplateId, ruleDescription, delegationType, activeInd, extensionValues);
 
         if (StringUtils.isNotBlank(delegationType) && !delegationType.equals(KEWConstants.DELEGATION_BOTH)) {
                 crit.addEqualTo("delegationType", delegationType);
         }
         
         if (StringUtils.isNotBlank(parentRuleBaseVaueId) && StringUtils.isNumeric(parentRuleBaseVaueId)) {
             crit.addIn("responsibilityId", this.getRuleResponsibilitySubQuery(new Long(parentRuleBaseVaueId)));
         }
 
         if (StringUtils.isNotBlank(parentResponsibilityId) && StringUtils.isNumeric(parentResponsibilityId)) {
             crit.addEqualTo("responsibilityId", parentResponsibilityId);
         }
 
         crit.addIn("delegateRuleId", getRuleBaseValuesSubQuery(docTypeName, ruleId,
                                                                ruleTemplateId, ruleDescription, workgroupId,
                                                                principalId, activeInd,
                                                                extensionValues, workflowIdDirective));
 
         return (List<RuleDelegation>) this.getPersistenceBrokerTemplate().getCollectionByQuery(new QueryByCriteria(RuleDelegation.class, crit, true));
     }
 
     /**
      * This overridden method ...
      *
      * @see org.kuali.rice.kew.rule.dao.RuleDelegationDAO#search(java.lang.String, java.lang.Long, java.lang.String, java.util.Collection, java.lang.String, java.lang.String, java.lang.Boolean, java.util.Map, java.util.Collection)
      */
     public List<RuleDelegation> search(String parentRuleBaseVaueId, String parentResponsibilityId, String docTypeName, Long ruleTemplateId,
             String ruleDescription, Collection<String> workgroupIds,
             String workflowId, String delegationType, Boolean activeInd,
             Map extensionValues, Collection actionRequestCodes) {
         Criteria crit = new Criteria();
         
         if (StringUtils.isNotBlank(delegationType) && !delegationType.equals(KEWConstants.DELEGATION_BOTH)) {
                 crit.addEqualTo("delegationType", delegationType);
         }
         
         if (StringUtils.isNotBlank(parentRuleBaseVaueId) && StringUtils.isNumeric(parentRuleBaseVaueId)) {
             crit.addIn("responsibilityId", this.getRuleResponsibilitySubQuery(new Long(parentRuleBaseVaueId)));
         }
 
         if (StringUtils.isNotBlank(parentResponsibilityId) && StringUtils.isNumeric(parentResponsibilityId)) {
             crit.addEqualTo("responsibilityId", parentResponsibilityId);
         }
 
         crit.addIn("delegateRuleId", getRuleBaseValuesSubQuery(docTypeName, ruleTemplateId,
                                                                ruleDescription, workgroupIds,
                                                                workflowId, activeInd,
                                                                extensionValues, actionRequestCodes));
        return (List) this.getPersistenceBrokerTemplate().getCollectionByQuery(new QueryByCriteria(RuleDelegation.class, crit, true));
     }
 
     private ReportQueryByCriteria getResponsibilitySubQuery(String ruleResponsibilityName) {
         Criteria responsibilityCrit = new Criteria();
         responsibilityCrit.addLike("ruleResponsibilityName", ruleResponsibilityName);
         ReportQueryByCriteria query = QueryFactory.newReportQuery(RuleResponsibility.class, responsibilityCrit);
         query.setAttributes(new String[] { "ruleBaseValuesId" });
         return query;
     }
 
     private ReportQueryByCriteria getWorkgroupResponsibilitySubQuery(Set<Long> workgroupIds) {
             Set<String> workgroupIdStrings = new HashSet<String>();
             for (Long workgroupId : workgroupIds) {
                 workgroupIdStrings.add(workgroupId.toString());
             }
         Criteria responsibilityCrit = new Criteria();
         responsibilityCrit.addIn("ruleResponsibilityName", workgroupIds);
         responsibilityCrit.addEqualTo("ruleResponsibilityType", KEWConstants.RULE_RESPONSIBILITY_GROUP_ID);
         ReportQueryByCriteria query = QueryFactory.newReportQuery(RuleResponsibility.class, responsibilityCrit);
         query.setAttributes(new String[] { "ruleBaseValuesId" });
         return query;
     }
 
     private ReportQueryByCriteria getRuleBaseValuesSubQuery(String docTypeName, Long ruleTemplateId,
             String ruleDescription, Collection<String> workgroupIds,
             String workflowId, Boolean activeInd,
             Map extensionValues, Collection actionRequestCodes) {
         Criteria crit = getSearchCriteria(docTypeName, ruleTemplateId, ruleDescription, activeInd, extensionValues);
         crit.addIn("responsibilities.ruleBaseValuesId", getResponsibilitySubQuery(workgroupIds, workflowId, actionRequestCodes, (workflowId != null), ((workgroupIds != null) && !workgroupIds.isEmpty())));
         crit.addEqualTo("delegateRule", 1);
         ReportQueryByCriteria query = QueryFactory.newReportQuery(RuleBaseValues.class, crit);
         query.setAttributes(new String[] { "ruleBaseValuesId" });
         return query;
     }
 
     private ReportQueryByCriteria getRuleBaseValuesSubQuery(String docTypeName, Long ruleId,
             Long ruleTemplateId, String ruleDescription, String workgroupId,
             String principalId, Boolean activeInd,
             Map extensionValues, String workflowIdDirective) {
         Criteria crit = getSearchCriteria(docTypeName, ruleTemplateId, ruleDescription, activeInd, extensionValues);
         if (ruleId != null) {
             crit.addEqualTo("ruleBaseValuesId", ruleId);
         }
         if (workgroupId != null) {
             crit.addIn("responsibilities.ruleBaseValuesId", getResponsibilitySubQuery(workgroupId));
         }
         List<String> workgroupIds = new ArrayList<String>();
         Boolean searchUser = Boolean.FALSE;
         Boolean searchUserInWorkgroups = Boolean.FALSE;
         if (workflowIdDirective != null) {/** IU patch EN-1552 */
             if ("group".equals(workflowIdDirective)) {
                 searchUserInWorkgroups = Boolean.TRUE;
             } else if ("".equals(workflowIdDirective)) {
                 searchUser = Boolean.TRUE;
                 searchUserInWorkgroups = Boolean.TRUE;
             } else {
                 searchUser = Boolean.TRUE;
             }
         }
         if (!Utilities.isEmpty(principalId) && searchUserInWorkgroups)
         {
             KimPrincipal principal = KIMServiceLocator.getIdentityManagementService().getPrincipal(principalId);
 
             if (principal == null)
             {
                 throw new RiceRuntimeException("Failed to locate user for the given workflow id: " + principalId);
             }
             workgroupIds = KIMServiceLocator.getIdentityManagementService().getGroupIdsForPrincipal(principalId);
         }
         crit.addIn("responsibilities.ruleBaseValuesId", getResponsibilitySubQuery(workgroupIds, principalId, searchUser, searchUserInWorkgroups));
         crit.addEqualTo("delegateRule", 1);
         ReportQueryByCriteria query = QueryFactory.newReportQuery(RuleBaseValues.class, crit);
         query.setAttributes(new String[] { "ruleBaseValuesId" });
         return query;
         //return (List<RuleDelegation>) this.getPersistenceBrokerTemplate().getCollectionByQuery(new QueryByCriteria(RuleDelegation.class, crit, true));
     }
 
     private ReportQueryByCriteria getRuleResponsibilitySubQuery(Long ruleBaseValuesId) {
         Criteria crit = new Criteria();
         crit.addEqualTo("ruleBaseValuesId", ruleBaseValuesId);
         ReportQueryByCriteria query = QueryFactory.newReportQuery(RuleResponsibility.class, crit);
         query.setAttributes(new String[] { "responsibilityId" });
         return query;
         //return getResponsibilitySubQuery(workgroupIdStrings,workflowId,new ArrayList<String>(), searchUser, searchUserInWorkgroups);
     }
 
     private ReportQueryByCriteria getResponsibilitySubQuery(List<String> workgroupIds, String workflowId, Boolean searchUser, Boolean searchUserInWorkgroups) {
         Collection<String> workgroupIdStrings = new ArrayList<String>();
         for (String workgroupId : workgroupIds) {
             workgroupIdStrings.add(workgroupId);
         }
         return getResponsibilitySubQuery(workgroupIdStrings,workflowId,new ArrayList<String>(), searchUser, searchUserInWorkgroups);
     }
 
     private ReportQueryByCriteria getResponsibilitySubQuery(Collection<String> workgroupIds, String workflowId, Collection actionRequestCodes, Boolean searchUser, Boolean searchUserInWorkgroups) {
         Criteria responsibilityCrit = new Criteria();
         if ( (actionRequestCodes != null) && (!actionRequestCodes.isEmpty()) ) {
             responsibilityCrit.addIn("actionRequestedCd", actionRequestCodes);
         }
 
         Criteria ruleResponsibilityNameCrit = null;
         if (!Utilities.isEmpty(workflowId)) {
             // workflow user id exists
             if (searchUser != null && searchUser) {
                 // searching user wishes to search for rules specific to user
                 ruleResponsibilityNameCrit = new Criteria();
                 ruleResponsibilityNameCrit.addLike("ruleResponsibilityName", workflowId);
                 ruleResponsibilityNameCrit.addEqualTo("ruleResponsibilityType", KEWConstants.RULE_RESPONSIBILITY_WORKFLOW_ID);
             }
             if ( (searchUserInWorkgroups != null && searchUserInWorkgroups) && (workgroupIds != null) && (!workgroupIds.isEmpty()) ) {
                 // at least one workgroup id exists and user wishes to search on workgroups
                 if (ruleResponsibilityNameCrit == null) {
                     ruleResponsibilityNameCrit = new Criteria();
                 }
                 Criteria workgroupCrit = new Criteria();
                 workgroupCrit.addIn("ruleResponsibilityName", workgroupIds);
                 workgroupCrit.addEqualTo("ruleResponsibilityType", KEWConstants.RULE_RESPONSIBILITY_GROUP_ID);
                 ruleResponsibilityNameCrit.addOrCriteria(workgroupCrit);
             }
         } else if ( (workgroupIds != null) && (workgroupIds.size() == 1) ) {
             // no user and one workgroup id
             ruleResponsibilityNameCrit = new Criteria();
             ruleResponsibilityNameCrit.addLike("ruleResponsibilityName", workgroupIds.iterator().next());
             ruleResponsibilityNameCrit.addEqualTo("ruleResponsibilityType", KEWConstants.RULE_RESPONSIBILITY_GROUP_ID);
         } else if ( (workgroupIds != null) && (workgroupIds.size() > 1) ) {
             // no user and more than one workgroup id
             ruleResponsibilityNameCrit = new Criteria();
             ruleResponsibilityNameCrit.addIn("ruleResponsibilityName", workgroupIds);
             ruleResponsibilityNameCrit.addEqualTo("ruleResponsibilityType", KEWConstants.RULE_RESPONSIBILITY_GROUP_ID);
         }
         if (ruleResponsibilityNameCrit != null) {
             responsibilityCrit.addAndCriteria(ruleResponsibilityNameCrit);
         }
 
         ReportQueryByCriteria query = QueryFactory.newReportQuery(RuleResponsibility.class, responsibilityCrit);
         query.setAttributes(new String[] { "ruleBaseValuesId" });
         return query;
     }
 
 
     private Criteria getSearchCriteria(String docTypeName, Long ruleTemplateId, String ruleDescription, Boolean activeInd, Map extensionValues) {
         Criteria crit = new Criteria();
         crit.addEqualTo("currentInd", Boolean.TRUE);
         crit.addEqualTo("templateRuleInd", Boolean.FALSE);
         if (activeInd != null) {
             crit.addEqualTo("activeInd", activeInd);
         }
         if (docTypeName != null) {
             crit.addLike("UPPER(docTypeName)", docTypeName.toUpperCase());
         }
         if (ruleDescription != null && !ruleDescription.trim().equals("")) {
             crit.addLike("UPPER(description)", ruleDescription.toUpperCase());
         }
         if (ruleTemplateId != null) {
             crit.addEqualTo("ruleTemplateId", ruleTemplateId);
         }
         if (extensionValues != null && !extensionValues.isEmpty()) {
             for (Iterator iter2 = extensionValues.entrySet().iterator(); iter2.hasNext();) {
                 Map.Entry entry = (Map.Entry) iter2.next();
                 if (!Utilities.isEmpty((String) entry.getValue())) {
                     // Criteria extensionCrit = new Criteria();
                     // extensionCrit.addEqualTo("extensionValues.key",
                     // entry.getKey());
                     // extensionCrit.addLike("extensionValues.value",
                     // "%"+(String) entry.getValue()+"%");
 
                     Criteria extensionCrit2 = new Criteria();
                     extensionCrit2.addEqualTo("extensionValues.key", entry.getKey());
                     extensionCrit2.addLike("UPPER(extensionValues.value)", ("%" + (String) entry.getValue() + "%").toUpperCase());
 
                     // Criteria extensionCrit3 = new Criteria();
                     // extensionCrit3.addEqualTo("extensionValues.key",
                     // entry.getKey());
                     // extensionCrit3.addLike("extensionValues.value",
                     // ("%"+(String) entry.getValue()+"%").toLowerCase());
 
                     // extensionCrit.addOrCriteria(extensionCrit2);
                     // extensionCrit.addOrCriteria(extensionCrit3);
                     ReportQueryByCriteria query = QueryFactory.newReportQuery(RuleExtension.class, extensionCrit2);
                     query.setAttributes(new String[] { "ruleBaseValuesId" });
                     crit.addIn("ruleExtensions.ruleBaseValuesId", query);
                 }
             }
         }
         return crit;
     }
 }

1		/*
2		* Copyright 2005-2007 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.dao.impl;
18
19		import org.apache.commons.lang.StringUtils;
20		import org.apache.ojb.broker.query.Criteria;
21		import org.apache.ojb.broker.query.QueryByCriteria;
22		import org.apache.ojb.broker.query.QueryFactory;
23		import org.apache.ojb.broker.query.ReportQueryByCriteria;
24		import org.kuali.rice.core.exception.RiceRuntimeException;
25		import org.kuali.rice.kew.rule.RuleBaseValues;
26		import org.kuali.rice.kew.rule.RuleDelegation;
27		import org.kuali.rice.kew.rule.RuleExtension;
28		import org.kuali.rice.kew.rule.RuleResponsibility;
29		import org.kuali.rice.kew.rule.dao.RuleDelegationDAO;
30		import org.kuali.rice.kew.util.KEWConstants;
31		import org.kuali.rice.kew.util.Utilities;
32		import org.kuali.rice.kim.bo.entity.KimPrincipal;
33		import org.kuali.rice.kim.service.KIMServiceLocator;
34		import org.springmodules.orm.ojb.support.PersistenceBrokerDaoSupport;
35
36		import java.util.*;
37
38
39	0	public class RuleDelegationDAOOjbImpl extends PersistenceBrokerDaoSupport implements RuleDelegationDAO {
40
41		public List findByDelegateRuleId(Long ruleId) {
42	0	Criteria crit = new Criteria();
43	0	crit.addEqualTo("delegateRuleId", ruleId);
44	0	return (List) this.getPersistenceBrokerTemplate().getCollectionByQuery(new QueryByCriteria(RuleDelegation.class, crit));
45		}
46
47		public void save(RuleDelegation ruleDelegation) {
48	0	this.getPersistenceBrokerTemplate().store(ruleDelegation);
49	0	}
50		public List findAllCurrentRuleDelegations(){
51	0	Criteria crit = new Criteria();
52	0	crit.addEqualTo("delegationRuleBaseValues.currentInd", true);
53	0	return (List) this.getPersistenceBrokerTemplate().getCollectionByQuery(new QueryByCriteria(RuleDelegation.class, crit));
54		}
55
56		public RuleDelegation findByRuleDelegationId(Long ruleDelegationId){
57	0	Criteria crit = new Criteria();
58	0	crit.addEqualTo("ruleDelegationId", ruleDelegationId);
59	0	return (RuleDelegation) this.getPersistenceBrokerTemplate().getObjectByQuery(new QueryByCriteria(RuleDelegation.class, crit));
60
61		}
62		public void delete(Long ruleDelegationId){
63	0	this.getPersistenceBrokerTemplate().delete(findByRuleDelegationId(ruleDelegationId));
64	0	}
65
66		public List<RuleDelegation> findByResponsibilityIdWithCurrentRule(Long responsibilityId) {
67	0	Criteria crit = new Criteria();
68	0	crit.addEqualTo("responsibilityId", responsibilityId);
69	0	crit.addEqualTo("delegationRuleBaseValues.currentInd", true);
70	0	Collection delegations = getPersistenceBrokerTemplate().getCollectionByQuery(new QueryByCriteria(RuleDelegation.class, crit));
71	0	return new ArrayList<RuleDelegation>(delegations);
72		}
73
74		/**
75		* This overridden method ...
76		*
77		* @see org.kuali.rice.kew.rule.dao.RuleDelegationDAO#search(java.lang.String, java.lang.Long, java.lang.Long, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.Boolean, java.util.Map, java.lang.String)
78		*/
79		public List<RuleDelegation> search(String parentRuleBaseVaueId, String parentResponsibilityId, String docTypeName, Long ruleId,
80		Long ruleTemplateId, String ruleDescription, String workgroupId,
81		String principalId, String delegationType, Boolean activeInd,
82		Map extensionValues, String workflowIdDirective) {
83	0	Criteria crit = new Criteria(); //getSearchCriteria(docTypeName, ruleTemplateId, ruleDescription, delegationType, activeInd, extensionValues);
84
85	0	if (StringUtils.isNotBlank(delegationType) && !delegationType.equals(KEWConstants.DELEGATION_BOTH)) {
86	0	crit.addEqualTo("delegationType", delegationType);
87		}
88
89	0	if (StringUtils.isNotBlank(parentRuleBaseVaueId) && StringUtils.isNumeric(parentRuleBaseVaueId)) {
90	0	crit.addIn("responsibilityId", this.getRuleResponsibilitySubQuery(new Long(parentRuleBaseVaueId)));
91		}
92
93	0	if (StringUtils.isNotBlank(parentResponsibilityId) && StringUtils.isNumeric(parentResponsibilityId)) {
94	0	crit.addEqualTo("responsibilityId", parentResponsibilityId);
95		}
96
97	0	crit.addIn("delegateRuleId", getRuleBaseValuesSubQuery(docTypeName, ruleId,
98		ruleTemplateId, ruleDescription, workgroupId,
99		principalId, activeInd,
100		extensionValues, workflowIdDirective));
101
102	0	return (List<RuleDelegation>) this.getPersistenceBrokerTemplate().getCollectionByQuery(new QueryByCriteria(RuleDelegation.class, crit, true));
103		}
104
105		/**
106		* This overridden method ...
107		*
108		* @see org.kuali.rice.kew.rule.dao.RuleDelegationDAO#search(java.lang.String, java.lang.Long, java.lang.String, java.util.Collection, java.lang.String, java.lang.String, java.lang.Boolean, java.util.Map, java.util.Collection)
109		*/
110		public List<RuleDelegation> search(String parentRuleBaseVaueId, String parentResponsibilityId, String docTypeName, Long ruleTemplateId,
111		String ruleDescription, Collection<String> workgroupIds,
112		String workflowId, String delegationType, Boolean activeInd,
113		Map extensionValues, Collection actionRequestCodes) {
114	0	Criteria crit = new Criteria();
115
116	0	if (StringUtils.isNotBlank(delegationType) && !delegationType.equals(KEWConstants.DELEGATION_BOTH)) {
117	0	crit.addEqualTo("delegationType", delegationType);
118		}
119
120	0	if (StringUtils.isNotBlank(parentRuleBaseVaueId) && StringUtils.isNumeric(parentRuleBaseVaueId)) {
121	0	crit.addIn("responsibilityId", this.getRuleResponsibilitySubQuery(new Long(parentRuleBaseVaueId)));
122		}
123
124	0	if (StringUtils.isNotBlank(parentResponsibilityId) && StringUtils.isNumeric(parentResponsibilityId)) {
125	0	crit.addEqualTo("responsibilityId", parentResponsibilityId);
126		}
127
128	0	crit.addIn("delegateRuleId", getRuleBaseValuesSubQuery(docTypeName, ruleTemplateId,
129		ruleDescription, workgroupIds,
130		workflowId, activeInd,
131		extensionValues, actionRequestCodes));
132	0	return (List) this.getPersistenceBrokerTemplate().getCollectionByQuery(new QueryByCriteria(RuleDelegation.class, crit, true));
133		}
134
135		private ReportQueryByCriteria getResponsibilitySubQuery(String ruleResponsibilityName) {
136	0	Criteria responsibilityCrit = new Criteria();
137	0	responsibilityCrit.addLike("ruleResponsibilityName", ruleResponsibilityName);
138	0	ReportQueryByCriteria query = QueryFactory.newReportQuery(RuleResponsibility.class, responsibilityCrit);
139	0	query.setAttributes(new String[] { "ruleBaseValuesId" });
140	0	return query;
141		}
142
143		private ReportQueryByCriteria getWorkgroupResponsibilitySubQuery(Set<Long> workgroupIds) {
144	0	Set<String> workgroupIdStrings = new HashSet<String>();
145	0	for (Long workgroupId : workgroupIds) {
146	0	workgroupIdStrings.add(workgroupId.toString());
147		}
148	0	Criteria responsibilityCrit = new Criteria();
149	0	responsibilityCrit.addIn("ruleResponsibilityName", workgroupIds);
150	0	responsibilityCrit.addEqualTo("ruleResponsibilityType", KEWConstants.RULE_RESPONSIBILITY_GROUP_ID);
151	0	ReportQueryByCriteria query = QueryFactory.newReportQuery(RuleResponsibility.class, responsibilityCrit);
152	0	query.setAttributes(new String[] { "ruleBaseValuesId" });
153	0	return query;
154		}
155
156		private ReportQueryByCriteria getRuleBaseValuesSubQuery(String docTypeName, Long ruleTemplateId,
157		String ruleDescription, Collection<String> workgroupIds,
158		String workflowId, Boolean activeInd,
159		Map extensionValues, Collection actionRequestCodes) {
160	0	Criteria crit = getSearchCriteria(docTypeName, ruleTemplateId, ruleDescription, activeInd, extensionValues);
161	0	crit.addIn("responsibilities.ruleBaseValuesId", getResponsibilitySubQuery(workgroupIds, workflowId, actionRequestCodes, (workflowId != null), ((workgroupIds != null) && !workgroupIds.isEmpty())));
162	0	crit.addEqualTo("delegateRule", 1);
163	0	ReportQueryByCriteria query = QueryFactory.newReportQuery(RuleBaseValues.class, crit);
164	0	query.setAttributes(new String[] { "ruleBaseValuesId" });
165	0	return query;
166		}
167
168		private ReportQueryByCriteria getRuleBaseValuesSubQuery(String docTypeName, Long ruleId,
169		Long ruleTemplateId, String ruleDescription, String workgroupId,
170		String principalId, Boolean activeInd,
171		Map extensionValues, String workflowIdDirective) {
172	0	Criteria crit = getSearchCriteria(docTypeName, ruleTemplateId, ruleDescription, activeInd, extensionValues);
173	0	if (ruleId != null) {
174	0	crit.addEqualTo("ruleBaseValuesId", ruleId);
175		}
176	0	if (workgroupId != null) {
177	0	crit.addIn("responsibilities.ruleBaseValuesId", getResponsibilitySubQuery(workgroupId));
178		}
179	0	List<String> workgroupIds = new ArrayList<String>();
180	0	Boolean searchUser = Boolean.FALSE;
181	0	Boolean searchUserInWorkgroups = Boolean.FALSE;
182	0	if (workflowIdDirective != null) {/** IU patch EN-1552 */
183	0	if ("group".equals(workflowIdDirective)) {
184	0	searchUserInWorkgroups = Boolean.TRUE;
185	0	} else if ("".equals(workflowIdDirective)) {
186	0	searchUser = Boolean.TRUE;
187	0	searchUserInWorkgroups = Boolean.TRUE;
188		} else {
189	0	searchUser = Boolean.TRUE;
190		}
191		}
192	0	if (!Utilities.isEmpty(principalId) && searchUserInWorkgroups)
193		{
194	0	KimPrincipal principal = KIMServiceLocator.getIdentityManagementService().getPrincipal(principalId);
195
196	0	if (principal == null)
197		{
198	0	throw new RiceRuntimeException("Failed to locate user for the given workflow id: " + principalId);
199		}
200	0	workgroupIds = KIMServiceLocator.getIdentityManagementService().getGroupIdsForPrincipal(principalId);
201		}
202	0	crit.addIn("responsibilities.ruleBaseValuesId", getResponsibilitySubQuery(workgroupIds, principalId, searchUser, searchUserInWorkgroups));
203	0	crit.addEqualTo("delegateRule", 1);
204	0	ReportQueryByCriteria query = QueryFactory.newReportQuery(RuleBaseValues.class, crit);
205	0	query.setAttributes(new String[] { "ruleBaseValuesId" });
206	0	return query;
207		//return (List<RuleDelegation>) this.getPersistenceBrokerTemplate().getCollectionByQuery(new QueryByCriteria(RuleDelegation.class, crit, true));
208		}
209
210		private ReportQueryByCriteria getRuleResponsibilitySubQuery(Long ruleBaseValuesId) {
211	0	Criteria crit = new Criteria();
212	0	crit.addEqualTo("ruleBaseValuesId", ruleBaseValuesId);
213	0	ReportQueryByCriteria query = QueryFactory.newReportQuery(RuleResponsibility.class, crit);
214	0	query.setAttributes(new String[] { "responsibilityId" });
215	0	return query;
216		//return getResponsibilitySubQuery(workgroupIdStrings,workflowId,new ArrayList<String>(), searchUser, searchUserInWorkgroups);
217		}
218
219		private ReportQueryByCriteria getResponsibilitySubQuery(List<String> workgroupIds, String workflowId, Boolean searchUser, Boolean searchUserInWorkgroups) {
220	0	Collection<String> workgroupIdStrings = new ArrayList<String>();
221	0	for (String workgroupId : workgroupIds) {
222	0	workgroupIdStrings.add(workgroupId);
223		}
224	0	return getResponsibilitySubQuery(workgroupIdStrings,workflowId,new ArrayList<String>(), searchUser, searchUserInWorkgroups);
225		}
226
227		private ReportQueryByCriteria getResponsibilitySubQuery(Collection<String> workgroupIds, String workflowId, Collection actionRequestCodes, Boolean searchUser, Boolean searchUserInWorkgroups) {
228	0	Criteria responsibilityCrit = new Criteria();
229	0	if ( (actionRequestCodes != null) && (!actionRequestCodes.isEmpty()) ) {
230	0	responsibilityCrit.addIn("actionRequestedCd", actionRequestCodes);
231		}
232
233	0	Criteria ruleResponsibilityNameCrit = null;
234	0	if (!Utilities.isEmpty(workflowId)) {
235		// workflow user id exists
236	0	if (searchUser != null && searchUser) {
237		// searching user wishes to search for rules specific to user
238	0	ruleResponsibilityNameCrit = new Criteria();
239	0	ruleResponsibilityNameCrit.addLike("ruleResponsibilityName", workflowId);
240	0	ruleResponsibilityNameCrit.addEqualTo("ruleResponsibilityType", KEWConstants.RULE_RESPONSIBILITY_WORKFLOW_ID);
241		}
242	0	if ( (searchUserInWorkgroups != null && searchUserInWorkgroups) && (workgroupIds != null) && (!workgroupIds.isEmpty()) ) {
243		// at least one workgroup id exists and user wishes to search on workgroups
244	0	if (ruleResponsibilityNameCrit == null) {
245	0	ruleResponsibilityNameCrit = new Criteria();
246		}
247	0	Criteria workgroupCrit = new Criteria();
248	0	workgroupCrit.addIn("ruleResponsibilityName", workgroupIds);
249	0	workgroupCrit.addEqualTo("ruleResponsibilityType", KEWConstants.RULE_RESPONSIBILITY_GROUP_ID);
250	0	ruleResponsibilityNameCrit.addOrCriteria(workgroupCrit);
251	0	}
252	0	} else if ( (workgroupIds != null) && (workgroupIds.size() == 1) ) {
253		// no user and one workgroup id
254	0	ruleResponsibilityNameCrit = new Criteria();
255	0	ruleResponsibilityNameCrit.addLike("ruleResponsibilityName", workgroupIds.iterator().next());
256	0	ruleResponsibilityNameCrit.addEqualTo("ruleResponsibilityType", KEWConstants.RULE_RESPONSIBILITY_GROUP_ID);
257	0	} else if ( (workgroupIds != null) && (workgroupIds.size() > 1) ) {
258		// no user and more than one workgroup id
259	0	ruleResponsibilityNameCrit = new Criteria();
260	0	ruleResponsibilityNameCrit.addIn("ruleResponsibilityName", workgroupIds);
261	0	ruleResponsibilityNameCrit.addEqualTo("ruleResponsibilityType", KEWConstants.RULE_RESPONSIBILITY_GROUP_ID);
262		}
263	0	if (ruleResponsibilityNameCrit != null) {
264	0	responsibilityCrit.addAndCriteria(ruleResponsibilityNameCrit);
265		}
266
267	0	ReportQueryByCriteria query = QueryFactory.newReportQuery(RuleResponsibility.class, responsibilityCrit);
268	0	query.setAttributes(new String[] { "ruleBaseValuesId" });
269	0	return query;
270		}
271
272
273		private Criteria getSearchCriteria(String docTypeName, Long ruleTemplateId, String ruleDescription, Boolean activeInd, Map extensionValues) {
274	0	Criteria crit = new Criteria();
275	0	crit.addEqualTo("currentInd", Boolean.TRUE);
276	0	crit.addEqualTo("templateRuleInd", Boolean.FALSE);
277	0	if (activeInd != null) {
278	0	crit.addEqualTo("activeInd", activeInd);
279		}
280	0	if (docTypeName != null) {
281	0	crit.addLike("UPPER(docTypeName)", docTypeName.toUpperCase());
282		}
283	0	if (ruleDescription != null && !ruleDescription.trim().equals("")) {
284	0	crit.addLike("UPPER(description)", ruleDescription.toUpperCase());
285		}
286	0	if (ruleTemplateId != null) {
287	0	crit.addEqualTo("ruleTemplateId", ruleTemplateId);
288		}
289	0	if (extensionValues != null && !extensionValues.isEmpty()) {
290	0	for (Iterator iter2 = extensionValues.entrySet().iterator(); iter2.hasNext();) {
291	0	Map.Entry entry = (Map.Entry) iter2.next();
292	0	if (!Utilities.isEmpty((String) entry.getValue())) {
293		// Criteria extensionCrit = new Criteria();
294		// extensionCrit.addEqualTo("extensionValues.key",
295		// entry.getKey());
296		// extensionCrit.addLike("extensionValues.value",
297		// "%"+(String) entry.getValue()+"%");
298
299	0	Criteria extensionCrit2 = new Criteria();
300	0	extensionCrit2.addEqualTo("extensionValues.key", entry.getKey());
301	0	extensionCrit2.addLike("UPPER(extensionValues.value)", ("%" + (String) entry.getValue() + "%").toUpperCase());
302
303		// Criteria extensionCrit3 = new Criteria();
304		// extensionCrit3.addEqualTo("extensionValues.key",
305		// entry.getKey());
306		// extensionCrit3.addLike("extensionValues.value",
307		// ("%"+(String) entry.getValue()+"%").toLowerCase());
308
309		// extensionCrit.addOrCriteria(extensionCrit2);
310		// extensionCrit.addOrCriteria(extensionCrit3);
311	0	ReportQueryByCriteria query = QueryFactory.newReportQuery(RuleExtension.class, extensionCrit2);
312	0	query.setAttributes(new String[] { "ruleBaseValuesId" });
313	0	crit.addIn("ruleExtensions.ruleBaseValuesId", query);
314		}
315	0	}
316		}
317	0	return crit;
318		}
319		}