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.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 extends IdentifiableServiceBase<AgentBase,IAgentDao> implements IAgentService {
  51     private static final Logger logger = Logger.getLogger(AgentServiceImpl.class);
  52
  53     @Autowired
  54     ICdmGenericDao genericDao;
  55
  56         @Override
  57     @Autowired
  58         protected void setDao(IAgentDao dao) {
  59                 assert dao != null;
  60                 this.dao = dao;
  61         }
  62
  63         /**
  64          * Constructor
  65          */
  66         public AgentServiceImpl(){
  67                 if (logger.isDebugEnabled()) { logger.debug("Load AgentService Bean"); }
  68         }
  69
  70
  71         @Override
  72         @Transactional(readOnly = false)
  73     public void updateTitleCache(Class<? extends AgentBase> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<AgentBase> cacheStrategy, IProgressMonitor monitor) {
  74                 if (clazz == null){
  75                         clazz = AgentBase.class;
  76                 }
  77                 super.updateTitleCacheImpl(clazz, stepSize, cacheStrategy, monitor);
  78         }
  79
  80         @Override
  81         public List<Institution> searchInstitutionByCode(String code) {
  82                 return dao.getInstitutionByCode(code);
  83         }
  84
  85         @Override
  86         public Pager<InstitutionalMembership> getInstitutionalMemberships(Person person, Integer pageSize, Integer pageNumber) {
  87         Integer numberOfResults = dao.countInstitutionalMemberships(person);
  88
  89                 List<InstitutionalMembership> results = new ArrayList<InstitutionalMembership>();
  90                 if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
  91                         results = dao.getInstitutionalMemberships(person, pageSize, pageNumber);
  92                 }
  93
  94                 return new DefaultPagerImpl<InstitutionalMembership>(pageNumber, numberOfResults, pageSize, results);
  95         }
  96
  97         @Override
  98         public Pager<Person> getMembers(Team team, Integer pageSize, Integer pageNumber) {
  99                 Integer numberOfResults = dao.countMembers(team);
 100
 101                 List<Person> results = new ArrayList<Person>();
 102                 if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
 103                         results = dao.getMembers(team, pageSize, pageNumber);
 104                 }
 105
 106                 return new DefaultPagerImpl<Person>(pageNumber, numberOfResults, pageSize, results);
 107         }
 108
 109         @Override
 110         public Pager<Address> getAddresses(AgentBase agent, Integer pageSize, Integer pageNumber) {
 111                 Integer numberOfResults = dao.countAddresses(agent);
 112
 113                 List<Address> results = new ArrayList<Address>();
 114                 if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
 115                         results = dao.getAddresses(agent, pageSize, pageNumber);
 116                 }
 117
 118                 return new DefaultPagerImpl<Address>(pageNumber, numberOfResults, pageSize, results);
 119         }
 120
 121         @Override
 122         public List<UuidAndTitleCache<Team>> getTeamUuidAndNomenclaturalTitle() {
 123                 return dao.getTeamUuidAndNomenclaturalTitle();
 124         }
 125
 126         @Override
 127         public List<UuidAndTitleCache<Person>> getPersonUuidAndTitleCache() {
 128                 return dao.getPersonUuidAndTitleCache();
 129         }
 130
 131         @Override
 132         public List<UuidAndTitleCache<Team>> getTeamUuidAndTitleCache() {
 133                 return dao.getTeamUuidAndTitleCache();
 134         }
 135
 136         @Override
 137         public List<UuidAndTitleCache<Institution>> getInstitutionUuidAndTitleCache() {
 138                 return dao.getInstitutionUuidAndTitleCache();
 139         }
 140
 141         @Override
 142     public DeleteResult delete(UUID agentUUID){
 143                 AgentBase base = dao.load(agentUUID);
 144                 DeleteResult result = this.isDeletable(base, null);
 145
 146         if (result.isOk()){
 147                         if (base instanceof Team){
 148                                 Team baseTeam = (Team) base;
 149                                 List<Person> members = baseTeam.getTeamMembers();
 150                                 List<Person> temp = new ArrayList<Person>();
 151                                 for (Person member:members){
 152                                         temp.add(member);
 153                                 }
 154                                 for (Person member: temp){
 155                                         members.remove(member);
 156                                 }
 157                         }
 158                         saveOrUpdate(base);
 159
 160                         dao.delete(base);
 161
 162                 }
 163
 164                 return result;
 165     }
 166
 167         @Override
 168     public DeleteResult delete(AgentBase agent){
 169                 return delete(agent.getUuid());
 170         }
 171
 172         @Override
 173         public Person convertTeam2Person(Team team) throws MergeException {
 174                 Person result = null;
 175                 team = CdmBase.deproxy(team, Team.class);
 176                 if (team.getTeamMembers().size() > 1){
 177                         throw new IllegalArgumentException("Team must not have more than 1 member to be convertable into a person");
 178                 }else if (team.getTeamMembers().size() == 1){
 179                         result = team.getTeamMembers().get(0);
 180                         IMergeStrategy strategy = DefaultMergeStrategy.NewInstance(TeamOrPersonBase.class);
 181                         strategy.setDefaultCollectionMergeMode(MergeMode.FIRST);
 182                         genericDao.merge(result, team, strategy);
 183                 }else if (team.getTeamMembers().isEmpty()){
 184                         result = Person.NewInstance();
 185                         genericDao.save(result);
 186                         IMergeStrategy strategy = DefaultMergeStrategy.NewInstance(TeamOrPersonBase.class);
 187                         strategy.setDefaultMergeMode(MergeMode.SECOND);
 188                         strategy.setDefaultCollectionMergeMode(MergeMode.SECOND);
 189                         genericDao.merge(result, team, strategy);
 190                 }else{
 191                         throw new IllegalStateException("Unhandled state of team members collection");
 192                 }
 193
 194                 return result;
 195         }
 196
 197         @Override
 198         public Team convertPerson2Team(Person person) throws MergeException, IllegalArgumentException {
 199                 Team team = Team.NewInstance();
 200                 IMergeStrategy strategy = DefaultMergeStrategy.NewInstance(TeamOrPersonBase.class);
 201                 strategy.setDefaultMergeMode(MergeMode.SECOND);
 202                 strategy.setDefaultCollectionMergeMode(MergeMode.SECOND);
 203
 204                 if (! genericDao.isMergeable(team, person, strategy)){
 205                         throw new MergeException("Person can not be transformed into team.");
 206                 }
 207                 try {
 208                         this.save(team);
 209                         team.setProtectedNomenclaturalTitleCache(true);
 210                         genericDao.merge(team, person, strategy);
 211 //                      team.setNomenclaturalTitle(person.getNomenclaturalTitle(), true);
 212                 } catch (Exception e) {
 213                         throw new MergeException("Unhandled merge exception", e);
 214                 }
 215                 return team;
 216         }
 217
 218
 219 }