EDIT

/**

* Copyright (C) 2007 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.persistence.dao.agent;

import java.util.List;

import eu.etaxonomy.cdm.model.agent.Address;

import eu.etaxonomy.cdm.model.agent.AgentBase;

import eu.etaxonomy.cdm.model.agent.Institution;

import eu.etaxonomy.cdm.model.agent.InstitutionalMembership;

import eu.etaxonomy.cdm.model.agent.Person;

import eu.etaxonomy.cdm.model.agent.Team;

import eu.etaxonomy.cdm.persistence.dao.common.IIdentifiableDao;

import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;

public interface IAgentDao extends IIdentifiableDao<AgentBase> {

	public List<Institution> getInstitutionByCode(String code);

	/**

	 * Return a List of the institutional memberships of a given person

	 *

	 * @param person the person

	 * @param pageSize The maximum number of institutional memberships returned (can be null for all memberships)

	 * @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based)

	 * @return a List of InstitutionalMembership instances

	 */

	public List<InstitutionalMembership> getInstitutionalMemberships(Person person, Integer pageSize, Integer pageNumber);

	/**

	 * Return a count of institutional memberships held by a person

	 *

	 * @param person the person

	 * @return a count of InstitutionalMembership instances

	 */

	public int countInstitutionalMemberships(Person person);

	/**

	 * Return a List of members of a given team

	 *

	 * @param team the team

	 * @param pageSize The maximum number of people returned (can be null for all members)

	 * @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based)

	 * @return a List of Person instances

	 */

	public List<Person> getMembers(Team team, Integer pageSize, Integer pageNumber);

	/**

	 * Return a count of members of a given team

	 *

	 * @param team the team

	 * @return a count of Person instances

	 */

	public int countMembers(Team team);

	/**

	 * Return a count of addresses of a given agent

	 *

	 * @param agent the agent

	 * @return a count of Address instances

	 */

	public Integer countAddresses(AgentBase agent);

	/**

	 * Return a List of addresses of a given agent

	 *

	 * @param agent the agent

	 * @param pageSize The maximum number of addresses returned (can be null for all addresses)

	 * @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based)

	 * @return a List of Address instances

	 */

	public List<Address> getAddresses(AgentBase agent, Integer pageSize,Integer pageNumber);

	/**

	 * Returns a list of <code>UuidAndTitleCache</code> containing all <code>Person</code>s

	 *

	 * @return a list of <code>UuidAndTitleCache</code> instances

	 */

	public List<UuidAndTitleCache<Person>> getPersonUuidAndTitleCache();

	/**

	 * Returns a list of <code>UuidAndTitleCache</code> containing all <code>TeamOrPersonBase</code> obejcts

	 * with their respective nomenclaturalTitle instead of regular titleCache

	 *

	 * @return a list of <code>UuidAndTitleCache</code> instances

	 */

	public List<UuidAndTitleCache<Team>> getTeamUuidAndNomenclaturalTitle();

	/**

	 * Returns a list of <code>UuidAndTitleCache</code> containing all <code>TeamOrPersonBase</code> obejcts

	 * with their respective titleCache

	 *

	 * @return a list of <code>UuidAndTitleCache</code> instances

	 */

	public List<UuidAndTitleCache<Team>> getTeamUuidAndTitleCache();

	/**

	 * @return

	 */

	public List<UuidAndTitleCache<Institution>> getInstitutionUuidAndTitleCache();

    /**

     * @return

     */

    List<Person> getPersonsUsedAsUser();

}

	@Override

	public List<Person> getPersonsUsedAsUser(){

	       Query query = getSession().createQuery("SELECT ab.uuid, ob.idInSource FROM Person ab JOIN ab.sources ob WHERE ob.idNamespace LIKE 'User'");

	       List<Person> result = query.list();

	       return result;

	}

// $Id$

/**

* Copyright (C) 2007 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.api.service;

import java.util.ArrayList;

import java.util.List;

import java.util.UUID;

import org.apache.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import eu.etaxonomy.cdm.api.service.pager.Pager;

import eu.etaxonomy.cdm.api.service.pager.impl.DefaultPagerImpl;

import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;

import eu.etaxonomy.cdm.model.agent.Address;

import eu.etaxonomy.cdm.model.agent.AgentBase;

import eu.etaxonomy.cdm.model.agent.Institution;

import eu.etaxonomy.cdm.model.agent.InstitutionalMembership;

import eu.etaxonomy.cdm.model.agent.Person;

import eu.etaxonomy.cdm.model.agent.Team;

import eu.etaxonomy.cdm.model.agent.TeamOrPersonBase;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.persistence.dao.agent.IAgentDao;

import eu.etaxonomy.cdm.persistence.dao.common.ICdmGenericDao;

import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;

import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy;

import eu.etaxonomy.cdm.strategy.merge.ConvertMergeStrategy;

import eu.etaxonomy.cdm.strategy.merge.DefaultMergeStrategy;

import eu.etaxonomy.cdm.strategy.merge.IMergeStrategy;

import eu.etaxonomy.cdm.strategy.merge.MergeException;

import eu.etaxonomy.cdm.strategy.merge.MergeMode;

/**

 * @author a.mueller

 *

 */

