Coverage Report

Coverage Report - org.kuali.student.lum.lu.dao.impl.LuDaoImpl

Classes in this File

Line Coverage

Branch Coverage

Complexity

LuDaoImpl

0/233

0/22

1.234

 /**
  * Copyright 2010 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.osedu.org/licenses/ECL-2.0
  *
  * 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.student.lum.lu.dao.impl;
 
 import java.util.Collections;
 import java.util.Date;
 import java.util.List;
 
 import javax.persistence.EntityManager;
 import javax.persistence.PersistenceContext;
 import javax.persistence.Query;
 
 import org.kuali.student.common.dao.impl.AbstractSearchableCrudDaoImpl;
 import org.kuali.student.common.versionmanagement.dto.VersionDisplayInfo;
 import org.kuali.student.lum.lu.dao.LuDao;
 import org.kuali.student.lum.lu.entity.Clu;
 import org.kuali.student.lum.lu.entity.CluCluRelation;
 import org.kuali.student.lum.lu.entity.CluLoRelation;
 import org.kuali.student.lum.lu.entity.CluPublication;
 import org.kuali.student.lum.lu.entity.CluResult;
 import org.kuali.student.lum.lu.entity.CluResultType;
 import org.kuali.student.lum.lu.entity.CluSet;
 import org.kuali.student.lum.lu.entity.Lui;
 import org.kuali.student.lum.lu.entity.LuiLuiRelation;
 
 
 public class LuDaoImpl extends AbstractSearchableCrudDaoImpl implements LuDao {
 
         @PersistenceContext(unitName = "Lu")
         @Override
         public void setEm(EntityManager em) {
                 super.setEm(em);
         }
 
         @Override
         public List<Clu> getClusByIdList(List<String> cluIdList) {
                 Query query = em.createNamedQuery("Clu.findClusByIdList");
                 query.setParameter("idList", cluIdList);
                 @SuppressWarnings("unchecked")
                 List<Clu> resultList = query.getResultList();
                 return resultList;
         }
 
         @Override
         public List<Clu> getClusByLuType(String luTypeKey, String luState) {
                 Query query = em.createNamedQuery("Clu.getClusByLuType");
                 query.setParameter("luTypeKey", luTypeKey);
                 query.setParameter("luState", luState);
                 @SuppressWarnings("unchecked")
                 List<Clu> resultList = query.getResultList();
                 return resultList;
         }
 
         @Override
         public List<CluSet> getCluSetInfoByIdList(List<String> cluSetIdList) {
                 Query query = em.createNamedQuery("CluSet.getCluSetInfoByIdList");
                 query.setParameter("cluSetIdList", cluSetIdList);
                 @SuppressWarnings("unchecked")
                 List<CluSet> resultList = query.getResultList();
                 return resultList;
         }
 
         @Override
         public List<Lui> getLuisByIdList(List<String> luiIds) {
                 Query query = em.createNamedQuery("Lui.getLuisByIdList");
                 query.setParameter("luiIdList", luiIds);
                 @SuppressWarnings("unchecked")
                 List<Lui> luis = query.getResultList();
                 return luis;
         }
 
         @Override
         public List<String> getLuiIdsByCluId(String cluId) {
                 Query query = em.createNamedQuery("Lui.getLuiIdsByCluId");
                 query.setParameter("cluId", cluId);
                 @SuppressWarnings("unchecked")
                 List<String> luiIds = query.getResultList();
                 return luiIds;
         }
 
         @Override
         public List<Lui> getLuisByRelationType(String luiId,
                         String luLuRelationTypeId) {
                 Query query = em
                                 .createNamedQuery("LuiLuiRelation.getLuisByRelationType");
                 query.setParameter("luiId", luiId);
                 query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
 
                 @SuppressWarnings("unchecked")
                 List<Lui> luis = query.getResultList();
                 return luis;
         }
 
         @Override
         public List<String> getLuiIdsByRelationType(String relatedLuiId,
                         String luLuRelationTypeId) {
                 Query query = em
                                 .createNamedQuery("LuiLuiRelation.getLuiIdsByRelationType");
                 query.setParameter("luiId", relatedLuiId);
                 query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
 
                 @SuppressWarnings("unchecked")
                 List<String> luiIds = query.getResultList();
                 return luiIds;
         }
 
         @Override
         public List<String> getLuiIdsInAtpByCluId(String cluId, String atpKey) {
                 Query query = em.createNamedQuery("Lui.getLuiIdsInAtpByCluId");
                 query.setParameter("cluId", cluId);
                 query.setParameter("atpKey", atpKey);
                 @SuppressWarnings("unchecked")
                 List<String> luiIds = query.getResultList();
                 return luiIds;
         }
 
         @Override
         public Boolean isCluInCluSet(String cluId, String cluSetId) {
                 Query query = em.createNamedQuery("CluSet.isCluInCluSet");
                 query.setParameter("cluId", cluId);
                 query.setParameter("cluSetId", cluSetId);
                 Long valid = (Long) query.getSingleResult();
                 return valid.intValue() > 0;
         }
 
         @Override
         public List<LuiLuiRelation> getLuiLuiRelations(String luiId) {
                 Query query = em
                                 .createNamedQuery("LuiLuiRelation.getLuiLuiRelationsByLuiId");
                 query.setParameter("luiId", luiId);
                 @SuppressWarnings("unchecked")
                 List<LuiLuiRelation> luiLuiRelations = query.getResultList();
                 return luiLuiRelations;
         }
 
         @Override
         public List<CluCluRelation> getCluCluRelationsByClu(String cluId) {
                 Query query = em.createNamedQuery("CluCluRelation.getCluCluRelation");
                 query.setParameter("cluId", cluId);
                 @SuppressWarnings("unchecked")
                 List<CluCluRelation> cluCluRelations = query.getResultList();
                 return cluCluRelations;
         }
 
         @Override
         public List<String> getCluIdsByLoId(String loId) {
                 Query query = em.createNamedQuery("Clu.getCluIdsByLoId");
                 query.setParameter("loId", loId);
                 @SuppressWarnings("unchecked")
                 List<String> cluIds = query.getResultList();
                 return cluIds;
         }
 
         @Override
         public List<String> getRelatedCluIdsByCluId(String cluId,
                         String luLuRelationTypeId) {
                 Query query = em
                                 .createNamedQuery("CluCluRelation.getRelatedCluIdsByCluId");
                 query.setParameter("cluId", cluId);
                 query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
                 @SuppressWarnings("unchecked")
                 List<String> relatedCluIds = query.getResultList();
                 return relatedCluIds;
         }
 
         @Override
     public List<String> getCluIdsByRelatedCluId(String relatedCluId, String luLuRelationTypeId) {
         Query query = em.createNamedQuery("CluCluRelation.getCluIdsByRelatedCluId");
         query.setParameter("relatedCluId", relatedCluId);
         query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
         @SuppressWarnings("unchecked")
         List<String> relatedCluIds = query.getResultList();
         return relatedCluIds;
     }
 
     @Override
         public List<Clu> getRelatedClusByCluId(String cluId,
                         String luLuRelationTypeId) {
                 Query query = em
                                 .createNamedQuery("CluCluRelation.getRelatedClusByCluId");
                 query.setParameter("cluId", cluId);
                 query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
                 @SuppressWarnings("unchecked")
                 List<Clu> relatedClus = query.getResultList();
                 return relatedClus;
         }
 
     @Override
         public List<Clu> getClusByRelatedCluId(String relatedCluId,
                         String luLuRelationTypeId) {
                 Query query = em
                                 .createNamedQuery("CluCluRelation.getClusByRelatedCluId");
                 query.setParameter("relatedCluId", relatedCluId);
                 query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
                 @SuppressWarnings("unchecked")
                 List<Clu> relatedClus = query.getResultList();
                 return relatedClus;
         }
     
     
     
         @Override
         public List<String> getRelatedLuiIdsByLuiId(String luiId,
                         String luLuRelationTypeId) {
                 Query query = em
                                 .createNamedQuery("LuiLuiRelation.getRelatedLuiIdsByLuiId");
                 query.setParameter("luiId", luiId);
                 query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
                 @SuppressWarnings("unchecked")
                 List<String> relatedLuiIds = query.getResultList();
                 return relatedLuiIds;
         }
 
         @Override
         public List<Lui> getRelatedLuisByLuiId(String luiId,
                         String luLuRelationTypeId) {
                 Query query = em
                                 .createNamedQuery("LuiLuiRelation.getRelatedLuisByLuiId");
                 query.setParameter("luiId", luiId);
                 query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
                 @SuppressWarnings("unchecked")
                 List<Lui> relatedLuis = query.getResultList();
                 return relatedLuis;
         }
 
         @Override
         public List<Clu> getClusByRelation(String parentCluId,
                         String luLuRelationTypeKey) {
                 Query query = em.createNamedQuery("Clu.getClusByRelation");
                 query.setParameter("parentCluId", parentCluId);
                 query.setParameter("luLuRelationTypeKey", luLuRelationTypeKey);
                 @SuppressWarnings("unchecked")
                 List<Clu> resultList = query.getResultList();
                 return resultList;
         }
 
         @Override
         public List<CluLoRelation> getCluLoRelationsByClu(String cluId) {
                 Query query = em
                                 .createNamedQuery("CluLoRelation.getCluLoRelationByClu");
                 query.setParameter("cluId", cluId);
                 @SuppressWarnings("unchecked")
                 List<CluLoRelation> cluLoRelations = query.getResultList();
                 return cluLoRelations;
         }
 
         @Override
         public List<CluLoRelation> getCluLoRelationsByLo(String loId) {
                 Query query = em
                                 .createNamedQuery("CluLoRelation.getCluLoRelationByLo");
                 query.setParameter("loId", loId);
                 @SuppressWarnings("unchecked")
                 List<CluLoRelation> cluLoRelations = query.getResultList();
                 return cluLoRelations;
         }
 
         @Override
         public List<CluLoRelation> getCluLoRelationsByCludIdAndLoId(String cluId,
                         String loId) {
                 Query query = em.createNamedQuery("CluLoRelation.getCluLoRelation");
                 query.setParameter("cluId", cluId);
                 query.setParameter("loId", loId);
 
                 @SuppressWarnings("unchecked")
                 List<CluLoRelation> rels = query.getResultList();
                 return rels;
         }
 
         @Override
         public List<String> getAllowedLuLuRelationTypesForLuType(String luTypeId,
                         String relatedLuTypeId) {
                 Query query = em
                                 .createNamedQuery("AllowedLuLuRelationType.getAllowedTypesByLuTypes");
                 query.setParameter("luTypeId", luTypeId);
                 query.setParameter("relatedLuTypeId", relatedLuTypeId);
                 @SuppressWarnings("unchecked")
                 List<String> resultList = query.getResultList();
                 return resultList;
         }
 
         @Override
         public List<String> getAllowedCluLoRelationTypesForLuType(String luTypeId) {
                 Query query = em
                                 .createNamedQuery("AllowedCluLoRealtionType.getAllowedTypesByLuType");
                 query.setParameter("luTypeId", luTypeId);
                 @SuppressWarnings("unchecked")
                 List<String> resultList = query.getResultList();
                 return resultList;
         }
 
         @Override
         public List<String> getAllowedResultUsageTypesForLuType(String luTypeId) {
                 Query query = em
                                 .createNamedQuery("AllowedResultUsageLuType.getAllowedTypesByLuType");
                 query.setParameter("luTypeId", luTypeId);
                 @SuppressWarnings("unchecked")
                 List<String> resultList = query.getResultList();
                 return resultList;
         }
 
         @Override
         public List<String> getAllowedResultComponentTypesForResultUsageType(
                         String resultUsageType) {
                 Query query = em
                                 .createNamedQuery("AllowedResultComponentUsageType.getAllowedComponentsByUsageType");
                 query.setParameter("resultUsageType", resultUsageType);
                 @SuppressWarnings("unchecked")
                 List<String> resultList = query.getResultList();
                 return resultList;
         }
 
         @Override
         public List<CluResultType> getAllowedCluResultTypesForLuType(String luTypeId) {
                 Query query = em
                                 .createNamedQuery("AllowedCluResultLuType.getAllowedTypesByLuType");
                 query.setParameter("luTypeId", luTypeId);
                 @SuppressWarnings("unchecked")
                 List<CluResultType> resultList = query.getResultList();
                 return resultList;
         }
 
         @Override
         public List<String> getCluIdsByResultUsageType(String resultUsageTypeKey) {
                 Query query = em
                                 .createNamedQuery("CluResult.getCluIdByResultUsageType");
                 query.setParameter("resultUsageType", resultUsageTypeKey);
                 @SuppressWarnings("unchecked")
                 List<String> resultList = query.getResultList();
                 return resultList;
         }
 
         @Override
         public List<String> getCluIdsByResultComponentId(String resultComponentId) {
                 Query query = em
                                 .createNamedQuery("CluResult.getCluIdByResultComponentId");
                 query.setParameter("resultComponentId", resultComponentId);
                 @SuppressWarnings("unchecked")
                 List<String> resultList = query.getResultList();
                 return resultList;
         }
 
         @Override
         public List<String> getAllowedLuLuRelationTypesByLuiId(String luiId,
                         String relatedLuiId) {
                 Query query = em
                                 .createNamedQuery("LuiLuiRelation.getRelationTypeByLuiId");
                 query.setParameter("luiId", luiId);
                 query.setParameter("relatedLuiId", relatedLuiId);
                 @SuppressWarnings("unchecked")
                 List<String> resultList = query.getResultList();
                 return resultList;
         }
 
         @Override
         public List<String> getAllowedLuLuRelationTypesByCluId(String cluId,
                         String relatedCluId) {
                 Query query = em
                                 .createNamedQuery("CluCluRelation.getRelationTypeByCluId");
                 query.setParameter("cluId", cluId);
                 query.setParameter("relatedCluId", relatedCluId);
                 @SuppressWarnings("unchecked")
                 List<String> resultList = query.getResultList();
                 return resultList;
         }
 
         @Override
         public List<CluResult> getCluResultByClu(String cluId) {
                 Query query = em
                                 .createNamedQuery("CluResult.getCluResultByCluId");
                 query.setParameter("cluId", cluId);
                 @SuppressWarnings("unchecked")
                 List<CluResult> resultList = query.getResultList();
                 return resultList;
         }
 
     @Override
     public Clu getLatestCluVersion(String cluVersionIndId) {
         Query query = em.createNamedQuery("Clu.findLatestClu");
         query.setParameter("versionIndId", cluVersionIndId);
         Clu clu = (Clu)query.getSingleResult();
         return clu;
     }
 
         @Override
         public Clu getCurrentCluVersion(String cluVersionIndId) {
         Query query = em.createNamedQuery("Clu.findCurrentClu");
         query.setParameter("versionIndId", cluVersionIndId);
         query.setParameter("currentTime", new Date());
         Clu clu = (Clu)query.getSingleResult();
         return clu;
         }
 
         @Override
         public VersionDisplayInfo getCurrentCluVersionInfo(String cluVersionIndId, String objectTypeURI) {
         Query query = em.createNamedQuery("Clu.findCurrentVersionInfo");
         query.setParameter("versionIndId", cluVersionIndId);
         query.setParameter("currentTime", new Date());
         VersionDisplayInfo versionDisplayInfo = (VersionDisplayInfo)query.getSingleResult();
         versionDisplayInfo.setObjectTypeURI(objectTypeURI);
         return versionDisplayInfo;
         }
 
         @Override
         public VersionDisplayInfo getCurrentVersionOnDate(String versionIndId,
                         String objectTypeURI, Date date) {
         Query query = em.createNamedQuery("Clu.findCurrentVersionOnDate");
         query.setParameter("versionIndId", versionIndId);
         query.setParameter("date", date);
         VersionDisplayInfo versionDisplayInfo = (VersionDisplayInfo)query.getSingleResult();
         versionDisplayInfo.setObjectTypeURI(objectTypeURI);
         return versionDisplayInfo;
         }
 
         @Override
         public VersionDisplayInfo getFirstVersion(String versionIndId,
                         String objectTypeURI) {
         Query query = em.createNamedQuery("Clu.findFirstVersion");
         query.setParameter("versionIndId", versionIndId);
         VersionDisplayInfo versionDisplayInfo = (VersionDisplayInfo)query.getSingleResult();
         versionDisplayInfo.setObjectTypeURI(objectTypeURI);
         return versionDisplayInfo;
         }
 
         @Override
         public VersionDisplayInfo getLatestVersion(String versionIndId,
                         String objectTypeURI) {
         Query query = em.createNamedQuery("Clu.findLatestVersion");
         query.setParameter("versionIndId", versionIndId);
         VersionDisplayInfo versionDisplayInfo = (VersionDisplayInfo)query.getSingleResult();
         versionDisplayInfo.setObjectTypeURI(objectTypeURI);
         return versionDisplayInfo;
         }
 
         @Override
         public VersionDisplayInfo getVersionBySequenceNumber(String versionIndId,
                         String objectTypeURI, Long sequenceNumber) {
         Query query = em.createNamedQuery("Clu.findVersionBySequence");
         query.setParameter("versionIndId", versionIndId);
         query.setParameter("sequenceNumber", sequenceNumber);
         VersionDisplayInfo versionDisplayInfo = (VersionDisplayInfo)query.getSingleResult();
         versionDisplayInfo.setObjectTypeURI(objectTypeURI);
         return versionDisplayInfo;
         }
 
         @Override
         public List<VersionDisplayInfo> getVersions(String versionIndId,
                         String objectTypeURI) {
         Query query = em.createNamedQuery("Clu.findVersions");
         query.setParameter("versionIndId", versionIndId);
         List<VersionDisplayInfo> versionDisplayInfos = (List<VersionDisplayInfo>)query.getResultList();
         if(versionDisplayInfos==null){
                 versionDisplayInfos = Collections.emptyList();
         }
         for(VersionDisplayInfo versionDisplayInfo:versionDisplayInfos){
                 versionDisplayInfo.setObjectTypeURI(objectTypeURI);
         }
         return versionDisplayInfos;
         }
 
         @Override
         public List<VersionDisplayInfo> getVersionsInDateRange(String versionIndId,
                         String objectTypeURI, Date from, Date to) {
                 if(from==null&&to==null){
                         throw new IllegalArgumentException("from and to dates can not both be null");
                 }
                 Query query;
                 if(from==null){
                         query = em.createNamedQuery("Clu.findVersionsBeforeDate");
                 query.setParameter("versionIndId", versionIndId);
                 query.setParameter("date", to);                        
                 }else if(to==null){
                         query = em.createNamedQuery("Clu.findVersionsAfterDate");
                 query.setParameter("versionIndId", versionIndId);
                 query.setParameter("date", from);
                 }else{
                         query = em.createNamedQuery("Clu.findVersionsInDateRange");
                 query.setParameter("versionIndId", versionIndId);
                 query.setParameter("from", from);
                 query.setParameter("to", to);
                 }
                 
         List<VersionDisplayInfo> versionDisplayInfos = (List<VersionDisplayInfo>)query.getResultList();
         if(versionDisplayInfos==null){
                 versionDisplayInfos = Collections.emptyList();
         }
         for(VersionDisplayInfo versionDisplayInfo:versionDisplayInfos){
                 versionDisplayInfo.setObjectTypeURI(objectTypeURI);
         }
         return versionDisplayInfos;
         }
 
         @Override
         public List<CluPublication> getCluPublicationsByType(
                         String luPublicationTypeKey) {
         Query query = em.createNamedQuery("CluPublication.findCluPublicationsByType");
         query.setParameter("luPublicationTypeKey", luPublicationTypeKey);
         List<CluPublication> cluPublications = query.getResultList();
         return cluPublications;
         }
 
         @Override
         public List<CluPublication> getCluPublicationsByCluId(String cluId) {
         Query query = em.createNamedQuery("CluPublication.findPublicationsByCluId");
         query.setParameter("cluId", cluId);
         List<CluPublication> cluPublications = query.getResultList();
         return cluPublications;
         }
 
         @Override
         public List<CluSet> getCluSetsByCluVersionIndId(List<String> cluVersionIndIds) {
         Query query = em.createNamedQuery("CluSet.findCluSetsByCluVersionIndIds");
         query.setParameter("cluVersionIndIds", cluVersionIndIds);
         List<CluSet> cluSetIds = query.getResultList();
         return cluSetIds;
         }
 
         @Override
         public List<CluSet> getAllDynamicCluSets() {
         Query query = em.createNamedQuery("CluSet.findAllDynamicCluSets");
         List<CluSet> cluSetIds = query.getResultList();
         return cluSetIds;
         }
 
         @Override
         public List<Clu> getCrossListedClusByCodes(List<String> crossListedCodes) {
                 if(crossListedCodes!=null && crossListedCodes.isEmpty()){
                         crossListedCodes.add(""); //Add a blank param value because jpql IN(:var) has problems with empty lists
                 }
         Query query = em.createNamedQuery("Clu.getCrossListedClusByCodes");
         query.setParameter("crossListedCodes", crossListedCodes);
         List<Clu> clus = query.getResultList();
         return clus;
         }
         
 }

1		/**
2		* Copyright 2010 The Kuali Foundation Licensed under the
3		* Educational Community License, Version 2.0 (the "License"); you may
4		* not use this file except in compliance with the License. You may
5		* obtain a copy of the License at
6		*
7		* http://www.osedu.org/licenses/ECL-2.0
8		*
9		* Unless required by applicable law or agreed to in writing,
10		* software distributed under the License is distributed on an "AS IS"
11		* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
12		* or implied. See the License for the specific language governing
13		* permissions and limitations under the License.
14		*/
15
16		package org.kuali.student.lum.lu.dao.impl;
17
18		import java.util.Collections;
19		import java.util.Date;
20		import java.util.List;
21
22		import javax.persistence.EntityManager;
23		import javax.persistence.PersistenceContext;
24		import javax.persistence.Query;
25
26		import org.kuali.student.common.dao.impl.AbstractSearchableCrudDaoImpl;
27		import org.kuali.student.common.versionmanagement.dto.VersionDisplayInfo;
28		import org.kuali.student.lum.lu.dao.LuDao;
29		import org.kuali.student.lum.lu.entity.Clu;
30		import org.kuali.student.lum.lu.entity.CluCluRelation;
31		import org.kuali.student.lum.lu.entity.CluLoRelation;
32		import org.kuali.student.lum.lu.entity.CluPublication;
33		import org.kuali.student.lum.lu.entity.CluResult;
34		import org.kuali.student.lum.lu.entity.CluResultType;
35		import org.kuali.student.lum.lu.entity.CluSet;
36		import org.kuali.student.lum.lu.entity.Lui;
37		import org.kuali.student.lum.lu.entity.LuiLuiRelation;
38
39
40	0	public class LuDaoImpl extends AbstractSearchableCrudDaoImpl implements LuDao {
41
42		@PersistenceContext(unitName = "Lu")
43		@Override
44		public void setEm(EntityManager em) {
45	0	super.setEm(em);
46	0	}
47
48		@Override
49		public List<Clu> getClusByIdList(List<String> cluIdList) {
50	0	Query query = em.createNamedQuery("Clu.findClusByIdList");
51	0	query.setParameter("idList", cluIdList);
52		@SuppressWarnings("unchecked")
53	0	List<Clu> resultList = query.getResultList();
54	0	return resultList;
55		}
56
57		@Override
58		public List<Clu> getClusByLuType(String luTypeKey, String luState) {
59	0	Query query = em.createNamedQuery("Clu.getClusByLuType");
60	0	query.setParameter("luTypeKey", luTypeKey);
61	0	query.setParameter("luState", luState);
62		@SuppressWarnings("unchecked")
63	0	List<Clu> resultList = query.getResultList();
64	0	return resultList;
65		}
66
67		@Override
68		public List<CluSet> getCluSetInfoByIdList(List<String> cluSetIdList) {
69	0	Query query = em.createNamedQuery("CluSet.getCluSetInfoByIdList");
70	0	query.setParameter("cluSetIdList", cluSetIdList);
71		@SuppressWarnings("unchecked")
72	0	List<CluSet> resultList = query.getResultList();
73	0	return resultList;
74		}
75
76		@Override
77		public List<Lui> getLuisByIdList(List<String> luiIds) {
78	0	Query query = em.createNamedQuery("Lui.getLuisByIdList");
79	0	query.setParameter("luiIdList", luiIds);
80		@SuppressWarnings("unchecked")
81	0	List<Lui> luis = query.getResultList();
82	0	return luis;
83		}
84
85		@Override
86		public List<String> getLuiIdsByCluId(String cluId) {
87	0	Query query = em.createNamedQuery("Lui.getLuiIdsByCluId");
88	0	query.setParameter("cluId", cluId);
89		@SuppressWarnings("unchecked")
90	0	List<String> luiIds = query.getResultList();
91	0	return luiIds;
92		}
93
94		@Override
95		public List<Lui> getLuisByRelationType(String luiId,
96		String luLuRelationTypeId) {
97	0	Query query = em
98		.createNamedQuery("LuiLuiRelation.getLuisByRelationType");
99	0	query.setParameter("luiId", luiId);
100	0	query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
101
102		@SuppressWarnings("unchecked")
103	0	List<Lui> luis = query.getResultList();
104	0	return luis;
105		}
106
107		@Override
108		public List<String> getLuiIdsByRelationType(String relatedLuiId,
109		String luLuRelationTypeId) {
110	0	Query query = em
111		.createNamedQuery("LuiLuiRelation.getLuiIdsByRelationType");
112	0	query.setParameter("luiId", relatedLuiId);
113	0	query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
114
115		@SuppressWarnings("unchecked")
116	0	List<String> luiIds = query.getResultList();
117	0	return luiIds;
118		}
119
120		@Override
121		public List<String> getLuiIdsInAtpByCluId(String cluId, String atpKey) {
122	0	Query query = em.createNamedQuery("Lui.getLuiIdsInAtpByCluId");
123	0	query.setParameter("cluId", cluId);
124	0	query.setParameter("atpKey", atpKey);
125		@SuppressWarnings("unchecked")
126	0	List<String> luiIds = query.getResultList();
127	0	return luiIds;
128		}
129
130		@Override
131		public Boolean isCluInCluSet(String cluId, String cluSetId) {
132	0	Query query = em.createNamedQuery("CluSet.isCluInCluSet");
133	0	query.setParameter("cluId", cluId);
134	0	query.setParameter("cluSetId", cluSetId);
135	0	Long valid = (Long) query.getSingleResult();
136	0	return valid.intValue() > 0;
137		}
138
139		@Override
140		public List<LuiLuiRelation> getLuiLuiRelations(String luiId) {
141	0	Query query = em
142		.createNamedQuery("LuiLuiRelation.getLuiLuiRelationsByLuiId");
143	0	query.setParameter("luiId", luiId);
144		@SuppressWarnings("unchecked")
145	0	List<LuiLuiRelation> luiLuiRelations = query.getResultList();
146	0	return luiLuiRelations;
147		}
148
149		@Override
150		public List<CluCluRelation> getCluCluRelationsByClu(String cluId) {
151	0	Query query = em.createNamedQuery("CluCluRelation.getCluCluRelation");
152	0	query.setParameter("cluId", cluId);
153		@SuppressWarnings("unchecked")
154	0	List<CluCluRelation> cluCluRelations = query.getResultList();
155	0	return cluCluRelations;
156		}
157
158		@Override
159		public List<String> getCluIdsByLoId(String loId) {
160	0	Query query = em.createNamedQuery("Clu.getCluIdsByLoId");
161	0	query.setParameter("loId", loId);
162		@SuppressWarnings("unchecked")
163	0	List<String> cluIds = query.getResultList();
164	0	return cluIds;
165		}
166
167		@Override
168		public List<String> getRelatedCluIdsByCluId(String cluId,
169		String luLuRelationTypeId) {
170	0	Query query = em
171		.createNamedQuery("CluCluRelation.getRelatedCluIdsByCluId");
172	0	query.setParameter("cluId", cluId);
173	0	query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
174		@SuppressWarnings("unchecked")
175	0	List<String> relatedCluIds = query.getResultList();
176	0	return relatedCluIds;
177		}
178
179		@Override
180		public List<String> getCluIdsByRelatedCluId(String relatedCluId, String luLuRelationTypeId) {
181	0	Query query = em.createNamedQuery("CluCluRelation.getCluIdsByRelatedCluId");
182	0	query.setParameter("relatedCluId", relatedCluId);
183	0	query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
184		@SuppressWarnings("unchecked")
185	0	List<String> relatedCluIds = query.getResultList();
186	0	return relatedCluIds;
187		}
188
189		@Override
190		public List<Clu> getRelatedClusByCluId(String cluId,
191		String luLuRelationTypeId) {
192	0	Query query = em
193		.createNamedQuery("CluCluRelation.getRelatedClusByCluId");
194	0	query.setParameter("cluId", cluId);
195	0	query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
196		@SuppressWarnings("unchecked")
197	0	List<Clu> relatedClus = query.getResultList();
198	0	return relatedClus;
199		}
200
201		@Override
202		public List<Clu> getClusByRelatedCluId(String relatedCluId,
203		String luLuRelationTypeId) {
204	0	Query query = em
205		.createNamedQuery("CluCluRelation.getClusByRelatedCluId");
206	0	query.setParameter("relatedCluId", relatedCluId);
207	0	query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
208		@SuppressWarnings("unchecked")
209	0	List<Clu> relatedClus = query.getResultList();
210	0	return relatedClus;
211		}
212
213
214
215		@Override
216		public List<String> getRelatedLuiIdsByLuiId(String luiId,
217		String luLuRelationTypeId) {
218	0	Query query = em
219		.createNamedQuery("LuiLuiRelation.getRelatedLuiIdsByLuiId");
220	0	query.setParameter("luiId", luiId);
221	0	query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
222		@SuppressWarnings("unchecked")
223	0	List<String> relatedLuiIds = query.getResultList();
224	0	return relatedLuiIds;
225		}
226
227		@Override
228		public List<Lui> getRelatedLuisByLuiId(String luiId,
229		String luLuRelationTypeId) {
230	0	Query query = em
231		.createNamedQuery("LuiLuiRelation.getRelatedLuisByLuiId");
232	0	query.setParameter("luiId", luiId);
233	0	query.setParameter("luLuRelationTypeId", luLuRelationTypeId);
234		@SuppressWarnings("unchecked")
235	0	List<Lui> relatedLuis = query.getResultList();
236	0	return relatedLuis;
237		}
238
239		@Override
240		public List<Clu> getClusByRelation(String parentCluId,
241		String luLuRelationTypeKey) {
242	0	Query query = em.createNamedQuery("Clu.getClusByRelation");
243	0	query.setParameter("parentCluId", parentCluId);
244	0	query.setParameter("luLuRelationTypeKey", luLuRelationTypeKey);
245		@SuppressWarnings("unchecked")
246	0	List<Clu> resultList = query.getResultList();
247	0	return resultList;
248		}
249
250		@Override
251		public List<CluLoRelation> getCluLoRelationsByClu(String cluId) {
252	0	Query query = em
253		.createNamedQuery("CluLoRelation.getCluLoRelationByClu");
254	0	query.setParameter("cluId", cluId);
255		@SuppressWarnings("unchecked")
256	0	List<CluLoRelation> cluLoRelations = query.getResultList();
257	0	return cluLoRelations;
258		}
259
260		@Override
261		public List<CluLoRelation> getCluLoRelationsByLo(String loId) {
262	0	Query query = em
263		.createNamedQuery("CluLoRelation.getCluLoRelationByLo");
264	0	query.setParameter("loId", loId);
265		@SuppressWarnings("unchecked")
266	0	List<CluLoRelation> cluLoRelations = query.getResultList();
267	0	return cluLoRelations;
268		}
269
270		@Override
271		public List<CluLoRelation> getCluLoRelationsByCludIdAndLoId(String cluId,
272		String loId) {
273	0	Query query = em.createNamedQuery("CluLoRelation.getCluLoRelation");
274	0	query.setParameter("cluId", cluId);
275	0	query.setParameter("loId", loId);
276
277		@SuppressWarnings("unchecked")
278	0	List<CluLoRelation> rels = query.getResultList();
279	0	return rels;
280		}
281
282		@Override
283		public List<String> getAllowedLuLuRelationTypesForLuType(String luTypeId,
284		String relatedLuTypeId) {
285	0	Query query = em
286		.createNamedQuery("AllowedLuLuRelationType.getAllowedTypesByLuTypes");
287	0	query.setParameter("luTypeId", luTypeId);
288	0	query.setParameter("relatedLuTypeId", relatedLuTypeId);
289		@SuppressWarnings("unchecked")
290	0	List<String> resultList = query.getResultList();
291	0	return resultList;
292		}
293
294		@Override
295		public List<String> getAllowedCluLoRelationTypesForLuType(String luTypeId) {
296	0	Query query = em
297		.createNamedQuery("AllowedCluLoRealtionType.getAllowedTypesByLuType");
298	0	query.setParameter("luTypeId", luTypeId);
299		@SuppressWarnings("unchecked")
300	0	List<String> resultList = query.getResultList();
301	0	return resultList;
302		}
303
304		@Override
305		public List<String> getAllowedResultUsageTypesForLuType(String luTypeId) {
306	0	Query query = em
307		.createNamedQuery("AllowedResultUsageLuType.getAllowedTypesByLuType");
308	0	query.setParameter("luTypeId", luTypeId);
309		@SuppressWarnings("unchecked")
310	0	List<String> resultList = query.getResultList();
311	0	return resultList;
312		}
313
314		@Override
315		public List<String> getAllowedResultComponentTypesForResultUsageType(
316		String resultUsageType) {
317	0	Query query = em
318		.createNamedQuery("AllowedResultComponentUsageType.getAllowedComponentsByUsageType");
319	0	query.setParameter("resultUsageType", resultUsageType);
320		@SuppressWarnings("unchecked")
321	0	List<String> resultList = query.getResultList();
322	0	return resultList;
323		}
324
325		@Override
326		public List<CluResultType> getAllowedCluResultTypesForLuType(String luTypeId) {
327	0	Query query = em
328		.createNamedQuery("AllowedCluResultLuType.getAllowedTypesByLuType");
329	0	query.setParameter("luTypeId", luTypeId);
330		@SuppressWarnings("unchecked")
331	0	List<CluResultType> resultList = query.getResultList();
332	0	return resultList;
333		}
334
335		@Override
336		public List<String> getCluIdsByResultUsageType(String resultUsageTypeKey) {
337	0	Query query = em
338		.createNamedQuery("CluResult.getCluIdByResultUsageType");
339	0	query.setParameter("resultUsageType", resultUsageTypeKey);
340		@SuppressWarnings("unchecked")
341	0	List<String> resultList = query.getResultList();
342	0	return resultList;
343		}
344
345		@Override
346		public List<String> getCluIdsByResultComponentId(String resultComponentId) {
347	0	Query query = em
348		.createNamedQuery("CluResult.getCluIdByResultComponentId");
349	0	query.setParameter("resultComponentId", resultComponentId);
350		@SuppressWarnings("unchecked")
351	0	List<String> resultList = query.getResultList();
352	0	return resultList;
353		}
354
355		@Override
356		public List<String> getAllowedLuLuRelationTypesByLuiId(String luiId,
357		String relatedLuiId) {
358	0	Query query = em
359		.createNamedQuery("LuiLuiRelation.getRelationTypeByLuiId");
360	0	query.setParameter("luiId", luiId);
361	0	query.setParameter("relatedLuiId", relatedLuiId);
362		@SuppressWarnings("unchecked")
363	0	List<String> resultList = query.getResultList();
364	0	return resultList;
365		}
366
367		@Override
368		public List<String> getAllowedLuLuRelationTypesByCluId(String cluId,
369		String relatedCluId) {
370	0	Query query = em
371		.createNamedQuery("CluCluRelation.getRelationTypeByCluId");
372	0	query.setParameter("cluId", cluId);
373	0	query.setParameter("relatedCluId", relatedCluId);
374		@SuppressWarnings("unchecked")
375	0	List<String> resultList = query.getResultList();
376	0	return resultList;
377		}
378
379		@Override
380		public List<CluResult> getCluResultByClu(String cluId) {
381	0	Query query = em
382		.createNamedQuery("CluResult.getCluResultByCluId");
383	0	query.setParameter("cluId", cluId);
384		@SuppressWarnings("unchecked")
385	0	List<CluResult> resultList = query.getResultList();
386	0	return resultList;
387		}
388
389		@Override
390		public Clu getLatestCluVersion(String cluVersionIndId) {
391	0	Query query = em.createNamedQuery("Clu.findLatestClu");
392	0	query.setParameter("versionIndId", cluVersionIndId);
393	0	Clu clu = (Clu)query.getSingleResult();
394	0	return clu;
395		}
396
397		@Override
398		public Clu getCurrentCluVersion(String cluVersionIndId) {
399	0	Query query = em.createNamedQuery("Clu.findCurrentClu");
400	0	query.setParameter("versionIndId", cluVersionIndId);
401	0	query.setParameter("currentTime", new Date());
402	0	Clu clu = (Clu)query.getSingleResult();
403	0	return clu;
404		}
405
406		@Override
407		public VersionDisplayInfo getCurrentCluVersionInfo(String cluVersionIndId, String objectTypeURI) {
408	0	Query query = em.createNamedQuery("Clu.findCurrentVersionInfo");
409	0	query.setParameter("versionIndId", cluVersionIndId);
410	0	query.setParameter("currentTime", new Date());
411	0	VersionDisplayInfo versionDisplayInfo = (VersionDisplayInfo)query.getSingleResult();
412	0	versionDisplayInfo.setObjectTypeURI(objectTypeURI);
413	0	return versionDisplayInfo;
414		}
415
416		@Override
417		public VersionDisplayInfo getCurrentVersionOnDate(String versionIndId,
418		String objectTypeURI, Date date) {
419	0	Query query = em.createNamedQuery("Clu.findCurrentVersionOnDate");
420	0	query.setParameter("versionIndId", versionIndId);
421	0	query.setParameter("date", date);
422	0	VersionDisplayInfo versionDisplayInfo = (VersionDisplayInfo)query.getSingleResult();
423	0	versionDisplayInfo.setObjectTypeURI(objectTypeURI);
424	0	return versionDisplayInfo;
425		}
426
427		@Override
428		public VersionDisplayInfo getFirstVersion(String versionIndId,
429		String objectTypeURI) {
430	0	Query query = em.createNamedQuery("Clu.findFirstVersion");
431	0	query.setParameter("versionIndId", versionIndId);
432	0	VersionDisplayInfo versionDisplayInfo = (VersionDisplayInfo)query.getSingleResult();
433	0	versionDisplayInfo.setObjectTypeURI(objectTypeURI);
434	0	return versionDisplayInfo;
435		}
436
437		@Override
438		public VersionDisplayInfo getLatestVersion(String versionIndId,
439		String objectTypeURI) {
440	0	Query query = em.createNamedQuery("Clu.findLatestVersion");
441	0	query.setParameter("versionIndId", versionIndId);
442	0	VersionDisplayInfo versionDisplayInfo = (VersionDisplayInfo)query.getSingleResult();
443	0	versionDisplayInfo.setObjectTypeURI(objectTypeURI);
444	0	return versionDisplayInfo;
445		}
446
447		@Override
448		public VersionDisplayInfo getVersionBySequenceNumber(String versionIndId,
449		String objectTypeURI, Long sequenceNumber) {
450	0	Query query = em.createNamedQuery("Clu.findVersionBySequence");
451	0	query.setParameter("versionIndId", versionIndId);
452	0	query.setParameter("sequenceNumber", sequenceNumber);
453	0	VersionDisplayInfo versionDisplayInfo = (VersionDisplayInfo)query.getSingleResult();
454	0	versionDisplayInfo.setObjectTypeURI(objectTypeURI);
455	0	return versionDisplayInfo;
456		}
457
458		@Override
459		public List<VersionDisplayInfo> getVersions(String versionIndId,
460		String objectTypeURI) {
461	0	Query query = em.createNamedQuery("Clu.findVersions");
462	0	query.setParameter("versionIndId", versionIndId);
463	0	List<VersionDisplayInfo> versionDisplayInfos = (List<VersionDisplayInfo>)query.getResultList();
464	0	if(versionDisplayInfos==null){
465	0	versionDisplayInfos = Collections.emptyList();
466		}
467	0	for(VersionDisplayInfo versionDisplayInfo:versionDisplayInfos){
468	0	versionDisplayInfo.setObjectTypeURI(objectTypeURI);
469		}
470	0	return versionDisplayInfos;
471		}
472
473		@Override
474		public List<VersionDisplayInfo> getVersionsInDateRange(String versionIndId,
475		String objectTypeURI, Date from, Date to) {
476	0	if(from==null&&to==null){
477	0	throw new IllegalArgumentException("from and to dates can not both be null");
478		}
479		Query query;
480	0	if(from==null){
481	0	query = em.createNamedQuery("Clu.findVersionsBeforeDate");
482	0	query.setParameter("versionIndId", versionIndId);
483	0	query.setParameter("date", to);
484	0	}else if(to==null){
485	0	query = em.createNamedQuery("Clu.findVersionsAfterDate");
486	0	query.setParameter("versionIndId", versionIndId);
487	0	query.setParameter("date", from);
488		}else{
489	0	query = em.createNamedQuery("Clu.findVersionsInDateRange");
490	0	query.setParameter("versionIndId", versionIndId);
491	0	query.setParameter("from", from);
492	0	query.setParameter("to", to);
493		}
494
495	0	List<VersionDisplayInfo> versionDisplayInfos = (List<VersionDisplayInfo>)query.getResultList();
496	0	if(versionDisplayInfos==null){
497	0	versionDisplayInfos = Collections.emptyList();
498		}
499	0	for(VersionDisplayInfo versionDisplayInfo:versionDisplayInfos){
500	0	versionDisplayInfo.setObjectTypeURI(objectTypeURI);
501		}
502	0	return versionDisplayInfos;
503		}
504
505		@Override
506		public List<CluPublication> getCluPublicationsByType(
507		String luPublicationTypeKey) {
508	0	Query query = em.createNamedQuery("CluPublication.findCluPublicationsByType");
509	0	query.setParameter("luPublicationTypeKey", luPublicationTypeKey);
510	0	List<CluPublication> cluPublications = query.getResultList();
511	0	return cluPublications;
512		}
513
514		@Override
515		public List<CluPublication> getCluPublicationsByCluId(String cluId) {
516	0	Query query = em.createNamedQuery("CluPublication.findPublicationsByCluId");
517	0	query.setParameter("cluId", cluId);
518	0	List<CluPublication> cluPublications = query.getResultList();
519	0	return cluPublications;
520		}
521
522		@Override
523		public List<CluSet> getCluSetsByCluVersionIndId(List<String> cluVersionIndIds) {
524	0	Query query = em.createNamedQuery("CluSet.findCluSetsByCluVersionIndIds");
525	0	query.setParameter("cluVersionIndIds", cluVersionIndIds);
526	0	List<CluSet> cluSetIds = query.getResultList();
527	0	return cluSetIds;
528		}
529
530		@Override
531		public List<CluSet> getAllDynamicCluSets() {
532	0	Query query = em.createNamedQuery("CluSet.findAllDynamicCluSets");
533	0	List<CluSet> cluSetIds = query.getResultList();
534	0	return cluSetIds;
535		}
536
537		@Override
538		public List<Clu> getCrossListedClusByCodes(List<String> crossListedCodes) {
539	0	if(crossListedCodes!=null && crossListedCodes.isEmpty()){
540	0	crossListedCodes.add(""); //Add a blank param value because jpql IN(:var) has problems with empty lists
541		}
542	0	Query query = em.createNamedQuery("Clu.getCrossListedClusByCodes");
543	0	query.setParameter("crossListedCodes", crossListedCodes);
544	0	List<Clu> clus = query.getResultList();
545	0	return clus;
546		}
547
548		}