PaymentsRestController.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.webservices.rest;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

import nl.strohalm.cyclos.entities.access.Channel;
import nl.strohalm.cyclos.entities.access.User.TransactionPasswordStatus;
import nl.strohalm.cyclos.entities.accounts.AccountOwner;
import nl.strohalm.cyclos.entities.accounts.AccountType;
import nl.strohalm.cyclos.entities.accounts.Currency;
import nl.strohalm.cyclos.entities.accounts.MemberAccountType;
import nl.strohalm.cyclos.entities.accounts.SystemAccountOwner;
import nl.strohalm.cyclos.entities.accounts.transactions.Payment;
import nl.strohalm.cyclos.entities.accounts.transactions.TransferType;
import nl.strohalm.cyclos.entities.accounts.transactions.TransferTypeQuery;
import nl.strohalm.cyclos.entities.customization.fields.PaymentCustomField;
import nl.strohalm.cyclos.entities.customization.fields.PaymentCustomFieldValue;
import nl.strohalm.cyclos.entities.exceptions.EntityNotFoundException;
import nl.strohalm.cyclos.entities.members.Member;
import nl.strohalm.cyclos.entities.settings.LocalSettings;
import nl.strohalm.cyclos.services.access.AccessService;
import nl.strohalm.cyclos.services.access.exceptions.BlockedCredentialsException;
import nl.strohalm.cyclos.services.access.exceptions.InvalidCredentialsException;
import nl.strohalm.cyclos.services.accounts.AccountDTO;
import nl.strohalm.cyclos.services.accounts.AccountService;
import nl.strohalm.cyclos.services.accounts.AccountTypeService;
import nl.strohalm.cyclos.services.customization.PaymentCustomFieldService;
import nl.strohalm.cyclos.services.elements.ElementService;
import nl.strohalm.cyclos.services.elements.MemberService;
import nl.strohalm.cyclos.services.settings.SettingsService;
import nl.strohalm.cyclos.services.transactions.DoPaymentDTO;
import nl.strohalm.cyclos.services.transactions.PaymentService;
import nl.strohalm.cyclos.services.transactions.TransactionContext;
import nl.strohalm.cyclos.services.transactions.exceptions.MaxAmountPerDayExceededException;
import nl.strohalm.cyclos.services.transactions.exceptions.NotEnoughCreditsException;
import nl.strohalm.cyclos.services.transactions.exceptions.PaymentException;
import nl.strohalm.cyclos.services.transactions.exceptions.TransferMinimumPaymentException;
import nl.strohalm.cyclos.services.transactions.exceptions.UpperCreditLimitReachedException;
import nl.strohalm.cyclos.services.transfertypes.TransactionFeePreviewDTO;
import nl.strohalm.cyclos.services.transfertypes.TransactionFeeService;
import nl.strohalm.cyclos.services.transfertypes.TransferTypeService;
import nl.strohalm.cyclos.utils.CustomFieldHelper;
import nl.strohalm.cyclos.utils.RelationshipHelper;
import nl.strohalm.cyclos.utils.access.LoggedUser;
import nl.strohalm.cyclos.utils.query.QueryParameters.ResultType;
import nl.strohalm.cyclos.utils.validation.ValidationException;
import nl.strohalm.cyclos.webservices.model.AccountStatusVO;
import nl.strohalm.cyclos.webservices.model.DetailedTransferTypeVO;
import nl.strohalm.cyclos.webservices.model.FieldValueVO;
import nl.strohalm.cyclos.webservices.model.MemberVO;
import nl.strohalm.cyclos.webservices.model.PaymentDataVO;
import nl.strohalm.cyclos.webservices.model.ServerErrorVO;
import nl.strohalm.cyclos.webservices.model.TransactionFeeVO;
import nl.strohalm.cyclos.webservices.model.TransferTypeVO;
import nl.strohalm.cyclos.webservices.rest.TransferTypesRestController.Destination;
import nl.strohalm.cyclos.webservices.rest.TransferTypesRestController.TransferTypeSearchParams;

import org.apache.commons.lang.StringUtils;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.ResponseStatus;

/**
 * Controller which handles /payments paths
 * 
 * @author luis
 */
@Controller
public class PaymentsRestController extends BaseRestController {

    /**
     * Result after doing a payment confirmation
     * @author jcomas
     */
    public static class ConfirmPaymentResult {
        private Long    id;
        private boolean pending;

        public Long getId() {
            return id;
        }

