3 * Copyright (C) 2007 EDIT
4 * European Distributed Institute of Taxonomy
5 * http://www.e-taxonomy.eu
7 * The contents of this file are subject to the Mozilla Public License Version 1.1
8 * See LICENSE.TXT at the top of this package for the full license terms.
11 package eu
.etaxonomy
.cdm
.api
.service
;
13 import java
.util
.Collection
;
14 import java
.util
.HashMap
;
15 import java
.util
.Iterator
;
16 import java
.util
.List
;
20 import org
.apache
.log4j
.Logger
;
21 import org
.hibernate
.collection
.spi
.PersistentCollection
;
22 import org
.springframework
.beans
.factory
.annotation
.Autowired
;
23 import org
.springframework
.stereotype
.Service
;
24 //import org.springframework.transaction.annotation.Propagation;
25 import org
.springframework
.transaction
.annotation
.Transactional
;
27 import eu
.etaxonomy
.cdm
.model
.common
.CdmBase
;
28 import eu
.etaxonomy
.cdm
.model
.common
.ISourceable
;
29 import eu
.etaxonomy
.cdm
.model
.common
.IdentifiableEntity
;
30 import eu
.etaxonomy
.cdm
.model
.common
.OriginalSourceBase
;
31 import eu
.etaxonomy
.cdm
.model
.metadata
.CdmMetaData
;
32 import eu
.etaxonomy
.cdm
.model
.metadata
.CdmMetaData
.MetaDataPropertyName
;
33 import eu
.etaxonomy
.cdm
.persistence
.dao
.common
.ICdmGenericDao
;
34 import eu
.etaxonomy
.cdm
.persistence
.dao
.common
.IOriginalSourceDao
;
35 import eu
.etaxonomy
.cdm
.strategy
.match
.DefaultMatchStrategy
;
36 import eu
.etaxonomy
.cdm
.strategy
.match
.IMatchStrategy
;
37 import eu
.etaxonomy
.cdm
.strategy
.match
.IMatchable
;
38 import eu
.etaxonomy
.cdm
.strategy
.match
.MatchException
;
39 import eu
.etaxonomy
.cdm
.strategy
.merge
.DefaultMergeStrategy
;
40 import eu
.etaxonomy
.cdm
.strategy
.merge
.IMergable
;
41 import eu
.etaxonomy
.cdm
.strategy
.merge
.IMergeStrategy
;
42 import eu
.etaxonomy
.cdm
.strategy
.merge
.MergeException
;
46 @Transactional(readOnly
= true)
47 public class CommonServiceImpl
extends ServiceBase
<OriginalSourceBase
,IOriginalSourceDao
> implements ICommonService
{
48 @SuppressWarnings("unused")
49 private static final Logger logger
= Logger
.getLogger(CommonServiceImpl
.class);
52 IOriginalSourceDao originalSourceDao
;
55 ICdmGenericDao genericDao
;
59 protected void setDao(IOriginalSourceDao dao
) {
64 public CdmBase
find(Class
<?
extends CdmBase
> clazz
, int id
){
65 return genericDao
.find(clazz
, id
);
70 public Map
<String
, ?
extends ISourceable
> getSourcedObjectsByIdInSource(Class clazz
, Set
<String
> idInSourceSet
, String idNamespace
) {
71 Map
<String
, ?
extends ISourceable
> list
= originalSourceDao
.findOriginalSourcesByIdInSource(clazz
, idInSourceSet
, idNamespace
);
76 public ISourceable
getSourcedObjectByIdInSource(Class clazz
, String idInSource
, String idNamespace
) {
77 ISourceable result
= null;
78 List
<IdentifiableEntity
> list
= originalSourceDao
.findOriginalSourceByIdInSource(clazz
, idInSource
, idNamespace
);
79 if (! list
.isEmpty()){
86 public Set
<CdmBase
> getReferencingObjects(CdmBase referencedCdmBase
){
87 return this.genericDao
.getReferencingObjects(referencedCdmBase
);
90 // Set<Class<? extends CdmBase>> allCdmClasses = genericDao.getAllCdmClasses(false); //findAllCdmClasses();
92 // referencedCdmBase = (CdmBase)HibernateProxyHelper.deproxy(referencedCdmBase);
93 // Class referencedClass = referencedCdmBase.getClass();
94 // Set<CdmBase> result = new HashSet<CdmBase>();
95 // logger.debug("Referenced Class: " + referencedClass.getName());
97 // for (Class<? extends CdmBase> cdmClass : allCdmClasses){
98 // Set<Field> fields = getFields(cdmClass);
99 // for (Field field: fields){
100 // Class<?> type = field.getType();
102 // if (! type.isInterface()){
103 // if (referencedClass.isAssignableFrom(type)||
104 // type.isAssignableFrom(referencedClass) && CdmBase.class.isAssignableFrom(type)){
105 // handleSingleClass(referencedClass, type, field, cdmClass, result, referencedCdmBase, false);
108 // }else if (type.isAssignableFrom(referencedClass)){
109 // handleSingleClass(referencedClass, type, field, cdmClass, result, referencedCdmBase, false);
110 // }else if (Collection.class.isAssignableFrom(type)){
112 // if (checkIsSetOfType(field, referencedClass, type) == true){
113 // handleSingleClass(referencedClass, type, field, cdmClass, result, referencedCdmBase, true);
116 //// Class[] interfaces = referencedClass.getInterfaces();
117 //// for (Class interfaze: interfaces){
118 //// if (interfaze == type){
119 ////// if(interfaze.isAssignableFrom(returnType)){
120 //// handleSingleClass(interfaze, type, field, cdmClass, result, referencedCdmBase);
126 // } catch (Exception e) {
127 // e.printStackTrace();
128 // throw new RuntimeException(e);
133 // private boolean checkIsSetOfType(Field field, Class referencedClass, Class<?> type){
134 // Type genericType = (ParameterizedTypeImpl)field.getGenericType();
135 // if (genericType instanceof ParameterizedTypeImpl){
136 // ParameterizedTypeImpl paraType = (ParameterizedTypeImpl)genericType;
137 // paraType.getRawType();
138 // Type[] arguments = paraType.getActualTypeArguments();
139 // //logger.debug(arguments.length);
140 // if (arguments.length == 1){
141 // Class collectionClass;
143 // if (arguments[0] instanceof Class){
144 // collectionClass = (Class)arguments[0];
145 // }else if(arguments[0] instanceof TypeVariableImpl){
146 // TypeVariableImpl typeVariable = (TypeVariableImpl)arguments[0];
147 // GenericDeclaration genericDeclaration = typeVariable.getGenericDeclaration();
148 // collectionClass = (Class)genericDeclaration;
150 // logger.warn("Unknown Type");
153 // if (CdmBase.class.isAssignableFrom(collectionClass) && collectionClass.isAssignableFrom(referencedClass) ){
156 // } catch (Exception e) {
157 // logger.warn(e.getMessage());
160 // logger.warn("Length of arguments <> 1");
163 // logger.warn("Not a generic type of type ParameterizedTypeImpl");
171 // private boolean handleSingleClass(Class itemClass, Class type, Field field, Class cdmClass, Set<CdmBase> result,CdmBase value, boolean isCollection){
172 // if (! Modifier.isStatic(field.getModifiers())){
173 // String methodName = StringUtils.rightPad(field.getName(), 30);
174 // String className = StringUtils.rightPad(cdmClass.getSimpleName(), 30);
175 // String returnTypeName = StringUtils.rightPad(type.getSimpleName(), 30);
177 // logger.debug(methodName + "\t\t" + className + "\t\t" + returnTypeName);
178 //// result_old.add(method);
179 // result.addAll(getCdmBasesByFieldAndClass(field, itemClass, cdmClass, value, isCollection));
184 // private Set<Field> getFields(Class clazz){
185 // Set<Field> result = new HashSet<Field>();
186 // for (Field field: clazz.getDeclaredFields()){
187 // if (!Modifier.isStatic(field.getModifiers())){
188 // result.add(field);
191 // Class superclass = clazz.getSuperclass();
192 // if (CdmBase.class.isAssignableFrom(superclass)){
193 // result.addAll(getFields(superclass));
198 // private Set<CdmBase> getCdmBasesByFieldAndClass(Field field, Class itemClass, Class otherClazz, CdmBase item, boolean isCollection){
199 // Set<CdmBase> result = new HashSet<CdmBase>();
200 // if (isCollection){
201 // result.addAll(genericDao.getCdmBasesWithItemInCollection(itemClass, otherClazz, field.getName(), item));
203 // result.addAll(genericDao.getCdmBasesByFieldAndClass(otherClazz, field.getName(), item));
209 public List
getHqlResult(String hqlQuery
){
210 return genericDao
.getHqlResult(hqlQuery
);
214 public <T
extends IMergable
> void merge(T mergeFirst
, T mergeSecond
, IMergeStrategy mergeStrategy
) throws MergeException
{
215 if (mergeStrategy
== null){
216 mergeStrategy
= DefaultMergeStrategy
.NewInstance(((CdmBase
)mergeFirst
).getClass());
218 genericDao
.merge((CdmBase
)mergeFirst
, (CdmBase
)mergeSecond
, mergeStrategy
);
223 public <T
extends IMatchable
> List
<T
> findMatching(T objectToMatch
, IMatchStrategy matchStrategy
) throws MatchException
{
224 if (matchStrategy
== null){
225 matchStrategy
= DefaultMatchStrategy
.NewInstance(((objectToMatch
).getClass()));
227 return genericDao
.findMatching(objectToMatch
, matchStrategy
);
233 // * @see eu.etaxonomy.cdm.api.service.IService#list(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
236 // public <TYPE extends OriginalSourceBase> Pager<TYPE> list(Class<TYPE> type,
237 // Integer pageSize, Integer pageNumber, List<OrderHint> orderHints,
238 // List<String> propertyPaths) {
239 // logger.warn("Not yet implemented");
243 @Transactional(readOnly
= false)
245 public void saveAllMetaData(Collection
<CdmMetaData
> metaData
) {
246 Iterator
<CdmMetaData
> iterator
= metaData
.iterator();
247 while(iterator
.hasNext()){
248 CdmMetaData cdmMetaData
= iterator
.next();
249 genericDao
.saveMetaData(cdmMetaData
);
254 public Map
<MetaDataPropertyName
, CdmMetaData
> getCdmMetaData() {
255 Map
<MetaDataPropertyName
, CdmMetaData
> result
= new HashMap
<MetaDataPropertyName
, CdmMetaData
>();
256 List
<CdmMetaData
> metaDataList
= genericDao
.getMetaData();
257 for (CdmMetaData metaData
: metaDataList
){
258 MetaDataPropertyName propertyName
= metaData
.getPropertyName();
259 result
.put(propertyName
, metaData
);
265 public PersistentCollection
initializeCollection(PersistentCollection col
) {
266 return genericDao
.initializeCollection(col
);
271 public boolean isEmpty(PersistentCollection col
) {
272 return genericDao
.isEmpty(col
);
277 public int size(PersistentCollection col
) {
278 return genericDao
.size(col
);
282 public Object
get(PersistentCollection col
, int index
) {
283 return genericDao
.get(col
, index
);
287 public boolean contains(PersistentCollection col
, Object element
) {
288 return genericDao
.contains(col
, element
);
292 public boolean containsKey(PersistentCollection col
, Object key
) {
293 return genericDao
.containsKey(col
, key
);
297 public boolean containsValue(PersistentCollection col
, Object element
) {
298 return genericDao
.containsValue(col
, element
);