LoanServiceImpl.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.transactions;

import java.math.BigDecimal;
import java.math.MathContext;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.Collections;
import java.util.EnumMap;
import java.util.List;
import java.util.Map;

import nl.strohalm.cyclos.access.AdminMemberPermission;
import nl.strohalm.cyclos.access.AdminSystemPermission;
import nl.strohalm.cyclos.dao.accounts.loans.LoanDAO;
import nl.strohalm.cyclos.dao.accounts.loans.LoanPaymentDAO;
import nl.strohalm.cyclos.entities.Relationship;
import nl.strohalm.cyclos.entities.accounts.Currency;
import nl.strohalm.cyclos.entities.accounts.MemberAccount;
import nl.strohalm.cyclos.entities.accounts.SystemAccountOwner;
import nl.strohalm.cyclos.entities.accounts.external.ExternalTransfer;
import nl.strohalm.cyclos.entities.accounts.loans.Loan;
import nl.strohalm.cyclos.entities.accounts.loans.LoanParameters;
import nl.strohalm.cyclos.entities.accounts.loans.LoanPayment;
import nl.strohalm.cyclos.entities.accounts.loans.LoanPayment.Status;
import nl.strohalm.cyclos.entities.accounts.loans.LoanPaymentQuery;
import nl.strohalm.cyclos.entities.accounts.loans.LoanQuery;
import nl.strohalm.cyclos.entities.accounts.loans.LoanRepaymentAmountsDTO;
import nl.strohalm.cyclos.entities.accounts.transactions.Payment;
import nl.strohalm.cyclos.entities.accounts.transactions.Transfer;
import nl.strohalm.cyclos.entities.accounts.transactions.TransferAuthorizationDTO;
import nl.strohalm.cyclos.entities.accounts.transactions.TransferQuery;
import nl.strohalm.cyclos.entities.accounts.transactions.TransferType;
import nl.strohalm.cyclos.entities.alerts.MemberAlert;
import nl.strohalm.cyclos.entities.exceptions.UnexpectedEntityException;
import nl.strohalm.cyclos.entities.groups.AdminGroup;
import nl.strohalm.cyclos.entities.members.Element;
import nl.strohalm.cyclos.entities.members.Member;
import nl.strohalm.cyclos.entities.settings.LocalSettings;
import nl.strohalm.cyclos.services.InitializingService;
import nl.strohalm.cyclos.services.accounts.AccountDTO;
import nl.strohalm.cyclos.services.accounts.AccountServiceLocal;
import nl.strohalm.cyclos.services.accounts.rates.RateServiceLocal;
import nl.strohalm.cyclos.services.alerts.AlertServiceLocal;
import nl.strohalm.cyclos.services.customization.PaymentCustomFieldServiceLocal;
import nl.strohalm.cyclos.services.fetch.FetchServiceLocal;
import nl.strohalm.cyclos.services.permissions.PermissionServiceLocal;
import nl.strohalm.cyclos.services.settings.SettingsServiceLocal;
import nl.strohalm.cyclos.services.transactions.exceptions.AuthorizedPaymentInPastException;
import nl.strohalm.cyclos.utils.Amount;
import nl.strohalm.cyclos.utils.CacheCleaner;
import nl.strohalm.cyclos.utils.DateHelper;
import nl.strohalm.cyclos.utils.Period;
import nl.strohalm.cyclos.utils.RelationshipHelper;
import nl.strohalm.cyclos.utils.TransactionHelper;
import nl.strohalm.cyclos.utils.Transactional;
import nl.strohalm.cyclos.utils.access.LoggedUser;
import nl.strohalm.cyclos.utils.conversion.CoercionHelper;
import nl.strohalm.cyclos.utils.notifications.MemberNotificationHandler;
import nl.strohalm.cyclos.utils.query.QueryParameters.ResultType;
import nl.strohalm.cyclos.utils.validation.DelegatingValidator;
import nl.strohalm.cyclos.utils.validation.GeneralValidation;
import nl.strohalm.cyclos.utils.validation.InvalidError;
import nl.strohalm.cyclos.utils.validation.PositiveNonZeroValidation;
import nl.strohalm.cyclos.utils.validation.PropertyValidation;
import nl.strohalm.cyclos.utils.validation.RequiredError;
import nl.strohalm.cyclos.utils.validation.RequiredValidation;
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.lang.mutable.MutableBoolean;
import org.apache.commons.lang.time.DateUtils;
import org.springframework.transaction.TransactionStatus;

