BrokeringServiceImpl.java

/*
    This file is part of Cyclos (www.cyclos.org).
    A project of the Social Trade Organisation (www.socialtrade.org).

    Cyclos is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    Cyclos is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with Cyclos; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA

 */
package nl.strohalm.cyclos.services.elements;

import java.util.Calendar;
import java.util.Collection;
import java.util.EnumSet;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import nl.strohalm.cyclos.dao.members.ElementDAO;
import nl.strohalm.cyclos.dao.members.RemarkDAO;
import nl.strohalm.cyclos.dao.members.brokerings.BrokerCommissionContractDAO;
import nl.strohalm.cyclos.dao.members.brokerings.BrokeringCommissionStatusDAO;
import nl.strohalm.cyclos.dao.members.brokerings.BrokeringDAO;
import nl.strohalm.cyclos.entities.Relationship;
import nl.strohalm.cyclos.entities.accounts.fees.transaction.BrokerCommission;
import nl.strohalm.cyclos.entities.accounts.fees.transaction.TransactionFeeQuery;
import nl.strohalm.cyclos.entities.exceptions.UnexpectedEntityException;
import nl.strohalm.cyclos.entities.groups.BrokerGroup;
import nl.strohalm.cyclos.entities.groups.MemberGroup;
import nl.strohalm.cyclos.entities.members.BrokeringQuery;
import nl.strohalm.cyclos.entities.members.BrokeringQuery.Status;
import nl.strohalm.cyclos.entities.members.Element;
import nl.strohalm.cyclos.entities.members.FullTextMemberQuery;
import nl.strohalm.cyclos.entities.members.Member;
import nl.strohalm.cyclos.entities.members.brokerings.BrokerCommissionContract;
import nl.strohalm.cyclos.entities.members.brokerings.BrokerCommissionContractQuery;
import nl.strohalm.cyclos.entities.members.brokerings.Brokering;
import nl.strohalm.cyclos.entities.members.brokerings.BrokeringCommissionStatus;
import nl.strohalm.cyclos.entities.members.brokerings.BrokeringCommissionStatusQuery;
import nl.strohalm.cyclos.entities.members.remarks.BrokerRemark;
import nl.strohalm.cyclos.entities.settings.LocalSettings;
import nl.strohalm.cyclos.services.InitializingService;
import nl.strohalm.cyclos.services.elements.exceptions.MemberAlreadyInBrokeringsException;
import nl.strohalm.cyclos.services.fetch.FetchServiceLocal;
import nl.strohalm.cyclos.services.settings.SettingsServiceLocal;
import nl.strohalm.cyclos.services.transfertypes.TransactionFeeServiceLocal;
import nl.strohalm.cyclos.utils.CacheCleaner;
import nl.strohalm.cyclos.utils.DataIteratorHelper;
import nl.strohalm.cyclos.utils.DateHelper;
import nl.strohalm.cyclos.utils.TimePeriod;
import nl.strohalm.cyclos.utils.access.LoggedUser;
import nl.strohalm.cyclos.utils.notifications.MemberNotificationHandler;
import nl.strohalm.cyclos.utils.query.QueryParameters.ResultType;
import nl.strohalm.cyclos.utils.validation.InvalidError;
import nl.strohalm.cyclos.utils.validation.PropertyValidation;
import nl.strohalm.cyclos.utils.validation.RequiredError;
import nl.strohalm.cyclos.utils.validation.ValidationError;
import nl.strohalm.cyclos.utils.validation.ValidationException;
import nl.strohalm.cyclos.utils.validation.Validator;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang.StringUtils;

/**
 * Implementation for brokering service
 * @author luis
 */
public class BrokeringServiceImpl implements BrokeringServiceLocal, InitializingService {

    /**
     * Validates a property as being a broker
     * @author luis
     */
    public final class BrokerValidation implements PropertyValidation {
        private static final long serialVersionUID = 580603314020373024L;

