X-Git-Url: https://dev.e-taxonomy.eu/gitweb/cdmlib.git/blobdiff_plain/0849a0f406f45aea89b60db798eda9d941a74da5..aa2c2e07844968b18dc2f24b2d1a94af00512805:/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/CommonServiceImpl.java diff --git a/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/CommonServiceImpl.java b/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/CommonServiceImpl.java index 2b6da5ada2..4a3307489e 100644 --- a/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/CommonServiceImpl.java +++ b/cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/CommonServiceImpl.java @@ -1,12 +1,11 @@ -// $Id$ /** -* Copyright (C) 2007 EDIT -* European Distributed Institute of Taxonomy -* http://www.e-taxonomy.eu -* -* The contents of this file are subject to the Mozilla Public License Version 1.1 -* See LICENSE.TXT at the top of this package for the full license terms. -*/ + * Copyright (C) 2007 EDIT + * European Distributed Institute of Taxonomy + * http://www.e-taxonomy.eu + * + * The contents of this file are subject to the Mozilla Public License Version 1.1 + * See LICENSE.TXT at the top of this package for the full license terms. + */ package eu.etaxonomy.cdm.api.service; @@ -19,7 +18,6 @@ import java.util.Set; import java.util.UUID; import org.apache.log4j.Logger; -import org.hibernate.collection.spi.PersistentCollection; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; @@ -28,7 +26,7 @@ import eu.etaxonomy.cdm.model.common.CdmBase; import eu.etaxonomy.cdm.model.common.ISourceable; import eu.etaxonomy.cdm.model.common.IdentifiableEntity; import eu.etaxonomy.cdm.model.metadata.CdmMetaData; -import eu.etaxonomy.cdm.model.metadata.CdmMetaData.MetaDataPropertyName; +import eu.etaxonomy.cdm.model.metadata.CdmMetaDataPropertyName; import eu.etaxonomy.cdm.persistence.dao.common.ICdmGenericDao; import eu.etaxonomy.cdm.persistence.dao.common.IOriginalSourceDao; import eu.etaxonomy.cdm.persistence.query.OrderHint; @@ -47,192 +45,259 @@ import eu.etaxonomy.cdm.strategy.merge.MergeException; @Service @Transactional(readOnly = true) public class CommonServiceImpl /*extends ServiceBase*/ implements ICommonService { - @SuppressWarnings("unused") - private static final Logger logger = Logger.getLogger(CommonServiceImpl.class); - - - @Autowired - private IOriginalSourceDao originalSourceDao; - - - @Autowired - private ICdmGenericDao genericDao; - - - @Override - public CdmBase find(Class clazz, int id){ - return genericDao.find(clazz, id); - } - - - @Override - public Map getSourcedObjectsByIdInSource(Class clazz, Set idInSourceSet, String idNamespace) { - Map list = originalSourceDao.findOriginalSourcesByIdInSource(clazz, idInSourceSet, idNamespace); - return list; - } - - @Override - public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) { - ISourceable result = null; - List list = originalSourceDao.findOriginalSourceByIdInSource(clazz, idInSource, idNamespace); - if (! list.isEmpty()){ - result = list.get(0); - }return result; - } - - - @Override - public Set getReferencingObjects(CdmBase referencedCdmBase){ - return this.genericDao.getReferencingObjects(referencedCdmBase); - } - - - @Override - public Set getReferencingObjectsForDeletion(CdmBase referencedCdmBase){ - return this.genericDao.getReferencingObjectsForDeletion(referencedCdmBase); - } -// try { -// Set> allCdmClasses = genericDao.getAllCdmClasses(false); //findAllCdmClasses(); -// -// referencedCdmBase = (CdmBase)HibernateProxyHelper.deproxy(referencedCdmBase); -// Class referencedClass = referencedCdmBase.getClass(); -// Set result = new HashSet(); -// logger.debug("Referenced Class: " + referencedClass.getName()); -// -// for (Class cdmClass : allCdmClasses){ -// Set fields = getFields(cdmClass); -// for (Field field: fields){ -// Class type = field.getType(); -// //class -// if (! type.isInterface()){ -// if (referencedClass.isAssignableFrom(type)|| -// type.isAssignableFrom(referencedClass) && CdmBase.class.isAssignableFrom(type)){ -// handleSingleClass(referencedClass, type, field, cdmClass, result, referencedCdmBase, false); -// } -// //interface -// }else if (type.isAssignableFrom(referencedClass)){ -// handleSingleClass(referencedClass, type, field, cdmClass, result, referencedCdmBase, false); -// }else if (Collection.class.isAssignableFrom(type)){ -// -// if (checkIsSetOfType(field, referencedClass, type) == true){ -// handleSingleClass(referencedClass, type, field, cdmClass, result, referencedCdmBase, true); -// } -// } -//// Class[] interfaces = referencedClass.getInterfaces(); -//// for (Class interfaze: interfaces){ -//// if (interfaze == type){ -////// if(interfaze.isAssignableFrom(returnType)){ -//// handleSingleClass(interfaze, type, field, cdmClass, result, referencedCdmBase); -//// } -//// } -// } -// } -// return result; -// } catch (Exception e) { -// e.printStackTrace(); -// throw new RuntimeException(e); -// } -// -// } -// -// private boolean checkIsSetOfType(Field field, Class referencedClass, Class type){ -// Type genericType = (ParameterizedTypeImpl)field.getGenericType(); -// if (genericType instanceof ParameterizedTypeImpl){ -// ParameterizedTypeImpl paraType = (ParameterizedTypeImpl)genericType; -// paraType.getRawType(); -// Type[] arguments = paraType.getActualTypeArguments(); -// //logger.debug(arguments.length); -// if (arguments.length == 1){ -// Class collectionClass; -// try { -// if (arguments[0] instanceof Class){ -// collectionClass = (Class)arguments[0]; -// }else if(arguments[0] instanceof TypeVariableImpl){ -// TypeVariableImpl typeVariable = (TypeVariableImpl)arguments[0]; -// GenericDeclaration genericDeclaration = typeVariable.getGenericDeclaration(); -// collectionClass = (Class)genericDeclaration; -// }else{ -// logger.warn("Unknown Type"); -// return false; -// } -// if (CdmBase.class.isAssignableFrom(collectionClass) && collectionClass.isAssignableFrom(referencedClass) ){ -// return true; -// } -// } catch (Exception e) { -// logger.warn(e.getMessage()); -// } -// }else{ -// logger.warn("Length of arguments <> 1"); -// } -// }else{ -// logger.warn("Not a generic type of type ParameterizedTypeImpl"); -// } -// return false; -// } -// -// -// -// -// private boolean handleSingleClass(Class itemClass, Class type, Field field, Class cdmClass, Set result,CdmBase value, boolean isCollection){ -// if (! Modifier.isStatic(field.getModifiers())){ -// String methodName = StringUtils.rightPad(field.getName(), 30); -// String className = StringUtils.rightPad(cdmClass.getSimpleName(), 30); -// String returnTypeName = StringUtils.rightPad(type.getSimpleName(), 30); -// -// logger.debug(methodName + "\t\t" + className + "\t\t" + returnTypeName); -//// result_old.add(method); -// result.addAll(getCdmBasesByFieldAndClass(field, itemClass, cdmClass, value, isCollection)); -// } -// return true; -// } -// -// private Set getFields(Class clazz){ -// Set result = new HashSet(); -// for (Field field: clazz.getDeclaredFields()){ -// if (!Modifier.isStatic(field.getModifiers())){ -// result.add(field); -// } -// } -// Class superclass = clazz.getSuperclass(); -// if (CdmBase.class.isAssignableFrom(superclass)){ -// result.addAll(getFields(superclass)); -// } -// return result; -// } -// -// private Set getCdmBasesByFieldAndClass(Field field, Class itemClass, Class otherClazz, CdmBase item, boolean isCollection){ -// Set result = new HashSet(); -// if (isCollection){ -// result.addAll(genericDao.getCdmBasesWithItemInCollection(itemClass, otherClazz, field.getName(), item)); -// }else{ -// result.addAll(genericDao.getCdmBasesByFieldAndClass(otherClazz, field.getName(), item)); -// } -// return result; -// } - - @Override - public List getHqlResult(String hqlQuery){ - return genericDao.getHqlResult(hqlQuery); - } - - @Override - public void merge(T mergeFirst, T mergeSecond, IMergeStrategy mergeStrategy) throws MergeException { - if (mergeStrategy == null){ - mergeStrategy = DefaultMergeStrategy.NewInstance(((CdmBase)mergeFirst).getClass()); - } - genericDao.merge((CdmBase)mergeFirst, (CdmBase)mergeSecond, mergeStrategy); - } - - - @Override - public List findMatching(T objectToMatch, IMatchStrategy matchStrategy) throws MatchException { - if (matchStrategy == null){ - matchStrategy = DefaultMatchStrategy.NewInstance(((objectToMatch).getClass())); - } - return genericDao.findMatching(objectToMatch, matchStrategy); - } - - + @SuppressWarnings("unused") + private static final Logger logger = Logger.getLogger(CommonServiceImpl.class); + + + @Autowired + private IOriginalSourceDao originalSourceDao; + + + @Autowired + private ICdmGenericDao genericDao; + + + @Override + public T findWithUpdate(Class clazz, int id){ + return genericDao.find(clazz, id); + } + + @Override + public T find(Class clazz, int id){ + return genericDao.find(clazz, id); + } + + @Override + public T find(Class clazz, int id, List propertyPaths){ + return genericDao.find(clazz, id, propertyPaths); + } + + @Override + public T find(Class clazz, UUID uuid) { + return uuid == null ? null : genericDao.find(clazz, uuid); + } + + @Override + public T find(Class clazz, UUID uuid, List propertyPaths) { + return uuid == null ? null : genericDao.find(clazz, uuid, propertyPaths); + } + + @Override + public Map getSourcedObjectsByIdInSource(Class clazz, Set idInSourceSet, String idNamespace) { + Map list = originalSourceDao.findOriginalSourcesByIdInSource(clazz, idInSourceSet, idNamespace); + return list; + } + + @Override + public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) { + ISourceable result = null; + List list = originalSourceDao.findOriginalSourceByIdInSource(clazz, idInSource, idNamespace); + if (! list.isEmpty()){ + result = list.get(0); + }return result; + } + + + @Override + public Set getReferencingObjects(CdmBase referencedCdmBase){ + return this.genericDao.getReferencingObjects(referencedCdmBase); + } + + @Override + public Integer getReferencingObjectsCount(CdmBase referencedCdmBase){ + return this.genericDao.getReferencingObjectsCount(referencedCdmBase); + } + + @Override + public Set getReferencingObjectsForDeletion(CdmBase referencedCdmBase){ + return this.genericDao.getReferencingObjectsForDeletion(referencedCdmBase); + } + // try { + // Set> allCdmClasses = genericDao.getAllCdmClasses(false); //findAllCdmClasses(); + // + // referencedCdmBase = (CdmBase)HibernateProxyHelper.deproxy(referencedCdmBase); + // Class referencedClass = referencedCdmBase.getClass(); + // Set result = new HashSet<>(); + // logger.debug("Referenced Class: " + referencedClass.getName()); + // + // for (Class cdmClass : allCdmClasses){ + // Set fields = getFields(cdmClass); + // for (Field field: fields){ + // Class type = field.getType(); + // //class + // if (! type.isInterface()){ + // if (referencedClass.isAssignableFrom(type)|| + // type.isAssignableFrom(referencedClass) && CdmBase.class.isAssignableFrom(type)){ + // handleSingleClass(referencedClass, type, field, cdmClass, result, referencedCdmBase, false); + // } + // //interface + // }else if (type.isAssignableFrom(referencedClass)){ + // handleSingleClass(referencedClass, type, field, cdmClass, result, referencedCdmBase, false); + // }else if (Collection.class.isAssignableFrom(type)){ + // + // if (checkIsSetOfType(field, referencedClass, type) == true){ + // handleSingleClass(referencedClass, type, field, cdmClass, result, referencedCdmBase, true); + // } + // } + //// Class[] interfaces = referencedClass.getInterfaces(); + //// for (Class interfaze: interfaces){ + //// if (interfaze == type){ + ////// if(interfaze.isAssignableFrom(returnType)){ + //// handleSingleClass(interfaze, type, field, cdmClass, result, referencedCdmBase); + //// } + //// } + // } + // } + // return result; + // } catch (Exception e) { + // e.printStackTrace(); + // throw new RuntimeException(e); + // } + // + // } + // + // private boolean checkIsSetOfType(Field field, Class referencedClass, Class type){ + // Type genericType = (ParameterizedTypeImpl)field.getGenericType(); + // if (genericType instanceof ParameterizedTypeImpl){ + // ParameterizedTypeImpl paraType = (ParameterizedTypeImpl)genericType; + // paraType.getRawType(); + // Type[] arguments = paraType.getActualTypeArguments(); + // //logger.debug(arguments.length); + // if (arguments.length == 1){ + // Class collectionClass; + // try { + // if (arguments[0] instanceof Class){ + // collectionClass = (Class)arguments[0]; + // }else if(arguments[0] instanceof TypeVariableImpl){ + // TypeVariableImpl typeVariable = (TypeVariableImpl)arguments[0]; + // GenericDeclaration genericDeclaration = typeVariable.getGenericDeclaration(); + // collectionClass = (Class)genericDeclaration; + // }else{ + // logger.warn("Unknown Type"); + // return false; + // } + // if (CdmBase.class.isAssignableFrom(collectionClass) && collectionClass.isAssignableFrom(referencedClass) ){ + // return true; + // } + // } catch (Exception e) { + // logger.warn(e.getMessage()); + // } + // }else{ + // logger.warn("Length of arguments <> 1"); + // } + // }else{ + // logger.warn("Not a generic type of type ParameterizedTypeImpl"); + // } + // return false; + // } + // + // + // + // + // private boolean handleSingleClass(Class itemClass, Class type, Field field, Class cdmClass, Set result,CdmBase value, boolean isCollection){ + // if (! Modifier.isStatic(field.getModifiers())){ + // String methodName = StringUtils.rightPad(field.getName(), 30); + // String className = StringUtils.rightPad(cdmClass.getSimpleName(), 30); + // String returnTypeName = StringUtils.rightPad(type.getSimpleName(), 30); + // + // logger.debug(methodName + "\t\t" + className + "\t\t" + returnTypeName); + //// result_old.add(method); + // result.addAll(getCdmBasesByFieldAndClass(field, itemClass, cdmClass, value, isCollection)); + // } + // return true; + // } + // + // private Set getFields(Class clazz){ + // Set result = new HashSet<>(); + // for (Field field: clazz.getDeclaredFields()){ + // if (!Modifier.isStatic(field.getModifiers())){ + // result.add(field); + // } + // } + // Class superclass = clazz.getSuperclass(); + // if (CdmBase.class.isAssignableFrom(superclass)){ + // result.addAll(getFields(superclass)); + // } + // return result; + // } + // + // private Set getCdmBasesByFieldAndClass(Field field, Class itemClass, Class otherClazz, CdmBase item, boolean isCollection){ + // Set result = new HashSet<>(); + // if (isCollection){ + // result.addAll(genericDao.getCdmBasesWithItemInCollection(itemClass, otherClazz, field.getName(), item)); + // }else{ + // result.addAll(genericDao.getCdmBasesByFieldAndClass(otherClazz, field.getName(), item)); + // } + // return result; + // } + + @Override + public List getHqlResult(String hqlQuery){ + return genericDao.getHqlResult(hqlQuery); + } + + @Override + public void merge(T mergeFirst, T mergeSecond, IMergeStrategy mergeStrategy) throws MergeException { + if (mergeStrategy == null){ + mergeStrategy = DefaultMergeStrategy.NewInstance(((CdmBase)mergeFirst).getClass()); + } + genericDao.merge((CdmBase)mergeFirst, (CdmBase)mergeSecond, mergeStrategy); + } + + @Override + public void merge(T mergeFirst, T mergeSecond, Class clazz) throws MergeException { + IMergeStrategy mergeStrategy; + if (clazz == null){ + mergeStrategy = DefaultMergeStrategy.NewInstance(((CdmBase)mergeFirst).getClass()); + } else { + mergeStrategy = DefaultMergeStrategy.NewInstance(clazz); + } + merge(mergeFirst, mergeSecond, mergeStrategy); + } + + @Override + @Transactional(readOnly = false) + @Deprecated + public void merge(int mergeFirstId, int mergeSecondId, Class clazz) throws MergeException { + IMergeStrategy mergeStrategy; + T mergeFirst = (T) genericDao.find(clazz, mergeFirstId); + T mergeSecond = (T) genericDao.find(clazz, mergeSecondId); + mergeStrategy = DefaultMergeStrategy.NewInstance(clazz); + merge(mergeFirst, mergeSecond, mergeStrategy); + } + + @Override + @Transactional(readOnly = false) + public void merge(UUID mergeFirstUuid, UUID mergeSecondUuid, Class clazz) throws MergeException { + IMergeStrategy mergeStrategy; + T mergeFirst = (T) genericDao.find(clazz, mergeFirstUuid); + T mergeSecond = (T) genericDao.find(clazz, mergeSecondUuid); + if (mergeFirst == null){ + throw new MergeException("The merge target is not available anymore."); + } + if (mergeSecond == null){ + throw new MergeException("The merge candidate is not available anymore."); + } + mergeStrategy = DefaultMergeStrategy.NewInstance(clazz); + merge(mergeFirst, mergeSecond, mergeStrategy); + } + + @Override + public void merge(T mergeFirst, T mergeSecond) throws MergeException { + IMergeStrategy mergeStrategy = DefaultMergeStrategy.NewInstance(((CdmBase)mergeFirst).getClass()); + merge(mergeFirst, mergeSecond, mergeStrategy); + } + + + @Override + public List findMatching(T objectToMatch, IMatchStrategy matchStrategy) throws MatchException { + if (matchStrategy == null){ + matchStrategy = DefaultMatchStrategy.NewInstance(((objectToMatch).getClass())); + } + return genericDao.findMatching(objectToMatch, matchStrategy); + } + + /* (non-Javadoc) * @see eu.etaxonomy.cdm.api.service.ICommonService#findMatching(eu.etaxonomy.cdm.strategy.match.IMatchable, eu.etaxonomy.cdm.strategy.match.MatchStrategyConfigurator.MatchStrategy) @@ -242,83 +307,90 @@ public class CommonServiceImpl /*extends ServiceBase Pager list(Class type, -// Integer pageSize, Integer pageNumber, List orderHints, -// List propertyPaths) { -// logger.warn("Not yet implemented"); -// return null; -// } - + // /* (non-Javadoc) + // * @see eu.etaxonomy.cdm.api.service.IService#list(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + // */ + // @Override + // public Pager list(Class type, + // Integer pageSize, Integer pageNumber, List orderHints, + // List propertyPaths) { + // logger.warn("Not yet implemented"); + // return null; + // } + + + @Transactional(readOnly = false) + @Override + public void saveAllMetaData(Collection metaData) { + Iterator iterator = metaData.iterator(); + while(iterator.hasNext()){ + CdmMetaData cdmMetaData = iterator.next(); + genericDao.saveMetaData(cdmMetaData); + } + } + + @Override + public Map getCdmMetaData() { + Map result = new HashMap<>(); + List metaDataList = genericDao.getMetaData(); + for (CdmMetaData metaData : metaDataList){ + CdmMetaDataPropertyName propertyName = metaData.getPropertyName(); + result.put(propertyName, metaData); + } + return result; + } - @Transactional(readOnly = false) - @Override - public void saveAllMetaData(Collection metaData) { - Iterator iterator = metaData.iterator(); - while(iterator.hasNext()){ - CdmMetaData cdmMetaData = iterator.next(); - genericDao.saveMetaData(cdmMetaData); - } - } + @Override + public Object initializeCollection(UUID ownerUuid, String fieldName) { + return genericDao.initializeCollection(ownerUuid, fieldName); - @Override - public Map getCdmMetaData() { - Map result = new HashMap(); - List metaDataList = genericDao.getMetaData(); - for (CdmMetaData metaData : metaDataList){ - MetaDataPropertyName propertyName = metaData.getPropertyName(); - result.put(propertyName, metaData); - } - return result; - } + } @Override - public PersistentCollection initializeCollection(PersistentCollection col) { - return genericDao.initializeCollection(col); + public Object initializeCollection(UUID ownerUuid, String fieldName, List propertyPaths) { + return genericDao.initializeCollection(ownerUuid, fieldName, propertyPaths); } @Override - public boolean isEmpty(PersistentCollection col) { - return genericDao.isEmpty(col); + public boolean isEmpty(UUID ownerUuid, String fieldName) { + return genericDao.isEmpty(ownerUuid, fieldName); + + } + @Override + public int size(UUID ownerUuid, String fieldName) { + return genericDao.size(ownerUuid, fieldName); } + @Override - public int size(PersistentCollection col) { - return genericDao.size(col); + public Object get(UUID ownerUuid, String fieldName, int index) { + return genericDao.get(ownerUuid, fieldName, index); } @Override - public Object get(PersistentCollection col, int index) { - return genericDao.get(col, index); + public boolean contains(UUID ownerUuid, String fieldName, Object element) { + return genericDao.contains(ownerUuid, fieldName, element); } @Override - public boolean contains(PersistentCollection col, Object element) { - return genericDao.contains(col, element); + public boolean containsKey(UUID ownerUuid, String fieldName, Object key) { + return genericDao.containsKey(ownerUuid, fieldName, key); } @Override - public boolean containsKey(PersistentCollection col, Object key) { - return genericDao.containsKey(col, key); + public boolean containsValue(UUID ownerUuid, String fieldName, Object value) { + return genericDao.containsValue(ownerUuid, fieldName, value); } @Override - public boolean containsValue(PersistentCollection col, Object element) { - return genericDao.containsValue(col, element); + @Transactional(readOnly = false) + public void createFullSampleData() { + genericDao.createFullSampleData(); } - @Override - @Transactional(readOnly = false) - public void createFullSampleData() { - genericDao.createFullSampleData(); - } - @Override public List list(Class type, Integer limit, Integer start, List orderHints, List propertyPaths){ @@ -332,23 +404,43 @@ public class CommonServiceImpl /*extends ServiceBase Map save(Collection newInstances) { //this is very ugly, I know, but for now I do not want to copy the saveAll method from CdmEntityDaoBase to genericDao - //and generally the saveAll method should work for other CdmBase types with generics removed - return (Map)originalSourceDao.saveAll((Collection)newInstances); + //and generally the saveAll method should work for other CdmBase types with generics removed + return (Map)originalSourceDao.saveAll((Collection)newInstances); } + @Override + @Transactional(readOnly = false) + public Map saveOrUpdate(Collection newInstances) { + //this is very ugly, I know, but for now I do not want to copy the saveAll method from CdmEntityDaoBase to genericDao + //and generally the saveAll method should work for other CdmBase types with generics removed + return (Map)originalSourceDao.saveOrUpdateAll((Collection)newInstances); + } + + + @Override + public boolean isMergeable(T cdmBase1, T cdmBase2, IMergeStrategy mergeStrategy) throws MergeException { + return genericDao.isMergeable(cdmBase1, cdmBase2, mergeStrategy); + } - @Override - public boolean isMergeable(T cdmBase1, T cdmBase2, IMergeStrategy mergeStrategy) throws MergeException { - return genericDao.isMergeable(cdmBase1, cdmBase2, mergeStrategy); - } - }