/**
 * Implementation for loan service
 * @author luis
 */
public class LoanServiceImpl implements LoanServiceLocal, InitializingService {

    /**
     * Validates a transfer type, forcing it to be a loan type
     * @author luis
     */
    private class LoanTypeValidation implements PropertyValidation {

        private static final long serialVersionUID = -7166494808222423923L;

        public LoanTypeValidation() {
        }

        @Override
        public ValidationError validate(final Object object, final Object name, final Object value) {
            final TransferType transferType = (TransferType) value;
            if (transferType == null) {
                return null;
            }
            // Ensure transfer type is a loan
            if (!transferType.isLoanType()) {
                return new InvalidError();
            }
            return null;
        }
    }

    /**
     * Validator for multi-payment loan's collection of loan payment
     * @author luis
     */
    private final class MultiPaymentValidation implements PropertyValidation {
        private static final long serialVersionUID = -7905875152926109032L;

        @Override
        @SuppressWarnings("unchecked")
        public ValidationError validate(final Object object, final Object name, final Object value) {
            final GrantMultiPaymentLoanDTO dto = (GrantMultiPaymentLoanDTO) object;
            final Collection<LoanPayment> payments = (Collection<LoanPayment>) value;
            if (payments == null || payments.isEmpty()) {
                return null;
            }
            Calendar lastExpiration = DateHelper.truncate(Calendar.getInstance());
            BigDecimal paymentAmounts = BigDecimal.ZERO;
            final BigDecimal totalAmount = dto.getAmount();
            final boolean processAmount = totalAmount != null && totalAmount.compareTo(BigDecimal.ZERO) == 1;
            // Validate each payment
            for (final LoanPayment payment : payments) {
                // Check for required expiration date
                ValidationError error = RequiredValidation.instance().validate(object, name, payment.getExpirationDate());
                // Check for required amount
                final BigDecimal paymentAmount = payment.getAmount();
                if (error == null) {
                    error = RequiredValidation.instance().validate(object, name, paymentAmount);
                }
                if (error == null) {
                    error = PositiveNonZeroValidation.instance().validate(object, name, paymentAmount);
                }
                // Check if the current expiration date is after the last expiration date
                if (error == null && lastExpiration.after(payment.getExpirationDate())) {
                    error = new ValidationError("loan.grant.error.unsortedPayments");
                }
                // Return any error for this payment
                if (error != null) {
                    return error;
                }
                // Sum an accumulator for total amount comparision
                if (processAmount) {
                    paymentAmounts = paymentAmounts.add(paymentAmount);
                }
                lastExpiration = payment.getExpirationDate();
            }
            // Check if the payment amount sum == total amount
            if ((paymentAmounts.subtract(totalAmount)).abs().floatValue() > PRECISION_DELTA) {
                return new ValidationError("loan.grant.error.invalidAmount");
            }
            return null;
        }
    }

    private TransferAuthorizationServiceLocal transferAuthorizationService;
    private static final float                PRECISION_DELTA = 0.0001F;
    private AccountServiceLocal               accountService;
    private AlertServiceLocal                 alertService;
    private PaymentCustomFieldServiceLocal    paymentCustomFieldService;
    private FetchServiceLocal                 fetchService;
    private LoanDAO                           loanDao;
    private LoanPaymentDAO                    loanPaymentDao;
    private PaymentServiceLocal               paymentService;
    private RateServiceLocal                  rateService;
    private SettingsServiceLocal              settingsService;
    private final Map<Loan.Type, LoanHandler> handlersByType  = new EnumMap<Loan.Type, LoanHandler>(Loan.Type.class);
    private PermissionServiceLocal            permissionService;
    private MemberNotificationHandler         memberNotificationHandler;

