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