Coverage Report - org.kuali.rice.kew.rule.dao.impl.RuleDAOJpaImpl
 
Classes in this File Line Coverage Branch Coverage Complexity
RuleDAOJpaImpl
0%
0/237
0%
0/120
3.444
 
 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.dao.impl;
 18  
 
 19  
 import org.apache.commons.lang.StringUtils;
 20  
 import org.kuali.rice.core.exception.RiceRuntimeException;
 21  
 import org.kuali.rice.core.jpa.criteria.Criteria;
 22  
 import org.kuali.rice.core.jpa.criteria.QueryByCriteria;
 23  
 import org.kuali.rice.core.util.OrmUtils;
 24  
 import org.kuali.rice.kew.rule.RuleBaseValues;
 25  
 import org.kuali.rice.kew.rule.RuleExtension;
 26  
 import org.kuali.rice.kew.rule.RuleResponsibility;
 27  
 import org.kuali.rice.kew.rule.dao.RuleDAO;
 28  
 import org.kuali.rice.kew.util.KEWConstants;
 29  
 import org.kuali.rice.kew.util.Utilities;
 30  
 import org.kuali.rice.kim.bo.entity.KimPrincipal;
 31  
 import org.kuali.rice.kim.service.KIMServiceLocator;
 32  
 
 33  
 import javax.persistence.EntityManager;
 34  
 import javax.persistence.PersistenceContext;
 35  
 import javax.persistence.Query;
 36  
 import java.sql.Timestamp;
 37  
 import java.util.*;
 38  
 
 39  
 
 40  0
 public class RuleDAOJpaImpl implements RuleDAO {
 41  
 
 42  0
         private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(RuleDAOJpaImpl.class);
 43  
 
 44  
         @PersistenceContext(unitName="kew-unit")
 45  
         private EntityManager entityManager;
 46  
 
 47  
         private static final String OLD_DELEGATIONS_SQL =
 48  
                 "select oldDel.dlgn_rule_id "+
 49  
                 "from krew_rule_rsp_t oldRsp, krew_dlgn_rsp_t oldDel "+
 50  
                 "where oldRsp.rule_id=? and "+
 51  
                 "oldRsp.rule_rsp_id=oldDel.rule_rsp_id and "+
 52  
                 "oldDel.dlgn_rule_base_val_id not in "+
 53  
                 "(select newDel.dlgn_rule_base_val_id from krew_rule_rsp_t newRsp, krew_dlgn_rsp_t newDel "+
 54  
                 "where newRsp.rule_id=? and "+
 55  
                 "newRsp.rule_rsp_id=newDel.rule_rsp_id)";
 56  
 
 57  
         public void save(RuleBaseValues ruleBaseValues) {
 58  0
                 if(ruleBaseValues.getRuleBaseValuesId()==null){
 59  0
                         entityManager.persist(ruleBaseValues);
 60  
                 }else{
 61  0
                         OrmUtils.merge(entityManager, ruleBaseValues);
 62  
                 }
 63  0
         }
 64  
 
 65  
         public List fetchAllCurrentRulesForTemplateDocCombination(Long ruleTemplateId, List documentTypes) {
 66  0
                 Criteria crit = new Criteria(RuleBaseValues.class.getName());
 67  0
                 crit.in("docTypeName", documentTypes);
 68  0
                 crit.eq("ruleTemplateId", ruleTemplateId);
 69  0
                 crit.eq("currentInd", Boolean.TRUE);
 70  0
                 crit.eq("activeInd", Boolean.TRUE);
 71  0
                 crit.eq("delegateRule", Boolean.FALSE);
 72  0
                 crit.eq("templateRuleInd", Boolean.FALSE);
 73  
 
 74  0
                 crit.and(generateFromToDateCriteria(new Date()));
 75  0
                 return (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();
 76  
         }
 77  
 
 78  
         public List fetchAllCurrentRulesForTemplateDocCombination(Long ruleTemplateId, List documentTypes, Timestamp effectiveDate) {
 79  0
                 Criteria crit = new Criteria(RuleBaseValues.class.getName());
 80  0
                 crit.in("docTypeName", documentTypes);
 81  0
                 crit.eq("ruleTemplateId", ruleTemplateId);
 82  0
                 crit.eq("activeInd", Boolean.TRUE);
 83  0
                 crit.eq("delegateRule", Boolean.FALSE);
 84  0
                 crit.eq("templateRuleInd", Boolean.FALSE);
 85  0
                 if (effectiveDate != null) {
 86  0
                         crit.lte("activationDate", effectiveDate);
 87  0
                         crit.gte("deactivationDate", effectiveDate);
 88  
                 }
 89  
 
 90  0
                 crit.and(generateFromToDateCriteria(new Date()));
 91  0
                 return (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();
 92  
         }
 93  
 
 94  
         public Criteria generateFromToDateCriteria(Date date) {
 95  0
                 Criteria crit = new Criteria(RuleBaseValues.class.getName());
 96  
 
 97  0
                 Criteria fromCrit = new Criteria(RuleBaseValues.class.getName());
 98  0
                 Criteria fromNullCrit = new Criteria(RuleBaseValues.class.getName());
 99  0
                 fromNullCrit.isNull("fromDate");
 100  0
                 Criteria fromLessOrEqualCrit = new Criteria(RuleBaseValues.class.getName());
 101  0
                 fromLessOrEqualCrit.lte("fromDate", new Timestamp(date.getTime()));
 102  0
                 fromCrit.or(fromNullCrit);
 103  0
                 fromCrit.or(fromLessOrEqualCrit);
 104  
 
 105  0
                 Criteria toCrit = new Criteria(RuleBaseValues.class.getName());
 106  0
                 Criteria toNullCrit = new Criteria(RuleBaseValues.class.getName());
 107  0
                 toNullCrit.isNull("toDate");
 108  0
                 Criteria toGreaterOrEqualCrit = new Criteria(RuleBaseValues.class.getName());
 109  0
                 toGreaterOrEqualCrit.gte("toDate", new Timestamp(date.getTime()));
 110  0
                 toCrit.or(toNullCrit);
 111  0
                 toCrit.or(toGreaterOrEqualCrit);
 112  
 
 113  0
                 crit.and(fromCrit);
 114  0
                 crit.and(toCrit);
 115  
 
 116  0
                 return crit;
 117  
         }
 118  
 
 119  
         public List fetchAllRules(boolean currentRules) {
 120  0
                 Criteria crit = new Criteria(RuleBaseValues.class.getName());
 121  0
                 crit.eq("currentInd", new Boolean(currentRules));
 122  0
                 crit.eq("templateRuleInd", Boolean.FALSE);
 123  0
                 crit.orderBy("activationDate", false);
 124  
 
 125  0
                 QueryByCriteria query = new QueryByCriteria(entityManager, crit);
 126  
 
 127  0
                 return (List) query.toQuery().getResultList();
 128  
         }
 129  
 
 130  
         public void delete(Long ruleBaseValuesId) {
 131  0
                 entityManager.remove(entityManager.find(RuleBaseValues.class, ruleBaseValuesId));
 132  0
         }
 133  
 
 134  
         public List findByRouteHeaderId(Long routeHeaderId) {
 135  0
                 Criteria crit = new Criteria(RuleBaseValues.class.getName());
 136  0
                 crit.eq("routeHeaderId", routeHeaderId);
 137  0
                 return (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();
 138  
         }
 139  
 
 140  
     public RuleBaseValues findRuleBaseValuesByName(String name) {
 141  0
         Criteria crit = new Criteria(RuleBaseValues.class.getName());
 142  0
         crit.eq("name", name);
 143  0
         crit.eq("currentInd", Boolean.TRUE);
 144  
         try{
 145  0
                 return (RuleBaseValues) new QueryByCriteria(entityManager, crit).toQuery().getSingleResult();
 146  0
         }catch (javax.persistence.NoResultException e){
 147  0
                 return null;
 148  
         }
 149  
 
 150  
     }
 151  
 
 152  
         public RuleBaseValues findRuleBaseValuesById(Long ruleBaseValuesId) {
 153  0
                 Criteria crit = new Criteria(RuleBaseValues.class.getName());
 154  0
                 crit.eq("ruleBaseValuesId", ruleBaseValuesId);
 155  
                 try{
 156  0
                         return (RuleBaseValues) new QueryByCriteria(entityManager, crit).toQuery().getSingleResult();
 157  0
                 }catch(javax.persistence.NoResultException e){
 158  0
                         return null;
 159  
                 }
 160  
         }
 161  
 
 162  
         public List findRuleBaseValuesByResponsibilityReviewer(String reviewerName, String type) {
 163  0
                 Criteria crit = new Criteria(RuleResponsibility.class.getName());
 164  0
                 crit.eq("ruleResponsibilityName", reviewerName);
 165  0
                 crit.eq("ruleResponsibilityType", type);
 166  
 
 167  0
                 List responsibilities = (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();
 168  0
                 List rules = new ArrayList();
 169  
 
 170  0
                 for (Iterator iter = responsibilities.iterator(); iter.hasNext();) {
 171  0
                         RuleResponsibility responsibility = (RuleResponsibility) iter.next();
 172  0
                         RuleBaseValues rule = responsibility.getRuleBaseValues();
 173  0
                         if (rule != null && rule.getCurrentInd() != null && rule.getCurrentInd().booleanValue()) {
 174  0
                                 rules.add(rule);
 175  
                         }
 176  0
                 }
 177  0
                 return rules;
 178  
         }
 179  
 
 180  
         public List findRuleBaseValuesByResponsibilityReviewerTemplateDoc(String ruleTemplateName, String documentType, String reviewerName, String type) {
 181  0
             Criteria crit = new Criteria(RuleResponsibility.class.getName());
 182  0
                 crit.eq("ruleResponsibilityName", reviewerName);
 183  0
                 crit.eq("ruleResponsibilityType", type);
 184  0
                 crit.eq("ruleBaseValues.currentInd", Boolean.TRUE);
 185  0
                 if (!StringUtils.isBlank(ruleTemplateName)) {
 186  0
                     crit.like("ruleBaseValues.ruleTemplate.name", ruleTemplateName.replace("*", "%").concat("%"));
 187  
                 }
 188  0
                 if (!StringUtils.isBlank(documentType)) {
 189  0
                     crit.like("ruleBaseValues.docTypeName", documentType.replace("*", "%").concat("%"));
 190  
                 }
 191  
 
 192  0
                 List responsibilities = (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();
 193  0
                 List rules = new ArrayList();
 194  
 
 195  0
                 for (Iterator iter = responsibilities.iterator(); iter.hasNext();) {
 196  0
                         RuleResponsibility responsibility = (RuleResponsibility) iter.next();
 197  0
                         RuleBaseValues rule = responsibility.getRuleBaseValues();
 198  0
                         if (rule != null && rule.getCurrentInd() != null && rule.getCurrentInd().booleanValue()) {
 199  0
                                 rules.add(rule);
 200  
                         }
 201  0
                 }
 202  0
                 return rules;
 203  
         }
 204  
 
 205  
         //FIXME nothing uses this, it's not in ruleDAO interface
 206  
 //        public List findRuleBaseValuesByObjectGraph(RuleBaseValues ruleBaseValues) {
 207  
 //                ruleBaseValues.setCurrentInd(Boolean.TRUE);
 208  
 //                ruleBaseValues.setTemplateRuleInd(Boolean.FALSE);
 209  
 //                return (List) new QueryByObject(entityManager,ruleBaseValues).toQuery().getResultList();
 210  
 //        }
 211  
 
 212  
         public RuleResponsibility findRuleResponsibility(Long responsibilityId) {
 213  0
                 Criteria crit = new Criteria(RuleResponsibility.class.getName());
 214  0
                 crit.eq("responsibilityId", responsibilityId);
 215  0
                 Collection responsibilities = new QueryByCriteria(entityManager, crit).toQuery().getResultList();
 216  0
                 for (Iterator iterator = responsibilities.iterator(); iterator.hasNext();) {
 217  0
                         RuleResponsibility responsibility = (RuleResponsibility) iterator.next();
 218  0
                         if (responsibility.getRuleBaseValues().getCurrentInd().booleanValue()) {
 219  0
                                 return responsibility;
 220  
                         }
 221  0
                 }
 222  0
                 return null;
 223  
         }
 224  
 
 225  
         public List search(String docTypeName, Long ruleId, Long ruleTemplateId, String ruleDescription, String groupId, String principalId, Boolean delegateRule, Boolean activeInd, Map extensionValues, String workflowIdDirective) {
 226  0
         Criteria crit = getSearchCriteria(docTypeName, ruleTemplateId, ruleDescription, delegateRule, activeInd, extensionValues);
 227  0
         if (ruleId != null) {
 228  0
             crit.eq("ruleBaseValuesId", ruleId);
 229  
         }
 230  0
         if (groupId != null) {
 231  0
             crit.in("responsibilities.ruleBaseValuesId", getResponsibilitySubQuery(groupId), "ruleBaseValuesId");
 232  
         }
 233  0
         Collection<String> kimGroupIds = new HashSet<String>();
 234  0
         Boolean searchUser = Boolean.FALSE;
 235  0
         Boolean searchUserInWorkgroups = Boolean.FALSE;
 236  
         
 237  0
         if ("group".equals(workflowIdDirective)) {
 238  0
             searchUserInWorkgroups = Boolean.TRUE;
 239  0
         } else if (StringUtils.isBlank(workflowIdDirective)) {
 240  0
             searchUser = Boolean.TRUE;
 241  0
             searchUserInWorkgroups = Boolean.TRUE;
 242  
         } else {
 243  0
             searchUser = Boolean.TRUE;
 244  
         }
 245  
         
 246  0
         if (!Utilities.isEmpty(principalId) && searchUserInWorkgroups) {
 247  0
             KimPrincipal principal = null;
 248  
 
 249  0
             principal = KIMServiceLocator.getIdentityManagementService().getPrincipal(principalId);
 250  
 
 251  0
             if (principal == null)
 252  
             {
 253  0
                     throw new RiceRuntimeException("Failed to locate user for the given principal id: " + principalId);
 254  
             }
 255  0
             kimGroupIds = KIMServiceLocator.getIdentityManagementService().getGroupIdsForPrincipal(principalId);
 256  
         }
 257  0
         Criteria responsibilityCrit = getResponsibilitySubQuery(kimGroupIds, principalId, searchUser, searchUserInWorkgroups);
 258  0
         if (responsibilityCrit != null) {
 259  0
                 crit.in("responsibilities.ruleBaseValuesId", responsibilityCrit,"ruleBaseValuesId");
 260  
         }
 261  0
         crit.distinct(true);
 262  0
                 return (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();
 263  
         }
 264  
 
 265  
     public List search(String docTypeName, Long ruleTemplateId, String ruleDescription, Collection<String> workgroupIds, String workflowId, Boolean delegateRule, Boolean activeInd, Map extensionValues, Collection actionRequestCodes) {
 266  0
         Criteria crit = getSearchCriteria(docTypeName, ruleTemplateId, ruleDescription, delegateRule, activeInd, extensionValues);
 267  0
         Criteria responsibilityCrit = getResponsibilitySubQuery(workgroupIds, workflowId, actionRequestCodes, (workflowId != null), ((workgroupIds != null) && !workgroupIds.isEmpty()));
 268  0
         if (responsibilityCrit != null) {
 269  0
                 crit.in("responsibilities.ruleBaseValuesId", responsibilityCrit, "ruleBaseValuesId");
 270  
         }
 271  0
         return (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();
 272  
     }
 273  
 
 274  
     private Criteria getResponsibilitySubQuery(Collection<String> kimGroupIds, String principalId, Boolean searchUser, Boolean searchUserInWorkgroups) {
 275  0
         Collection<String> workgroupIdStrings = new ArrayList<String>();
 276  0
         for (String workgroupId : kimGroupIds) {
 277  0
             workgroupIdStrings.add(workgroupId.toString());
 278  
         }
 279  0
         return getResponsibilitySubQuery(workgroupIdStrings,principalId,new ArrayList<String>(), searchUser, searchUserInWorkgroups);
 280  
     }
 281  
     private Criteria getResponsibilitySubQuery(Collection<String> workgroupIds, String workflowId, Collection actionRequestCodes, Boolean searchUser, Boolean searchUserInWorkgroups) {
 282  0
         Criteria responsibilityCrit = null;
 283  
 
 284  0
         Criteria ruleResponsibilityNameCrit = null;
 285  0
         if (!Utilities.isEmpty(workflowId)) {
 286  
             // workflow user id exists
 287  0
             if (searchUser != null && searchUser) {
 288  
                 // searching user wishes to search for rules specific to user
 289  0
                 ruleResponsibilityNameCrit = new Criteria(RuleResponsibility.class.getName(), "rr");
 290  0
                 ruleResponsibilityNameCrit.like("ruleResponsibilityName", workflowId);
 291  0
                 ruleResponsibilityNameCrit.eq("ruleResponsibilityType", KEWConstants.RULE_RESPONSIBILITY_WORKFLOW_ID);
 292  
             }
 293  0
             if ( (searchUserInWorkgroups != null && searchUserInWorkgroups) && (workgroupIds != null) && (!workgroupIds.isEmpty()) ) {
 294  
                 // at least one workgroup id exists and user wishes to search on workgroups
 295  0
                 if (ruleResponsibilityNameCrit == null) {
 296  0
                     ruleResponsibilityNameCrit = new Criteria(RuleResponsibility.class.getName(), "rr");
 297  
                 }
 298  0
                 Criteria workgroupCrit = new Criteria(RuleResponsibility.class.getName(), "rr");
 299  0
                 workgroupCrit.in("ruleResponsibilityName", new ArrayList<String>(workgroupIds));
 300  0
                 workgroupCrit.eq("ruleResponsibilityType", KEWConstants.RULE_RESPONSIBILITY_GROUP_ID);
 301  0
                 ruleResponsibilityNameCrit.or(workgroupCrit);
 302  0
             }
 303  0
         } else if ( (workgroupIds != null) && (workgroupIds.size() == 1) ) {
 304  
             // no user and one workgroup id
 305  0
             ruleResponsibilityNameCrit = new Criteria(RuleResponsibility.class.getName(), "rr");
 306  0
             ruleResponsibilityNameCrit.like("ruleResponsibilityName", workgroupIds.iterator().next());
 307  0
             ruleResponsibilityNameCrit.eq("ruleResponsibilityType", KEWConstants.RULE_RESPONSIBILITY_GROUP_ID);
 308  0
         } else if ( (workgroupIds != null) && (workgroupIds.size() > 1) ) {
 309  
             // no user and more than one workgroup id
 310  0
             ruleResponsibilityNameCrit = new Criteria(RuleResponsibility.class.getName(), "rr");
 311  0
             ruleResponsibilityNameCrit.in("ruleResponsibilityName",  new ArrayList<String>(workgroupIds));
 312  0
             ruleResponsibilityNameCrit.eq("ruleResponsibilityType", KEWConstants.RULE_RESPONSIBILITY_GROUP_ID);
 313  
         }
 314  
 
 315  0
         if (ruleResponsibilityNameCrit != null) {
 316  0
                 responsibilityCrit = new Criteria(RuleResponsibility.class.getName(), "rr");
 317  0
             if ( (actionRequestCodes != null) && (!actionRequestCodes.isEmpty()) ) {
 318  0
                 responsibilityCrit.in("actionRequestedCd", new ArrayList(actionRequestCodes));
 319  
             }
 320  0
             responsibilityCrit.and(ruleResponsibilityNameCrit);
 321  
         }
 322  
 
 323  0
         return responsibilityCrit;
 324  
     }
 325  
 
 326  
     private Criteria getSearchCriteria(String docTypeName, Long ruleTemplateId, String ruleDescription, Boolean delegateRule, Boolean activeInd, Map extensionValues) {
 327  0
         Criteria crit = new Criteria(RuleBaseValues.class.getName());
 328  0
         crit.eq("currentInd", Boolean.TRUE);
 329  0
         crit.eq("templateRuleInd", Boolean.FALSE);
 330  0
         if (activeInd != null) {
 331  0
             crit.eq("activeInd", activeInd);
 332  
         }
 333  0
         if (docTypeName != null) {
 334  0
             crit.like("UPPER(docTypeName)", docTypeName.toUpperCase());
 335  
         }
 336  0
         if (ruleDescription != null && !ruleDescription.trim().equals("")) {
 337  0
             crit.like("UPPER(description)", ruleDescription.toUpperCase());
 338  
         }
 339  0
         if (ruleTemplateId != null) {
 340  0
             crit.eq("ruleTemplateId", ruleTemplateId);
 341  
         }
 342  0
         if (delegateRule != null) {
 343  0
             crit.eq("delegateRule", delegateRule);
 344  
         }
 345  0
         if (extensionValues != null && !extensionValues.isEmpty()) {
 346  0
             for (Iterator iter2 = extensionValues.entrySet().iterator(); iter2.hasNext();) {
 347  0
                 Map.Entry entry = (Map.Entry) iter2.next();
 348  0
                 if (!Utilities.isEmpty((String) entry.getValue())) {
 349  
                     // Criteria extensionCrit = new Criteria();
 350  
                     // extensionCrit.addEqualTo("extensionValues.key",
 351  
                     // entry.getKey());
 352  
                     // extensionCrit.addLike("extensionValues.value",
 353  
                     // "%"+(String) entry.getValue()+"%");
 354  
 
 355  0
                     Criteria extensionCrit2 = new Criteria(RuleExtension.class.getName());
 356  0
                     extensionCrit2.eq("extensionValues.key", entry.getKey());
 357  0
                     extensionCrit2.like("UPPER(extensionValues.value)", ("%" + (String) entry.getValue() + "%").toUpperCase());
 358  
 
 359  
                     // Criteria extensionCrit3 = new Criteria();
 360  
                     // extensionCrit3.addEqualTo("extensionValues.key",
 361  
                     // entry.getKey());
 362  
                     // extensionCrit3.addLike("extensionValues.value",
 363  
                     // ("%"+(String) entry.getValue()+"%").toLowerCase());
 364  
 
 365  
                     // extensionCrit.addOrCriteria(extensionCrit2);
 366  
                     // extensionCrit.addOrCriteria(extensionCrit3);
 367  0
                     crit.in("ruleExtensions.ruleBaseValuesId", extensionCrit2, "ruleBaseValuesId");
 368  
                 }
 369  0
             }
 370  
         }
 371  0
         return crit;
 372  
     }
 373  
 
 374  
 //    private Criteria getWorkgroupOrCriteria(Collection workgroupIds) {
 375  
 //        Criteria responsibilityCrit = new Criteria(RuleResponsibility.class.getName());
 376  
 //        for (Iterator iter = workgroupIds.iterator(); iter.hasNext();) {
 377  
 //            String workgroupIdFromList = (String) iter.next();
 378  
 //            Criteria orCriteria = new Criteria(RuleResponsibility.class.getName());
 379  
 //            orCriteria.like("ruleResponsibilityName", workgroupIdFromList);
 380  
 //            responsibilityCrit.or(orCriteria);
 381  
 //        }
 382  
 //
 383  
 //        Criteria crit = new Criteria();
 384  
 //        crit.in("responsibilities.ruleBaseValuesId", responsibilityCrit,"ruleBaseValuesId");
 385  
 //        return crit;
 386  
 //    }
 387  
 
 388  
         private Criteria getResponsibilitySubQuery(String ruleResponsibilityName) {
 389  0
                 Criteria responsibilityCrit = new Criteria(RuleResponsibility.class.getName());
 390  0
                 responsibilityCrit.like("ruleResponsibilityName", ruleResponsibilityName);
 391  
                 //ReportQueryByCriteria query = QueryFactory.newReportQuery(RuleResponsibility.class, responsibilityCrit);
 392  
                 //query.setAttributes(new String[] { "ruleBaseValuesId" });
 393  0
                 return responsibilityCrit;
 394  
         }
 395  
 
 396  
 //        private Criteria getWorkgroupResponsibilitySubQuery(Set<Long> workgroupIds) {
 397  
 //                    Set<String> workgroupIdStrings = new HashSet<String>();
 398  
 //                    for (Long workgroupId : workgroupIds) {
 399  
 //                        workgroupIdStrings.add(workgroupId.toString());
 400  
 //                    }
 401  
 //                Criteria responsibilityCrit = new Criteria(RuleResponsibility.class.getName());
 402  
 //                responsibilityCrit.in("ruleResponsibilityName", new ArrayList(workgroupIds));
 403  
 //                responsibilityCrit.eq("ruleResponsibilityType", KEWConstants.RULE_RESPONSIBILITY_GROUP_ID);
 404  
 ////                ReportQueryByCriteria query = QueryFactory.newReportQuery(RuleResponsibility.class, responsibilityCrit);
 405  
 ////                query.setAttributes(new String[] { "ruleBaseValuesId" });
 406  
 //                return responsibilityCrit;
 407  
 //        }
 408  
 
 409  
         public List findByPreviousVersionId(Long previousVersionId) {
 410  0
                 Criteria crit = new Criteria(RuleBaseValues.class.getName());
 411  0
                 crit.eq("previousVersionId", previousVersionId);
 412  0
                 return (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();
 413  
         }
 414  
 
 415  
         public RuleBaseValues findDefaultRuleByRuleTemplateId(Long ruleTemplateId) {
 416  0
                 Criteria crit = new Criteria(RuleBaseValues.class.getName());
 417  0
                 crit.eq("ruleTemplateId", ruleTemplateId);
 418  0
                 crit.eq("templateRuleInd", Boolean.TRUE);
 419  0
                 List rules = (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();
 420  0
                 if (rules != null && !rules.isEmpty()) {
 421  0
                         return (RuleBaseValues) rules.get(0);
 422  
                 }
 423  0
                 return null;
 424  
         }
 425  
 
 426  
         public void clearCache() {
 427  
                 //TODO clear the cache
 428  0
         }
 429  
 
 430  
         public void retrieveAllReferences(RuleBaseValues rule) {
 431  
                 // getPersistenceBroker().retrieveAllReferences(rule);
 432  0
         }
 433  
 
 434  
         public RuleBaseValues getParentRule(Long ruleBaseValuesId) {
 435  0
                 Criteria criteria = new Criteria(RuleBaseValues.class.getName());
 436  0
                 criteria.eq("currentInd", Boolean.TRUE);
 437  0
                 criteria.eq("responsibilities.delegationRules.delegateRuleId", ruleBaseValuesId);
 438  0
                 Collection rules = new QueryByCriteria(entityManager, criteria).toQuery().getResultList();
 439  0
                 RuleBaseValues rule = null;
 440  0
                 for (Iterator iterator = rules.iterator(); iterator.hasNext();) {
 441  0
                         RuleBaseValues currentRule = (RuleBaseValues) iterator.next();
 442  0
                         if (rule == null || currentRule.getVersionNbr().intValue() > rule.getVersionNbr().intValue()) {
 443  0
                                 rule = currentRule;
 444  
                         }
 445  0
                 }
 446  0
                 return rule;
 447  
         }
 448  
 
 449  
         public List findOldDelegations(final RuleBaseValues oldRule, final RuleBaseValues newRule) {
 450  
 
 451  0
                 Query q = entityManager.createNativeQuery(OLD_DELEGATIONS_SQL);
 452  0
                 q.setParameter(1, oldRule.getRuleBaseValuesId().longValue());
 453  0
                 q.setParameter(2, newRule.getRuleBaseValuesId().longValue());
 454  0
                 List oldDelegations = new ArrayList();
 455  0
                 for(Object l:q.getResultList()){
 456  0
                         oldDelegations.add(findRuleBaseValuesById((Long)l));
 457  
                 }
 458  0
                 return oldDelegations;
 459  
 
 460  
         }
 461  
         
 462  
         public Long findResponsibilityIdForRule(String ruleName, String ruleResponsibilityName, String ruleResponsibilityType) {
 463  0
                 Criteria crit = new Criteria(RuleResponsibility.class.getName());
 464  0
                 crit.eq("ruleResponsibilityName", ruleResponsibilityName);
 465  0
                 crit.eq("ruleResponsibilityType", ruleResponsibilityType);
 466  0
                 crit.eq("ruleBaseValues.currentInd", Boolean.TRUE);
 467  0
                 crit.eq("ruleBaseValues.name", ruleName);
 468  0
                 Collection responsibilities = new QueryByCriteria(entityManager, crit).toQuery().getResultList();
 469  0
                 if (responsibilities != null) {
 470  0
                         for (Iterator iter = responsibilities.iterator(); iter.hasNext();) {
 471  0
                                 RuleResponsibility responsibility = (RuleResponsibility) iter.next();
 472  0
                                 return responsibility.getResponsibilityId();
 473  
                         }
 474  
                 }
 475  0
                 return null;
 476  
         }
 477  
 
 478  
     public EntityManager getEntityManager() {
 479  0
         return this.entityManager;
 480  
     }
 481  
 
 482  
     public void setEntityManager(EntityManager entityManager) {
 483  0
         this.entityManager = entityManager;
 484  0
     }
 485  
 
 486  
 }