@Service

@Transactional(readOnly = true)

public class AgentServiceImpl extends IdentifiableServiceBase<AgentBase,IAgentDao> implements IAgentService {

    private static final Logger logger = Logger.getLogger(AgentServiceImpl.class);

    @Autowired

    ICdmGenericDao genericDao;

	@Override

    @Autowired

	protected void setDao(IAgentDao dao) {

		assert dao != null;

		this.dao = dao;

	}

 	/**

	 * Constructor

	 */

	public AgentServiceImpl(){

		if (logger.isDebugEnabled()) { logger.debug("Load AgentService Bean"); }

	}

	@Override

	@Transactional(readOnly = false)

    public void updateTitleCache(Class<? extends AgentBase> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<AgentBase> cacheStrategy, IProgressMonitor monitor) {

		if (clazz == null){

			clazz = AgentBase.class;

		}

		super.updateTitleCacheImpl(clazz, stepSize, cacheStrategy, monitor);

	}

	@Override

	public List<Institution> searchInstitutionByCode(String code) {

		return dao.getInstitutionByCode(code);

	}

	@Override

	public Pager<InstitutionalMembership> getInstitutionalMemberships(Person person, Integer pageSize, Integer pageNumber) {

        Integer numberOfResults = dao.countInstitutionalMemberships(person);

		List<InstitutionalMembership> results = new ArrayList<InstitutionalMembership>();

		if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)