        public boolean isPending() {
            return pending;
        }

        public void setId(final Long id) {
            this.id = id;
        }

        public void setPending(final boolean pending) {
            this.pending = pending;
        }
    }

    /**
     * Parameters for doing a payment to a member
     * @author luis
     */
    public static class DoMemberPaymentParameters extends DoPaymentParameters {
        private Long     toMemberId;
        private String   toMemberPrincipal;
        private Integer  installments = 0;
        private Calendar firstInstallmentDate;

        public Calendar getFirstInstallmentDate() {
            return firstInstallmentDate;
        }

        public int getInstallments() {
            return installments;
        }

        public Long getToMemberId() {
            return toMemberId;
        }

        public String getToMemberPrincipal() {
            return toMemberPrincipal;
        }

        public void setFirstInstallmentDate(final Calendar firstInstallmentDate) {
            this.firstInstallmentDate = firstInstallmentDate;
        }

        public void setInstallments(final int installments) {
            this.installments = installments;
        }

        public void setToMemberId(final Long toMemberId) {
            this.toMemberId = toMemberId;
        }

        public void setToMemberPrincipal(final String toMemberPrincipal) {
            this.toMemberPrincipal = toMemberPrincipal;
        }
    }

    /**
     * Parameters for doing a payment to system
     * @author luis
     */
    public static class DoPaymentParameters {
        private Long               currencyId;
        private String             currencySymbol;
        private Long               transferTypeId;
        private BigDecimal         amount;
        private String             description;
        private String             transactionPassword;
        private List<FieldValueVO> customValues;

        public BigDecimal getAmount() {
            return amount;
        }

        public Long getCurrencyId() {
            return currencyId;
        }

        public String getCurrencySymbol() {
            return currencySymbol;
        }

        public List<FieldValueVO> getCustomValues() {
            return customValues;
        }

        public String getDescription() {
            return description;
        }

        public String getTransactionPassword() {
            return transactionPassword;
        }

        public Long getTransferTypeId() {
            return transferTypeId;
        }

        public void setAmount(final BigDecimal amount) {
            this.amount = amount;
        }

        public void setCurrencyId(final Long currencyId) {
            this.currencyId = currencyId;
        }

        public void setCurrencySymbol(final String currencySymbol) {
            this.currencySymbol = currencySymbol;
        }

        public void setCustomValues(final List<FieldValueVO> customValues) {
            this.customValues = customValues;
        }

        public void setDescription(final String description) {
            this.description = description;
        }

        public void setTransactionPassword(final String transactionPassword) {
            this.transactionPassword = transactionPassword;
        }

        public void setTransferTypeId(final Long transferTypeId) {
            this.transferTypeId = transferTypeId;
        }

        @Override
        public String toString() {
            return "DoPaymentParameters [currencyId=" + currencyId + ", currencySymbol=" + currencySymbol + ", transferTypeId=" + transferTypeId + ", amount=" + amount + ", description=" + description + ", transactionPassword=" + transactionPassword + ", customValues=" + customValues + "]";
        }

    }

    /**
     * Result after doing a payment
     * @author luis
     */
    public static class DoPaymentResult {
        private boolean                wouldRequireAuthorization;
        private MemberVO               from;
        private MemberVO               to;
        private BigDecimal             finalAmount;
        private String                 formattedFinalAmount;
        private List<TransactionFeeVO> fees;
        private TransferTypeVO         transferType;
        private Map<String, String>    customValues;

        public Map<String, String> getCustomValues() {
            return customValues;
        }

        public List<TransactionFeeVO> getFees() {
            return fees;
        }

        public BigDecimal getFinalAmount() {
            return finalAmount;
        }

        public String getFormattedFinalAmount() {
            return formattedFinalAmount;
        }

        public MemberVO getFrom() {
            return from;
        }

        public MemberVO getTo() {
            return to;
        }

        public TransferTypeVO getTransferType() {
            return transferType;
        }

        public boolean isWouldRequireAuthorization() {
            return wouldRequireAuthorization;
        }

        public void setCustomValues(final Map<String, String> customValues) {
            this.customValues = customValues;
        }

        public void setFees(final List<TransactionFeeVO> fees) {
            this.fees = fees;
        }

        public void setFinalAmount(final BigDecimal finalAmount) {
            this.finalAmount = finalAmount;
        }

        public void setFormattedFinalAmount(final String formattedFinalAmount) {
            this.formattedFinalAmount = formattedFinalAmount;
        }

