Coverage Report

Coverage Report - org.kuali.rice.kew.doctype.dao.impl.DocumentTypeDAOJpaImpl

Classes in this File

Line Coverage

Branch Coverage

Complexity

DocumentTypeDAOJpaImpl

0/123

0/56

2.292

 /**
  * Copyright 2005-2011 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.doctype.dao.impl;
 
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
 
 import javax.persistence.EntityManager;
 import javax.persistence.PersistenceContext;
 import javax.persistence.Query;
 
 import org.apache.log4j.Logger;
 import org.kuali.rice.core.framework.persistence.jpa.OrmUtils;
 import org.kuali.rice.core.framework.persistence.jpa.criteria.Criteria;
 import org.kuali.rice.core.framework.persistence.jpa.criteria.QueryByCriteria;
 import org.kuali.rice.kew.doctype.DocumentTypeAttribute;
 import org.kuali.rice.kew.doctype.bo.DocumentType;
 import org.kuali.rice.kew.doctype.dao.DocumentTypeDAO;
 import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue;
 import org.kuali.rice.kew.rule.bo.RuleAttribute;
 
 
 public class DocumentTypeDAOJpaImpl implements DocumentTypeDAO {
 
         public static final Logger LOG = Logger.getLogger(DocumentTypeDAOJpaImpl.class);
 
         @PersistenceContext(unitName="kew-unit")
         private EntityManager entityManager;
 
 
         /**
          * @return the entityManager
          */
         public EntityManager getEntityManager() {
                 return this.entityManager;
         }
 
         /**
          * @param entityManager the entityManager to set
          */
         public void setEntityManager(EntityManager entityManager) {
                 this.entityManager = entityManager;
         }
 
         public void delete(DocumentType documentType) {
                 DocumentType docType = findById(documentType.getDocumentTypeId());
                 entityManager.remove(documentType);
         }
 
         public DocumentType findById(String docTypeId) {
                 Criteria crit = new Criteria(DocumentType.class.getName());
                 crit.eq("documentTypeId", docTypeId);
                         return (DocumentType) new QueryByCriteria(entityManager, crit).toQuery().getSingleResult();
         }
 
         public DocumentType findByName(String name){
                 return findByName(name, true); // by default find by name is case sensitive
         }
 
         public DocumentType findByName(String name, boolean caseSensitive) {
                 Criteria crit = new Criteria(DocumentType.class.getName());
                 if(!caseSensitive){
                         crit.like("UPPER(__JPA_ALIAS[[0]]__.name)", ("%" + name.trim() + "%").toUpperCase());
 
                 }else{
                         crit.eq("name", name);
                 }
                 crit.eq("currentInd", Boolean.TRUE);
                 DocumentType docType = (DocumentType) new QueryByCriteria(entityManager, crit).toQuery().getSingleResult();
                 return docType;
         }
 
         public Integer getMaxVersionNumber(String docTypeName) {
                 return getMostRecentDocType(docTypeName).getVersion();
         }
 
         public List<String> getChildDocumentTypeIds(String parentDocumentTypeId) {
                 List<String> childrenIds = new ArrayList<String>();
                 try {
                         String sql = "select DOC_TYP_ID from KREW_DOC_TYP_T where CUR_IND = 1 and PARNT_ID = " + parentDocumentTypeId;
                         Query query = entityManager.createNativeQuery(sql);
                         List resultIds = query.getResultList();
                         for (Object id : resultIds){
                                 childrenIds.add(id.toString());
                         }
 
                 } catch (Exception e) {
                         LOG.error("Error occured fetching children document type ids for document type " + parentDocumentTypeId, e);
                         throw new RuntimeException(e);
                 }
 
                 return childrenIds;
         }
 
         protected DocumentType getMostRecentDocType(String docTypeName) {
                 Criteria crit = new Criteria(DocumentType.class.getName());
                 crit.eq("name", docTypeName);
                 crit.orderBy("version", false);
 
                 Iterator docTypes = new QueryByCriteria(entityManager, crit).toQuery().getResultList().iterator();
                 while (docTypes.hasNext()) {
                         return (DocumentType) docTypes.next();
                 }
                 return null;
         }
 
         public void save(DocumentType documentType) {
                 if (documentType.getDocumentTypeId() == null){
                         entityManager.persist(documentType);
                 } else {
                         OrmUtils.merge(entityManager, documentType);
                 }
         }
 
         public List findByDocumentId(String documentId) {
                 Criteria crit = new Criteria(DocumentType.class.getName());
                 crit.eq("documentId", documentId);
                 return (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();
         }
 
         public Collection<DocumentType> find(DocumentType documentType, DocumentType docTypeParent, boolean climbHierarchy) {
                 LOG.debug("documentType: "+ documentType);
                 LOG.debug("docTypeParent: "+ docTypeParent);
                 LOG.debug("climbHierarchy: " + climbHierarchy);
 
                 Criteria crit = new Criteria(DocumentType.class.getName());
                 if (documentType != null && !org.apache.commons.lang.StringUtils.isEmpty(documentType.getLabel())) {
                         crit.like("UPPER(__JPA_ALIAS[[0]]__.label)", documentType.getLabel().trim().toUpperCase());
                 }
                 if (documentType != null && !org.apache.commons.lang.StringUtils.isEmpty(documentType.getName())) {
                         String docTypeName = documentType.getName();
                         crit.like("UPPER(__JPA_ALIAS[[0]]__.name)", ("%" + docTypeName.trim() + "%").toUpperCase());
                 }
                 if (documentType != null && documentType.getActive() != null) {
                         crit.eq("active", documentType.getActive());
                 }
                 if (documentType != null && documentType.getDocumentTypeId() != null) {
                         crit.eq("documentTypeId", documentType.getDocumentTypeId());
                 }
                 if (documentType != null && documentType.getActualApplicationId() != null){
                         crit.eq("applicationId", documentType.getActualApplicationId());
                 }
                 if (docTypeParent != null) {
                         if (!"".equals(docTypeParent.getName()) && docTypeParent.getName() != null) {
                                 Criteria parentCrit = new Criteria(DocumentType.class.getName());
                                 //addParentNameOrCriteria(docTypeParent.getName(), parentCrit);
                                 addParentIdOrCriteria(docTypeParent.getDocumentTypeId(), parentCrit);
                                 if (climbHierarchy) {
                                         assembleChildrenCriteria(docTypeParent.getChildrenDocTypes(), parentCrit);
                                 }
                                 parentCrit.eq("currentInd", Boolean.TRUE);
                                 crit.and(parentCrit);
                         }
                 } else {
                         if (documentType != null && !org.apache.commons.lang.StringUtils.isEmpty(documentType.getName())) {
                                 DocumentType searchDocumentType = findByName(documentType.getName());
                                 if ((searchDocumentType != null) && climbHierarchy) {
                                         LOG.debug("searchDocumentType: "+ searchDocumentType);
                                         Criteria criteria = new Criteria(DocumentType.class.getName());
                                         //addParentNameOrCriteria(searchDocumentType.getName(), criteria);
                     addParentIdOrCriteria(searchDocumentType.getDocumentTypeId(), criteria);
                     assembleChildrenCriteria(searchDocumentType.getChildrenDocTypes(), criteria);
                                         criteria.eq("currentInd", Boolean.TRUE);
                                         crit.or(criteria);
                                 }
                         }
                 }
                 crit.eq("currentInd", Boolean.TRUE);
                 return new QueryByCriteria(entityManager, crit).toQuery().getResultList();
         }
 
     private void addParentIdOrCriteria(String parentId, Criteria mainCriteria) {
         Criteria parentCriteria = new Criteria(DocumentType.class.getName());
         parentCriteria.eq("docTypeParentId", parentId);
         mainCriteria.or(parentCriteria);
     }
 
         private void assembleChildrenCriteria(Collection childrenDocTypes, Criteria crit) {
                 if (childrenDocTypes != null) {
                         Iterator childrenDocTypesIter = childrenDocTypes.iterator();
                         while (childrenDocTypesIter.hasNext()) {
                                 DocumentType child = (DocumentType) childrenDocTypesIter.next();
                                 addParentIdOrCriteria(child.getDocumentTypeId(), crit);
                                 assembleChildrenCriteria(child.getChildrenDocTypes(), crit);
                         }
                 }
         }
 
         
 
         public List findAllCurrentRootDocuments() {
                 Criteria crit = new Criteria(DocumentType.class.getName());
                 crit.isNull("docTypeParentId");
                 return findAllCurrent(crit);
         }
 
     public List findAllCurrent() {
             return findAllCurrent(new Criteria(DocumentType.class.getName()));
     }
 
     public List findAllCurrentByName(String name) {
                 Criteria crit = new Criteria(DocumentType.class.getName());
                 crit.eq("name", name);
                 return findAllCurrent(crit);
     }
 
     public List<DocumentType> findPreviousInstances(String name) {
         Criteria crit = new Criteria(DocumentType.class.getName());
         crit.eq("name", name);
         crit.eq("currentInd", Boolean.FALSE);
         return findAll(crit);
     }
 
     private List findAllCurrent(Criteria crit) {
         crit.eq("currentInd", Boolean.TRUE);
         return findAll(crit);
     }
 
     private List findAll(Criteria crit) {
         return (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();
     }
 
     public List findDocumentTypeAttributes(RuleAttribute ruleAttribute) {
             Criteria crit = new Criteria(DocumentTypeAttribute.class.getName());
             if (ruleAttribute.getId() != null) {
                     crit.eq("ruleAttributeId", ruleAttribute.getId());
             }
             return (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();
     }
 
     public String findDocumentTypeIdByDocumentId(String documentId) {
             Criteria crit = new Criteria(DocumentRouteHeaderValue.class.getName());
             crit.eq("documentId", documentId);
 
             final DocumentRouteHeaderValue docHeader = (DocumentRouteHeaderValue)new QueryByCriteria(entityManager, crit).toQuery().getSingleResult();
             return (docHeader != null) ? docHeader.getDocumentTypeId() : null;
     }
     
     public String findDocumentTypeIdByName(String documentTypeName) {
             Criteria crit = new Criteria(DocumentType.class.getName());
             crit.eq("name", documentTypeName);
         crit.eq("currentInd", Boolean.TRUE);
 
             final DocumentType documentType = (DocumentType)new QueryByCriteria(entityManager, crit).toQuery().getSingleResult();
             return (documentType != null) ? documentType.getDocumentTypeId() : null;
     }
     
     public String findDocumentTypeNameById(String documentTypeId) {
         Criteria crit = new Criteria(DocumentType.class.getName());
         crit.eq("documentTypeId", documentTypeId);
 
         final DocumentType documentType = (DocumentType)new QueryByCriteria(entityManager, crit).toQuery().getSingleResult();
         return (documentType != null) ? documentType.getName() : null;
     }
 
 }

1		/**
2		* Copyright 2005-2011 The Kuali Foundation
3		*
4		* Licensed under the Educational Community License, Version 2.0 (the "License");
5		* you may not use this file except in compliance with the License.
6		* You may obtain a copy of the License at
7		*
8		* http://www.opensource.org/licenses/ecl2.php
9		*
10		* Unless required by applicable law or agreed to in writing, software
11		* distributed under the License is distributed on an "AS IS" BASIS,
12		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13		* See the License for the specific language governing permissions and
14		* limitations under the License.
15		*/
16		package org.kuali.rice.kew.doctype.dao.impl;
17
18		import java.util.ArrayList;
19		import java.util.Collection;
20		import java.util.Iterator;
21		import java.util.List;
22
23		import javax.persistence.EntityManager;
24		import javax.persistence.PersistenceContext;
25		import javax.persistence.Query;
26
27		import org.apache.log4j.Logger;
28		import org.kuali.rice.core.framework.persistence.jpa.OrmUtils;
29		import org.kuali.rice.core.framework.persistence.jpa.criteria.Criteria;
30		import org.kuali.rice.core.framework.persistence.jpa.criteria.QueryByCriteria;
31		import org.kuali.rice.kew.doctype.DocumentTypeAttribute;
32		import org.kuali.rice.kew.doctype.bo.DocumentType;
33		import org.kuali.rice.kew.doctype.dao.DocumentTypeDAO;
34		import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue;
35		import org.kuali.rice.kew.rule.bo.RuleAttribute;
36
37
38	0	public class DocumentTypeDAOJpaImpl implements DocumentTypeDAO {
39
40	0	public static final Logger LOG = Logger.getLogger(DocumentTypeDAOJpaImpl.class);
41
42		@PersistenceContext(unitName="kew-unit")
43		private EntityManager entityManager;
44
45
46		/**
47		* @return the entityManager
48		*/
49		public EntityManager getEntityManager() {
50	0	return this.entityManager;
51		}
52
53		/**
54		* @param entityManager the entityManager to set
55		*/
56		public void setEntityManager(EntityManager entityManager) {
57	0	this.entityManager = entityManager;
58	0	}
59
60		public void delete(DocumentType documentType) {
61	0	DocumentType docType = findById(documentType.getDocumentTypeId());
62	0	entityManager.remove(documentType);
63	0	}
64
65		public DocumentType findById(String docTypeId) {
66	0	Criteria crit = new Criteria(DocumentType.class.getName());
67	0	crit.eq("documentTypeId", docTypeId);
68	0	return (DocumentType) new QueryByCriteria(entityManager, crit).toQuery().getSingleResult();
69		}
70
71		public DocumentType findByName(String name){
72	0	return findByName(name, true); // by default find by name is case sensitive
73		}
74
75		public DocumentType findByName(String name, boolean caseSensitive) {
76	0	Criteria crit = new Criteria(DocumentType.class.getName());
77	0	if(!caseSensitive){
78	0	crit.like("UPPER(__JPA_ALIAS[[0]]__.name)", ("%" + name.trim() + "%").toUpperCase());
79
80		}else{
81	0	crit.eq("name", name);
82		}
83	0	crit.eq("currentInd", Boolean.TRUE);
84	0	DocumentType docType = (DocumentType) new QueryByCriteria(entityManager, crit).toQuery().getSingleResult();
85	0	return docType;
86		}
87
88		public Integer getMaxVersionNumber(String docTypeName) {
89	0	return getMostRecentDocType(docTypeName).getVersion();
90		}
91
92		public List<String> getChildDocumentTypeIds(String parentDocumentTypeId) {
93	0	List<String> childrenIds = new ArrayList<String>();
94		try {
95	0	String sql = "select DOC_TYP_ID from KREW_DOC_TYP_T where CUR_IND = 1 and PARNT_ID = " + parentDocumentTypeId;
96	0	Query query = entityManager.createNativeQuery(sql);
97	0	List resultIds = query.getResultList();
98	0	for (Object id : resultIds){
99	0	childrenIds.add(id.toString());
100		}
101
102	0	} catch (Exception e) {
103	0	LOG.error("Error occured fetching children document type ids for document type " + parentDocumentTypeId, e);
104	0	throw new RuntimeException(e);
105	0	}
106
107	0	return childrenIds;
108		}
109
110		protected DocumentType getMostRecentDocType(String docTypeName) {
111	0	Criteria crit = new Criteria(DocumentType.class.getName());
112	0	crit.eq("name", docTypeName);
113	0	crit.orderBy("version", false);
114
115	0	Iterator docTypes = new QueryByCriteria(entityManager, crit).toQuery().getResultList().iterator();
116	0	while (docTypes.hasNext()) {
117	0	return (DocumentType) docTypes.next();
118		}
119	0	return null;
120		}
121
122		public void save(DocumentType documentType) {
123	0	if (documentType.getDocumentTypeId() == null){
124	0	entityManager.persist(documentType);
125		} else {
126	0	OrmUtils.merge(entityManager, documentType);
127		}
128	0	}
129
130		public List findByDocumentId(String documentId) {
131	0	Criteria crit = new Criteria(DocumentType.class.getName());
132	0	crit.eq("documentId", documentId);
133	0	return (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();
134		}
135
136		public Collection<DocumentType> find(DocumentType documentType, DocumentType docTypeParent, boolean climbHierarchy) {
137	0	LOG.debug("documentType: "+ documentType);
138	0	LOG.debug("docTypeParent: "+ docTypeParent);
139	0	LOG.debug("climbHierarchy: " + climbHierarchy);
140
141	0	Criteria crit = new Criteria(DocumentType.class.getName());
142	0	if (documentType != null && !org.apache.commons.lang.StringUtils.isEmpty(documentType.getLabel())) {
143	0	crit.like("UPPER(__JPA_ALIAS[[0]]__.label)", documentType.getLabel().trim().toUpperCase());
144		}
145	0	if (documentType != null && !org.apache.commons.lang.StringUtils.isEmpty(documentType.getName())) {
146	0	String docTypeName = documentType.getName();
147	0	crit.like("UPPER(__JPA_ALIAS[[0]]__.name)", ("%" + docTypeName.trim() + "%").toUpperCase());
148		}
149	0	if (documentType != null && documentType.getActive() != null) {
150	0	crit.eq("active", documentType.getActive());
151		}
152	0	if (documentType != null && documentType.getDocumentTypeId() != null) {
153	0	crit.eq("documentTypeId", documentType.getDocumentTypeId());
154		}
155	0	if (documentType != null && documentType.getActualApplicationId() != null){
156	0	crit.eq("applicationId", documentType.getActualApplicationId());
157		}
158	0	if (docTypeParent != null) {
159	0	if (!"".equals(docTypeParent.getName()) && docTypeParent.getName() != null) {
160	0	Criteria parentCrit = new Criteria(DocumentType.class.getName());
161		//addParentNameOrCriteria(docTypeParent.getName(), parentCrit);
162	0	addParentIdOrCriteria(docTypeParent.getDocumentTypeId(), parentCrit);
163	0	if (climbHierarchy) {
164	0	assembleChildrenCriteria(docTypeParent.getChildrenDocTypes(), parentCrit);
165		}
166	0	parentCrit.eq("currentInd", Boolean.TRUE);
167	0	crit.and(parentCrit);
168	0	}
169		} else {
170	0	if (documentType != null && !org.apache.commons.lang.StringUtils.isEmpty(documentType.getName())) {
171	0	DocumentType searchDocumentType = findByName(documentType.getName());
172	0	if ((searchDocumentType != null) && climbHierarchy) {
173	0	LOG.debug("searchDocumentType: "+ searchDocumentType);
174	0	Criteria criteria = new Criteria(DocumentType.class.getName());
175		//addParentNameOrCriteria(searchDocumentType.getName(), criteria);
176	0	addParentIdOrCriteria(searchDocumentType.getDocumentTypeId(), criteria);
177	0	assembleChildrenCriteria(searchDocumentType.getChildrenDocTypes(), criteria);
178	0	criteria.eq("currentInd", Boolean.TRUE);
179	0	crit.or(criteria);
180		}
181		}
182		}
183	0	crit.eq("currentInd", Boolean.TRUE);
184	0	return new QueryByCriteria(entityManager, crit).toQuery().getResultList();
185		}
186
187		private void addParentIdOrCriteria(String parentId, Criteria mainCriteria) {
188	0	Criteria parentCriteria = new Criteria(DocumentType.class.getName());
189	0	parentCriteria.eq("docTypeParentId", parentId);
190	0	mainCriteria.or(parentCriteria);
191	0	}
192
193		private void assembleChildrenCriteria(Collection childrenDocTypes, Criteria crit) {
194	0	if (childrenDocTypes != null) {
195	0	Iterator childrenDocTypesIter = childrenDocTypes.iterator();
196	0	while (childrenDocTypesIter.hasNext()) {
197	0	DocumentType child = (DocumentType) childrenDocTypesIter.next();
198	0	addParentIdOrCriteria(child.getDocumentTypeId(), crit);
199	0	assembleChildrenCriteria(child.getChildrenDocTypes(), crit);
200	0	}
201		}
202	0	}
203
204
205
206		public List findAllCurrentRootDocuments() {
207	0	Criteria crit = new Criteria(DocumentType.class.getName());
208	0	crit.isNull("docTypeParentId");
209	0	return findAllCurrent(crit);
210		}
211
212		public List findAllCurrent() {
213	0	return findAllCurrent(new Criteria(DocumentType.class.getName()));
214		}
215
216		public List findAllCurrentByName(String name) {
217	0	Criteria crit = new Criteria(DocumentType.class.getName());
218	0	crit.eq("name", name);
219	0	return findAllCurrent(crit);
220		}
221
222		public List<DocumentType> findPreviousInstances(String name) {
223	0	Criteria crit = new Criteria(DocumentType.class.getName());
224	0	crit.eq("name", name);
225	0	crit.eq("currentInd", Boolean.FALSE);
226	0	return findAll(crit);
227		}
228
229		private List findAllCurrent(Criteria crit) {
230	0	crit.eq("currentInd", Boolean.TRUE);
231	0	return findAll(crit);
232		}
233
234		private List findAll(Criteria crit) {
235	0	return (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();
236		}
237
238		public List findDocumentTypeAttributes(RuleAttribute ruleAttribute) {
239	0	Criteria crit = new Criteria(DocumentTypeAttribute.class.getName());
240	0	if (ruleAttribute.getId() != null) {
241	0	crit.eq("ruleAttributeId", ruleAttribute.getId());
242		}
243	0	return (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();
244		}
245
246		public String findDocumentTypeIdByDocumentId(String documentId) {
247	0	Criteria crit = new Criteria(DocumentRouteHeaderValue.class.getName());
248	0	crit.eq("documentId", documentId);
249
250	0	final DocumentRouteHeaderValue docHeader = (DocumentRouteHeaderValue)new QueryByCriteria(entityManager, crit).toQuery().getSingleResult();
251	0	return (docHeader != null) ? docHeader.getDocumentTypeId() : null;
252		}
253
254		public String findDocumentTypeIdByName(String documentTypeName) {
255	0	Criteria crit = new Criteria(DocumentType.class.getName());
256	0	crit.eq("name", documentTypeName);
257	0	crit.eq("currentInd", Boolean.TRUE);
258
259	0	final DocumentType documentType = (DocumentType)new QueryByCriteria(entityManager, crit).toQuery().getSingleResult();
260	0	return (documentType != null) ? documentType.getDocumentTypeId() : null;
261		}
262
263		public String findDocumentTypeNameById(String documentTypeId) {
264	0	Criteria crit = new Criteria(DocumentType.class.getName());
265	0	crit.eq("documentTypeId", documentTypeId);
266
267	0	final DocumentType documentType = (DocumentType)new QueryByCriteria(entityManager, crit).toQuery().getSingleResult();
268	0	return (documentType != null) ? documentType.getName() : null;
269		}
270
271		}