Coverage Report

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

Classes in this File

Line Coverage

Branch Coverage

Complexity

DocumentTypeDAOJpaImpl

0/121

0/54

2.348

 /*
  * 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.doctype.dao.impl;
 
 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;
 
 import javax.persistence.EntityManager;
 import javax.persistence.PersistenceContext;
 import javax.persistence.Query;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Iterator;
 import java.util.List;
 
 
 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(Long 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 getChildDocumentTypeIds(Long parentDocumentTypeId) {
                 List childrenIds = new ArrayList();
                 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(new Long(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;
         }
 
         public 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(Long 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 DocumentType getMostRecentDocType(Long documentTypeId) {
                 Criteria crit = new Criteria(DocumentType.class.getName());
                 crit.eq("documentTypeId", documentTypeId);
                 crit.orderBy("version", false);
 
                 Iterator docTypes = new QueryByCriteria(entityManager, crit).toQuery().getResultList().iterator();
                 while (docTypes.hasNext()) {
                         return (DocumentType) docTypes.next();
                 }
                 return null;
         }
 
         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.getRuleAttributeId() != null) {
                     crit.eq("ruleAttributeId", ruleAttribute.getRuleAttributeId());
             }
             return (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();
     }
 
     public Long 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;
     }
 
 }

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.doctype.dao.impl;
18
19		import org.apache.log4j.Logger;
20		import org.kuali.rice.core.framework.persistence.jpa.OrmUtils;
21		import org.kuali.rice.core.framework.persistence.jpa.criteria.Criteria;
22		import org.kuali.rice.core.framework.persistence.jpa.criteria.QueryByCriteria;
23		import org.kuali.rice.kew.doctype.DocumentTypeAttribute;
24		import org.kuali.rice.kew.doctype.bo.DocumentType;
25		import org.kuali.rice.kew.doctype.dao.DocumentTypeDAO;
26		import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue;
27		import org.kuali.rice.kew.rule.bo.RuleAttribute;
28
29		import javax.persistence.EntityManager;
30		import javax.persistence.PersistenceContext;
31		import javax.persistence.Query;
32		import java.util.ArrayList;
33		import java.util.Collection;
34		import java.util.Iterator;
35		import java.util.List;
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(Long 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 getChildDocumentTypeIds(Long parentDocumentTypeId) {
93	0	List childrenIds = new ArrayList();
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(new Long(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		public 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(Long 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		public DocumentType getMostRecentDocType(Long documentTypeId) {
205	0	Criteria crit = new Criteria(DocumentType.class.getName());
206	0	crit.eq("documentTypeId", documentTypeId);
207	0	crit.orderBy("version", false);
208
209	0	Iterator docTypes = new QueryByCriteria(entityManager, crit).toQuery().getResultList().iterator();
210	0	while (docTypes.hasNext()) {
211	0	return (DocumentType) docTypes.next();
212		}
213	0	return null;
214		}
215
216		public List findAllCurrentRootDocuments() {
217	0	Criteria crit = new Criteria(DocumentType.class.getName());
218	0	crit.isNull("docTypeParentId");
219	0	return findAllCurrent(crit);
220		}
221
222		public List findAllCurrent() {
223	0	return findAllCurrent(new Criteria(DocumentType.class.getName()));
224		}
225
226		public List findAllCurrentByName(String name) {
227	0	Criteria crit = new Criteria(DocumentType.class.getName());
228	0	crit.eq("name", name);
229	0	return findAllCurrent(crit);
230		}
231
232		public List<DocumentType> findPreviousInstances(String name) {
233	0	Criteria crit = new Criteria(DocumentType.class.getName());
234	0	crit.eq("name", name);
235	0	crit.eq("currentInd", Boolean.FALSE);
236	0	return findAll(crit);
237		}
238
239		private List findAllCurrent(Criteria crit) {
240	0	crit.eq("currentInd", Boolean.TRUE);
241	0	return findAll(crit);
242		}
243
244		private List findAll(Criteria crit) {
245	0	return (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();
246		}
247
248		public List findDocumentTypeAttributes(RuleAttribute ruleAttribute) {
249	0	Criteria crit = new Criteria(DocumentTypeAttribute.class.getName());
250	0	if (ruleAttribute.getRuleAttributeId() != null) {
251	0	crit.eq("ruleAttributeId", ruleAttribute.getRuleAttributeId());
252		}
253	0	return (List) new QueryByCriteria(entityManager, crit).toQuery().getResultList();
254		}
255
256		public Long findDocumentTypeIdByDocumentId(String documentId) {
257	0	Criteria crit = new Criteria(DocumentRouteHeaderValue.class.getName());
258	0	crit.eq("documentId", documentId);
259
260	0	final DocumentRouteHeaderValue docHeader = (DocumentRouteHeaderValue)new QueryByCriteria(entityManager, crit).toQuery().getSingleResult();
261	0	return (docHeader != null) ? docHeader.getDocumentTypeId() : null;
262		}
263
264		}