        public void setFrom(final MemberVO from) {
            this.from = from;
        }

        public void setTo(final MemberVO to) {
            this.to = to;
        }

        public void setTransferType(final TransferTypeVO transferType) {
            this.transferType = transferType;
        }

        public void setWouldRequireAuthorization(final boolean wouldRequireAuthorization) {
            this.wouldRequireAuthorization = wouldRequireAuthorization;
        }

    }

    private static final String         BLOCKED_TRANSACTION_PASSWORD_ERROR  = "BLOCKED_TRANSACTION_PASSWORD";
    private static final String         INVALID_TRANSACTION_PASSWORD_ERROR  = "INVALID_TRANSACTION_PASSWORD";
    private static final String         MISSING_TRANSACTION_PASSWORD_ERROR  = "MISSING_TRANSACTION_PASSWORD";
    private static final String         INACTIVE_TRANSACTION_PASSWORD_ERROR = "INACTIVE_TRANSACTION_PASSWORD";
    private static final String         NO_POSSIBLE_TRANSFER_TYPES_ERROR    = "NO_POSSIBLE_TRANSFER_TYPES";

    private static final String         INVALID_AMOUNT_ERROR                = "INVALID_AMOUNT";

    private static final String         MAX_AMOUNT_PER_DAY_EXCEEDED         = "MAX_AMOUNT_PER_DAY_EXCEEDED";
    private static final String         NOT_ENOUGH_CREDITS                  = "NOT_ENOUGH_FUNDS";
    private static final String         UPPER_CREDIT_LIMIT_REACHED          = "UPPER_CREDIT_LIMIT_REACHED";
    protected static final String       TRANSFER_MINIMUM_PAYMENT            = "TRANSFER_MINIMUM_PAYMENT";
    protected static final String       UNKNOWN_PAYMENT_ERROR               = "UNKNOWN_PAYMENT_ERROR";

    private PaymentService              paymentService;
    private TransferTypeService         transferTypeService;
    private AccountTypeService          accountTypeService;
    private AccountService              accountService;
    private AccessService               accessService;
    private ElementService              elementService;
    private TransactionFeeService       transactionFeeService;
    private SettingsService             settingsService;
    private MemberService               memberService;
    private CustomFieldHelper           customFieldHelper;
    private PaymentCustomFieldService   paymentCustomFieldService;

    private TransferTypesRestController transferTypesRestController;
    private AccessRestController        accessRestController;
    private AccountsRestController      accountsRestController;

    /**
     * Confirms a payment to another member
     */
    @RequestMapping(value = "payments/confirmMemberPayment", method = RequestMethod.POST)
    @ResponseBody
    public ConfirmPaymentResult confirmPaymentToMember(@RequestBody final DoMemberPaymentParameters params) {
        if (params == null) {
            throw new ValidationException();
        }

        Member toMember = memberService.loadByIdOrPrincipal(params.getToMemberId(), null, params.getToMemberPrincipal());
        if (toMember == null) {
            throw new EntityNotFoundException(Member.class);
        }

        return confirmPayment(params, toMember);
    }

    /**
     * Confirms a payment to a system account
     */
    @RequestMapping(value = "payments/confirmSystemPayment", method = RequestMethod.POST)
    @ResponseBody
    public ConfirmPaymentResult confirmPaymentToSystem(@RequestBody final DoPaymentParameters params) {
        return confirmPayment(params, SystemAccountOwner.instance());
    }

    /**
     * Performs a payment between accounts
     */
    // TODO not possible now because transfer types with context self payment cannot have channels. Should we change this?
    // @RequestMapping(value = "payments/selfPayment", method = RequestMethod.POST)
    // @ResponseBody
    // public DoPaymentResult doPaymentToSelf(@RequestBody final DoPaymentParameters params) {
    // return doPayment(params, LoggedUser.member());
    // }

    /**
     * Performs a payment to another member
     */
    @RequestMapping(value = "payments/memberPayment", method = RequestMethod.POST)
    @ResponseBody
    public DoPaymentResult doPaymentToMember(@RequestBody final DoMemberPaymentParameters params) {
        AccountOwner to = memberService.loadByIdOrPrincipal(params.getToMemberId(), null, params.getToMemberPrincipal());
        if (to == null) {
            throw new EntityNotFoundException(Member.class);
        }
        return doPayment(params, to);
    }