    private TransactionHelper                 transactionHelper;

    @Override
    public void alertExpiredLoans(final Calendar time) {
        final Calendar deadline = DateHelper.truncate(time);
        deadline.add(Calendar.DATE, -1);
        final LoanPaymentQuery query = new LoanPaymentQuery();
        query.setResultType(ResultType.ITERATOR);
        query.fetch(RelationshipHelper.nested(LoanPayment.Relationships.LOAN, Loan.Relationships.TRANSFER, Payment.Relationships.TO, MemberAccount.Relationships.MEMBER, Element.Relationships.GROUP));
        query.setExpirationPeriod(Period.endingAt(deadline));
        query.setStatus(LoanPayment.Status.OPEN);
        CacheCleaner cacheCleaner = new CacheCleaner(fetchService);
        final List<LoanPayment> payments = search(query);
        for (final LoanPayment payment : payments) {
            final Loan loan = payment.getLoan();
            payment.setStatus(LoanPayment.Status.EXPIRED);
            loanPaymentDao.update(payment);
            // Create an alert
            final Member member = (Member) loan.getTransfer().getTo().getOwner();
            alertService.create(member, MemberAlert.Alerts.EXPIRED_LOAN);
            // Notify the member
            memberNotificationHandler.expiredLoanNotification(payment);
            cacheCleaner.clearCache();
        }
    }

    @Override
    public List<LoanPayment> calculatePaymentProjection(final ProjectionDTO params) {
        params.setTransferType(fetchService.fetch(params.getTransferType()));
        if (params.getDate() == null) {
            params.setDate(Calendar.getInstance());
        }
        getProjectionValidator().validate(params);
        return handlersByType.get(params.getTransferType().getLoan().getType()).calculatePaymentProjection(params);
    }

    @Override
    public LoanPayment discard(final LoanPaymentDTO dto) {
        final LoanPaymentDTO dateDto = new LoanPaymentDTO();
        dateDto.setLoan(dto.getLoan());
        dateDto.setLoanPayment(dto.getLoanPayment());
        return doDiscard(dateDto);
    }

    @Override
    public LoanPayment discardByExternalTransfer(final Loan loan, final ExternalTransfer externalTransfer) throws UnexpectedEntityException {
        final LoanPaymentDTO dto = new LoanPaymentDTO();
        dto.setLoan(loan);
        final LoanPayment loanPayment = doDiscard(dto);
        loanPayment.setExternalTransfer(externalTransfer);
        return loanPaymentDao.update(loanPayment);
    }