        @Override
        public ValidationError validate(final Object object, final Object name, final Object value) {
            final ChangeBrokerDTO dto = (ChangeBrokerDTO) object;
            final Member member = fetchService.fetch((Member) value, Element.Relationships.GROUP);
            if (value == null) {
                return null;
            }
            if (member != null && !member.getMemberGroup().isBroker()) {
                return new InvalidError();
            }
            final MemberGroup viewerGroup = (MemberGroup) member.getGroup();
            final Member brokeredMember = fetchService.fetch(dto.getMember());

            if (!viewerGroup.getCanViewProfileOfGroups().contains(brokeredMember.getGroup())) {
                throw new ValidationException();
            }

            return null;
        }
    }

    private BrokerCommissionContractDAO  brokerCommissionContractDao;
    private BrokeringCommissionStatusDAO brokeringCommissionStatusDao;
    private BrokeringDAO                 brokeringDao;
    private CommissionServiceLocal       commissionService;
    private ElementServiceLocal          elementService;
    private ElementDAO                   elementDao;
    private FetchServiceLocal            fetchService;
    private RemarkDAO                    remarkDao;
    private SettingsServiceLocal         settingsService;
    private TransactionFeeServiceLocal   transactionFeeService;

    private MemberNotificationHandler    memberNotificationHandler;

    @Override
    @SuppressWarnings("unchecked")
    public BulkMemberActionResultVO bulkChangeMemberBroker(final FullTextMemberQuery query, Member newBroker, final boolean suspendCommission, final String comments) {
        if (newBroker == null || newBroker.isTransient()) {
            throw new ValidationException();
        }
        if (StringUtils.isEmpty(comments)) {
            throw new ValidationException();
        }
        newBroker = fetchService.fetch(newBroker);

        int changed = 0;
        int unchanged = 0;
        // force the result type to ITERATOR to avoid load all members in memory
        query.setIterateAll();
        final List<Member> members = (List<Member>) elementService.fullTextSearch(query);
        CacheCleaner cacheCleaner = new CacheCleaner(fetchService);
        for (final Member member : members) {
            if (newBroker.equals(member.getBroker())) {
                unchanged++;
            } else {
                final ChangeBrokerDTO dto = new ChangeBrokerDTO();
                dto.setMember(member);
                dto.setNewBroker(newBroker);
                dto.setSuspendCommission(suspendCommission);
                dto.setComments(comments);
                changeBroker(dto);
                changed++;

                cacheCleaner.clearCache();
            }
        }
        return new BulkMemberActionResultVO(changed, unchanged);
    }

    @Override
    public Brokering changeBroker(final ChangeBrokerDTO dto) {
        memberNotificationHandler.removedBrokeringNotification(dto);
        return doChangeBroker(dto);
    }

    /**
     * Creates a new brokering
     */
    @Override
    public Brokering create(final Member broker, final Member brokered) {
        Brokering brokering = new Brokering();
        brokering.setBroker(broker);
        brokering.setBrokered(brokered);
        brokering.setStartDate(Calendar.getInstance());
        brokering = brokeringDao.insert(brokering);

        // Create brokering commission status
        createBrokeringCommissionStatus(brokering);

        return brokering;
    }

    @Override
    public Brokering getActiveBrokering(Member member) {
        member = fetchService.fetch(member, Member.Relationships.BROKER);
        if (member.getBroker() == null) {
            return null;
        }

        // Verifies if there is an active broker for the subject
        final BrokeringQuery query = new BrokeringQuery();
        query.fetch(Brokering.Relationships.BROKER);
        query.setBroker(member.getBroker());
        query.setBrokered(member);
        query.setStatus(BrokeringQuery.Status.ACTIVE);
        query.setUniqueResult();
        final List<Brokering> list = search(query);
        if (list != null && !list.isEmpty()) {
            return list.get(0);
        }
        return null;
    }

