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

   1 /**
   2 * Copyright (C) 2007 EDIT
   3 * European Distributed Institute of Taxonomy
   4 * http://www.e-taxonomy.eu
   5 *
   6 * The contents of this file are subject to the Mozilla Public License Version 1.1
   7 * See LICENSE.TXT at the top of this package for the full license terms.
   8 */
   9
  10 package eu.etaxonomy.cdm.api.service;
  11
  12 import java.util.ArrayList;
  13 import java.util.List;
  14 import java.util.UUID;
  15
  16 import org.apache.log4j.Logger;
  17 import org.springframework.beans.factory.annotation.Autowired;
  18 import org.springframework.stereotype.Service;
  19 import org.springframework.transaction.annotation.Transactional;
  20
  21 import eu.etaxonomy.cdm.api.service.pager.Pager;
  22 import eu.etaxonomy.cdm.api.service.pager.impl.DefaultPagerImpl;
  23 import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;
  24 import eu.etaxonomy.cdm.model.agent.Address;
  25 import eu.etaxonomy.cdm.model.agent.AgentBase;
  26 import eu.etaxonomy.cdm.model.agent.Institution;
  27 import eu.etaxonomy.cdm.model.agent.InstitutionalMembership;
  28 import eu.etaxonomy.cdm.model.agent.Person;
  29 import eu.etaxonomy.cdm.model.agent.Team;
  30 import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;
  31 import eu.etaxonomy.cdm.model.common.CdmBase;
  32 import eu.etaxonomy.cdm.persistence.dao.agent.IAgentDao;
  33 import eu.etaxonomy.cdm.persistence.dao.common.ICdmGenericDao;
  34 import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
  35 import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy;
  36 import eu.etaxonomy.cdm.strategy.merge.ConvertMergeStrategy;
  37 import eu.etaxonomy.cdm.strategy.merge.DefaultMergeStrategy;
  38 import eu.etaxonomy.cdm.strategy.merge.IMergeStrategy;
  39 import eu.etaxonomy.cdm.strategy.merge.MergeException;
  40 import eu.etaxonomy.cdm.strategy.merge.MergeMode;
  41
  42
  43
  44 /**
  45  * @author a.mueller
  46  *
  47  */
  48 @Service
  49 @Transactional(readOnly = true)
  50 public class AgentServiceImpl
  51         extends IdentifiableServiceBase<AgentBase,IAgentDao>
  52         implements IAgentService {
  53     private static final Logger logger = Logger.getLogger(AgentServiceImpl.class);
  54
  55     @Autowired
  56     ICdmGenericDao genericDao;
  57
  58         @Override
  59     @Autowired
  60         protected void setDao(IAgentDao dao) {
  61                 assert dao != null;
  62                 this.dao = dao;
  63         }
  64
  65         /**
  66          * Constructor
  67          */
  68         public AgentServiceImpl(){
  69                 if (logger.isDebugEnabled()) { logger.debug("Load AgentService Bean"); }
  70         }
  71
  72
  73         @Override
  74         @Transactional(readOnly = false)
  75     public UpdateResult updateCaches(Class<? extends AgentBase> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<AgentBase> cacheStrategy, IProgressMonitor monitor) {
  76                 if (clazz == null){
  77                         clazz = AgentBase.class;
  78                 }
  79                 return super.updateCachesImpl(clazz, stepSize, cacheStrategy, monitor);
  80         }
  81
  82         @Override
  83         public List<Institution> searchInstitutionByCode(String code) {
  84                 return dao.getInstitutionByCode(code);
  85         }
  86
  87         @Override
  88         public Pager<InstitutionalMembership> getInstitutionalMemberships(Person person, Integer pageSize, Integer pageNumber) {
  89         long numberOfResults = dao.countInstitutionalMemberships(person);
  90
  91                 List<InstitutionalMembership> results = new ArrayList<>();
  92                 if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
  93                         results = dao.getInstitutionalMemberships(person, pageSize, pageNumber);
  94                 }
  95
  96                 return new DefaultPagerImpl<>(pageNumber, numberOfResults, pageSize, results);
  97         }
  98
  99         @Override
 100         public Pager<Person> getMembers(Team team, Integer pageSize, Integer pageNumber) {
 101                 long numberOfResults = dao.countMembers(team);
 102
 103                 List<Person> results = new ArrayList<>();
 104                 if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
 105                         results = dao.getMembers(team, pageSize, pageNumber);
 106                 }
 107
 108                 return new DefaultPagerImpl<>(pageNumber, numberOfResults, pageSize, results);
 109         }
 110
 111         @Override
 112         public Pager<Address> getAddresses(AgentBase agent, Integer pageSize, Integer pageNumber) {
 113                 long numberOfResults = dao.countAddresses(agent);
 114
 115                 List<Address> results = new ArrayList<>();
 116                 if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
 117                         results = dao.getAddresses(agent, pageSize, pageNumber);
 118                 }
 119
 120                 return new DefaultPagerImpl<>(pageNumber, numberOfResults, pageSize, results);
 121         }
 122
 123         @Override
 124         public List<UuidAndTitleCache<Team>> getTeamUuidAndNomenclaturalTitle() {
 125                 return dao.getTeamUuidAndNomenclaturalTitle();
 126         }
 127
 128         @Override
 129         public List<UuidAndTitleCache<Person>> getPersonUuidAndTitleCache() {
 130                 return dao.getPersonUuidAndTitleCache();
 131         }
 132
 133         @Override
 134         public List<UuidAndTitleCache<Team>> getTeamUuidAndTitleCache() {
 135                 return dao.getTeamUuidAndTitleCache();
 136         }
 137
 138         @Override
 139         public List<UuidAndTitleCache<AgentBase>> getInstitutionUuidAndTitleCache(Integer limit, String pattern) {
 140                 return dao.getUuidAndAbbrevTitleCache(Institution.class, limit, pattern);
 141         }
 142
 143         @Override
 144         @Transactional(readOnly = false)
 145     public DeleteResult delete(UUID agentUUID){
 146             DeleteResult result = new DeleteResult();
 147             if (agentUUID == null){
 148                 result.setAbort();
 149                 result.addException(new Exception("Can't delete object without UUID."));
 150                 return result;
 151             }
 152                 AgentBase base = dao.load(agentUUID);
 153                 result = isDeletable(agentUUID, null);
 154
 155         if (result.isOk()){
 156                         if (base instanceof Team){
 157                                 Team baseTeam = (Team) base;
 158                                 List<Person> members = baseTeam.getTeamMembers();
 159                                 List<Person> temp = new ArrayList<Person>();
 160                                 for (Person member:members){
 161                                         temp.add(member);
 162                                 }
 163                                 for (Person member: temp){
 164                                         members.remove(member);
 165                                 }
 166                         }
 167                         saveOrUpdate(base);
 168
 169                         dao.delete(base);
 170                         result.addDeletedObject(base);
 171
 172                 }
 173
 174                 return result;
 175     }
 176
 177         @Override
 178     public DeleteResult delete(AgentBase agent){
 179                 return delete(agent.getUuid());
 180         }
 181
 182         @Override
 183         @Transactional(readOnly = false)
 184         public UpdateResult convertTeam2Person(UUID teamUuid) throws MergeException {
 185             Team team = CdmBase.deproxy(dao.load(teamUuid), Team.class);
 186             return convertTeam2Person(team);
 187         }
 188
 189         @Override
 190         public UpdateResult convertTeam2Person(Team team) throws MergeException {
 191         UpdateResult result = new UpdateResult();
 192         Person newPerson = null;
 193                 team = CdmBase.deproxy(team, Team.class);
 194                 if (team.getTeamMembers().size() > 1){
 195                         throw new IllegalArgumentException("Team must not have more than 1 member to be convertable into a person");
 196                 }else if (team.getTeamMembers().size() == 1){
 197                     newPerson = team.getTeamMembers().get(0);
 198                         IMergeStrategy strategy = DefaultMergeStrategy.NewInstance(TeamOrPersonBase.class);
 199                         strategy.setDefaultCollectionMergeMode(MergeMode.FIRST);
 200                         genericDao.merge(newPerson, team, strategy);
 201                 }else if (team.getTeamMembers().isEmpty()){
 202                     newPerson = Person.NewInstance();
 203             genericDao.save(newPerson);
 204                         IMergeStrategy strategy = DefaultMergeStrategy.NewInstance(TeamOrPersonBase.class);
 205                         strategy.setDefaultMergeMode(MergeMode.SECOND);
 206                         strategy.setDefaultCollectionMergeMode(MergeMode.SECOND);
 207                         genericDao.merge(newPerson, team, strategy);
 208                 }else{
 209                         throw new IllegalStateException("Unhandled state of team members collection");
 210                 }
 211                 result.setCdmEntity(newPerson);
 212                 return result;
 213         }
 214
 215         @Override
 216         @Transactional(readOnly = false)
 217         public UpdateResult convertPerson2Team(UUID personUuid) throws MergeException, IllegalArgumentException {
 218             Person person = CdmBase.deproxy(dao.load(personUuid), Person.class);
 219             return convertPerson2Team(person);
 220         }
 221
 222         @Override
 223         public UpdateResult convertPerson2Team(Person person) throws MergeException, IllegalArgumentException {
 224             UpdateResult result = new UpdateResult();
 225         Team team = Team.NewInstance();
 226                 ConvertMergeStrategy strategy = ConvertMergeStrategy.NewInstance(TeamOrPersonBase.class);
 227                 strategy.setDefaultMergeMode(MergeMode.SECOND);
 228                 strategy.setDefaultCollectionMergeMode(MergeMode.SECOND);
 229                 strategy.setDeleteSecondObject(true);
 230
 231
 232                 if (! genericDao.isMergeable(team, person, strategy)){
 233                         throw new MergeException("Person can not be transformed into team.");
 234                 }
 235                 try {
 236                         //this.save(team);
 237                         team.setProtectedNomenclaturalTitleCache(false);
 238                         team.setProtectedTitleCache(true);
 239                         team.setTitleCache(person.getTitleCache(), true);
 240                         team =(Team) this.save(team);
 241                         genericDao.merge(team, person, strategy);
 242                         //team.addTeamMember(person);
 243
 244                         //this.save(team);
 245 //                      team.setNomenclaturalTitle(person.getNomenclaturalTitle(), true);
 246                 } catch (Exception e) {
 247                         throw new MergeException("Unhandled merge exception", e);
 248                 }
 249                 result.setCdmEntity(team);
 250                 result.addUpdatedObject(team);
 251         return result;
 252         }
 253
 254     /* (non-Javadoc)
 255      * @see eu.etaxonomy.cdm.api.service.IAgentService#getUuidAndAbbrevTitleCache()
 256      */
 257     @Override
 258     public List<UuidAndTitleCache<AgentBase>> getUuidAndAbbrevTitleCache(Class clazz, Integer limit, String pattern) {
 259         return dao.getUuidAndAbbrevTitleCache(clazz, null, pattern);
 260     }
 261
 262 }