Transfer.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.entities.accounts.transactions;

import java.math.BigDecimal;
import java.util.Calendar;
import java.util.Collection;
import java.util.Map;

import nl.strohalm.cyclos.entities.Relationship;
import nl.strohalm.cyclos.entities.accounts.Account;
import nl.strohalm.cyclos.entities.accounts.AccountOwner;
import nl.strohalm.cyclos.entities.accounts.Rated;
import nl.strohalm.cyclos.entities.accounts.SystemAccountOwner;
import nl.strohalm.cyclos.entities.accounts.external.ExternalTransfer;
import nl.strohalm.cyclos.entities.accounts.fees.account.AccountFeeLog;
import nl.strohalm.cyclos.entities.accounts.fees.transaction.TransactionFee;
import nl.strohalm.cyclos.entities.accounts.loans.LoanPayment;
import nl.strohalm.cyclos.entities.members.Element;
import nl.strohalm.cyclos.entities.members.brokerings.BrokerCommissionContract;
import nl.strohalm.cyclos.entities.settings.LocalSettings;

import org.apache.commons.lang.ObjectUtils;

/**
 * A unit transfer between two accounts. A transaction may be performed with several transfers (ex: additional fees)
 * @author luis
 */
public class Transfer extends Payment implements Rated {

    public static enum Relationships implements Relationship {
        ACCOUNT_FEE_LOG("accountFeeLog"), CHILDREN("children"),
        CHARGED_BACK_BY("chargedBackBy"), LOAN_PAYMENT("loanPayment"),
        PARENT("parent"), CHARGEBACK_OF("chargebackOf"),
        TRANSACTION_FEE("transactionFee"), RECEIVER("receiver"),
        EXTERNAL_TRANSFER("externalTransfer"), AUTHORIZATIONS("authorizations"),
        NEXT_AUTHORIZATION_LEVEL("nextAuthorizationLevel"), SCHEDULED_PAYMENT("scheduledPayment");

        private final String name;

        private Relationships(final String name) {
            this.name = name;
        }

        @Override
        public String getName() {
            return name;
        }
    }

    private static final long                 serialVersionUID = -4749387454425166686L;
    private AccountFeeLog                     accountFeeLog;
    private Collection<Transfer>              children;
    private Transfer                          chargedBackBy;
    private String                            transactionNumber;
    private String                            traceNumber;
    private Long                              clientId;
    private String                            traceData;
    private LoanPayment                       loanPayment;
    private Transfer                          parent;
    private Transfer                          chargebackOf;
    private TransactionFee                    transactionFee;
    private Element                           receiver;
    private ExternalTransfer                  externalTransfer;
    private Collection<TransferAuthorization> authorizations;
    private AuthorizationLevel                nextAuthorizationLevel;
    private ScheduledPayment                  scheduledPayment;
    private BrokerCommissionContract          brokerCommissionContract;
    private Calendar                          expirationDate;
    private Calendar                          emissionDate;
    private BigDecimal                        iRate;
    private transient Transfer                root;

    public AccountFeeLog getAccountFeeLog() {
        return accountFeeLog;
    }

    /**
     * Returns the amount as a positive number, even when it's negative (i.e. chargeback)
     */
    public BigDecimal getActualAmount() {
        final BigDecimal amount = getAmount();
        return amount == null ? null : amount.abs();
    }

    /**
     * Returns the process date if not null, date otherwise
     */
    public Calendar getActualDate() {
        return getProcessDate() == null ? getDate() : getProcessDate();
    }

    /**
     * When the amount is negative (i.e. chargeback), returns the to account instead
     */
    public Account getActualFrom() {
        final BigDecimal amount = getAmount();
        return amount == null || amount.compareTo(BigDecimal.ZERO) >= 0 ? getFrom() : getTo();
    }

    /**
     * When the amount is negative (i.e. chargeback), returns the to account owner instead
     */
    public AccountOwner getActualFromOwner() {
        return getActualFrom().getOwner();
    }

    /**
     * When the amount is negative (i.e. chargeback), returns the from account instead
     */
    public Account getActualTo() {
        final BigDecimal amount = getAmount();
        return amount == null || amount.compareTo(BigDecimal.ZERO) >= 0 ? getTo() : getFrom();
    }

    /**
     * When the amount is negative (i.e. chargeback), returns the from account owner instead
     */
    public AccountOwner getActualToOwner() {
        return getActualTo().getOwner();
    }

    public Collection<TransferAuthorization> getAuthorizations() {
        return authorizations;
    }

    public BrokerCommissionContract getBrokerCommissionContract() {
        return brokerCommissionContract;
    }

    public Transfer getChargebackOf() {
        return chargebackOf;
    }

    public Transfer getChargedBackBy() {
        return chargedBackBy;
    }

    public Collection<Transfer> getChildren() {
        return children;
    }