    @Override
    public Brokering getBrokering(final Member broker, final Member member) throws ValidationException {
        final BrokeringQuery brokeringQuery = new BrokeringQuery();
        brokeringQuery.setBroker(broker);
        brokeringQuery.setBrokered(member);
        brokeringQuery.setStatus(BrokeringQuery.Status.ACTIVE);
        final List<Brokering> brokerings = search(brokeringQuery);
        if (CollectionUtils.isEmpty(brokerings)) {
            throw new ValidationException();
        }
        final Brokering brokering = brokerings.iterator().next();
        return brokering;
    }

    public ElementDAO getElementDao() {
        return elementDao;
    }

    @Override
    public void initializeService() {
        removeExpiredBrokerings(Calendar.getInstance());
    }

    @Override
    public Collection<Status> listPossibleStatuses(BrokerGroup brokerGroup) {
        brokerGroup = fetchService.fetch(brokerGroup, BrokerGroup.Relationships.POSSIBLE_INITIAL_GROUPS);
        boolean hasInactive = false;
        Collection<MemberGroup> possibleInitialGroups = brokerGroup.getPossibleInitialGroups();
        for (MemberGroup group : possibleInitialGroups) {
            if (!group.isActive()) {
                hasInactive = true;
                break;
            }
        }
        return hasInactive ? EnumSet.allOf(BrokeringQuery.Status.class) : EnumSet.complementOf(EnumSet.of(BrokeringQuery.Status.PENDING));
    }

    @Override
    public Brokering load(final Long id, final Relationship... fetch) {
        return brokeringDao.load(id, fetch);
    }

    @Override
    public Brokering remove(final Brokering brokering, final String remark) throws UnexpectedEntityException {
        if (brokering == null || brokering.isTransient() || brokering.getEndDate() != null) {
            throw new UnexpectedEntityException();
        }

        final ChangeBrokerDTO dto = new ChangeBrokerDTO();
        dto.setComments(remark);
        dto.setMember(brokering.getBrokered());
        dto.setNewBroker(null);
        return doChangeBroker(dto);
    }

    @Override
    public void removeExpiredBrokerings(final Calendar time) {
        final LocalSettings localSettings = settingsService.getLocalSettings();
        final TimePeriod brokeringExpirationPeriod = localSettings.getBrokeringExpirationPeriod();
        if (brokeringExpirationPeriod == null || brokeringExpirationPeriod.getNumber() <= 0) {
            return;
        }

        final Calendar startDate = brokeringExpirationPeriod.remove(DateHelper.truncate(time));
        final BrokeringQuery query = new BrokeringQuery();
        query.setResultType(ResultType.ITERATOR);
        query.setStatus(BrokeringQuery.Status.ACTIVE);
        query.setStartExpirationDate(startDate);
        CacheCleaner cleaner = new CacheCleaner(fetchService);
        final List<Brokering> expired = search(query);
        try {
            for (final Brokering brokering : expired) {
                // Update the brokering, expiring it
                brokering.setEndDate(time);
                brokeringDao.update(brokering);
                memberNotificationHandler.expiredBrokeringNotification(brokering);
                cleaner.clearCache();
            }
        } finally {
            DataIteratorHelper.close(expired);
        }
    }

    @Override
    public List<Brokering> search(final BrokeringQuery query) {
        return brokeringDao.search(query);
    }

    public void setBrokerCommissionContractDao(final BrokerCommissionContractDAO brokerCommissionContractDao) {
        this.brokerCommissionContractDao = brokerCommissionContractDao;
    }

    public void setBrokeringCommissionStatusDao(final BrokeringCommissionStatusDAO brokeringCommissionStatusDao) {
        this.brokeringCommissionStatusDao = brokeringCommissionStatusDao;
    }

    public void setBrokeringDao(final BrokeringDAO brokeringDAO) {
        brokeringDao = brokeringDAO;
    }

    public void setCommissionServiceLocal(final CommissionServiceLocal commissionService) {
        this.commissionService = commissionService;
    }

    public void setElementDao(final ElementDAO elementDao) {
        this.elementDao = elementDao;
    }