    /**
     * Performs a payment to a system account
     */
    @RequestMapping(value = "payments/systemPayment", method = RequestMethod.POST)
    @ResponseBody
    public DoPaymentResult doPaymentToSystem(@RequestBody final DoPaymentParameters params) {
        return doPayment(params, SystemAccountOwner.instance());
    }

    /**
     * Returns the necessary information to prepare a payment
     */
    @RequestMapping(value = "payments/paymentData", method = RequestMethod.GET)
    @ResponseBody
    public PaymentDataVO getPaymentData(final TransferTypeSearchParams params) {
        PaymentDataVO paymentData = new PaymentDataVO();
        TransferTypeQuery query = transferTypesRestController.toTransferTypeQuery(params);
        List<TransferType> transferTypes = transferTypeService.search(query);
        List<DetailedTransferTypeVO> transferTypeVOs = new ArrayList<DetailedTransferTypeVO>();
        for (TransferType transferType : transferTypes) {
            transferTypeVOs.add((DetailedTransferTypeVO) transferTypeService.getTransferTypeVO(transferType.getId(), true));
        }
        paymentData.setTransferTypes(transferTypeVOs);
        Map<Long, AccountStatusVO> statuses = new HashMap<Long, AccountStatusVO>();
        for (TransferType tt : transferTypes) {
            if (statuses.get(tt.getFrom().getId()) == null) {
                AccountDTO accountDTO = new AccountDTO(LoggedUser.member(), tt.getFrom());
                statuses.put(tt.getFrom().getId(), accountService.getCurrentAccountStatusVO(accountDTO));
            }
        }
        paymentData.setAccountsStatus(statuses);
        if (params.getDestination() == Destination.MEMBER) {
            Member toMember = null;
            if (params.getToMemberId() != null) {
                toMember = elementService.load(params.getToMemberId());
            } else if (params.getToMemberPrincipal() != null) {
                toMember = elementService.loadByPrincipal(null, params.getToMemberPrincipal());
            }
            paymentData.setToMember(memberService.getMemberVO(toMember, false, false));
        }

        return paymentData;
    }

    /**
     * Handles {@link PaymentException}s
     */
    @ExceptionHandler(PaymentException.class)
    @ResponseBody
    @ResponseStatus(HttpStatus.METHOD_FAILURE)
    public ServerErrorVO handlePaymentException(final PaymentException ex) {
        String errorCode = UNKNOWN_PAYMENT_ERROR;
        if (ex instanceof MaxAmountPerDayExceededException) {
            errorCode = MAX_AMOUNT_PER_DAY_EXCEEDED;
        } else if (ex instanceof NotEnoughCreditsException) {
            errorCode = NOT_ENOUGH_CREDITS;
        } else if (ex instanceof TransferMinimumPaymentException) {
            errorCode = TRANSFER_MINIMUM_PAYMENT;
        } else if (ex instanceof UpperCreditLimitReachedException) {
            errorCode = UPPER_CREDIT_LIMIT_REACHED;
        }
        return new ServerErrorVO(errorCode, null);
    }

    public void setAccessRestController(final AccessRestController accessRestController) {
        this.accessRestController = accessRestController;
    }

    public void setAccessService(final AccessService accessService) {
        this.accessService = accessService;
    }

    public void setAccountService(final AccountService accountService) {
        this.accountService = accountService;
    }

    public void setAccountsRestController(final AccountsRestController accountsRestController) {
        this.accountsRestController = accountsRestController;
    }

    public void setAccountTypeService(final AccountTypeService accountTypeService) {
        this.accountTypeService = accountTypeService;
    }

    public void setCustomFieldHelper(final CustomFieldHelper customFieldHelper) {
        this.customFieldHelper = customFieldHelper;
    }

    public void setElementService(final ElementService elementService) {
        this.elementService = elementService;
    }

    public void setMemberService(final MemberService memberService) {
        this.memberService = memberService;
    }

    public void setPaymentCustomFieldService(final PaymentCustomFieldService paymentCustomFieldService) {
        this.paymentCustomFieldService = paymentCustomFieldService;
    }

    public void setPaymentService(final PaymentService paymentService) {
        this.paymentService = paymentService;
    }

    public void setSettingsService(final SettingsService settingsService) {
        this.settingsService = settingsService;
    }

    // Create the result
    public void setTransactionFeeService(final TransactionFeeService transactionFeeService) {
        this.transactionFeeService = transactionFeeService;
    }

    public void setTransferTypeService(final TransferTypeService transferTypeService) {
        this.transferTypeService = transferTypeService;
    }