    /**
     * @return the (optional) client id that generates the transfer
     */
    public Long getClientId() {
        return clientId;
    }

    @Override
    public Calendar getEmissionDate() {
        return emissionDate;
    }

    @Override
    public Calendar getExpirationDate() {
        return expirationDate;
    }

    public ExternalTransfer getExternalTransfer() {
        return externalTransfer;
    }

    @Override
    public BigDecimal getiRate() {
        return iRate;
    }

    public LoanPayment getLoanPayment() {
        return loanPayment;
    }

    @Override
    public Nature getNature() {
        return Nature.TRANSFER;
    }

    public AuthorizationLevel getNextAuthorizationLevel() {
        return nextAuthorizationLevel;
    }

    public Transfer getParent() {
        return parent;
    }

    public Element getReceiver() {
        return receiver;
    }

    public Transfer getRootTransfer() {
        if (root == null) {
            Transfer topMost = this;
            while (topMost.getParent() != null) {
                topMost = topMost.getParent();
            }
            root = topMost;
        }

        return root;
    }

    public ScheduledPayment getScheduledPayment() {
        return scheduledPayment;
    }

    /**
     * Optional.
     * @returns the data set by the client making a payment.<br>
     * As an example: it could be used to link a payment with its notifications (payment received).<br>
     * It depends on the client side then there is no guarantee of uniqueness between different transfer.<br>
     * Note: It has nothing to do with the (unique) pair <traceNumber, clientId> (used to query transactions by those values).
     */
    public String getTraceData() {
        return traceData;
    }

    /**
     * @return the (optional) trace number generated by a client
     */
    public String getTraceNumber() {
        return traceNumber;
    }

    public TransactionFee getTransactionFee() {
        return transactionFee;
    }

    public String getTransactionNumber() {
        return transactionNumber;
    }

    /**
     * When the amount is negative (i.e. chargeback), returns whether the to account is a system account
     */
    public boolean isActuallyFromSystem() {
        return getActualFromOwner() instanceof SystemAccountOwner;
    }

    /**
     * When the amount is negative (i.e. chargeback), returns whether the from account is a system account
     */
    public boolean isActuallyToSystem() {
        return getActualToOwner() instanceof SystemAccountOwner;
    }

    public boolean isProcessedAtDifferentDate() {
        return !ObjectUtils.equals(getDate(), getProcessDate());
    }

    public boolean isRoot() {
        return parent == null;
    }

    public void setAccountFeeLog(final AccountFeeLog feeLog) {
        accountFeeLog = feeLog;
    }

    public void setAuthorizations(final Collection<TransferAuthorization> authorizations) {
        this.authorizations = authorizations;
    }

    public void setBrokerCommissionContract(final BrokerCommissionContract brokerCommissionContract) {
        this.brokerCommissionContract = brokerCommissionContract;
    }

    public void setChargebackOf(final Transfer chargebackOf) {
        this.chargebackOf = chargebackOf;
    }

    public void setChargedBackBy(final Transfer chargedBackBy) {
        this.chargedBackBy = chargedBackBy;
    }

    public void setChildren(final Collection<Transfer> children) {
        this.children = children;
    }

    public void setClientId(final Long clientId) {
        this.clientId = clientId;
    }

    public void setEmissionDate(final Calendar emissionDate) {
        this.emissionDate = emissionDate;
    }

    public void setExpirationDate(final Calendar expirationDate) {
        this.expirationDate = expirationDate;
    }

    public void setExternalTransfer(final ExternalTransfer externalTransfer) {
        this.externalTransfer = externalTransfer;
    }

    public void setiRate(final BigDecimal iRate) {
        this.iRate = iRate;
    }

    public void setLoanPayment(final LoanPayment loanComponent) {
        loanPayment = loanComponent;
    }

    public void setNextAuthorizationLevel(final AuthorizationLevel nextAuthorizationLevel) {
        this.nextAuthorizationLevel = nextAuthorizationLevel;
    }

    public void setParent(final Transfer parent) {
        this.parent = parent;
        root = null;
    }

    public void setReceiver(final Element receiver) {
        this.receiver = receiver;
    }

    public void setScheduledPayment(final ScheduledPayment scheduledPayment) {
        this.scheduledPayment = scheduledPayment;
    }

    public void setTraceData(final String traceData) {
        this.traceData = traceData;
    }

    public void setTraceNumber(final String traceNumber) {
        this.traceNumber = traceNumber;
    }

    public void setTransactionFee(final TransactionFee fee) {
        transactionFee = fee;
    }

    public void setTransactionNumber(final String transactionNumber) {
        this.transactionNumber = transactionNumber;
    }

    @Override
    protected void appendVariableValues(final Map<String, Object> variables, final LocalSettings localSettings) {
        super.appendVariableValues(variables, localSettings);
        variables.put("transaction_number", getTransactionNumber());
    }

}