    @Override
    public LoanRepaymentAmountsDTO getLoanPaymentAmount(final LoanPaymentDTO dto) {
        final LoanRepaymentAmountsDTO ret = new LoanRepaymentAmountsDTO();
        Calendar date = dto.getDate();
        if (date == null) {
            date = Calendar.getInstance();
        }
        final Loan loan = fetchService.fetch(dto.getLoan(), Loan.Relationships.TRANSFER, Loan.Relationships.PAYMENTS);
        LoanPayment payment = fetchService.fetch(dto.getLoanPayment());
        if (payment == null) {
            payment = loan.getFirstOpenPayment();
        }
        ret.setLoanPayment(payment);

        // Update the dto with fetched values
        dto.setLoan(loan);
        dto.setLoanPayment(payment);

        if (payment != null) {
            payment = fetchService.fetch(payment, LoanPayment.Relationships.TRANSFERS);
            final BigDecimal paymentAmount = payment.getAmount();
            BigDecimal remainingAmount = paymentAmount;
            Calendar expirationDate = payment.getExpirationDate();
            Calendar lastPaymentDate = (Calendar) expirationDate.clone();
            expirationDate = DateUtils.truncate(expirationDate, Calendar.DATE);
            final LoanParameters parameters = loan.getParameters();
            Collection<Transfer> transfers = payment.getTransfers();
            if (transfers == null) {
                transfers = Collections.emptyList();
            }
            final BigDecimal expirationDailyInterest = CoercionHelper.coerce(BigDecimal.class, parameters.getExpirationDailyInterest());
            final LocalSettings localSettings = settingsService.getLocalSettings();
            final MathContext mathContext = localSettings.getMathContext();
            for (final Transfer transfer : transfers) {
                Calendar trfDate = transfer.getDate();
                trfDate = DateUtils.truncate(trfDate, Calendar.DATE);
                final BigDecimal trfAmount = transfer.getAmount();
                BigDecimal actualAmount = trfAmount;
                final int diffDays = (int) ((trfDate.getTimeInMillis() - expirationDate.getTimeInMillis()) / DateUtils.MILLIS_PER_DAY);
                if (diffDays > 0 && expirationDailyInterest != null) {
                    // Apply interest
                    actualAmount = actualAmount.subtract(remainingAmount.multiply(new BigDecimal(diffDays)).multiply(expirationDailyInterest.divide(new BigDecimal(100), mathContext)));
                }
                remainingAmount = remainingAmount.subtract(actualAmount);
                lastPaymentDate = (Calendar) trfDate.clone();
            }
            date = DateHelper.truncate(date);
            BigDecimal remainingAmountAtDate = remainingAmount;
            final int diffDays = (int) ((date.getTimeInMillis() - (expirationDate.before(lastPaymentDate) ? lastPaymentDate.getTimeInMillis() : expirationDate.getTimeInMillis())) / DateUtils.MILLIS_PER_DAY);
            if (diffDays > 0 && expirationDailyInterest != null) {
                // Apply interest
                remainingAmountAtDate = remainingAmountAtDate.add(remainingAmount.multiply(new BigDecimal(diffDays)).multiply(expirationDailyInterest.divide(new BigDecimal(100), mathContext)));
            }
            final Amount expirationFee = parameters.getExpirationFee();
            if (expirationFee != null && (remainingAmountAtDate.compareTo(BigDecimal.ZERO) == 1) && expirationDate.before(date) && (expirationFee.getValue().compareTo(BigDecimal.ZERO) == 1)) {
                // Apply expiration fee
                remainingAmountAtDate = remainingAmountAtDate.add(expirationFee.apply(remainingAmount));
            }
            // Round the result
            ret.setRemainingAmountAtExpirationDate(localSettings.round(remainingAmount));
            ret.setRemainingAmountAtDate(localSettings.round(remainingAmountAtDate));
        }
        return ret;
    }

    @Override
    public TransactionSummaryVO getOpenLoansSummary(final Currency currency) {
        final LoanQuery query = new LoanQuery();
        query.setStatus(Loan.Status.OPEN);
        query.setCurrency(currency);
        if (LoggedUser.hasUser()) {
            AdminGroup adminGroup = LoggedUser.group();
            adminGroup = fetchService.fetch(adminGroup, AdminGroup.Relationships.MANAGES_GROUPS);
            query.setGroups(adminGroup.getManagesGroups());
        }
        return buildSummary(query);
    }

    @Override
    public Loan grant(final GrantLoanDTO params) {
        return doGrant(params, true);
    }

    @Override
    public Loan grantForGuarantee(final GrantLoanDTO params, final boolean automaticAuthorize) {
        final Loan loan = insert(params);

        if (automaticAuthorize && permissionService.hasPermission(AdminSystemPermission.PAYMENTS_AUTHORIZE) && (loan.getTransfer().getNextAuthorizationLevel() != null)) {
            final TransferAuthorizationDTO transferAuthorizationDto = new TransferAuthorizationDTO();
            transferAuthorizationDto.setTransfer(loan.getTransfer());
            transferAuthorizationService.authorize(transferAuthorizationDto, false);
        }

        return loan;
    }

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