    public void setTransferTypesRestController(final TransferTypesRestController transferTypesRestController) {
        this.transferTypesRestController = transferTypesRestController;
    }

    private DoPaymentDTO buildDoPaymentDTO(final DoPaymentParameters params, final AccountOwner toOwner, final TransferType transferType) {
        DoPaymentDTO dto = new DoPaymentDTO();
        dto.setContext(TransactionContext.PAYMENT);
        dto.setChannel(Channel.REST);
        dto.setAmount(params.getAmount());
        dto.setCurrency(null);
        dto.setTo(toOwner);
        dto.setTransferType(transferType);
        dto.setDescription(params.getDescription());
        // dto.setPayments(installments);
        List<PaymentCustomField> allowedFields = paymentCustomFieldService.list(transferType, true);
        final Collection<PaymentCustomFieldValue> customValues = customFieldHelper.toValueCollection(allowedFields, params.getCustomValues());
        dto.setCustomValues(customValues);
        return dto;
    }

    /*
     * 
     * private List<ScheduledPaymentDTO> buildInstallments(final DoPaymentParameters params, final Member loggedMember, final BigDecimal amount, final
     * TransferType transferType) { List<ScheduledPaymentDTO> installments = null; if (params instanceof DoMemberPaymentParameters) {
     * DoMemberPaymentParameters mp = (DoMemberPaymentParameters) params; Integer installmentCount = mp.getInstallments(); if (installmentCount !=
     * null && installmentCount > 0) { Calendar firstDate = mp.getFirstInstallmentDate(); if (firstDate == null) { firstDate = Calendar.getInstance();
     * } ProjectionDTO projection = new ProjectionDTO(); projection.setAmount(amount); projection.setFrom(loggedMember);
     * projection.setRecurrence(TimePeriod.ONE_MONTH); projection.setTransferType(transferType); projection.setFirstExpirationDate(firstDate);
     * projection.setPaymentCount(installmentCount); installments = paymentService.calculatePaymentProjection(projection); } } return installments; }
     */

    private ConfirmPaymentResult confirmPayment(final DoPaymentParameters params, final AccountOwner toOwner) {
        if (params == null) {
            throw new ValidationException();
        }

        Member loggedMember = LoggedUser.member();

        BigDecimal amount = params.getAmount();
        if (amount == null) {
            throw new IllegalArgumentException(INVALID_AMOUNT_ERROR);
        }

        TransferType transferType = resolveTransferType(params, toOwner);

        // Calculate the installments
        // List<ScheduledPaymentDTO> installments = buildInstallments(params, amount, transferType);

        // Check the transaction password, if needed
        if (accessRestController.isRequireTransactionPassword()) {
            String transactionPassword = params.getTransactionPassword();
            TransactionPasswordStatus status = loggedMember.getUser().getTransactionPasswordStatus();
            if (status == null || status == TransactionPasswordStatus.PENDING || status == TransactionPasswordStatus.NEVER_CREATED) {
                throw new IllegalArgumentException(INACTIVE_TRANSACTION_PASSWORD_ERROR);
            }
            if (StringUtils.isEmpty(transactionPassword)) {
                throw new IllegalArgumentException(MISSING_TRANSACTION_PASSWORD_ERROR);
            }
            try {
                accessService.checkTransactionPassword(transactionPassword);
            } catch (InvalidCredentialsException e) {
                throw new IllegalArgumentException(INVALID_TRANSACTION_PASSWORD_ERROR);
            } catch (BlockedCredentialsException e) {
                throw new IllegalArgumentException(BLOCKED_TRANSACTION_PASSWORD_ERROR);
            }
        }

        // Create the DoPaymentDTO
        DoPaymentDTO dto = buildDoPaymentDTO(params, toOwner, transferType);

        // Perform the payment

        Payment payment = paymentService.doPayment(dto);

        // Create the result
        ConfirmPaymentResult result = new ConfirmPaymentResult();
        result.setId(payment.getId());
        result.setPending(payment.getProcessDate() == null);
        return result;
    }

