cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/CommonServiceImpl.java

   1 // $Id$
   2 /**
   3  * Copyright (C) 2007 EDIT
   4  * European Distributed Institute of Taxonomy
   5  * http://www.e-taxonomy.eu
   6  *
   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.
   9  */
  10
  11 package eu.etaxonomy.cdm.api.service;
  12
  13 import java.util.Collection;
  14 import java.util.HashMap;
  15 import java.util.Iterator;
  16 import java.util.List;
  17 import java.util.Map;
  18 import java.util.Set;
  19 import java.util.UUID;
  20
  21 import org.apache.log4j.Logger;
  22 import org.springframework.beans.factory.annotation.Autowired;
  23 import org.springframework.stereotype.Service;
  24 import org.springframework.transaction.annotation.Transactional;
  25
  26 import eu.etaxonomy.cdm.model.common.CdmBase;
  27 import eu.etaxonomy.cdm.model.common.ISourceable;
  28 import eu.etaxonomy.cdm.model.common.IdentifiableEntity;
  29 import eu.etaxonomy.cdm.model.metadata.CdmMetaData;
  30 import eu.etaxonomy.cdm.model.metadata.CdmMetaData.MetaDataPropertyName;
  31 import eu.etaxonomy.cdm.persistence.dao.common.ICdmGenericDao;
  32 import eu.etaxonomy.cdm.persistence.dao.common.IOriginalSourceDao;
  33 import eu.etaxonomy.cdm.persistence.query.OrderHint;
  34 import eu.etaxonomy.cdm.strategy.match.DefaultMatchStrategy;
  35 import eu.etaxonomy.cdm.strategy.match.IMatchStrategy;
  36 import eu.etaxonomy.cdm.strategy.match.IMatchable;
  37 import eu.etaxonomy.cdm.strategy.match.MatchException;
  38 import eu.etaxonomy.cdm.strategy.match.MatchStrategyConfigurator;
  39 import eu.etaxonomy.cdm.strategy.match.MatchStrategyConfigurator.MatchStrategy;
  40 import eu.etaxonomy.cdm.strategy.merge.DefaultMergeStrategy;
  41 import eu.etaxonomy.cdm.strategy.merge.IMergable;
  42 import eu.etaxonomy.cdm.strategy.merge.IMergeStrategy;
  43 import eu.etaxonomy.cdm.strategy.merge.MergeException;
  44
  45
  46 @Service
  47 @Transactional(readOnly = true)
  48 public class CommonServiceImpl /*extends ServiceBase<OriginalSourceBase,IOriginalSourceDao>*/ implements ICommonService {
  49     @SuppressWarnings("unused")
  50     private static final Logger logger = Logger.getLogger(CommonServiceImpl.class);
  51
  52
  53     @Autowired
  54     private IOriginalSourceDao originalSourceDao;
  55
  56
  57     @Autowired
  58     private ICdmGenericDao genericDao;
  59
  60
  61     @Override
  62     public CdmBase find(Class<? extends CdmBase> clazz, int id){
  63         return genericDao.find(clazz, id);
  64     }
  65
  66     @Override
  67     public CdmBase find(Class<? extends CdmBase> clazz, int id, List<String> propertyPaths){
  68         return  genericDao.find(clazz, id, propertyPaths);
  69     }
  70
  71
  72     @Override
  73     public Map<String, ? extends ISourceable> getSourcedObjectsByIdInSource(Class clazz, Set<String> idInSourceSet, String idNamespace) {
  74         Map<String, ? extends ISourceable> list = originalSourceDao.findOriginalSourcesByIdInSource(clazz, idInSourceSet, idNamespace);
  75         return list;
  76     }
  77
  78     @Override
  79     public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) {
  80         ISourceable result = null;
  81         List<IdentifiableEntity> list = originalSourceDao.findOriginalSourceByIdInSource(clazz, idInSource, idNamespace);
  82         if (! list.isEmpty()){
  83             result = list.get(0);
  84         }return result;
  85     }
  86
  87
  88     @Override
  89     public Set<CdmBase> getReferencingObjects(CdmBase referencedCdmBase){
  90         return this.genericDao.getReferencingObjects(referencedCdmBase);
  91     }
  92
  93
  94     @Override
  95     public Set<CdmBase> getReferencingObjectsForDeletion(CdmBase referencedCdmBase){
  96         return this.genericDao.getReferencingObjectsForDeletion(referencedCdmBase);
  97     }
  98     //          try {
  99     //                  Set<Class<? extends CdmBase>> allCdmClasses = genericDao.getAllCdmClasses(false); //findAllCdmClasses();
 100     //
 101     //                  referencedCdmBase = (CdmBase)HibernateProxyHelper.deproxy(referencedCdmBase);
 102     //                  Class referencedClass = referencedCdmBase.getClass();
 103     //                  Set<CdmBase> result = new HashSet<CdmBase>();
 104     //                  logger.debug("Referenced Class: " + referencedClass.getName());
 105     //
 106     //                  for (Class<? extends CdmBase> cdmClass : allCdmClasses){
 107     //                          Set<Field> fields = getFields(cdmClass);
 108     //                          for (Field field: fields){
 109     //                                  Class<?> type = field.getType();
 110     //                                  //class
 111     //                                  if (! type.isInterface()){
 112     //                                          if (referencedClass.isAssignableFrom(type)||
 113     //                                                          type.isAssignableFrom(referencedClass) && CdmBase.class.isAssignableFrom(type)){
 114     //                                                  handleSingleClass(referencedClass, type, field, cdmClass, result, referencedCdmBase, false);
 115     //                                          }
 116     //                                  //interface
 117     //                                  }else if (type.isAssignableFrom(referencedClass)){
 118     //                                                  handleSingleClass(referencedClass, type, field, cdmClass, result, referencedCdmBase, false);
 119     //                                  }else if (Collection.class.isAssignableFrom(type)){
 120     //
 121     //                                          if (checkIsSetOfType(field, referencedClass, type) == true){
 122     //                                                  handleSingleClass(referencedClass, type, field, cdmClass, result, referencedCdmBase, true);
 123     //                                          }
 124     //                                  }
 125     ////                                Class[] interfaces = referencedClass.getInterfaces();
 126     ////                                for (Class interfaze: interfaces){
 127     ////                                        if (interfaze == type){
 128     //////                                      if(interfaze.isAssignableFrom(returnType)){
 129     ////                                                handleSingleClass(interfaze, type, field, cdmClass, result, referencedCdmBase);
 130     ////                                        }
 131     ////                                }
 132     //                          }
 133     //                  }
 134     //                  return result;
 135     //          } catch (Exception e) {
 136     //                  e.printStackTrace();
 137     //                  throw new RuntimeException(e);
 138     //          }
 139     //
 140     //  }
 141     //
 142     //  private boolean checkIsSetOfType(Field field, Class referencedClass, Class<?> type){
 143     //          Type genericType = (ParameterizedTypeImpl)field.getGenericType();
 144     //          if (genericType instanceof ParameterizedTypeImpl){
 145     //                  ParameterizedTypeImpl paraType = (ParameterizedTypeImpl)genericType;
 146     //                  paraType.getRawType();
 147     //                  Type[] arguments = paraType.getActualTypeArguments();
 148     //                  //logger.debug(arguments.length);
 149     //                  if (arguments.length == 1){
 150     //                          Class collectionClass;
 151     //                          try {
 152     //                                  if (arguments[0] instanceof Class){
 153     //                                          collectionClass = (Class)arguments[0];
 154     //                                  }else if(arguments[0] instanceof TypeVariableImpl){
 155     //                                          TypeVariableImpl typeVariable = (TypeVariableImpl)arguments[0];
 156     //                                          GenericDeclaration genericDeclaration = typeVariable.getGenericDeclaration();
 157     //                                          collectionClass = (Class)genericDeclaration;
 158     //                                  }else{
 159     //                                          logger.warn("Unknown Type");
 160     //                                          return false;
 161     //                                  }
 162     //                                  if (CdmBase.class.isAssignableFrom(collectionClass) && collectionClass.isAssignableFrom(referencedClass)  ){
 163     //                                          return true;
 164     //                                  }
 165     //                          } catch (Exception e) {
 166     //                                  logger.warn(e.getMessage());
 167     //                          }
 168     //                  }else{
 169     //                          logger.warn("Length of arguments <> 1");
 170     //                  }
 171     //          }else{
 172     //                  logger.warn("Not a generic type of type ParameterizedTypeImpl");
 173     //          }
 174     //          return false;
 175     //  }
 176     //
 177     //
 178     //
 179     //
 180     //  private boolean handleSingleClass(Class itemClass, Class type, Field field, Class cdmClass, Set<CdmBase> result,CdmBase value, boolean isCollection){
 181     //          if (! Modifier.isStatic(field.getModifiers())){
 182     //                  String methodName = StringUtils.rightPad(field.getName(), 30);
 183     //                  String className = StringUtils.rightPad(cdmClass.getSimpleName(), 30);
 184     //                  String returnTypeName = StringUtils.rightPad(type.getSimpleName(), 30);
 185     //
 186     //                  logger.debug(methodName +   "\t\t" + className + "\t\t" + returnTypeName);
 187     ////                        result_old.add(method);
 188     //                  result.addAll(getCdmBasesByFieldAndClass(field, itemClass, cdmClass, value, isCollection));
 189     //          }
 190     //          return true;
 191     //  }
 192     //
 193     //  private Set<Field> getFields(Class clazz){
 194     //          Set<Field> result = new HashSet<Field>();
 195     //          for (Field field: clazz.getDeclaredFields()){
 196     //                  if (!Modifier.isStatic(field.getModifiers())){
 197     //                          result.add(field);
 198     //                  }
 199     //          }
 200     //          Class superclass = clazz.getSuperclass();
 201     //          if (CdmBase.class.isAssignableFrom(superclass)){
 202     //                  result.addAll(getFields(superclass));
 203     //          }
 204     //          return result;
 205     //  }
 206     //
 207     //  private Set<CdmBase> getCdmBasesByFieldAndClass(Field field, Class itemClass, Class otherClazz, CdmBase item, boolean isCollection){
 208     //          Set<CdmBase> result = new HashSet<CdmBase>();
 209     //          if (isCollection){
 210     //                  result.addAll(genericDao.getCdmBasesWithItemInCollection(itemClass, otherClazz, field.getName(), item));
 211     //          }else{
 212     //                  result.addAll(genericDao.getCdmBasesByFieldAndClass(otherClazz, field.getName(), item));
 213     //          }
 214     //          return result;
 215     //  }
 216
 217     @Override
 218     public List getHqlResult(String hqlQuery){
 219         return genericDao.getHqlResult(hqlQuery);
 220     }
 221
 222     @Override
 223     public <T extends IMergable> void merge(T mergeFirst, T mergeSecond, IMergeStrategy mergeStrategy) throws MergeException {
 224         if (mergeStrategy == null){
 225             mergeStrategy = DefaultMergeStrategy.NewInstance(((CdmBase)mergeFirst).getClass());
 226         }
 227         genericDao.merge((CdmBase)mergeFirst, (CdmBase)mergeSecond, mergeStrategy);
 228     }
 229
 230     @Override
 231     public <T extends IMergable> void merge(T mergeFirst, T mergeSecond, Class<? extends CdmBase> clazz) throws MergeException {
 232         IMergeStrategy mergeStrategy;
 233         if (clazz == null){
 234             mergeStrategy = DefaultMergeStrategy.NewInstance(((CdmBase)mergeFirst).getClass());
 235         } else {
 236             mergeStrategy = DefaultMergeStrategy.NewInstance(clazz);
 237         }
 238         merge(mergeFirst, mergeSecond, mergeStrategy);
 239     }
 240
 241     @Override
 242     public <T extends IMergable> void merge(T mergeFirst, T mergeSecond) throws MergeException {
 243         IMergeStrategy mergeStrategy = DefaultMergeStrategy.NewInstance(((CdmBase)mergeFirst).getClass());
 244         merge(mergeFirst, mergeSecond, mergeStrategy);
 245     }
 246
 247
 248     @Override
 249     public <T extends IMatchable> List<T> findMatching(T objectToMatch, IMatchStrategy matchStrategy) throws MatchException {
 250         if (matchStrategy == null){
 251             matchStrategy = DefaultMatchStrategy.NewInstance(((objectToMatch).getClass()));
 252         }
 253         return genericDao.findMatching(objectToMatch, matchStrategy);
 254     }
 255
 256
 257
 258     /* (non-Javadoc)
 259      * @see eu.etaxonomy.cdm.api.service.ICommonService#findMatching(eu.etaxonomy.cdm.strategy.match.IMatchable, eu.etaxonomy.cdm.strategy.match.MatchStrategyConfigurator.MatchStrategy)
 260      */
 261     @Override
 262     public <T extends IMatchable> List<T> findMatching(T objectToMatch, MatchStrategy strategy) throws MatchException {
 263         return findMatching(objectToMatch, MatchStrategyConfigurator.getMatchStrategy(strategy));
 264     }
 265
 266     //  /* (non-Javadoc)
 267     //   * @see eu.etaxonomy.cdm.api.service.IService#list(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 268     //   */
 269     //  @Override
 270     //  public <TYPE extends OriginalSourceBase> Pager<TYPE> list(Class<TYPE> type,
 271     //                  Integer pageSize, Integer pageNumber, List<OrderHint> orderHints,
 272     //                  List<String> propertyPaths) {
 273     //          logger.warn("Not yet implemented");
 274     //          return null;
 275     //  }
 276
 277
 278     @Transactional(readOnly = false)
 279     @Override
 280     public void saveAllMetaData(Collection<CdmMetaData> metaData) {
 281         Iterator<CdmMetaData> iterator = metaData.iterator();
 282         while(iterator.hasNext()){
 283             CdmMetaData cdmMetaData = iterator.next();
 284             genericDao.saveMetaData(cdmMetaData);
 285         }
 286     }
 287
 288     @Override
 289     public Map<MetaDataPropertyName, CdmMetaData> getCdmMetaData() {
 290         Map<MetaDataPropertyName, CdmMetaData> result = new HashMap<MetaDataPropertyName, CdmMetaData>();
 291         List<CdmMetaData> metaDataList = genericDao.getMetaData();
 292         for (CdmMetaData metaData : metaDataList){
 293             MetaDataPropertyName propertyName = metaData.getPropertyName();
 294             result.put(propertyName, metaData);
 295         }
 296         return result;
 297     }
 298
 299     @Override
 300     public Object initializeCollection(UUID ownerUuid, String fieldName) {
 301         return genericDao.initializeCollection(ownerUuid, fieldName);
 302
 303     }
 304
 305     @Override
 306     public Object initializeCollection(UUID ownerUuid, String fieldName, List<String> propertyPaths) {
 307         return genericDao.initializeCollection(ownerUuid, fieldName, propertyPaths);
 308
 309     }
 310
 311     @Override
 312     public boolean isEmpty(UUID ownerUuid, String fieldName) {
 313         return genericDao.isEmpty(ownerUuid, fieldName);
 314
 315     }
 316
 317     @Override
 318     public int size(UUID ownerUuid, String fieldName) {
 319         return genericDao.size(ownerUuid, fieldName);
 320     }
 321
 322
 323     @Override
 324     public Object get(UUID ownerUuid, String fieldName, int index) {
 325         return genericDao.get(ownerUuid, fieldName, index);
 326     }
 327
 328     @Override
 329     public boolean contains(UUID ownerUuid, String fieldName, Object element) {
 330         return genericDao.contains(ownerUuid, fieldName, element);
 331     }
 332
 333     @Override
 334     public boolean containsKey(UUID ownerUuid, String fieldName, Object key) {
 335         return genericDao.containsKey(ownerUuid, fieldName, key);
 336     }
 337
 338     @Override
 339     public boolean containsValue(UUID ownerUuid, String fieldName, Object value) {
 340         return genericDao.containsValue(ownerUuid, fieldName, value);
 341     }
 342
 343     @Override
 344     @Transactional(readOnly = false)
 345     public void createFullSampleData() {
 346         genericDao.createFullSampleData();
 347     }
 348
 349
 350
 351     @Override
 352     public <S extends CdmBase> List<S> list(Class<S> type, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths){
 353         return genericDao.list(type,limit, start, orderHints,propertyPaths);
 354     }
 355
 356     @Override
 357     public <S extends CdmBase> int count(Class<S> type) {
 358         return genericDao.count(type);
 359     }
 360
 361     @Override
 362     @Transactional(readOnly = false)
 363     public CdmBase save(CdmBase newInstance) {
 364         return genericDao.save(newInstance);
 365     }
 366
 367
 368     @Override
 369     @Transactional(readOnly = false)
 370     public <T extends CdmBase> Map<UUID,T> save(Collection<T> newInstances) {
 371         //this is very ugly, I know, but for now I do not want to copy the saveAll method from CdmEntityDaoBase to genericDao
 372         //and generally the saveAll method should work for other CdmBase types with generics removed
 373         return (Map)originalSourceDao.saveAll((Collection)newInstances);
 374     }
 375
 376
 377     @Override
 378     public <T extends CdmBase> boolean isMergeable(T cdmBase1, T cdmBase2, IMergeStrategy mergeStrategy) throws MergeException {
 379         return genericDao.isMergeable(cdmBase1, cdmBase2, mergeStrategy);
 380     }
 381
 382 }