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
  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.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.merge.DefaultMergeStrategy;
  39 import eu.etaxonomy.cdm.strategy.merge.IMergable;
  40 import eu.etaxonomy.cdm.strategy.merge.IMergeStrategy;
  41 import eu.etaxonomy.cdm.strategy.merge.MergeException;
  42
  43
  44 @Service
  45 @Transactional(readOnly = true)
  46 public class CommonServiceImpl /*extends ServiceBase<OriginalSourceBase,IOriginalSourceDao>*/ implements ICommonService {
  47         @SuppressWarnings("unused")
  48         private static final Logger logger = Logger.getLogger(CommonServiceImpl.class);
  49
  50         @Autowired
  51         private IOriginalSourceDao originalSourceDao;
  52
  53         @Autowired
  54         private ICdmGenericDao genericDao;
  55
  56         @Override
  57         public CdmBase find(Class<? extends CdmBase> clazz, int id){
  58                 return genericDao.find(clazz, id);
  59         }
  60
  61
  62         @Override
  63         public Map<String, ? extends ISourceable> getSourcedObjectsByIdInSource(Class clazz, Set<String> idInSourceSet, String idNamespace) {
  64                 Map<String, ? extends ISourceable> list = originalSourceDao.findOriginalSourcesByIdInSource(clazz, idInSourceSet, idNamespace);
  65                 return list;
  66         }
  67
  68         @Override
  69         public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) {
  70                 ISourceable result = null;
  71                 List<IdentifiableEntity> list = originalSourceDao.findOriginalSourceByIdInSource(clazz, idInSource, idNamespace);
  72                 if (! list.isEmpty()){
  73                         result = list.get(0);
  74                 }return result;
  75         }
  76
  77
  78         @Override
  79         public Set<CdmBase> getReferencingObjects(CdmBase referencedCdmBase){
  80                 return this.genericDao.getReferencingObjects(referencedCdmBase);
  81         }
  82
  83
  84         @Override
  85         public Set<CdmBase> getReferencingObjectsForDeletion(CdmBase referencedCdmBase){
  86                 return this.genericDao.getReferencingObjectsForDeletion(referencedCdmBase);
  87         }
  88 //              try {
  89 //                      Set<Class<? extends CdmBase>> allCdmClasses = genericDao.getAllCdmClasses(false); //findAllCdmClasses();
  90 //
  91 //                      referencedCdmBase = (CdmBase)HibernateProxyHelper.deproxy(referencedCdmBase);
  92 //                      Class referencedClass = referencedCdmBase.getClass();
  93 //                      Set<CdmBase> result = new HashSet<CdmBase>();
  94 //                      logger.debug("Referenced Class: " + referencedClass.getName());
  95 //
  96 //                      for (Class<? extends CdmBase> cdmClass : allCdmClasses){
  97 //                              Set<Field> fields = getFields(cdmClass);
  98 //                              for (Field field: fields){
  99 //                                      Class<?> type = field.getType();
 100 //                                      //class
 101 //                                      if (! type.isInterface()){
 102 //                                              if (referencedClass.isAssignableFrom(type)||
 103 //                                                              type.isAssignableFrom(referencedClass) && CdmBase.class.isAssignableFrom(type)){
 104 //                                                      handleSingleClass(referencedClass, type, field, cdmClass, result, referencedCdmBase, false);
 105 //                                              }
 106 //                                      //interface
 107 //                                      }else if (type.isAssignableFrom(referencedClass)){
 108 //                                                      handleSingleClass(referencedClass, type, field, cdmClass, result, referencedCdmBase, false);
 109 //                                      }else if (Collection.class.isAssignableFrom(type)){
 110 //
 111 //                                              if (checkIsSetOfType(field, referencedClass, type) == true){
 112 //                                                      handleSingleClass(referencedClass, type, field, cdmClass, result, referencedCdmBase, true);
 113 //                                              }
 114 //                                      }
 115 ////                            Class[] interfaces = referencedClass.getInterfaces();
 116 ////                            for (Class interfaze: interfaces){
 117 ////                                    if (interfaze == type){
 118 //////                                  if(interfaze.isAssignableFrom(returnType)){
 119 ////                                            handleSingleClass(interfaze, type, field, cdmClass, result, referencedCdmBase);
 120 ////                                    }
 121 ////                            }
 122 //                              }
 123 //                      }
 124 //                      return result;
 125 //              } catch (Exception e) {
 126 //                      e.printStackTrace();
 127 //                      throw new RuntimeException(e);
 128 //              }
 129 //
 130 //      }
 131 //
 132 //      private boolean checkIsSetOfType(Field field, Class referencedClass, Class<?> type){
 133 //              Type genericType = (ParameterizedTypeImpl)field.getGenericType();
 134 //              if (genericType instanceof ParameterizedTypeImpl){
 135 //                      ParameterizedTypeImpl paraType = (ParameterizedTypeImpl)genericType;
 136 //                      paraType.getRawType();
 137 //                      Type[] arguments = paraType.getActualTypeArguments();
 138 //                      //logger.debug(arguments.length);
 139 //                      if (arguments.length == 1){
 140 //                              Class collectionClass;
 141 //                              try {
 142 //                                      if (arguments[0] instanceof Class){
 143 //                                              collectionClass = (Class)arguments[0];
 144 //                                      }else if(arguments[0] instanceof TypeVariableImpl){
 145 //                                              TypeVariableImpl typeVariable = (TypeVariableImpl)arguments[0];
 146 //                                              GenericDeclaration genericDeclaration = typeVariable.getGenericDeclaration();
 147 //                                              collectionClass = (Class)genericDeclaration;
 148 //                                      }else{
 149 //                                              logger.warn("Unknown Type");
 150 //                                              return false;
 151 //                                      }
 152 //                                      if (CdmBase.class.isAssignableFrom(collectionClass) && collectionClass.isAssignableFrom(referencedClass)  ){
 153 //                                              return true;
 154 //                                      }
 155 //                              } catch (Exception e) {
 156 //                                      logger.warn(e.getMessage());
 157 //                              }
 158 //                      }else{
 159 //                              logger.warn("Length of arguments <> 1");
 160 //                      }
 161 //              }else{
 162 //                      logger.warn("Not a generic type of type ParameterizedTypeImpl");
 163 //              }
 164 //              return false;
 165 //      }
 166 //
 167 //
 168 //
 169 //
 170 //      private boolean handleSingleClass(Class itemClass, Class type, Field field, Class cdmClass, Set<CdmBase> result,CdmBase value, boolean isCollection){
 171 //              if (! Modifier.isStatic(field.getModifiers())){
 172 //                      String methodName = StringUtils.rightPad(field.getName(), 30);
 173 //                      String className = StringUtils.rightPad(cdmClass.getSimpleName(), 30);
 174 //                      String returnTypeName = StringUtils.rightPad(type.getSimpleName(), 30);
 175 //
 176 //                      logger.debug(methodName +   "\t\t" + className + "\t\t" + returnTypeName);
 177 ////                    result_old.add(method);
 178 //                      result.addAll(getCdmBasesByFieldAndClass(field, itemClass, cdmClass, value, isCollection));
 179 //              }
 180 //              return true;
 181 //      }
 182 //
 183 //      private Set<Field> getFields(Class clazz){
 184 //              Set<Field> result = new HashSet<Field>();
 185 //              for (Field field: clazz.getDeclaredFields()){
 186 //                      if (!Modifier.isStatic(field.getModifiers())){
 187 //                              result.add(field);
 188 //                      }
 189 //              }
 190 //              Class superclass = clazz.getSuperclass();
 191 //              if (CdmBase.class.isAssignableFrom(superclass)){
 192 //                      result.addAll(getFields(superclass));
 193 //              }
 194 //              return result;
 195 //      }
 196 //
 197 //      private Set<CdmBase> getCdmBasesByFieldAndClass(Field field, Class itemClass, Class otherClazz, CdmBase item, boolean isCollection){
 198 //              Set<CdmBase> result = new HashSet<CdmBase>();
 199 //              if (isCollection){
 200 //                      result.addAll(genericDao.getCdmBasesWithItemInCollection(itemClass, otherClazz, field.getName(), item));
 201 //              }else{
 202 //                      result.addAll(genericDao.getCdmBasesByFieldAndClass(otherClazz, field.getName(), item));
 203 //              }
 204 //              return result;
 205 //      }
 206
 207         @Override
 208         public List getHqlResult(String hqlQuery){
 209                 return genericDao.getHqlResult(hqlQuery);
 210         }
 211
 212         @Override
 213         public <T extends IMergable> void merge(T mergeFirst, T mergeSecond, IMergeStrategy mergeStrategy) throws MergeException {
 214                 if (mergeStrategy == null){
 215                         mergeStrategy = DefaultMergeStrategy.NewInstance(((CdmBase)mergeFirst).getClass());
 216                 }
 217                 genericDao.merge((CdmBase)mergeFirst, (CdmBase)mergeSecond, mergeStrategy);
 218         }
 219
 220
 221         @Override
 222         public <T extends IMatchable> List<T> findMatching(T objectToMatch, IMatchStrategy matchStrategy) throws MatchException {
 223                 if (matchStrategy == null){
 224                         matchStrategy = DefaultMatchStrategy.NewInstance(((objectToMatch).getClass()));
 225                 }
 226                 return genericDao.findMatching(objectToMatch, matchStrategy);
 227         }
 228
 229
 230         @Transactional(readOnly = false)
 231         @Override
 232         public void saveAllMetaData(Collection<CdmMetaData> metaData) {
 233                 Iterator<CdmMetaData> iterator = metaData.iterator();
 234                 while(iterator.hasNext()){
 235                         CdmMetaData cdmMetaData = iterator.next();
 236                         genericDao.saveMetaData(cdmMetaData);
 237                 }
 238         }
 239
 240         @Override
 241         public Map<MetaDataPropertyName, CdmMetaData> getCdmMetaData() {
 242                 Map<MetaDataPropertyName, CdmMetaData> result = new HashMap<MetaDataPropertyName, CdmMetaData>();
 243                 List<CdmMetaData> metaDataList = genericDao.getMetaData();
 244                 for (CdmMetaData metaData : metaDataList){
 245                         MetaDataPropertyName propertyName = metaData.getPropertyName();
 246                         result.put(propertyName, metaData);
 247                 }
 248                 return result;
 249         }
 250
 251     @Override
 252     public PersistentCollection initializeCollection(PersistentCollection col) {
 253             return genericDao.initializeCollection(col);
 254
 255     }
 256
 257     @Override
 258     public boolean isEmpty(PersistentCollection col) {
 259             return genericDao.isEmpty(col);
 260
 261     }
 262
 263     @Override
 264         public int size(PersistentCollection col) {
 265         return genericDao.size(col);
 266     }
 267
 268     @Override
 269     public Object get(PersistentCollection col, int index) {
 270         return genericDao.get(col, index);
 271     }
 272
 273     @Override
 274     public boolean contains(PersistentCollection col, Object element) {
 275         return genericDao.contains(col, element);
 276     }
 277
 278     @Override
 279     public boolean containsKey(PersistentCollection col, Object key) {
 280         return genericDao.containsKey(col, key);
 281     }
 282
 283     @Override
 284     public boolean containsValue(PersistentCollection col, Object element) {
 285         return genericDao.containsValue(col, element);
 286     }
 287
 288         @Override
 289         @Transactional(readOnly = false)
 290         public void createFullSampleData() {
 291                 genericDao.createFullSampleData();
 292         }
 293
 294
 295     @Override
 296     public void updateEntity(CdmBase cdmBase) {
 297         genericDao.update(cdmBase);
 298     }
 299
 300     @Override
 301     public <S extends CdmBase> List<S> list(Class<S> type, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths){
 302         return genericDao.list(type,limit, start, orderHints,propertyPaths);
 303     }
 304
 305     @Override
 306     public <S extends CdmBase> int count(Class<S> type) {
 307         return genericDao.count(type);
 308     }
 309
 310
 311
 312 }