    private DoPaymentResult doPayment(final DoPaymentParameters params, final AccountOwner to) {
        DoPaymentResult result = new DoPaymentResult();

        if (params == null) {
            throw new ValidationException();
        }

        AccountOwner from = LoggedUser.accountOwner();

        TransferType transferType = resolveTransferType(params, to);
        transferType = transferTypeService.load(transferType.getId(), RelationshipHelper.nested(TransferType.Relationships.FROM, AccountType.Relationships.CURRENCY), TransferType.Relationships.TO);

        DoPaymentDTO doPaymentDTO = buildDoPaymentDTO(params, to, transferType);
        paymentService.validate(doPaymentDTO);

        result.setTransferType(transferTypeService.getTransferTypeVO(transferType.getId(), false));
        final boolean wouldRequireAuthorization = paymentService.wouldRequireAuthorization(transferType, params.getAmount(), LoggedUser.accountOwner());
        result.setWouldRequireAuthorization(wouldRequireAuthorization);

        // TODO support past dates
        // if (wouldRequireAuthorization && params.getDate() != null) {
        // throw new ValidationException("payment.error.authorizedInPast");
        // }

        // Fetch related data

        result.setFrom(memberService.getMemberVO((Member) from, false, false));
        if (to != null && to instanceof Member) {
            result.setTo(memberService.getMemberVO((Member) to, false, false));
        }

        // Store the transaction fees
        final TransactionFeePreviewDTO preview = transactionFeeService.preview(from, to, transferType, params.getAmount());
        result.setFinalAmount(preview.getFinalAmount());

        final LocalSettings localSettings = settingsService.getLocalSettings();
        String formattedAmount = localSettings.getUnitsConverter(transferType.getCurrency().getPattern()).toString(preview.getFinalAmount());

        result.setFees(transactionFeeService.getTransactionFeeVOs(preview));
        result.setFormattedFinalAmount(formattedAmount);

        // TODO: support scheduled payments
        // Calculate the transaction fees for every scheduled payment
        /*
         * final List<ScheduledPaymentDTO> payments = payment.getPayments(); final boolean isScheduled = CollectionUtils.isNotEmpty(payments); if
         * (isScheduled) { for (final ScheduledPaymentDTO current : payments) { final TransactionFeePreviewDTO currentPreview =
         * transactionFeeService.preview(from, to, transferType, current.getAmount()); current.setFinalAmount(currentPreview.getFinalAmount()); } }
         * request.setAttribute("isScheduled", isScheduled);
         */

        // Add the custom values to the result.
        if (doPaymentDTO.getCustomValues() != null) {
            Map<String, String> customValues = new LinkedHashMap<String, String>();
            for (PaymentCustomFieldValue cfv : doPaymentDTO.getCustomValues()) {
                customValues.put(cfv.getField().getName(), cfv.getValue());
            }
            result.setCustomValues(customValues);
        }

        return result;

    }

    private TransferType resolveTransferType(final DoPaymentParameters params, final AccountOwner toOwner) {
        Member loggedMember = LoggedUser.member();
        Currency currency = accountsRestController.loadCurrencyByIdOrSymbol(params.getCurrencyId(), params.getCurrencySymbol());
        final TransferTypeQuery query = new TransferTypeQuery();
        query.setResultType(ResultType.LIST);
        query.setContext(loggedMember.equals(toOwner) ? TransactionContext.SELF_PAYMENT : TransactionContext.PAYMENT);
        query.setChannel(Channel.REST);
        query.setFromOwner(loggedMember);
        query.setToOwner(toOwner);
        query.setCurrency(currency);
        List<TransferType> possibleTransferTypes = transferTypeService.search(query);
        if (possibleTransferTypes.isEmpty()) {
            throw new IllegalArgumentException(NO_POSSIBLE_TRANSFER_TYPES_ERROR);
        }

        // Resolve the transfer type
        Long transferTypeId = params.getTransferTypeId();
        TransferType transferType = null;
        if (transferTypeId != null) {
            for (TransferType tt : possibleTransferTypes) {
                if (tt.getId().equals(transferTypeId)) {
                    transferType = tt;
                    break;
                }
            }
        } else {
            // When there are multiple transfer types, prefer the first one from the default account
            if (possibleTransferTypes.size() > 1) {
                MemberAccountType defaultType = accountTypeService.getDefault(loggedMember.getMemberGroup());
                for (TransferType current : possibleTransferTypes) {
                    if (current.getFrom().equals(defaultType)) {
                        transferType = current;
                        break;
                    }
                }
            }
            // No TT found so far. Get the first one
            if (transferType == null) {
                transferType = possibleTransferTypes.isEmpty() ? null : possibleTransferTypes.get(0);
            }
        }
        if (transferType == null) {
            throw new EntityNotFoundException(TransferType.class);
        }
        return transferType;
    }

}