    @Override
    public Loan insert(final GrantLoanDTO params) {
        return doGrant(params, false);
    }

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

    @Override
    public TransactionSummaryVO loanSummary(final Member member) {
        final LoanQuery query = new LoanQuery();
        query.setMember(member);
        query.setStatus(Loan.Status.OPEN);
        return buildSummary(query);
    }

    @Override
    public Loan markAsInProcess(final Loan loan) throws UnexpectedEntityException {
        return markAs(loan, LoanPayment.Status.EXPIRED, LoanPayment.Status.IN_PROCESS);
    }

    @Override
    public Loan markAsRecovered(final Loan loan) throws UnexpectedEntityException {
        return markAs(loan, LoanPayment.Status.IN_PROCESS, LoanPayment.Status.RECOVERED);
    }

    @Override
    public Loan markAsUnrecoverable(final Loan loan) throws UnexpectedEntityException {
        return markAs(loan, LoanPayment.Status.IN_PROCESS, LoanPayment.Status.UNRECOVERABLE);
    }

    @Override
    public TransactionSummaryVO paymentsSummary(final LoanPaymentQuery query) {
        final Status status = query.getStatus();
        if (status == null) {
            throw new ValidationException("status", "loanPayment.status", new RequiredError());
        }
        return loanPaymentDao.paymentsSummary(query);
    }

    @Override
    public Transfer repay(final RepayLoanDTO params) {
        return transactionHelper.maybeRunInNewTransaction(new Transactional<Transfer>() {

            @Override
            public Transfer afterCommit(final Transfer result) {
                return fetchService.fetch(result);
            }

            @Override
            public Transfer doInTransaction(final TransactionStatus status) {
                return doRepay(params);
            }

        });
    }

    @Override
    public List<LoanPayment> search(final LoanPaymentQuery query) {
        return loanPaymentDao.search(query);
    }

    @Override
    public List<Loan> search(final LoanQuery query) {
        if (query.getQueryStatus() == null) {
            query.setHideAuthorizationRelated(!permissionService.hasPermission(AdminMemberPermission.LOANS_VIEW_AUTHORIZED));
        }
        return loanDao.search(query);
    }

    public void setAccountServiceLocal(final AccountServiceLocal accountService) {
        this.accountService = accountService;
    }

    public void setAlertServiceLocal(final AlertServiceLocal alertService) {
        this.alertService = alertService;
    }

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

    public void setLoanDao(final LoanDAO loanDao) {
        this.loanDao = loanDao;
    }

    public void setLoanPaymentDao(final LoanPaymentDAO loanPaymentDao) {
        this.loanPaymentDao = loanPaymentDao;
    }

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

    public void setMultiPaymentHandler(final LoanHandler handler) {
        handlersByType.put(Loan.Type.MULTI_PAYMENT, handler);
    }

    public void setPaymentCustomFieldServiceLocal(final PaymentCustomFieldServiceLocal paymentCustomFieldService) {
        this.paymentCustomFieldService = paymentCustomFieldService;
    }

    public void setPaymentServiceLocal(final PaymentServiceLocal paymentService) {
        this.paymentService = paymentService;
    }

    public void setPermissionServiceLocal(final PermissionServiceLocal permissionService) {
        this.permissionService = permissionService;
    }

    public void setRateServiceLocal(final RateServiceLocal rateService) {
        this.rateService = rateService;
    }

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

    public void setSinglePaymentHandler(final LoanHandler handler) {
        handlersByType.put(Loan.Type.SINGLE_PAYMENT, handler);
    }