    public void setElementServiceLocal(final ElementServiceLocal elementService) {
        this.elementService = elementService;
    }

    public void setFetchServiceLocal(final FetchServiceLocal fetchService) {
        this.fetchService = fetchService;
    }

    public void setMemberNotificationHandler(final MemberNotificationHandler memberNotificationHandler) {
        this.memberNotificationHandler = memberNotificationHandler;
    }

    public void setRemarkDao(final RemarkDAO remarkDao) {
        this.remarkDao = remarkDao;
    }

    public void setSettingsServiceLocal(final SettingsServiceLocal settingsService) {
        this.settingsService = settingsService;
    }

    public void setTransactionFeeServiceLocal(final TransactionFeeServiceLocal transactionFeeService) {
        this.transactionFeeService = transactionFeeService;
    }

    @Override
    public void validate(final Brokering brokering) throws ValidationException {
        getBrokeringValidator().validate(brokering);
    }

    @Override
    public void validate(final ChangeBrokerDTO dto) throws ValidationException {
        getDtoValidator().validate(dto);
    }

    private void closeBrokerContractsAndBrokeringStatus(final Brokering brokering) {
        // Close active broker commission contracts
        final BrokerCommissionContractQuery bccQuery = new BrokerCommissionContractQuery();
        bccQuery.setBroker(brokering.getBroker());
        bccQuery.setMember(brokering.getBrokered());
        bccQuery.setStatus(BrokerCommissionContract.Status.ACTIVE);
        final List<BrokerCommissionContract> brokerCommissionContracts = brokerCommissionContractDao.search(bccQuery);
        for (final BrokerCommissionContract brokerCommissionContract : brokerCommissionContracts) {
            brokerCommissionContract.setStatus(BrokerCommissionContract.Status.CLOSED);
            brokerCommissionContractDao.update(brokerCommissionContract);
        }

        // Close active brokering commission status
        final Calendar now = Calendar.getInstance();
        final BrokeringCommissionStatusQuery bcsQuery = new BrokeringCommissionStatusQuery();
        bcsQuery.setBrokering(brokering);
        bcsQuery.setOnlyActive(true);
        final List<BrokeringCommissionStatus> brokeringCommissionStatusList = brokeringCommissionStatusDao.search(bcsQuery);
        for (final BrokeringCommissionStatus brokeringCommissionStatus : brokeringCommissionStatusList) {
            brokeringCommissionStatus.getPeriod().setEnd(now);
            brokeringCommissionStatusDao.update(brokeringCommissionStatus);
        }

    }

    /*
     * Creates a new brokering commission status for each broker commission and the specified brokering. This method is called by doChangeBroker()
     */
    @SuppressWarnings("unchecked")
    private void createBrokeringCommissionStatus(final Brokering brokering) {
        final Member broker = fetchService.fetch(brokering.getBroker(), Element.Relationships.GROUP);
        final BrokerGroup brokerGroup = (BrokerGroup) broker.getGroup();

        // Create a brokering commission status for each broker commission applicable to the broker
        final TransactionFeeQuery query = new TransactionFeeQuery();
        query.setEntityType(BrokerCommission.class);
        query.setBrokerGroup(brokerGroup);
        query.setReturnDisabled(true);
        final List<BrokerCommission> brokerCommissions = (List<BrokerCommission>) transactionFeeService.search(query);
        for (final BrokerCommission brokerCommission : brokerCommissions) {
            commissionService.createBrokeringCommissionStatus(brokering, brokerCommission);
        }
    }