			results = dao.getInstitutionalMemberships(person, pageSize, pageNumber);

		}

		return new DefaultPagerImpl<InstitutionalMembership>(pageNumber, numberOfResults, pageSize, results);

	}

	@Override

	public Pager<Person> getMembers(Team team, Integer pageSize, Integer pageNumber) {

		Integer numberOfResults = dao.countMembers(team);

		List<Person> results = new ArrayList<Person>();

		if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)

			results = dao.getMembers(team, pageSize, pageNumber);

		}

		return new DefaultPagerImpl<Person>(pageNumber, numberOfResults, pageSize, results);

	}

	@Override

	public Pager<Address> getAddresses(AgentBase agent, Integer pageSize, Integer pageNumber) {

		Integer numberOfResults = dao.countAddresses(agent);

		List<Address> results = new ArrayList<Address>();

		if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)

			results = dao.getAddresses(agent, pageSize, pageNumber);

		}

		return new DefaultPagerImpl<Address>(pageNumber, numberOfResults, pageSize, results);

	}

	@Override

	public List<UuidAndTitleCache<Team>> getTeamUuidAndNomenclaturalTitle() {

		return dao.getTeamUuidAndNomenclaturalTitle();

	}

	@Override

	public List<UuidAndTitleCache<Person>> getPersonUuidAndTitleCache() {

		return dao.getPersonUuidAndTitleCache();

	}

	@Override

	public List<UuidAndTitleCache<Team>> getTeamUuidAndTitleCache() {

		return dao.getTeamUuidAndTitleCache();

	}

	@Override

	public List<UuidAndTitleCache<Institution>> getInstitutionUuidAndTitleCache() {

		return dao.getInstitutionUuidAndTitleCache();

	}

	@Override

	@Transactional(readOnly = false)

    public DeleteResult delete(UUID agentUUID){

		AgentBase base = dao.load(agentUUID);

		DeleteResult result = this.isDeletable(base, null);

    	if (result.isOk()){

			if (base instanceof Team){

				Team baseTeam = (Team) base;

				List<Person> members = baseTeam.getTeamMembers();

				List<Person> temp = new ArrayList<Person>();

				for (Person member:members){

					temp.add(member);

				}

				for (Person member: temp){

					members.remove(member);

				}

			}

			saveOrUpdate(base);

			dao.delete(base);

		}

		return result;

    }

	@Override

    public DeleteResult delete(AgentBase agent){

		return delete(agent.getUuid());

	}

	@Override

	@Transactional(readOnly = false)

	public UpdateResult convertTeam2Person(UUID teamUuid) throws MergeException {

	    Team team = CdmBase.deproxy(dao.load(teamUuid), Team.class);

	    return convertTeam2Person(team);

	}

	@Override

	public UpdateResult convertTeam2Person(Team team) throws MergeException {

        UpdateResult result = new UpdateResult();

        Person newPerson = null;

		team = CdmBase.deproxy(team, Team.class);

		if (team.getTeamMembers().size() > 1){

			throw new IllegalArgumentException("Team must not have more than 1 member to be convertable into a person");

		}else if (team.getTeamMembers().size() == 1){

		    newPerson = team.getTeamMembers().get(0);

			IMergeStrategy strategy = DefaultMergeStrategy.NewInstance(TeamOrPersonBase.class);

			strategy.setDefaultCollectionMergeMode(MergeMode.FIRST);

			genericDao.merge(newPerson, team, strategy);

		}else if (team.getTeamMembers().isEmpty()){

		    newPerson = Person.NewInstance();

            genericDao.save(newPerson);

			IMergeStrategy strategy = DefaultMergeStrategy.NewInstance(TeamOrPersonBase.class);

			strategy.setDefaultMergeMode(MergeMode.SECOND);

			strategy.setDefaultCollectionMergeMode(MergeMode.SECOND);

			genericDao.merge(newPerson, team, strategy);

		}else{

			throw new IllegalStateException("Unhandled state of team members collection");

		}

		result.setCdmEntity(newPerson);

		return result;

	}

	@Override

	@Transactional(readOnly = false)

	public UpdateResult convertPerson2Team(UUID personUuid) throws MergeException, IllegalArgumentException {

	    Person person = CdmBase.deproxy(dao.load(personUuid), Person.class);

	    return convertPerson2Team(person);

	}

	@Override

	public UpdateResult convertPerson2Team(Person person) throws MergeException, IllegalArgumentException {

	    UpdateResult result = new UpdateResult();

        Team team = Team.NewInstance();

		ConvertMergeStrategy strategy = ConvertMergeStrategy.NewInstance(TeamOrPersonBase.class);

		strategy.setDefaultMergeMode(MergeMode.SECOND);

		strategy.setDefaultCollectionMergeMode(MergeMode.SECOND);

		strategy.setDeleteSecondObject(true);

		if (! genericDao.isMergeable(team, person, strategy)){

			throw new MergeException("Person can not be transformed into team.");

		}

		try {

			this.save(team);

			team.setProtectedNomenclaturalTitleCache(false);

			team.setProtectedTitleCache(true);

			team.setTitleCache(person.getTitleCache(), true);

			genericDao.merge(team, person, strategy);

			//team.addTeamMember(person);

			//this.save(team);

//			team.setNomenclaturalTitle(person.getNomenclaturalTitle(), true);

		} catch (Exception e) {

			throw new MergeException("Unhandled merge exception", e);

		}

		result.setCdmEntity(team);

        return result;

	}

	@Override

    @Transactional(readOnly = false)

    public List<Person> getAllAgentsUsedAsUser(){

	    return dao.getPersonsUsedAsUser();

	}

}

// $Id$

