| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.fineract.cn.interoperation.service.internal.service; |
| |
| import org.apache.fineract.cn.accounting.api.v1.domain.Account; |
| import org.apache.fineract.cn.accounting.api.v1.domain.AccountType; |
| import org.apache.fineract.cn.accounting.api.v1.domain.Creditor; |
| import org.apache.fineract.cn.accounting.api.v1.domain.Debtor; |
| import org.apache.fineract.cn.accounting.api.v1.domain.JournalEntry; |
| import org.apache.fineract.cn.api.util.UserContextHolder; |
| import org.apache.fineract.cn.deposit.api.v1.definition.domain.Charge; |
| import org.apache.fineract.cn.deposit.api.v1.definition.domain.Currency; |
| import org.apache.fineract.cn.deposit.api.v1.definition.domain.ProductDefinition; |
| import org.apache.fineract.cn.deposit.api.v1.instance.domain.ProductInstance; |
| import org.apache.fineract.cn.interoperation.api.v1.domain.InteropActionState; |
| import org.apache.fineract.cn.interoperation.api.v1.domain.InteropActionType; |
| import org.apache.fineract.cn.interoperation.api.v1.domain.InteropIdentifierType; |
| import org.apache.fineract.cn.interoperation.api.v1.domain.InteropState; |
| import org.apache.fineract.cn.interoperation.api.v1.domain.InteropStateMachine; |
| import org.apache.fineract.cn.interoperation.api.v1.domain.TransactionType; |
| import org.apache.fineract.cn.interoperation.api.v1.domain.data.*; |
| import org.apache.fineract.cn.interoperation.api.v1.util.MathUtil; |
| import org.apache.fineract.cn.interoperation.service.ServiceConstants; |
| import org.apache.fineract.cn.interoperation.service.internal.repository.InteropActionEntity; |
| import org.apache.fineract.cn.interoperation.service.internal.repository.InteropActionRepository; |
| import org.apache.fineract.cn.interoperation.service.internal.repository.InteropIdentifierEntity; |
| import org.apache.fineract.cn.interoperation.service.internal.repository.InteropIdentifierRepository; |
| import org.apache.fineract.cn.interoperation.service.internal.repository.InteropTransactionEntity; |
| import org.apache.fineract.cn.interoperation.service.internal.repository.InteropTransactionRepository; |
| import org.apache.fineract.cn.interoperation.service.internal.service.helper.InteropAccountingService; |
| import org.apache.fineract.cn.interoperation.service.internal.service.helper.InteropDepositService; |
| import org.apache.fineract.cn.lang.DateConverter; |
| import org.slf4j.Logger; |
| import org.springframework.beans.factory.annotation.Autowired; |
| import org.springframework.beans.factory.annotation.Qualifier; |
| import org.springframework.data.jpa.domain.Specification; |
| import org.springframework.data.jpa.domain.Specifications; |
| import org.springframework.stereotype.Service; |
| import org.springframework.transaction.annotation.Propagation; |
| import org.springframework.transaction.annotation.Transactional; |
| |
| import javax.persistence.criteria.CriteriaBuilder; |
| import javax.persistence.criteria.CriteriaQuery; |
| import javax.persistence.criteria.Path; |
| import javax.persistence.criteria.Root; |
| import javax.validation.constraints.NotNull; |
| import java.math.BigDecimal; |
| import java.math.MathContext; |
| import java.time.Clock; |
| import java.time.LocalDateTime; |
| import java.util.ArrayList; |
| import java.util.HashSet; |
| import java.util.List; |
| |
| //import static org.apache.fineract.cn.interoperation.api.v1.util.InteroperationUtil.DEFAULT_ROUTING_CODE; |
| |
| @Service |
| public class InteropService { |
| |
| public static final String ACCOUNT_NAME_NOSTRO = "Interoperation NOSTRO"; |
| |
| private final Logger logger; |
| |
| private final InteropIdentifierRepository identifierRepository; |
| private final InteropTransactionRepository transactionRepository; |
| private final InteropActionRepository actionRepository; |
| |
| private final InteropDepositService depositService; |
| private final InteropAccountingService accountingService; |
| |
| |
| @Autowired |
| public InteropService(@Qualifier(ServiceConstants.LOGGER_NAME) final Logger logger, |
| InteropIdentifierRepository interopIdentifierRepository, |
| InteropTransactionRepository interopTransactionRepository, |
| InteropActionRepository interopActionRepository, |
| InteropDepositService interopDepositService, |
| InteropAccountingService interopAccountingService) { |
| this.logger = logger; |
| this.identifierRepository = interopIdentifierRepository; |
| this.transactionRepository = interopTransactionRepository; |
| this.actionRepository = interopActionRepository; |
| this.depositService = interopDepositService; |
| this.accountingService = interopAccountingService; |
| } |
| |
| @NotNull |
| public InteropIdentifierData getAccountByIdentifier(@NotNull InteropIdentifierType idType, @NotNull String idValue, String subIdOrType) { |
| InteropIdentifierEntity identifier = findIdentifier(idType, idValue, subIdOrType); |
| if (identifier == null) |
| throw new UnsupportedOperationException("Account not found for identifier " + idType + "/" + idValue + (subIdOrType == null ? "" : ("/" + subIdOrType))); |
| |
| return new InteropIdentifierData(identifier.getCustomerAccountIdentifier()); |
| } |
| |
| @NotNull |
| @Transactional(propagation = Propagation.MANDATORY) |
| public InteropIdentifierData registerAccountIdentifier(@NotNull InteropIdentifierCommand request) { |
| //TODO: error handling |
| String accountId = request.getAccountId(); |
| validateAndGetAccount(accountId); |
| |
| String createdBy = getLoginUser(); |
| LocalDateTime createdOn = getNow(); |
| |
| InteropIdentifierEntity identifier = new InteropIdentifierEntity(accountId, request.getIdType(), request.getIdValue(), |
| request.getSubIdOrType(), createdBy, createdOn); |
| |
| identifierRepository.save(identifier); |
| |
| return new InteropIdentifierData(accountId); |
| } |
| |
| @NotNull |
| @Transactional(propagation = Propagation.MANDATORY) |
| public InteropIdentifierData deleteAccountIdentifier(@NotNull InteropIdentifierDeleteCommand request) { |
| InteropIdentifierType idType = request.getIdType(); |
| String idValue = request.getIdValue(); |
| String subIdOrType = request.getSubIdOrType(); |
| |
| InteropIdentifierEntity identifier = findIdentifier(idType, idValue, subIdOrType); |
| if (identifier == null) |
| throw new UnsupportedOperationException("Account not found for identifier " + idType + "/" + idValue + (subIdOrType == null ? "" : ("/" + subIdOrType))); |
| |
| String customerAccountIdentifier = identifier.getCustomerAccountIdentifier(); |
| |
| identifierRepository.delete(identifier); |
| |
| return new InteropIdentifierData(customerAccountIdentifier); |
| } |
| |
| public InteropTransactionRequestResponseData getTransactionRequest(@NotNull String transactionCode, @NotNull String requestCode) { |
| InteropActionEntity action = validateAndGetAction(transactionCode, calcActionIdentifier(requestCode, InteropActionType.REQUEST), |
| InteropActionType.REQUEST); |
| return InteropTransactionRequestResponseData.build(transactionCode, action.getState(), action.getExpirationDate(), requestCode); |
| } |
| |
| @NotNull |
| @Transactional(propagation = Propagation.MANDATORY) |
| public InteropTransactionRequestResponseData createTransactionRequest(@NotNull InteropTransactionRequestData request) { |
| // only when Payee request transaction from Payer, so here role must be always Payer |
| //TODO: error handling |
| AccountWrapper accountWrapper = validateAndGetAccount(request); |
| //TODO: transaction expiration separated from action expiration |
| InteropTransactionEntity transaction = validateAndGetTransaction(request, accountWrapper); |
| InteropActionEntity action = addAction(transaction, request); |
| |
| transactionRepository.save(transaction); |
| |
| return InteropTransactionRequestResponseData.build(request.getTransactionCode(), action.getState(), action.getExpirationDate(), |
| request.getExtensionList(), request.getRequestCode()); |
| } |
| |
| public InteropQuoteResponseData getQuote(@NotNull String transactionCode, @NotNull String quoteCode) { |
| InteropActionEntity action = validateAndGetAction(transactionCode, calcActionIdentifier(quoteCode, InteropActionType.QUOTE), |
| InteropActionType.QUOTE); |
| |
| Currency currency = getCurrency(action); |
| |
| return InteropQuoteResponseData.build(transactionCode, action.getState(), action.getExpirationDate(), quoteCode, |
| MoneyData.build(action.getFee(), currency), MoneyData.build(action.getCommission(), currency)); |
| } |
| |
| @NotNull |
| @Transactional(propagation = Propagation.MANDATORY) |
| public InteropQuoteResponseData createQuote(@NotNull InteropQuoteRequestData request) { |
| //TODO: error handling |
| AccountWrapper accountWrapper = validateAndGetAccount(request); |
| //TODO: transaction expiration separated from action expiration |
| InteropTransactionEntity transaction = validateAndGetTransaction(request, accountWrapper); |
| |
| TransactionType transactionType = request.getTransactionRole().getTransactionType(); |
| String accountId = accountWrapper.account.getIdentifier(); |
| List<Charge> charges = depositService.getCharges(accountId, transactionType); |
| |
| BigDecimal amount = request.getAmount().getAmount(); |
| BigDecimal fee = MathUtil.normalize(calcTotalCharges(charges, amount), MathUtil.DEFAULT_MATH_CONTEXT); |
| |
| Double withdrawableBalance = getWithdrawableBalance(accountWrapper.account, accountWrapper.productDefinition); |
| boolean withdraw = request.getTransactionRole().isWithdraw(); |
| |
| BigDecimal total = MathUtil.nullToZero(withdraw ? MathUtil.add(amount, fee) : fee); |
| if (withdraw && withdrawableBalance < total.doubleValue()) |
| throw new UnsupportedOperationException("Account balance is not enough to pay the fee " + accountId); |
| |
| // TODO add action and set the status to failed in separated transaction |
| InteropActionEntity action = addAction(transaction, request); |
| action.setFee(fee); |
| // TODO: extend Charge with a property that could be stored in charges |
| |
| transactionRepository.save(transaction); |
| |
| InteropQuoteResponseData build = InteropQuoteResponseData.build(request.getTransactionCode(), action.getState(), |
| action.getExpirationDate(), request.getExtensionList(), request.getQuoteCode(), |
| MoneyData.build(fee, accountWrapper.productDefinition.getCurrency()), null); |
| return build; |
| } |
| |
| public InteropTransferResponseData getTransfer(@NotNull String transactionCode, @NotNull String transferCode) { |
| InteropActionEntity action = validateAndGetAction(transactionCode, calcActionIdentifier(transferCode, InteropActionType.PREPARE), |
| InteropActionType.PREPARE, false); |
| if (action == null) |
| action = validateAndGetAction(transactionCode, calcActionIdentifier(transferCode, InteropActionType.COMMIT), |
| InteropActionType.COMMIT); |
| |
| return InteropTransferResponseData.build(transactionCode, action.getState(), action.getExpirationDate(), transferCode, action.getCreatedOn()); |
| } |
| |
| @NotNull |
| @Transactional(propagation = Propagation.MANDATORY) |
| public InteropTransferResponseData prepareTransfer(@NotNull InteropTransferCommand request) { |
| //TODO: error handling |
| //TODO: ABORT |
| AccountWrapper accountWrapper = validateAndGetAccount(request); |
| |
| LocalDateTime transactionDate = getNow(); |
| //TODO: transaction expiration separated from action expiration |
| InteropTransactionEntity transaction = validateAndGetTransaction(request, accountWrapper, transactionDate, true); |
| |
| validateTransfer(request, accountWrapper); |
| |
| TransactionType transactionType = request.getTransactionRole().getTransactionType(); |
| List<Charge> charges = depositService.getCharges(accountWrapper.account.getIdentifier(), transactionType); |
| |
| // TODO add action and set the status to failed in separated transaction |
| InteropActionEntity action = addAction(transaction, request, transactionDate); |
| MoneyData fee = request.getFspFee(); |
| action.setFee(fee == null ? null : fee.getAmount()); |
| // TODO: extend Charge with a property that could be stored in charges |
| |
| prepareTransfer(request, accountWrapper, action, charges, transactionDate); |
| |
| transactionRepository.save(transaction); |
| |
| return InteropTransferResponseData.build(request.getTransferCode(), action.getState(), action.getExpirationDate(), |
| request.getExtensionList(), request.getTransferCode(), transactionDate); |
| } |
| |
| @NotNull |
| @Transactional(propagation = Propagation.MANDATORY) |
| public InteropTransferResponseData commitTransfer(@NotNull InteropTransferCommand request) { |
| //TODO: error handling |
| //TODO: ABORT |
| AccountWrapper accountWrapper = validateAndGetAccount(request); |
| |
| LocalDateTime transactionDate = getNow(); |
| //TODO: transaction expiration separated from action expiration |
| InteropTransactionEntity transaction = validateAndGetTransaction(request, accountWrapper, transactionDate, true); |
| transaction.setTransactionDate(transactionDate); |
| |
| validateTransfer(request, accountWrapper); |
| |
| TransactionType transactionType = request.getTransactionRole().getTransactionType(); |
| List<Charge> charges = depositService.getCharges(accountWrapper.account.getIdentifier(), transactionType); |
| |
| // TODO add action and set the status to failed in separated transaction |
| InteropActionEntity action = addAction(transaction, request, transactionDate); |
| MoneyData fee = request.getFspFee(); |
| action.setFee(fee == null ? null : fee.getAmount()); |
| // TODO: extend Charge with a property that could be stored in charges |
| |
| bookTransfer(request, accountWrapper, action, charges, transactionDate); |
| |
| transactionRepository.save(transaction); |
| |
| return InteropTransferResponseData.build(request.getTransferCode(), action.getState(), action.getExpirationDate(), |
| request.getExtensionList(), request.getTransferCode(), transactionDate); |
| } |
| |
| Double getWithdrawableBalance(Account account, ProductDefinition productDefinition) { |
| // on-hold amount, if any, is subtracted to payable account |
| return MathUtil.subtractToZero(account.getBalance(), productDefinition.getMinimumBalance()); |
| } |
| |
| private void prepareTransfer(@NotNull InteropTransferCommand request, @NotNull AccountWrapper accountWrapper, @NotNull InteropActionEntity action, |
| List<Charge> charges, LocalDateTime transactionDate) { |
| BigDecimal amount = request.getAmount().getAmount(); |
| // TODO: validate amount with quote amount |
| boolean isDebit = request.getTransactionRole().isWithdraw(); |
| if (!isDebit) |
| return; |
| |
| String prepareAccountId = action.getTransaction().getPrepareAccountIdentifier(); |
| Account payableAccount = prepareAccountId == null ? null : validateAndGetAccount(request, prepareAccountId); |
| if (payableAccount == null) { |
| logger.warn("Can not prepare transfer: Payable account was not found for " + accountWrapper.account.getIdentifier()); |
| return; |
| } |
| |
| final JournalEntry journalEntry = createJournalEntry(action.getIdentifier(), TransactionType.CURRENCY_WITHDRAWAL.getCode(), |
| DateConverter.toIsoString(transactionDate), request.getNote(), getLoginUser()); |
| |
| HashSet<Debtor> debtors = new HashSet<>(1); |
| HashSet<Creditor> creditors = new HashSet<>(1); |
| |
| addCreditor(accountWrapper.account.getIdentifier(), amount.doubleValue(), creditors); |
| addDebtor(payableAccount.getIdentifier(), amount.doubleValue(), debtors); |
| |
| prepareCharges(request, accountWrapper, action, charges, payableAccount, debtors, creditors); |
| |
| if (debtors.isEmpty()) // must be same size as creditors |
| return; |
| |
| journalEntry.setDebtors(debtors); |
| journalEntry.setCreditors(creditors); |
| accountingService.createJournalEntry(journalEntry); |
| } |
| |
| private void prepareCharges(@NotNull InteropTransferCommand request, @NotNull AccountWrapper accountWrapper, @NotNull InteropActionEntity action, |
| @NotNull List<Charge> charges, Account payableAccount, HashSet<Debtor> debtors, HashSet<Creditor> creditors) { |
| MoneyData fspFee = request.getFspFee(); // TODO compare with calculated and with quote |
| |
| BigDecimal amount = request.getAmount().getAmount(); |
| Currency currency = accountWrapper.productDefinition.getCurrency(); |
| |
| BigDecimal total = MathUtil.normalize(calcTotalCharges(charges, amount), currency); |
| |
| if (MathUtil.isEmpty(total)) { |
| return; |
| } |
| |
| if (creditors == null) { |
| creditors = new HashSet<>(1); |
| } |
| if (debtors == null) { |
| debtors = new HashSet<>(charges.size()); |
| } |
| addCreditor(accountWrapper.account.getIdentifier(), total.doubleValue(), creditors); |
| addDebtor(payableAccount.getIdentifier(), total.doubleValue(), debtors); |
| } |
| |
| private void bookTransfer(@NotNull InteropTransferCommand request, @NotNull AccountWrapper accountWrapper, @NotNull InteropActionEntity action, |
| List<Charge> charges, LocalDateTime transactionDate) { |
| boolean isDebit = request.getTransactionRole().isWithdraw(); |
| String accountId = accountWrapper.account.getIdentifier(); |
| String message = request.getNote(); |
| double doubleAmount = request.getAmount().getAmount().doubleValue(); |
| |
| String loginUser = getLoginUser(); |
| String transactionTypeCode = (isDebit ? TransactionType.CURRENCY_WITHDRAWAL : TransactionType.CURRENCY_DEPOSIT).getCode(); |
| String transactionDateString = DateConverter.toIsoString(transactionDate); |
| |
| InteropTransactionEntity transaction = action.getTransaction(); |
| Account nostroAccount = validateAndGetAccount(request, transaction.getNostroAccountIdentifier()); |
| Account payableAccount = null; |
| |
| double preparedAmount = 0d; |
| double accountNostroAmount = doubleAmount; |
| |
| if (isDebit) { |
| InteropActionEntity prepareAction = findAction(transaction, InteropActionType.PREPARE); |
| if (prepareAction != null) { |
| JournalEntry prepareJournal = accountingService.findJournalEntry(prepareAction.getIdentifier()); |
| if (prepareJournal == null) |
| throw new UnsupportedOperationException("Can not find prepare result for " + action.getActionType() + |
| "/" + request.getIdentifier()); |
| |
| payableAccount = validateAndGetAccount(request, transaction.getPrepareAccountIdentifier()); |
| preparedAmount = prepareJournal.getDebtors().stream().mapToDouble(d -> Double.valueOf(d.getAmount())).sum(); |
| if (preparedAmount < doubleAmount) |
| throw new UnsupportedOperationException("Prepared amount " + preparedAmount + " is less than transfer amount " + |
| doubleAmount + " for " + request.getIdentifier()); |
| |
| // now fails if prepared is not enough |
| accountNostroAmount = preparedAmount >= doubleAmount ? 0d : doubleAmount - preparedAmount; |
| |
| double fromPrepareToNostroAmount = doubleAmount - accountNostroAmount; |
| preparedAmount -= fromPrepareToNostroAmount; |
| |
| if (fromPrepareToNostroAmount > 0) { |
| final JournalEntry fromPrepareToNostroEntry = createJournalEntry(action.getIdentifier(), |
| transactionTypeCode, transactionDateString, message + " #commit", loginUser); |
| |
| HashSet<Debtor> debtors = new HashSet<>(1); |
| HashSet<Creditor> creditors = new HashSet<>(1); |
| |
| addCreditor(payableAccount.getIdentifier(), fromPrepareToNostroAmount, creditors); |
| addDebtor(nostroAccount.getIdentifier(), fromPrepareToNostroAmount, debtors); |
| |
| fromPrepareToNostroEntry.setDebtors(debtors); |
| fromPrepareToNostroEntry.setCreditors(creditors); |
| accountingService.createJournalEntry(fromPrepareToNostroEntry); |
| } |
| } |
| } |
| if (accountNostroAmount > 0) { |
| // can not happen that prepared amount is less than requested transfer amount (identifier and message can be default) |
| final JournalEntry journalEntry = createJournalEntry(action.getIdentifier(), transactionTypeCode, |
| transactionDateString, message/* + (payableAccount == null ? "" : " #difference")*/, loginUser); |
| |
| HashSet<Debtor> debtors = new HashSet<>(1); |
| HashSet<Creditor> creditors = new HashSet<>(1); |
| |
| addCreditor(isDebit ? accountId : nostroAccount.getIdentifier(), accountNostroAmount, creditors); |
| addDebtor(isDebit ? nostroAccount.getIdentifier() : accountId, accountNostroAmount, debtors); |
| |
| journalEntry.setDebtors(debtors); |
| journalEntry.setCreditors(creditors); |
| accountingService.createJournalEntry(journalEntry); |
| } |
| |
| preparedAmount = bookCharges(request, accountWrapper, action, charges, payableAccount, preparedAmount, transactionDate); |
| |
| if (preparedAmount > 0) { |
| // throw new UnsupportedOperationException("Prepared amount differs from transfer amount " + doubleAmount + " for " + request.getIdentifier()); |
| // transfer back remaining prepared amount TODO: JM maybe fail this case? |
| |
| final JournalEntry fromPrepareToAccountEntry = createJournalEntry(action.getIdentifier() + InteropRequestData.IDENTIFIER_SEPARATOR + "diff", |
| transactionTypeCode, transactionDateString, message + " #release difference", loginUser); |
| |
| HashSet<Debtor> debtors = new HashSet<>(1); |
| HashSet<Creditor> creditors = new HashSet<>(1); |
| |
| addCreditor(payableAccount.getIdentifier(), preparedAmount, creditors); |
| addDebtor(accountId, preparedAmount, debtors); |
| |
| fromPrepareToAccountEntry.setDebtors(debtors); |
| fromPrepareToAccountEntry.setCreditors(creditors); |
| accountingService.createJournalEntry(fromPrepareToAccountEntry); |
| } |
| } |
| |
| private double bookCharges(@NotNull InteropTransferCommand request, @NotNull AccountWrapper accountWrapper, @NotNull InteropActionEntity action, |
| @NotNull List<Charge> charges, Account payableAccount, double preparedAmount, LocalDateTime transactionDate) { |
| boolean isDebit = request.getTransactionRole().isWithdraw(); |
| String accountId = accountWrapper.account.getIdentifier(); |
| String message = request.getNote(); |
| BigDecimal amount = request.getAmount().getAmount(); |
| Currency currency = accountWrapper.productDefinition.getCurrency(); |
| |
| BigDecimal calcFee = MathUtil.normalize(calcTotalCharges(charges, amount), currency); |
| BigDecimal requestFee = request.getFspFee().getAmount(); |
| if (!MathUtil.isEqualTo(calcFee, requestFee)) |
| throw new UnsupportedOperationException("Quote fee " + requestFee + " differs from transfer fee " + calcFee); |
| |
| if (MathUtil.isEmpty(calcFee)) { |
| return preparedAmount; |
| } |
| |
| String loginUser = getLoginUser(); |
| String transactionTypeCode = (isDebit ? TransactionType.CURRENCY_WITHDRAWAL : TransactionType.CURRENCY_DEPOSIT).getCode(); |
| String transactionDateString = DateConverter.toIsoString(transactionDate); |
| |
| ArrayList<Charge> unpaidCharges = new ArrayList<>(charges); |
| if (preparedAmount > 0) { |
| InteropActionEntity prepareAction = findAction(action.getTransaction(), InteropActionType.PREPARE); |
| if (prepareAction != null) { |
| final JournalEntry fromPrepareToRevenueEntry = createJournalEntry(action.getIdentifier() + InteropRequestData.IDENTIFIER_SEPARATOR + "fee", |
| transactionTypeCode, transactionDateString, message + " #commit fee", loginUser); |
| |
| double payedAmount = 0d; |
| |
| HashSet<Debtor> debtors = new HashSet<>(1); |
| HashSet<Creditor> creditors = new HashSet<>(1); |
| |
| for (Charge charge : charges) { |
| BigDecimal value = calcChargeAmount(amount, charge, currency, true); |
| if (value == null) |
| continue; |
| |
| double doubleValue = value.doubleValue(); |
| if (doubleValue > preparedAmount) { |
| break; |
| } |
| unpaidCharges.remove(charge); |
| preparedAmount -= doubleValue; |
| payedAmount += doubleValue; |
| |
| addDebtor(charge.getIncomeAccountIdentifier(), doubleValue, debtors); |
| } |
| if (!unpaidCharges.isEmpty()) |
| throw new UnsupportedOperationException("Prepared amount " + preparedAmount + " is less than transfer fee amount for " + |
| request.getIdentifier()); |
| |
| if (payedAmount > 0) { |
| addCreditor(payableAccount.getIdentifier(), payedAmount, creditors); |
| |
| fromPrepareToRevenueEntry.setDebtors(debtors); |
| fromPrepareToRevenueEntry.setCreditors(creditors); |
| accountingService.createJournalEntry(fromPrepareToRevenueEntry); |
| } |
| } |
| } |
| if (!unpaidCharges.isEmpty()) { |
| // can not happen that prepared amount is more or less than requested transfer amount (identifier and message can be default) |
| final JournalEntry journalEntry = createJournalEntry(action.getIdentifier() + InteropRequestData.IDENTIFIER_SEPARATOR + "fee", |
| transactionTypeCode, transactionDateString, message + " #fee", loginUser); |
| |
| HashSet<Debtor> debtors = new HashSet<>(1); |
| HashSet<Creditor> creditors = new HashSet<>(1); |
| |
| double payedAmount = 0d; |
| for (Charge charge : charges) { |
| BigDecimal value = calcChargeAmount(amount, charge, currency, true); |
| if (value == null) |
| continue; |
| |
| double doubleValue = value.doubleValue(); |
| payedAmount += doubleValue; |
| |
| addDebtor(charge.getIncomeAccountIdentifier(), doubleValue, debtors); |
| } |
| |
| if (payedAmount > 0) { |
| addCreditor(accountId, payedAmount, creditors); |
| |
| journalEntry.setDebtors(debtors); |
| journalEntry.setCreditors(creditors); |
| accountingService.createJournalEntry(journalEntry); |
| } |
| } |
| |
| return preparedAmount; |
| } |
| |
| // Util |
| |
| private JournalEntry createJournalEntry(String actionIdentifier, String transactionType, String transactionDate, String message, String loginUser) { |
| final JournalEntry fromPrepareToNostroEntry = new JournalEntry(); |
| fromPrepareToNostroEntry.setTransactionIdentifier(actionIdentifier); |
| fromPrepareToNostroEntry.setTransactionType(transactionType); |
| fromPrepareToNostroEntry.setTransactionDate(transactionDate); |
| fromPrepareToNostroEntry.setMessage(message); |
| fromPrepareToNostroEntry.setClerk(loginUser); |
| return fromPrepareToNostroEntry; |
| } |
| |
| private void addCreditor(String accountNumber, double amount, HashSet<Creditor> creditors) { |
| Creditor creditor = new Creditor(); |
| creditor.setAccountNumber(accountNumber); |
| creditor.setAmount(Double.toString(amount)); |
| creditors.add(creditor); |
| } |
| |
| private void addDebtor(String accountNumber, double amount, HashSet<Debtor> debtors) { |
| Debtor debtor = new Debtor(); |
| debtor.setAccountNumber(accountNumber); |
| debtor.setAmount(Double.toString(amount)); |
| debtors.add(debtor); |
| } |
| |
| private BigDecimal calcChargeAmount(BigDecimal amount, Charge charge) { |
| return calcChargeAmount(amount, charge, null, false); |
| } |
| |
| private BigDecimal calcChargeAmount(@NotNull BigDecimal amount, @NotNull Charge charge, Currency currency, boolean norm) { |
| Double value = charge.getAmount(); |
| if (value == null) |
| return null; |
| |
| BigDecimal portion = BigDecimal.valueOf(100.00d); |
| MathContext mc = MathUtil.CALCULATION_MATH_CONTEXT; |
| BigDecimal feeAmount = BigDecimal.valueOf(MathUtil.nullToZero(charge.getAmount())); |
| BigDecimal result = charge.getProportional() |
| ? amount.multiply(feeAmount.divide(portion, mc), mc) |
| : feeAmount; |
| return norm ? MathUtil.normalize(result, currency) : result; |
| } |
| |
| @NotNull |
| private BigDecimal calcTotalCharges(@NotNull List<Charge> charges, BigDecimal amount) { |
| return charges.stream().map(charge -> calcChargeAmount(amount, charge)).reduce(MathUtil::add).orElse(BigDecimal.ZERO); |
| } |
| |
| private Account validateAndGetAccount(@NotNull String accountId) { |
| //TODO: error handling |
| Account account = accountingService.findAccount(accountId); |
| validateAccount(account); |
| |
| return account; |
| } |
| |
| private AccountWrapper validateAndGetAccount(@NotNull InteropRequestData request) { |
| //TODO: error handling |
| String accountId = request.getAccountId(); |
| Account account = accountingService.findAccount(accountId); |
| validateAccount(request, account); |
| |
| ProductInstance product = depositService.findProductInstance(accountId); |
| ProductDefinition productDefinition = depositService.findProductDefinition(product.getProductIdentifier()); |
| |
| Currency currency = productDefinition.getCurrency(); |
| if (!currency.getCode().equals(request.getAmount().getCurrency())) |
| throw new UnsupportedOperationException(); |
| |
| request.normalizeAmounts(currency); |
| |
| Double withdrawableBalance = getWithdrawableBalance(account, productDefinition); |
| if (request.getTransactionRole().isWithdraw() && withdrawableBalance < request.getAmount().getAmount().doubleValue()) |
| throw new UnsupportedOperationException(); |
| |
| return new AccountWrapper(account, product, productDefinition, withdrawableBalance); |
| } |
| |
| private Account validateAndGetPayableAccount(@NotNull InteropRequestData request, @NotNull AccountWrapper wrapper) { |
| String referenceId = wrapper.account.getReferenceAccount(); |
| if (referenceId == null) |
| return null; |
| |
| return validateAndGetAccount(request, referenceId); |
| } |
| |
| @NotNull |
| private Account validateAndGetNostroAccount(@NotNull InteropRequestData request) { |
| //TODO: error handling |
| List<Account> nostros = fetchAccounts(false, ACCOUNT_NAME_NOSTRO, AccountType.ASSET.name(), false, null, null, null, null); |
| int size = nostros.size(); |
| if (size != 1) |
| throw new UnsupportedOperationException("NOSTRO Account " + (size == 0 ? "not found" : "is ambigous")); |
| |
| Account nostro = nostros.get(0); |
| validateAccount(request, nostro); |
| return nostro; |
| } |
| |
| @NotNull |
| private Account validateAndGetAccount(@NotNull InteropRequestData request, @NotNull String accountId) { |
| //TODO: error handling |
| Account account = accountingService.findAccount(accountId); |
| |
| validateAccount(request, account); |
| return account; |
| } |
| |
| private void validateAccount(Account account) { |
| if (account == null) |
| throw new UnsupportedOperationException("Account not found"); |
| if (!account.getState().equals(Account.State.OPEN.name())) |
| throw new UnsupportedOperationException("Account is in state " + account.getState()); |
| } |
| |
| private void validateAccount(@NotNull InteropRequestData request, Account account) { |
| validateAccount(account); |
| |
| String accountId = account.getIdentifier(); |
| |
| if (account.getHolders() != null) { // customer account |
| ProductInstance product = depositService.findProductInstance(accountId); |
| ProductDefinition productDefinition = depositService.findProductDefinition(product.getProductIdentifier()); |
| if (!Boolean.TRUE.equals(productDefinition.getActive())) |
| throw new UnsupportedOperationException("NOSTRO Product Definition is inactive"); |
| |
| Currency currency = productDefinition.getCurrency(); |
| if (!currency.getCode().equals(request.getAmount().getCurrency())) |
| throw new UnsupportedOperationException(); |
| } |
| } |
| |
| private BigDecimal validateTransfer(@NotNull InteropTransferRequestData request, @NotNull AccountWrapper accountWrapper) { |
| BigDecimal amount = request.getAmount().getAmount(); |
| |
| boolean isDebit = request.getTransactionRole().isWithdraw(); |
| Currency currency = accountWrapper.productDefinition.getCurrency(); |
| |
| BigDecimal total = isDebit ? amount : MathUtil.negate(amount); |
| MoneyData fspFee = request.getFspFee(); |
| if (fspFee != null) { |
| if (!currency.getCode().equals(fspFee.getCurrency())) |
| throw new UnsupportedOperationException(); |
| //TODO: compare with calculated quote fee |
| total = MathUtil.add(total, fspFee.getAmount()); |
| } |
| MoneyData fspCommission = request.getFspCommission(); |
| if (fspCommission != null) { |
| if (!currency.getCode().equals(fspCommission.getCurrency())) |
| throw new UnsupportedOperationException(); |
| //TODO: compare with calculated quote commission |
| total = MathUtil.subtractToZero(total, fspCommission.getAmount()); |
| } |
| if (isDebit && accountWrapper.withdrawableBalance < request.getAmount().getAmount().doubleValue()) |
| throw new UnsupportedOperationException(); |
| return total; |
| } |
| |
| public List<Account> fetchAccounts(boolean includeClosed, String term, String type, boolean includeCustomerAccounts, |
| Integer pageIndex, Integer size, String sortColumn, String sortDirection) { |
| return accountingService.fetchAccounts(includeClosed, term, type, includeCustomerAccounts, pageIndex, size, sortColumn, sortDirection); |
| } |
| |
| public InteropIdentifierEntity findIdentifier(@NotNull InteropIdentifierType idType, @NotNull String idValue, String subIdOrType) { |
| return identifierRepository.findOne(Specifications.where(idTypeEqual(idType)).and(idValueEqual(idValue)).and(subIdOrTypeEqual(subIdOrType))); |
| } |
| |
| public static Specification<InteropIdentifierEntity> idTypeEqual(@NotNull InteropIdentifierType idType) { |
| return (Root<InteropIdentifierEntity> root, CriteriaQuery<?> query, CriteriaBuilder cb) -> cb.and(cb.equal(root.get("type"), idType)); |
| } |
| |
| public static Specification<InteropIdentifierEntity> idValueEqual(@NotNull String idValue) { |
| return (Root<InteropIdentifierEntity> root, CriteriaQuery<?> query, CriteriaBuilder cb) -> cb.and(cb.equal(root.get("value"), idValue)); |
| } |
| |
| public static Specification<InteropIdentifierEntity> subIdOrTypeEqual(String subIdOrType) { |
| return (Root<InteropIdentifierEntity> root, CriteriaQuery<?> query, CriteriaBuilder cb) -> { |
| Path<Object> path = root.get("subValueOrType"); |
| return cb.and(subIdOrType == null ? cb.isNull(path) : cb.equal(path, subIdOrType)); |
| }; |
| } |
| |
| @NotNull |
| private String calcActionIdentifier(@NotNull String actionCode, @NotNull InteropActionType actionType) { |
| return actionType == InteropActionType.PREPARE || actionType == InteropActionType.COMMIT ? actionType + InteropRequestData.IDENTIFIER_SEPARATOR + actionCode : actionCode; |
| } |
| |
| private InteropActionEntity validateAndGetAction(@NotNull String transactionCode, @NotNull String actionIdentifier, @NotNull InteropActionType actionType) { |
| return validateAndGetAction(transactionCode, actionIdentifier, actionType, true); |
| } |
| |
| private InteropActionEntity validateAndGetAction(@NotNull String transactionCode, @NotNull String actionIdentifier, @NotNull InteropActionType actionType, boolean one) { |
| //TODO: error handling |
| InteropActionEntity action = actionRepository.findByIdentifier(actionIdentifier); |
| if (action == null) { |
| if (one) |
| throw new UnsupportedOperationException("Interperation action " + actionType + '/' + actionIdentifier + " was not found for this transaction " + transactionCode); |
| return null; |
| } |
| if (!action.getTransaction().getIdentifier().equals(transactionCode)) |
| throw new UnsupportedOperationException("Interperation action " + actionType + '/' + actionIdentifier + " does not exist in this transaction " + transactionCode); |
| if (action.getActionType() != actionType) |
| throw new UnsupportedOperationException("Interperation action " + actionIdentifier + " is not this type " + actionType); |
| |
| return action; |
| } |
| |
| @NotNull |
| private InteropTransactionEntity validateAndGetTransaction(@NotNull InteropRequestData request, @NotNull AccountWrapper accountWrapper) { |
| return validateAndGetTransaction(request, accountWrapper, true); |
| } |
| |
| @NotNull |
| private InteropTransactionEntity validateAndGetTransaction(@NotNull InteropRequestData request, @NotNull AccountWrapper accountWrapper, boolean create) { |
| return validateAndGetTransaction(request, accountWrapper, getNow(), create); |
| } |
| |
| @NotNull |
| private InteropTransactionEntity validateAndGetTransaction(@NotNull InteropRequestData request, @NotNull AccountWrapper accountWrapper, |
| @NotNull LocalDateTime createdOn, boolean create) { |
| //TODO: error handling |
| String transactionCode = request.getTransactionCode(); |
| InteropTransactionEntity transaction = transactionRepository.findOneByIdentifier(request.getTransactionCode()); |
| InteropState state = InteropStateMachine.handleTransition(transaction == null ? null : transaction.getState(), request.getActionType()); |
| LocalDateTime now = getNow(); |
| if (transaction == null) { |
| if (!create) |
| throw new UnsupportedOperationException("Interperation transaction " + request.getTransactionCode() + " does not exist "); |
| transaction = new InteropTransactionEntity(transactionCode, accountWrapper.account.getIdentifier(), getLoginUser(), now); |
| transaction.setState(state); |
| transaction.setAmount(request.getAmount().getAmount()); |
| transaction.setName(request.getNote()); |
| transaction.setTransactionType(request.getTransactionRole().getTransactionType()); |
| Account payableAccount = validateAndGetPayableAccount(request, accountWrapper); |
| transaction.setPrepareAccountIdentifier(payableAccount == null ? null : payableAccount.getIdentifier()); |
| transaction.setNostroAccountIdentifier(validateAndGetNostroAccount(request).getIdentifier()); |
| transaction.setExpirationDate(request.getExpiration()); |
| } |
| LocalDateTime expirationDate = transaction.getExpirationDate(); |
| if (expirationDate != null && expirationDate.isBefore(now)) |
| throw new UnsupportedOperationException("Interperation transaction expired on " + expirationDate); |
| return transaction; |
| } |
| |
| private Currency getCurrency(InteropActionEntity action) { |
| ProductInstance product = depositService.findProductInstance(action.getTransaction().getCustomerAccountIdentifier()); |
| ProductDefinition productDefinition = depositService.findProductDefinition(product.getProductIdentifier()); |
| return productDefinition.getCurrency(); |
| } |
| |
| private InteropActionEntity addAction(@NotNull InteropTransactionEntity transaction, @NotNull InteropRequestData request) { |
| return addAction(transaction, request, getNow()); |
| } |
| |
| private InteropActionEntity addAction(@NotNull InteropTransactionEntity transaction, @NotNull InteropRequestData request, |
| @NotNull LocalDateTime createdOn) { |
| InteropActionEntity lastAction = getLastAction(transaction); |
| |
| InteropActionType actionType = request.getActionType(); |
| String actionIdentifier = calcActionIdentifier(request.getIdentifier(), request.getActionType()); |
| InteropActionEntity action = new InteropActionEntity(actionIdentifier, transaction, request.getActionType(), |
| (lastAction == null ? 0 : lastAction.getSeqNo() + 1), getLoginUser(), |
| (lastAction == null ? transaction.getCreatedOn() : createdOn)); |
| action.setState(InteropActionState.ACCEPTED); |
| action.setAmount(request.getAmount().getAmount()); |
| action.setExpirationDate(request.getExpiration()); |
| transaction.getActions().add(action); |
| |
| InteropState currentState = transaction.getState(); |
| if (transaction.getId() != null || InteropStateMachine.isValidAction(currentState, actionType)) // newly created was already set |
| transaction.setState(InteropStateMachine.handleTransition(currentState, actionType)); |
| return action; |
| } |
| |
| private InteropActionEntity getLastAction(InteropTransactionEntity transaction) { |
| List<InteropActionEntity> actions = transaction.getActions(); |
| int size = actions.size(); |
| return size == 0 ? null : actions.get(size - 1); |
| } |
| |
| private InteropActionEntity findAction(InteropTransactionEntity transaction, InteropActionType actionType) { |
| List<InteropActionEntity> actions = transaction.getActions(); |
| for (InteropActionEntity action : actions) { |
| if (action.getActionType() == actionType) |
| return action; |
| } |
| return null; |
| } |
| |
| private LocalDateTime getNow() { |
| return LocalDateTime.now(Clock.systemUTC()); |
| } |
| |
| private String getLoginUser() { |
| return UserContextHolder.checkedGetUser(); |
| } |
| |
| public static class AccountWrapper { |
| @NotNull |
| private final Account account; |
| @NotNull |
| private final ProductInstance product; |
| @NotNull |
| private final ProductDefinition productDefinition; |
| @NotNull |
| private final Double withdrawableBalance; |
| |
| public AccountWrapper(Account account, ProductInstance product, ProductDefinition productDefinition, Double withdrawableBalance) { |
| this.account = account; |
| this.product = product; |
| this.productDefinition = productDefinition; |
| this.withdrawableBalance = withdrawableBalance; |
| } |
| } |
| } |