    public void setTransactionHelper(final TransactionHelper transactionHelper) {
        this.transactionHelper = transactionHelper;
    }

    public void setTransferAuthorizationServiceLocal(final TransferAuthorizationServiceLocal transferAuthorizationService) {
        this.transferAuthorizationService = transferAuthorizationService;
    }

    public void setWithInterestHandler(final LoanHandler handler) {
        handlersByType.put(Loan.Type.WITH_INTEREST, handler);
    }

    @Override
    public void validate(final GrantLoanDTO params) {
        final Validator validator = getValidator(params);
        if (validator == null) {
            throw new ValidationException("transferType", "loan.type", new InvalidError());
        }
        validator.validate(params);
    }

    private TransactionSummaryVO buildSummary(final LoanQuery query) {
        BigDecimal amount = BigDecimal.ZERO;
        int count = 0;
        final List<Loan> loans = loanDao.search(query);
        for (Loan loan : loans) {
            count++;
            loan = fetchService.fetch(loan, Loan.Relationships.PAYMENTS);
            final List<LoanPayment> payments = loan.getPayments();
            if (payments != null) {
                for (final LoanPayment payment : payments) {
                    amount = amount.add(payment.getRemainingAmount());
                }
            }
        }
        final TransactionSummaryVO ret = new TransactionSummaryVO();
        ret.setCount(count);
        ret.setAmount(amount);
        return ret;
    }

    private LoanPayment doDiscard(final LoanPaymentDTO dto) {
        final Loan loan = fetchService.fetch(dto.getLoan(), Loan.Relationships.PAYMENTS);
        LoanPayment payment = fetchService.fetch(dto.getLoanPayment());
        final Calendar date = dto.getDate() == null ? Calendar.getInstance() : dto.getDate();
        if (payment == null) {
            payment = loan.getFirstOpenPayment();
        }
        if (payment == null) {
            throw new UnexpectedEntityException();
        }
        payment.setStatus(LoanPayment.Status.DISCARDED);
        payment.setRepaymentDate(date);
        return loanPaymentDao.update(payment);
    }

    private Loan doGrant(final GrantLoanDTO params, final boolean newTransaction) {
        validate(params);

        // Fetch and update the transfer type
        final TransferType transferType = fetchService.fetch(params.getTransferType());
        params.setTransferType(transferType);

        // Insert the loan
        final Loan loan = handlersByType.get(params.getLoanType()).buildLoan(params);

        return transactionHelper.maybeRunInNewTransaction(new Transactional<Loan>() {

            @Override
            public Loan afterCommit(final Loan result) {
                return fetchService.fetch(result);
            }

            @Override
            public Loan doInTransaction(final TransactionStatus status) {
                return doGrant(loan, params);
            }
        }, newTransaction);
    }

    private Loan doGrant(Loan loan, final GrantLoanDTO params) {
        final LocalSettings localSettings = settingsService.getLocalSettings();
        final TransferType transferType = params.getTransferType();

        // Create the loan transfer
        final TransferDTO transferDto = new TransferDTO();
        if (params.isAutomatic()) {
            transferDto.setContext(TransactionContext.AUTOMATIC_LOAN);
        } else {
            transferDto.setContext(TransactionContext.LOAN);
        }
        if (params.getDate() != null) {
            transferDto.setDate(params.getDate());
        }
        transferDto.setToOwner(params.getMember());
        transferDto.setFrom(accountService.getAccount(new AccountDTO(SystemAccountOwner.instance(), transferType.getFrom())));
        transferDto.setTo(accountService.getAccount(new AccountDTO(transferDto.getToOwner(), transferType.getTo())));
        transferDto.setAmount(params.getAmount());
        transferDto.setDescription(params.getDescription());
        transferDto.setTransferType(transferType);
        transferDto.setCustomValues(params.getCustomValues());
        transferDto.setRates(rateService.applyLoan(transferDto, params));
        final Transfer transfer = (Transfer) paymentService.insertWithoutNotification(transferDto);
        if (transfer.getProcessDate() == null && params.getDate() != null && DateHelper.daysBetween(params.getDate(), Calendar.getInstance()) != 0) {
            throw new AuthorizedPaymentInPastException();
        }

        // Persist the loan
        loan.setTransfer(transfer);
        final List<LoanPayment> payments = loan.getPayments();
        loan = loanDao.insert(loan);
        loan.setPayments(new ArrayList<LoanPayment>());

        // Insert the installments
        int index = 0;
        BigDecimal total = BigDecimal.ZERO;
        for (final LoanPayment payment : payments) {
            payment.setLoan(loan);
            payment.setIndex(index++);
            BigDecimal amount = localSettings.round(payment.getAmount());
            if (index == payments.size()) {
                // The last payment should round to total amount
                amount = localSettings.round(loan.getTotalAmount().subtract(total));
            } else {
                total = total.add(amount);
            }
            payment.setAmount(amount);
            loan.getPayments().add(loanPaymentDao.insert(payment));
        }

        // Notify
        memberNotificationHandler.grantedLoanNotification(loan);

        return loan;
    }