/**

* Copyright (C) 2007 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.api.service;

import java.util.List;

import java.util.UUID;

import eu.etaxonomy.cdm.api.service.pager.Pager;

import eu.etaxonomy.cdm.model.agent.Address;

import eu.etaxonomy.cdm.model.agent.AgentBase;

import eu.etaxonomy.cdm.model.agent.Institution;

import eu.etaxonomy.cdm.model.agent.InstitutionalMembership;

import eu.etaxonomy.cdm.model.agent.Person;

import eu.etaxonomy.cdm.model.agent.Team;

import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;

import eu.etaxonomy.cdm.persistence.query.OrderHint;

import eu.etaxonomy.cdm.strategy.merge.MergeException;

public interface IAgentService extends IIdentifiableEntityService<AgentBase> {

	public List<Institution> searchInstitutionByCode(String code);

	/**

	 * Return a paged list of the institutional memberships held by a person

	 *

	 * @param person the person

	 * @param pageSize The maximum number of memberships returned (can be null for all memberships)

	 * @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based)

	 * @return a Pager containing InstitutionalMembership  instances

	 */

	public Pager<InstitutionalMembership> getInstitutionalMemberships(Person person, Integer pageSize, Integer pageNumber);

	/**

	 * Return a paged list of the members of a team

	 *

	 * @param team the team

	 * @param pageSize The maximum number of members returned (can be null for all members)

	 * @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based)

	 * @return a Pager containing Person  instances

	 */

	public Pager<Person> getMembers(Team team, Integer pageSize, Integer pageNumber);

	/**

	 * Return a paged list of the addresses of an agent

	 *

	 * @param agent the agent

	 * @param pageSize The maximum number of addresses returned (can be null for all members)

	 * @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based)

	 * @return a Pager containing Address  instances

	 */

	public Pager<Address> getAddresses(AgentBase agent, Integer pageSize, Integer pageNumber);

	/**

	 * Returns a Paged List of AgentBase instances where the default field matches the String queryString (as interpreted by the Lucene QueryParser)

	 *

	 * @param clazz filter the results by class (or pass null to return all AgentBase instances)

	 * @param queryString

	 * @param pageSize The maximum number of agents returned (can be null for all matching agents)

	 * @param pageNumber The offset (in pageSize chunks) from the start of the result set (0 - based)

	 * @param orderHints

	 *            Supports path like <code>orderHints.propertyNames</code> which

	 *            include *-to-one properties like createdBy.username or

	 *            authorTeam.persistentTitleCache

	 * @param propertyPaths properties to be initialized

	 * @return a Pager Agent instances

	 * @see <a href="http://lucene.apache.org/java/2_4_0/queryparsersyntax.html">Apache Lucene - Query Parser Syntax</a>

	 */

	@Override

    public Pager<AgentBase> search(Class<? extends AgentBase> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths);

	/**

	 * Returns a list of <code>UuidAndTitleCache</code> containing all <code>Person</code>s

	 *

	 * @return a list of <code>UuidAndTitleCache</code> instances

	 */

	public List<UuidAndTitleCache<Person>> getPersonUuidAndTitleCache();

	/**

	 * Returns a list of <code>UuidAndTitleCache</code> containing all <code>TeamOrPersonBase</code> objects

	 * with their respective titleCache

	 *

	 * @return a list of <code>UuidAndTitleCache</code> instances

	 */

	public List<UuidAndTitleCache<Team>> getTeamUuidAndTitleCache();

	/**

	 * Returns a list of <code>UuidAndTitleCache</code> containing all <code>TeamOrPersonBase</code> objects

	 * with their respective nomenclaturalTitle instead of regular titleCache

	 *

	 * @return a list of <code>UuidAndTitleCache</code> instances

	 */

	public List<UuidAndTitleCache<Team>> getTeamUuidAndNomenclaturalTitle();

	/**

	 * Returns a list of <code>UuidAndTitleCache</code> containing all {@link Institution} objects

	 * with their respective titleCache

	 *

	 * @return a list of <code>UuidAndTitleCache</code> instances

	 */

	public List<UuidAndTitleCache<Institution>> getInstitutionUuidAndTitleCache();

    /**

     * @param teamUuid

     * @return

     * @throws MergeException

     */

    public UpdateResult convertTeam2Person(UUID teamUuid) throws MergeException;

	/**

	 * If the given {@link Team} is a single member team all links to the team are redirected to the

	 * single member and the team itself is deleted.

	 * <BR>

	 * If the given {@link Team} has no members (protected caches) a new {@link Person} is created

	 * and all links to the team are redirected to the new person and the team itself is deleted.

	 * <BR>

	 * Otherwise, an {@link IllegalArgumentException} is thrown.

	 *

	 * @param team the team to be converted

	 * @return the existing or new person that replaces the given team

	 * @throws IllegalArgumentException if team has > 1 members

	 * @throws MergeException if anything else goes wrong during merge

	 */

	public UpdateResult convertTeam2Person(Team team) throws MergeException, IllegalArgumentException;

    /**

     * @param personUuid

     * @return

     * @throws MergeException

     * @throws IllegalArgumentException

     */

    public UpdateResult convertPerson2Team(UUID personUuid) throws MergeException, IllegalArgumentException;

	/**

	 * If possible replaces the given person by a new {@link Team}.

	 * <BR>This is only possible if the person is at no place used in person only mode, which

	 * is the case e.g. at User.person or FieldUnit.primaryCollector.

	 * <BR>

	 * If the person can not be replaced a {@link MergeException} is thrown.

	 *

	 * @param person the {@link Person} to be converted

	 * @return the new team that replaces the given person

	 * @throws MergeException if anything else goes wrong during merge

	 */

	public UpdateResult convertPerson2Team(Person person) throws MergeException, IllegalArgumentException;

    /**

     * @return

     */

    List<Person> getAllAgentsUsedAsUser();

}