    private Brokering doChangeBroker(final ChangeBrokerDTO dto) {
        validate(dto);
        final Calendar now = Calendar.getInstance();
        final Member member = fetchService.reload(dto.getMember(), Element.Relationships.USER);
        final Brokering oldBrokering = getActiveBrokering(member);
        final Member oldBroker = (oldBrokering == null) ? null : oldBrokering.getBroker();
        final Member newBroker = fetchService.fetch(dto.getNewBroker(), Member.Relationships.BROKER);

        // Check if it's just to suspend commission
        final boolean justSuspendCommission = (oldBroker != null && oldBroker.equals(newBroker) && dto.isSuspendCommission());

        if (!justSuspendCommission) {

            // Check for circular brokerings
            if (member.equals(newBroker)) {
                throw new ValidationException("brokering.error.circularBrokering");
            }
            Member current = newBroker;
            final Set<Member> visited = new HashSet<Member>();
            while (current != null) {
                if (visited.contains(current)) {
                    throw new ValidationException("brokering.error.circularBrokering");
                }
                visited.add(current);
                current = fetchService.fetch(current, Member.Relationships.BROKER).getBroker();
            }

            // Check if the member is already on the brokering list
            if (newBroker != null) {
                final BrokeringQuery query = new BrokeringQuery();
                query.setBroker(newBroker);
                query.setBrokered(member);
                query.setStatus(BrokeringQuery.Status.ACTIVE);
                if (!search(query).isEmpty()) {
                    throw new MemberAlreadyInBrokeringsException();
                }
            }

            // Update the brokered member
            member.setBroker(newBroker);
            elementDao.update(member, false);

            // Reindex the element
            elementDao.addToIndex(member);
        }

        // Update the active brokering
        if (oldBrokering != null) {
            if (!justSuspendCommission) {
                oldBrokering.setEndDate(now);
            }
            brokeringDao.update(oldBrokering, false);

            // Close broker commission contracts and brokering commission status
            closeBrokerContractsAndBrokeringStatus(oldBrokering);
        }

        // Build a brokering to return
        Brokering brokering;
        if (justSuspendCommission) {
            // If just suspending commission, the result will be the same brokering
            brokering = oldBrokering;
        } else if (newBroker != null) {
            // Create a new brokering if not just suspending commission
            brokering = new Brokering();
            brokering.setBroker(newBroker);
            brokering.setBrokered(member);
            brokering.setStartDate(now);
            brokering = brokeringDao.insert(brokering, false);
            createBrokeringCommissionStatus(brokering);
        } else {
            // No new broker - return null
            brokering = null;
        }

        // Create the broker remark
        final BrokerRemark remark = new BrokerRemark();
        remark.setWriter(LoggedUser.element());
        remark.setSubject(member);
        remark.setDate(now);
        remark.setComments(dto.getComments());
        remark.setOldBroker(oldBroker);
        remark.setNewBroker(newBroker);
        remark.setSuspendCommission(dto.isSuspendCommission());
        remarkDao.insert(remark);

        return brokering;
    }

    private Validator getBrokeringValidator() {
        final Validator brokeringValidator = new Validator();
        brokeringValidator.property("broker").key("member.broker").required().add(new BrokerValidation());
        brokeringValidator.property("brokered").key("member.member").required();
        brokeringValidator.property("notes").key("brokering.notes").maxLength(1000);
        return brokeringValidator;
    }

    private Validator getDtoValidator() {
        final Validator dtoValidator = new Validator();
        dtoValidator.property("member").required();
        dtoValidator.property("newBroker").key("changeBroker.new").add(new BrokerValidation()).add(new PropertyValidation() {
            private static final long serialVersionUID = 580603314020373024L;

            @Override
            public ValidationError validate(final Object object, final Object name, final Object value) {
                final ChangeBrokerDTO dto = (ChangeBrokerDTO) object;
                final Member newBroker = (Member) value;
                if (dto.isSuspendCommission()) {
                    // When commission is suspended, there must be a new broker
                    if (newBroker == null || newBroker.isTransient()) {
                        return new RequiredError();
                    }
                } else {
                    // The old and new brokers can be the same only when suspending commission
                    final Member member = fetchService.fetch(dto.getMember());
                    if (member != null && newBroker != null && newBroker.equals(member.getBroker())) {
                        return new InvalidError();
                    }
                }
                return null;
            }
        });
        dtoValidator.property("comments").key("remark.comments").required().maxLength(4000);
        return dtoValidator;
    }
}