    private Transfer doRepay(final RepayLoanDTO params) {
        BigDecimal amount = params.getAmount();

        // Check if the amount is valid
        if (amount.compareTo(paymentService.getMinimumPayment()) < 0) {
            throw new ValidationException("amount", "loan.amount", new InvalidError());
        }

        // Get the loan payment to repay
        Calendar date = params.getDate();
        if (date == null) {
            date = Calendar.getInstance();
            params.setDate(date);
        }
        final LoanRepaymentAmountsDTO amountsDTO = getLoanPaymentAmount(params);
        final LoanPayment payment = amountsDTO.getLoanPayment();
        if (payment == null) {
            throw new UnexpectedEntityException();
        }

        // Validate the amount
        final BigDecimal remainingAmount = amountsDTO.getRemainingAmountAtDate();
        final BigDecimal diff = remainingAmount.subtract(amount);
        final MutableBoolean totallyRepaid = new MutableBoolean();
        // If the amount is on an acceptable delta, set the transfer value = parcel value
        if (diff.abs().floatValue() < PRECISION_DELTA) {
            amount = remainingAmount;
            totallyRepaid.setValue(true);
        } else if (diff.compareTo(BigDecimal.ZERO) < 0 || !params.getLoan().getTransfer().getType().getLoan().getType().allowsPartialRepayments()) {
            throw new ValidationException("amount", "loan.amount", new InvalidError());
        }
        final LocalSettings localSettings = settingsService.getLocalSettings();
        Loan loan = fetchService.fetch(params.getLoan(), Loan.Relationships.PAYMENTS, RelationshipHelper.nested(Loan.Relationships.TRANSFER, Payment.Relationships.TO, MemberAccount.Relationships.MEMBER), Loan.Relationships.TO_MEMBERS);

        // Build the transfers for repayment
        final List<TransferDTO> transfers = handlersByType.get(loan.getParameters().getType()).buildTransfersForRepayment(params, amountsDTO);
        Transfer root = null;
        BigDecimal totalAmount = BigDecimal.ZERO;
        for (final TransferDTO dto : transfers) {
            if (dto.getAmount().floatValue() < PRECISION_DELTA) {
                // If the root amount is zero, it means that the parent transfer should be the last transfer for this loan payment
                final TransferQuery tq = new TransferQuery();
                tq.setLoanPayment(payment);
                tq.setReverseOrder(true);
                tq.setUniqueResult();
                final List<Transfer> paymentTransfers = paymentService.search(tq);
                if (paymentTransfers.isEmpty()) {
                    throw new IllegalStateException("The root transfer has amount 0 and there is no other transfers for this payment");
                }
                root = paymentTransfers.iterator().next();
            } else {
                totalAmount = totalAmount.add(dto.getAmount());
                dto.setParent(root);
                dto.setLoanPayment(payment);
                final Transfer transfer = (Transfer) paymentService.insertWithoutNotification(dto);
                if (root == null) {
                    // The first will be the root. All others are it's children
                    root = transfer;
                }
            }
        }

        // Update the loan payment
        final BigDecimal totalRepaid = localSettings.round(payment.getRepaidAmount().add(totalAmount));
        payment.setRepaidAmount(totalRepaid);
        if (totallyRepaid.booleanValue()) {
            // Mark the payment as repaid, if is the case
            payment.setStatus(LoanPayment.Status.REPAID);
            payment.setRepaymentDate(params.getDate());
        }
        payment.setTransfers(null); // Avoid 2 representations of the transfers collection. It's inverse="true", no problem setting null
        loanPaymentDao.update(payment);

        // Return the generated root transfer
        return root;
    }

