001 /**
002 * Copyright 2005-2013 The Kuali Foundation
003 *
004 * Licensed under the Educational Community License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.opensource.org/licenses/ecl2.php
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016 package org.kuali.rice.kew.routeheader.dao.impl;
017
018 import org.apache.commons.lang.StringUtils;
019 import org.kuali.rice.core.api.resourceloader.GlobalResourceLoader;
020 import org.kuali.rice.core.api.util.RiceConstants;
021 import org.kuali.rice.core.framework.persistence.jpa.OrmUtils;
022 import org.kuali.rice.core.framework.persistence.jpa.criteria.Criteria;
023 import org.kuali.rice.core.framework.persistence.jpa.criteria.QueryByCriteria;
024 import org.kuali.rice.core.framework.persistence.platform.DatabasePlatform;
025 import org.kuali.rice.kew.actionitem.ActionItem;
026 import org.kuali.rice.kew.actionlist.service.ActionListService;
027 import org.kuali.rice.kew.api.WorkflowRuntimeException;
028 import org.kuali.rice.kew.api.action.ActionRequestStatus;
029 import org.kuali.rice.kew.docsearch.SearchableAttributeValue;
030 import org.kuali.rice.kew.api.exception.LockingException;
031 import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue;
032 import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValueContent;
033 import org.kuali.rice.kew.routeheader.dao.DocumentRouteHeaderDAO;
034 import org.kuali.rice.kew.service.KEWServiceLocator;
035
036 import javax.persistence.EntityManager;
037 import javax.persistence.EntityNotFoundException;
038 import javax.persistence.PersistenceContext;
039 import javax.persistence.Query;
040 import java.math.BigDecimal;
041 import java.util.ArrayList;
042 import java.util.Collection;
043 import java.util.Iterator;
044 import java.util.List;
045 import java.util.Set;
046
047
048 public class DocumentRouteHeaderDAOJpaImpl implements DocumentRouteHeaderDAO {
049
050 @PersistenceContext(unitName="kew-unit")
051 private EntityManager entityManager;
052 private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(DocumentRouteHeaderDAOJpaImpl.class);
053
054
055 /**
056 * @return the entityManager
057 */
058 public EntityManager getEntityManager() {
059 return this.entityManager;
060 }
061
062 /**
063 * @param entityManager the entityManager to set
064 */
065 public void setEntityManager(EntityManager entityManager) {
066 this.entityManager = entityManager;
067 }
068
069 public void saveRouteHeader(DocumentRouteHeaderValue routeHeader) {
070 DocumentRouteHeaderValueContent documentContent = routeHeader.getDocumentContent();
071 // List<SearchableAttributeValue> searchableAttributes = routeHeader.getSearchableAttributeValues();
072
073 if (routeHeader.getDocumentId() == null){
074 entityManager.persist(routeHeader);
075 } else {
076 OrmUtils.merge(entityManager, routeHeader);
077 }
078
079 //Save document content (document content retrieved via a service call)
080 documentContent.setDocumentId(routeHeader.getDocumentId());
081 entityManager.merge(documentContent);
082
083 /*
084 //Save searchable attributes
085 for (SearchableAttributeValue searchableAttributeValue:searchableAttributes){
086 searchableAttributeValue.setDocumentId(routeHeader.getDocumentId());
087 if (searchableAttributeValue.getSearchableAttributeValueId() == null){
088 entityManager.persist(searchableAttributeValue);
089 } else {
090 entityManager.merge(searchableAttributeValue);
091 }
092 }
093 */
094 }
095
096 public DocumentRouteHeaderValueContent getContent(String documentId) {
097 Query query = entityManager.createNamedQuery("DocumentRouteHeaderValueContent.FindByDocumentId");
098 query.setParameter("documentId", documentId);
099 return (DocumentRouteHeaderValueContent)query.getSingleResult();
100 }
101
102 public void clearRouteHeaderSearchValues(String documentId) {
103 Collection<SearchableAttributeValue> searchableAttributeValues = findSearchableAttributeValues(documentId);
104 for (SearchableAttributeValue searchableAttributeValue:searchableAttributeValues){
105 entityManager.remove(searchableAttributeValue);
106 }
107 }
108
109 public Collection<SearchableAttributeValue> findSearchableAttributeValues(String documentId){
110 List<SearchableAttributeValue> searchableAttributeValues = new ArrayList<SearchableAttributeValue>();
111
112 for (int i=1;i<=4; i++){
113 String namedQuery = "";
114 switch (i) {
115 case 1: namedQuery = "SearchableAttributeFloatValue.FindByDocumentId"; break;
116 case 2: namedQuery = "SearchableAttributeDateTimeValue.FindByDocumentId"; break;
117 case 3: namedQuery = "SearchableAttributeLongValue.FindByDocumentId";break;
118 case 4: namedQuery = "SearchableAttributeStringValue.FindByDocumentId"; break;
119 }
120 Query query = entityManager.createNamedQuery(namedQuery);
121 query.setParameter("documentId", documentId);
122 searchableAttributeValues.addAll(query.getResultList());
123 }
124
125 return searchableAttributeValues;
126 }
127
128 public void lockRouteHeader(final String documentId, final boolean wait) {
129 String sql = getPlatform().getLockRouteHeaderQuerySQL(documentId, wait);
130 try{
131 Query query = entityManager.createNativeQuery(sql);
132 query.setParameter(1, documentId);
133 query.getSingleResult();
134 } catch (Exception e){
135 //FIXME: Should this check for hibernate LockAcquisitionException
136 throw new LockingException("Could not aquire lock on document, documentId=" + documentId, e);
137 }
138 }
139
140 public DocumentRouteHeaderValue findRouteHeader(String documentId) {
141 return findRouteHeader(documentId, false);
142 }
143
144 public DocumentRouteHeaderValue findRouteHeader(String documentId, boolean clearCache) {
145 Query query = entityManager.createNamedQuery("DocumentRouteHeaderValue.FindByDocumentId");
146 query.setParameter("documentId", documentId);
147
148 //TODO: What cache do we clear when using JPA
149 if (clearCache) {
150 //this.getPersistenceBrokerTemplate().clearCache();
151 }
152
153 DocumentRouteHeaderValue routeHeader = (DocumentRouteHeaderValue) query.getSingleResult();
154 // routeHeader.setSearchableAttributeValues(findSearchableAttributeValues(documentId));
155 return routeHeader;
156 }
157
158 public Collection<DocumentRouteHeaderValue> findRouteHeaders(Collection<String> documentIds) {
159 return findRouteHeaders(documentIds, false);
160 }
161
162 public Collection<DocumentRouteHeaderValue> findRouteHeaders(Collection<String> documentIds, boolean clearCache) {
163 if (documentIds == null || documentIds.isEmpty()) {
164 return null;
165 }
166 Criteria crit = new Criteria(DocumentRouteHeaderValue.class.getName());
167 crit.in("documentId", documentIds);
168
169 //TODO: What cache do we clear when using JPA
170 if (clearCache) {
171 //this.getPersistenceBrokerTemplate().clearCache();
172 }
173
174 return new QueryByCriteria(entityManager, crit).toQuery().getResultList();
175 }
176
177 public void deleteRouteHeader(DocumentRouteHeaderValue routeHeader) {
178 DocumentRouteHeaderValue attachedRouteHeader = findRouteHeader(routeHeader.getDocumentId());
179 entityManager.remove(attachedRouteHeader);
180 }
181
182 public String getNextDocumentId() {
183 Long nextDocumentId = getPlatform().getNextValSQL("KREW_DOC_HDR_S", entityManager);
184 return nextDocumentId.toString();
185 }
186
187 protected DatabasePlatform getPlatform() {
188 return (DatabasePlatform) GlobalResourceLoader.getService(RiceConstants.DB_PLATFORM);
189 }
190
191 @Override
192 public Collection<String> findPendingByResponsibilityIds(Set<String> responsibilityIds) {
193
194 if (responsibilityIds.isEmpty()) {
195 return new ArrayList();
196 }
197
198 String respIds = "('";
199 int index = 0;
200 for (String responsibilityId : responsibilityIds) {
201 respIds += responsibilityId + (index == responsibilityIds.size()-1 ? "" : "','");
202 }
203 respIds += "')";
204
205 String query = "SELECT DISTINCT(doc_hdr_id) FROM KREW_ACTN_RQST_T "+
206 "WHERE (STAT_CD='" +
207 ActionRequestStatus.INITIALIZED.getCode()+
208 "' OR STAT_CD='"+
209 ActionRequestStatus.ACTIVATED.getCode()+
210 "') AND RSP_ID IN "+respIds;
211
212 LOG.debug("Query to find pending documents for requeue: " + query);
213
214 List<String> idList = new ArrayList<String>();
215 for (Object tempId : entityManager.createNativeQuery(query).getResultList()) {
216 idList.add(((String) tempId));
217 }
218
219 return idList; //(List<Long>)entityManager.createNativeQuery(query).getResultList();
220 }
221
222 public boolean hasSearchableAttributeValue(String documentId, String searchableAttributeKey, String searchableAttributeValue) {
223 return hasSearchableAttributeValue(documentId, searchableAttributeKey, searchableAttributeValue, "SearchableAttributeDateTimeValue.FindByKey")
224 || hasSearchableAttributeValue(documentId, searchableAttributeKey, searchableAttributeValue, "SearchableAttributeStringValue.FindByKey")
225 || hasSearchableAttributeValue(documentId, searchableAttributeKey, searchableAttributeValue, "SearchableAttributeLongValue.FindByKey")
226 || hasSearchableAttributeValue(documentId, searchableAttributeKey, searchableAttributeValue, "SearchableAttributeFloatValue.FindByKey");
227 }
228
229 private boolean hasSearchableAttributeValue(String documentId, String searchableAttributeKey, String searchableAttributeValue, String namedQuery) {
230 Query query = entityManager.createNamedQuery(namedQuery);
231 query.setParameter("documentId", documentId);
232 query.setParameter("searchableAttributeKey", searchableAttributeKey);
233 Collection results = query.getResultList();
234 if (!results.isEmpty()) {
235 for (Iterator iterator = results.iterator(); iterator.hasNext();) {
236 SearchableAttributeValue attribute = (SearchableAttributeValue) iterator.next();
237 if (StringUtils.equals(attribute.getSearchableAttributeDisplayValue(), searchableAttributeValue)) {
238 return true;
239 }
240 }
241 }
242 return false;
243 }
244
245 public String getApplicationIdByDocumentId(String documentId) {
246 if (documentId == null) {
247 throw new IllegalArgumentException("Encountered a null document ID.");
248 }
249
250 String applicationId = null;
251
252 try {
253 String sql = "SELECT DT.APPL_ID FROM KREW_DOC_TYP_T DT, KREW_DOC_HDR_T DH "+
254 "WHERE DH.DOC_TYP_ID=DT.DOC_TYP_ID AND "+
255 "DH.DOC_HDR_ID=?";
256
257 Query query = entityManager.createNativeQuery(sql);
258 query.setParameter(1, documentId);
259
260 applicationId = (String)query.getSingleResult();
261 } catch (EntityNotFoundException enfe) {
262 throw new WorkflowRuntimeException(enfe.getMessage());
263 }
264
265 return applicationId;
266 }
267
268 public String getDocumentStatus(String documentId) {
269 DocumentRouteHeaderValue document = findRouteHeader(documentId);
270
271 return document.getDocRouteStatus();
272 }
273
274 public String getAppDocId(String documentId) {
275 Query query = entityManager.createNamedQuery("DocumentRouteHeaderValue.GetAppDocId");
276 query.setParameter("documentId", documentId);
277 return (String) query.getSingleResult();
278 }
279
280 public String getAppDocStatus(String documentId) {
281 Query query = entityManager.createNamedQuery("DocumentRouteHeaderValue.GetAppDocStatus");
282 query.setParameter("documentId", documentId);
283 return (String) query.getSingleResult();
284 }
285
286 public void save(SearchableAttributeValue searchableAttributeValue) {
287 if (searchableAttributeValue.getSearchableAttributeValueId() == null){
288 entityManager.persist(searchableAttributeValue);
289 } else {
290 entityManager.merge(searchableAttributeValue);
291 }
292 }
293
294 public Collection findByDocTypeAndAppId(String documentTypeName,
295 String appId) {
296 try {
297 String sql =
298 "SELECT DISTINCT " +
299 " (docHdr.doc_hdr_id) " +
300 "FROM " +
301 " KREW_DOC_HDR_T docHdr, " +
302 " KREW_DOC_TYP_T docTyp " +
303 "WHERE " +
304 " docHdr.APP_DOC_ID = ? " +
305 " AND docHdr.DOC_TYP_ID = docTyp.DOC_TYP_ID " +
306 " AND docTyp.DOC_TYP_NM = ?";
307
308 Query query = entityManager.createNativeQuery(sql);
309 query.setParameter(1, appId);
310 query.setParameter(2, documentTypeName);
311 Collection<Long> idCollection = new ArrayList<Long>();
312 for (Object tempId : query.getResultList()) {
313 idCollection.add(((BigDecimal)tempId).longValueExact());
314 }
315 return idCollection;
316 } catch (EntityNotFoundException enfe) {
317 throw new WorkflowRuntimeException(enfe.getMessage());
318 }
319 }
320
321
322 }