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, 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 Person 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 Person convertTeam2Person(Team team) throws MergeException {
 183                 Person result = null;
 184                 team = CdmBase.deproxy(team, Team.class);
 185                 if (team.getTeamMembers().size() > 1){
 186                         throw new IllegalArgumentException("Team must not have more than 1 member to be convertable into a person");
 187                 }else if (team.getTeamMembers().size() == 1){
 188                         result = team.getTeamMembers().get(0);
 189                         IMergeStrategy strategy = DefaultMergeStrategy.NewInstance(TeamOrPersonBase.class);
 190                         strategy.setDefaultCollectionMergeMode(MergeMode.FIRST);
 191                         genericDao.merge(result, team, strategy);
 192                 }else if (team.getTeamMembers().isEmpty()){
 193                         result = Person.NewInstance();
 194                         genericDao.save(result);
 195                         IMergeStrategy strategy = DefaultMergeStrategy.NewInstance(TeamOrPersonBase.class);
 196                         strategy.setDefaultMergeMode(MergeMode.SECOND);
 197                         strategy.setDefaultCollectionMergeMode(MergeMode.SECOND);
 198                         genericDao.merge(result, team, strategy);
 199                 }else{
 200                         throw new IllegalStateException("Unhandled state of team members collection");
 201                 }
 202
 203                 return result;
 204         }
 205
 206         @Override
 207         @Transactional(readOnly = false)
 208         public Team convertPerson2Team(UUID personUuid) throws MergeException, IllegalArgumentException {
 209             Person person = CdmBase.deproxy(dao.load(personUuid), Person.class);
 210             return convertPerson2Team(person);
 211         }
 212
 213         @Override
 214         public Team convertPerson2Team(Person person) throws MergeException, IllegalArgumentException {
 215                 Team team = Team.NewInstance();
 216                 ConvertMergeStrategy strategy = ConvertMergeStrategy.NewInstance(TeamOrPersonBase.class);
 217                 strategy.setDefaultMergeMode(MergeMode.SECOND);
 218                 strategy.setDefaultCollectionMergeMode(MergeMode.SECOND);
 219                 strategy.setDeleteSecondObject(true);
 220
 221
 222                 if (! genericDao.isMergeable(team, person, strategy)){
 223                         throw new MergeException("Person can not be transformed into team.");
 224                 }
 225                 try {
 226                         this.save(team);
 227                         team.setProtectedNomenclaturalTitleCache(false);
 228                         team.setProtectedTitleCache(true);
 229                         team.setTitleCache(person.getTitleCache(), true);
 230                         genericDao.merge(team, person, strategy);
 231                         //team.addTeamMember(person);
 232
 233                         //this.save(team);
 234 //                      team.setNomenclaturalTitle(person.getNomenclaturalTitle(), true);
 235                 } catch (Exception e) {
 236                         throw new MergeException("Unhandled merge exception", e);
 237                 }
 238                 return team;
 239         }
 240
 241
 242 }