    private Validator getProjectionValidator() {
        final Validator projectionValidator = new Validator("loan");
        projectionValidator.property("transferType").key("loan.type").required().add(new LoanTypeValidation());
        projectionValidator.property("amount").required().positiveNonZero();
        projectionValidator.property("firstExpirationDate").future().required();
        projectionValidator.property("paymentCount").required().positiveNonZero();
        return projectionValidator;
    }

    private Validator getValidator(final GrantLoanDTO params) {
        // The transfer type is implicitly validated by returning null on non-loan types
        final TransferType transferType = fetchService.fetch(params.getTransferType());
        Loan.Type type;
        try {
            type = transferType.getLoan().getType();
        } catch (final Exception e) {
            return null;
        }

        final Validator validator = new Validator("loan");
        validator.property("amount").required().positiveNonZero();
        final Currency currency = fetchService.fetch(transferType.getCurrency(), Currency.Relationships.A_RATE_PARAMETERS, Currency.Relationships.D_RATE_PARAMETERS);
        if (currency.isEnableARate() || currency.isEnableDRate()) {
            // if the date is not null, it might be a payment in past, which is not allowed with rates enabled.
            if (params.getDate() != null) {
                final Calendar now = Calendar.getInstance();
                // make a few minutes earlier, because if the transfer's date has just before been set to Calendar.getInstance(), it may already be a
                // few milliseconds or even seconds later.
                now.add(Calendar.MINUTE, -4);
                if (params.getDate().before(now)) {
                    validator.general(new GeneralValidation() {
                        private static final long serialVersionUID = -7221645724425619586L;

                        @Override
                        public ValidationError validate(final Object object) {
                            return new ValidationError("payment.error.pastDateWithRates");
                        }
                    });
                }
            }
        } else {
            validator.property("date").key("loan.grant.manualDate").pastOrToday();
        }
        validator.property("description").required().maxLength(1000);
        validator.property("member").key("member.member").required();
        switch (type) {
            case SINGLE_PAYMENT:
                validator.property("repaymentDate").required();
                break;
            case MULTI_PAYMENT:
                validator.property("payments").required().add(new MultiPaymentValidation());
                break;
            case WITH_INTEREST:
                validator.property("firstRepaymentDate").future().required();
                validator.property("paymentCount").required().positiveNonZero();
        }
        // Custom fields
        validator.chained(new DelegatingValidator(new DelegatingValidator.DelegateSource() {
            @Override
            public Validator getValidator() {
                return paymentCustomFieldService.getValueValidator(transferType);
            }
        }));
        return validator;
    }

    private Loan markAs(Loan loan, final LoanPayment.Status expectedStatus, final LoanPayment.Status newStatus) {
        loan = fetchService.fetch(loan, Loan.Relationships.PAYMENTS);
        for (final LoanPayment current : loan.getPayments()) {
            if (current.getStatus() == expectedStatus) {
                current.setStatus(newStatus);
                loanPaymentDao.update(current);
            }
        }
        return fetchService.reload(loan);
    }

}