Java tutorial
/** * 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 com.gst.portfolio.savings.service; import static com.gst.portfolio.savings.SavingsApiConstants.*; import java.math.BigDecimal; import java.math.MathContext; import java.util.*; import org.apache.commons.lang.StringUtils; import com.gst.accounting.journalentry.service.JournalEntryWritePlatformService; import com.gst.infrastructure.configuration.domain.ConfigurationDomainService; import com.gst.infrastructure.core.api.JsonCommand; import com.gst.infrastructure.core.data.ApiParameterError; import com.gst.infrastructure.core.data.CommandProcessingResult; import com.gst.infrastructure.core.data.CommandProcessingResultBuilder; import com.gst.infrastructure.core.data.DataValidatorBuilder; import com.gst.infrastructure.core.exception.PlatformApiDataValidationException; import com.gst.infrastructure.core.exception.PlatformServiceUnavailableException; import com.gst.infrastructure.core.service.DateUtils; import com.gst.infrastructure.dataqueries.data.EntityTables; import com.gst.infrastructure.dataqueries.data.StatusEnum; import com.gst.infrastructure.dataqueries.service.EntityDatatableChecksWritePlatformService; import com.gst.infrastructure.security.service.PlatformSecurityContext; import com.gst.organisation.holiday.domain.HolidayRepositoryWrapper; import com.gst.organisation.monetary.domain.*; import com.gst.organisation.office.domain.Office; import com.gst.organisation.staff.domain.Staff; import com.gst.organisation.staff.domain.StaffRepositoryWrapper; import com.gst.organisation.workingdays.domain.WorkingDaysRepositoryWrapper; import com.gst.portfolio.account.PortfolioAccountType; import com.gst.portfolio.account.domain.AccountTransferStandingInstruction; import com.gst.portfolio.account.domain.StandingInstructionRepository; import com.gst.portfolio.account.domain.StandingInstructionStatus; import com.gst.portfolio.account.service.AccountAssociationsReadPlatformService; import com.gst.portfolio.account.service.AccountTransfersReadPlatformService; import com.gst.portfolio.charge.domain.Charge; import com.gst.portfolio.charge.domain.ChargeRepositoryWrapper; import com.gst.portfolio.charge.domain.ChargeTimeType; import com.gst.portfolio.client.domain.Client; import com.gst.portfolio.client.exception.ClientNotActiveException; import com.gst.portfolio.common.BusinessEventNotificationConstants.BUSINESS_ENTITY; import com.gst.portfolio.common.BusinessEventNotificationConstants.BUSINESS_EVENTS; import com.gst.portfolio.common.service.BusinessEventNotifierService; import com.gst.portfolio.group.domain.Group; import com.gst.portfolio.group.exception.GroupNotActiveException; import com.gst.portfolio.note.domain.Note; import com.gst.portfolio.note.domain.NoteRepository; import com.gst.portfolio.paymentdetail.domain.PaymentDetail; import com.gst.portfolio.paymentdetail.service.PaymentDetailWritePlatformService; import com.gst.portfolio.savings.SavingsAccountTransactionType; import com.gst.portfolio.savings.SavingsApiConstants; import com.gst.portfolio.savings.SavingsTransactionBooleanValues; import com.gst.portfolio.savings.data.SavingsAccountChargeDataValidator; import com.gst.portfolio.savings.data.SavingsAccountDataValidator; import com.gst.portfolio.savings.data.SavingsAccountTransactionDTO; import com.gst.portfolio.savings.data.SavingsAccountTransactionDataValidator; import com.gst.portfolio.savings.domain.*; import com.gst.portfolio.savings.exception.*; import com.gst.portfolio.savings.exception.PostInterestAsOnDateException.PostInterestAsOnException_TYPE; import com.gst.useradministration.domain.AppUser; import com.gst.useradministration.domain.AppUserRepositoryWrapper; import org.joda.time.LocalDate; import org.joda.time.format.DateTimeFormat; import org.joda.time.format.DateTimeFormatter; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import org.springframework.util.CollectionUtils; @Service public class SavingsAccountWritePlatformServiceJpaRepositoryImpl implements SavingsAccountWritePlatformService { private final PlatformSecurityContext context; private final SavingsAccountDataValidator fromApiJsonDeserializer; private final SavingsAccountRepositoryWrapper savingAccountRepositoryWrapper; private final StaffRepositoryWrapper staffRepository; private final SavingsAccountTransactionRepository savingsAccountTransactionRepository; private final SavingsAccountAssembler savingAccountAssembler; private final SavingsAccountTransactionDataValidator savingsAccountTransactionDataValidator; private final SavingsAccountChargeDataValidator savingsAccountChargeDataValidator; private final PaymentDetailWritePlatformService paymentDetailWritePlatformService; private final ApplicationCurrencyRepositoryWrapper applicationCurrencyRepositoryWrapper; private final JournalEntryWritePlatformService journalEntryWritePlatformService; private final SavingsAccountDomainService savingsAccountDomainService; private final NoteRepository noteRepository; private final AccountTransfersReadPlatformService accountTransfersReadPlatformService; private final AccountAssociationsReadPlatformService accountAssociationsReadPlatformService; private final ChargeRepositoryWrapper chargeRepository; private final SavingsAccountChargeRepositoryWrapper savingsAccountChargeRepository; private final HolidayRepositoryWrapper holidayRepository; private final WorkingDaysRepositoryWrapper workingDaysRepository; private final ConfigurationDomainService configurationDomainService; private final DepositAccountOnHoldTransactionRepository depositAccountOnHoldTransactionRepository; private final EntityDatatableChecksWritePlatformService entityDatatableChecksWritePlatformService; private final AppUserRepositoryWrapper appuserRepository; private final StandingInstructionRepository standingInstructionRepository; private final BusinessEventNotifierService businessEventNotifierService; @Autowired public SavingsAccountWritePlatformServiceJpaRepositoryImpl(final PlatformSecurityContext context, final SavingsAccountRepositoryWrapper savingAccountRepositoryWrapper, final SavingsAccountTransactionRepository savingsAccountTransactionRepository, final SavingsAccountAssembler savingAccountAssembler, final SavingsAccountTransactionDataValidator savingsAccountTransactionDataValidator, final SavingsAccountChargeDataValidator savingsAccountChargeDataValidator, final PaymentDetailWritePlatformService paymentDetailWritePlatformService, final ApplicationCurrencyRepositoryWrapper applicationCurrencyRepositoryWrapper, final JournalEntryWritePlatformService journalEntryWritePlatformService, final SavingsAccountDomainService savingsAccountDomainService, final NoteRepository noteRepository, final AccountTransfersReadPlatformService accountTransfersReadPlatformService, final HolidayRepositoryWrapper holidayRepository, final WorkingDaysRepositoryWrapper workingDaysRepository, final AccountAssociationsReadPlatformService accountAssociationsReadPlatformService, final ChargeRepositoryWrapper chargeRepository, final SavingsAccountChargeRepositoryWrapper savingsAccountChargeRepository, final SavingsAccountDataValidator fromApiJsonDeserializer, final StaffRepositoryWrapper staffRepository, final ConfigurationDomainService configurationDomainService, final DepositAccountOnHoldTransactionRepository depositAccountOnHoldTransactionRepository, final EntityDatatableChecksWritePlatformService entityDatatableChecksWritePlatformService, final AppUserRepositoryWrapper appuserRepository, final StandingInstructionRepository standingInstructionRepository, final BusinessEventNotifierService businessEventNotifierService) { this.context = context; this.savingAccountRepositoryWrapper = savingAccountRepositoryWrapper; this.savingsAccountTransactionRepository = savingsAccountTransactionRepository; this.savingAccountAssembler = savingAccountAssembler; this.savingsAccountTransactionDataValidator = savingsAccountTransactionDataValidator; this.savingsAccountChargeDataValidator = savingsAccountChargeDataValidator; this.paymentDetailWritePlatformService = paymentDetailWritePlatformService; this.applicationCurrencyRepositoryWrapper = applicationCurrencyRepositoryWrapper; this.journalEntryWritePlatformService = journalEntryWritePlatformService; this.savingsAccountDomainService = savingsAccountDomainService; this.noteRepository = noteRepository; this.accountTransfersReadPlatformService = accountTransfersReadPlatformService; this.accountAssociationsReadPlatformService = accountAssociationsReadPlatformService; this.chargeRepository = chargeRepository; this.savingsAccountChargeRepository = savingsAccountChargeRepository; this.holidayRepository = holidayRepository; this.workingDaysRepository = workingDaysRepository; this.fromApiJsonDeserializer = fromApiJsonDeserializer; this.staffRepository = staffRepository; this.configurationDomainService = configurationDomainService; this.depositAccountOnHoldTransactionRepository = depositAccountOnHoldTransactionRepository; this.entityDatatableChecksWritePlatformService = entityDatatableChecksWritePlatformService; this.appuserRepository = appuserRepository; this.standingInstructionRepository = standingInstructionRepository; this.businessEventNotifierService = businessEventNotifierService; } @Transactional @Override public CommandProcessingResult activate(final Long savingsId, final JsonCommand command) { final AppUser user = this.context.authenticatedUser(); this.savingsAccountTransactionDataValidator.validateActivation(command); final SavingsAccount account = this.savingAccountAssembler.assembleFrom(savingsId); checkClientOrGroupActive(account); final Set<Long> existingTransactionIds = new HashSet<>(); final Set<Long> existingReversedTransactionIds = new HashSet<>(); updateExistingTransactionsDetails(account, existingTransactionIds, existingReversedTransactionIds); final Map<String, Object> changes = account.activate(user, command, DateUtils.getLocalDateOfTenant()); entityDatatableChecksWritePlatformService.runTheCheckForProduct(savingsId, EntityTables.SAVING.getName(), StatusEnum.ACTIVATE.getCode().longValue(), EntityTables.SAVING.getForeignKeyColumnNameOnDatatable(), account.productId()); if (!changes.isEmpty()) { final Locale locale = command.extractLocale(); final DateTimeFormatter fmt = DateTimeFormat.forPattern(command.dateFormat()).withLocale(locale); processPostActiveActions(account, fmt, existingTransactionIds, existingReversedTransactionIds); this.savingAccountRepositoryWrapper.saveAndFlush(account); } postJournalEntries(account, existingTransactionIds, existingReversedTransactionIds); this.businessEventNotifierService.notifyBusinessEventWasExecuted(BUSINESS_EVENTS.SAVINGS_ACTIVATE, constructEntityMap(BUSINESS_ENTITY.SAVING, account)); return new CommandProcessingResultBuilder() // .withEntityId(savingsId) // .withOfficeId(account.officeId()) // .withClientId(account.clientId()) // .withGroupId(account.groupId()) // .withSavingsId(savingsId) // .with(changes) // .build(); } @Override public void processPostActiveActions(final SavingsAccount account, final DateTimeFormatter fmt, final Set<Long> existingTransactionIds, final Set<Long> existingReversedTransactionIds) { AppUser user = getAppUserIfPresent(); final boolean isSavingsInterestPostingAtCurrentPeriodEnd = this.configurationDomainService .isSavingsInterestPostingAtCurrentPeriodEnd(); final Integer financialYearBeginningMonth = this.configurationDomainService .retrieveFinancialYearBeginningMonth(); Money amountForDeposit = account.activateWithBalance(); boolean isRegularTransaction = false; if (amountForDeposit.isGreaterThanZero()) { boolean isAccountTransfer = false; this.savingsAccountDomainService.handleDeposit(account, fmt, account.getActivationLocalDate(), amountForDeposit.getAmount(), null, isAccountTransfer, isRegularTransaction); updateExistingTransactionsDetails(account, existingTransactionIds, existingReversedTransactionIds); } account.processAccountUponActivation(isSavingsInterestPostingAtCurrentPeriodEnd, financialYearBeginningMonth, user); List<DepositAccountOnHoldTransaction> depositAccountOnHoldTransactions = null; if (account.getOnHoldFunds().compareTo(BigDecimal.ZERO) == 1) { depositAccountOnHoldTransactions = this.depositAccountOnHoldTransactionRepository .findBySavingsAccountAndReversedFalseOrderByCreatedDateAsc(account); } account.validateAccountBalanceDoesNotBecomeNegative(SavingsAccountTransactionType.PAY_CHARGE.name(), depositAccountOnHoldTransactions); } @Transactional @Override public CommandProcessingResult deposit(final Long savingsId, final JsonCommand command) { this.context.authenticatedUser(); this.savingsAccountTransactionDataValidator.validate(command); final SavingsAccount account = this.savingAccountAssembler.assembleFrom(savingsId); checkClientOrGroupActive(account); final Locale locale = command.extractLocale(); final DateTimeFormatter fmt = DateTimeFormat.forPattern(command.dateFormat()).withLocale(locale); final LocalDate transactionDate = command.localDateValueOfParameterNamed("transactionDate"); final BigDecimal transactionAmount = command.bigDecimalValueOfParameterNamed("transactionAmount"); final Map<String, Object> changes = new LinkedHashMap<>(); final PaymentDetail paymentDetail = this.paymentDetailWritePlatformService .createAndPersistPaymentDetail(command, changes); boolean isAccountTransfer = false; boolean isRegularTransaction = true; final SavingsAccountTransaction deposit = this.savingsAccountDomainService.handleDeposit(account, fmt, transactionDate, transactionAmount, paymentDetail, isAccountTransfer, isRegularTransaction); return new CommandProcessingResultBuilder() // .withEntityId(deposit.getId()) // .withOfficeId(account.officeId()) // .withClientId(account.clientId()) // .withGroupId(account.groupId()) // .withSavingsId(savingsId) // .with(changes) // .build(); } private Long saveTransactionToGenerateTransactionId(final SavingsAccountTransaction transaction) { this.savingsAccountTransactionRepository.saveAndFlush(transaction); return transaction.getId(); } @Transactional @Override public CommandProcessingResult withdrawal(final Long savingsId, final JsonCommand command) { this.savingsAccountTransactionDataValidator.validate(command); final LocalDate transactionDate = command.localDateValueOfParameterNamed("transactionDate"); final BigDecimal transactionAmount = command.bigDecimalValueOfParameterNamed("transactionAmount"); final Locale locale = command.extractLocale(); final DateTimeFormatter fmt = DateTimeFormat.forPattern(command.dateFormat()).withLocale(locale); final Map<String, Object> changes = new LinkedHashMap<>(); final PaymentDetail paymentDetail = this.paymentDetailWritePlatformService .createAndPersistPaymentDetail(command, changes); final SavingsAccount account = this.savingAccountAssembler.assembleFrom(savingsId); checkClientOrGroupActive(account); final boolean isAccountTransfer = false; final boolean isRegularTransaction = true; final boolean isApplyWithdrawFee = true; final boolean isInterestTransfer = false; final boolean isWithdrawBalance = false; final SavingsTransactionBooleanValues transactionBooleanValues = new SavingsTransactionBooleanValues( isAccountTransfer, isRegularTransaction, isApplyWithdrawFee, isInterestTransfer, isWithdrawBalance); final SavingsAccountTransaction withdrawal = this.savingsAccountDomainService.handleWithdrawal(account, fmt, transactionDate, transactionAmount, paymentDetail, transactionBooleanValues); return new CommandProcessingResultBuilder() // .withEntityId(withdrawal.getId()) // .withOfficeId(account.officeId()) // .withClientId(account.clientId()) // .withGroupId(account.groupId()) // .withSavingsId(savingsId) // .with(changes)// .build(); } @Transactional @Override public CommandProcessingResult applyAnnualFee(final Long savingsAccountChargeId, final Long accountId) { AppUser user = getAppUserIfPresent(); final SavingsAccountCharge savingsAccountCharge = this.savingsAccountChargeRepository .findOneWithNotFoundDetection(savingsAccountChargeId, accountId); final DateTimeFormatter fmt = DateTimeFormat.forPattern("dd MM yyyy"); this.payCharge(savingsAccountCharge, savingsAccountCharge.getDueLocalDate(), savingsAccountCharge.amount(), fmt, user); return new CommandProcessingResultBuilder() // .withEntityId(savingsAccountCharge.getId()) // .withOfficeId(savingsAccountCharge.savingsAccount().officeId()) // .withClientId(savingsAccountCharge.savingsAccount().clientId()) // .withGroupId(savingsAccountCharge.savingsAccount().groupId()) // .withSavingsId(savingsAccountCharge.savingsAccount().getId()) // .build(); } @Transactional @Override public CommandProcessingResult calculateInterest(final Long savingsId) { final boolean isSavingsInterestPostingAtCurrentPeriodEnd = this.configurationDomainService .isSavingsInterestPostingAtCurrentPeriodEnd(); final Integer financialYearBeginningMonth = this.configurationDomainService .retrieveFinancialYearBeginningMonth(); final SavingsAccount account = this.savingAccountAssembler.assembleFrom(savingsId); checkClientOrGroupActive(account); final LocalDate today = DateUtils.getLocalDateOfTenant(); final MathContext mc = new MathContext(15, MoneyHelper.getRoundingMode()); boolean isInterestTransfer = false; final LocalDate postInterestOnDate = null; account.calculateInterestUsing(mc, today, isInterestTransfer, isSavingsInterestPostingAtCurrentPeriodEnd, financialYearBeginningMonth, postInterestOnDate); this.savingAccountRepositoryWrapper.save(account); return new CommandProcessingResultBuilder() // .withEntityId(savingsId) // .withOfficeId(account.officeId()) // .withClientId(account.clientId()) // .withGroupId(account.groupId()) // .withSavingsId(savingsId) // .build(); } @Override public CommandProcessingResult postInterest(final JsonCommand command) { Long savingsId = command.getSavingsId(); final boolean postInterestAs = command.booleanPrimitiveValueOfParameterNamed("isPostInterestAsOn"); final LocalDate transactionDate = command.localDateValueOfParameterNamed("transactionDate"); final SavingsAccount account = this.savingAccountAssembler.assembleFrom(savingsId); checkClientOrGroupActive(account); if (postInterestAs == true) { if (transactionDate == null) { throw new PostInterestAsOnDateException(PostInterestAsOnException_TYPE.VALID_DATE); } if (transactionDate.isBefore(account.accountSubmittedOrActivationDate())) { throw new PostInterestAsOnDateException(PostInterestAsOnException_TYPE.ACTIVATION_DATE); } List<SavingsAccountTransaction> savingTransactions = account.getTransactions(); for (SavingsAccountTransaction savingTransaction : savingTransactions) { if (transactionDate.toDate().before(savingTransaction.getDateOf())) { throw new PostInterestAsOnDateException(PostInterestAsOnException_TYPE.LAST_TRANSACTION_DATE); } } LocalDate today = DateUtils.getLocalDateOfTenant(); if (transactionDate.isAfter(today)) { throw new PostInterestAsOnDateException(PostInterestAsOnException_TYPE.FUTURE_DATE); } } postInterest(account, postInterestAs, transactionDate); return new CommandProcessingResultBuilder() // .withEntityId(savingsId) // .withOfficeId(account.officeId()) // .withClientId(account.clientId()) // .withGroupId(account.groupId()) // .withSavingsId(savingsId) // .build(); } @Transactional @Override public void postInterest(final SavingsAccount account, final boolean postInterestAs, final LocalDate transactionDate) { final boolean isSavingsInterestPostingAtCurrentPeriodEnd = this.configurationDomainService .isSavingsInterestPostingAtCurrentPeriodEnd(); final Integer financialYearBeginningMonth = this.configurationDomainService .retrieveFinancialYearBeginningMonth(); if (account.getNominalAnnualInterestRate().compareTo(BigDecimal.ZERO) > 0 || (account.allowOverdraft() && account.getNominalAnnualInterestRateOverdraft().compareTo(BigDecimal.ZERO) > 0)) { final Set<Long> existingTransactionIds = new HashSet<>(); final Set<Long> existingReversedTransactionIds = new HashSet<>(); updateExistingTransactionsDetails(account, existingTransactionIds, existingReversedTransactionIds); final LocalDate today = DateUtils.getLocalDateOfTenant(); final MathContext mc = new MathContext(10, MoneyHelper.getRoundingMode()); boolean isInterestTransfer = false; LocalDate postInterestOnDate = null; if (postInterestAs) { postInterestOnDate = transactionDate; } account.postInterest(mc, today, isInterestTransfer, isSavingsInterestPostingAtCurrentPeriodEnd, financialYearBeginningMonth, postInterestOnDate); // for generating transaction id's List<SavingsAccountTransaction> transactions = account.getTransactions(); for (SavingsAccountTransaction accountTransaction : transactions) { if (accountTransaction.getId() == null) { this.savingsAccountTransactionRepository.save(accountTransaction); } } this.savingAccountRepositoryWrapper.saveAndFlush(account); postJournalEntries(account, existingTransactionIds, existingReversedTransactionIds); } } @Override public CommandProcessingResult undoTransaction(final Long savingsId, final Long transactionId, final boolean allowAccountTransferModification) { final boolean isSavingsInterestPostingAtCurrentPeriodEnd = this.configurationDomainService .isSavingsInterestPostingAtCurrentPeriodEnd(); final Integer financialYearBeginningMonth = this.configurationDomainService .retrieveFinancialYearBeginningMonth(); final SavingsAccount account = this.savingAccountAssembler.assembleFrom(savingsId); final Set<Long> existingTransactionIds = new HashSet<>(); final Set<Long> existingReversedTransactionIds = new HashSet<>(); updateExistingTransactionsDetails(account, existingTransactionIds, existingReversedTransactionIds); final SavingsAccountTransaction savingsAccountTransaction = this.savingsAccountTransactionRepository .findOneByIdAndSavingsAccountId(transactionId, savingsId); if (savingsAccountTransaction == null) { throw new SavingsAccountTransactionNotFoundException(savingsId, transactionId); } if (!allowAccountTransferModification && this.accountTransfersReadPlatformService .isAccountTransfer(transactionId, PortfolioAccountType.SAVINGS)) { throw new PlatformServiceUnavailableException( "error.msg.saving.account.transfer.transaction.update.not.allowed", "Savings account transaction:" + transactionId + " update not allowed as it involves in account transfer", transactionId); } if (!account.allowModify()) { throw new PlatformServiceUnavailableException("error.msg.saving.account.transaction.update.not.allowed", "Savings account transaction:" + transactionId + " update not allowed for this savings type", transactionId); } final LocalDate today = DateUtils.getLocalDateOfTenant(); final MathContext mc = new MathContext(15, MoneyHelper.getRoundingMode()); if (account.isNotActive()) { throwValidationForActiveStatus(SavingsApiConstants.undoTransactionAction); } account.undoTransaction(transactionId); // undoing transaction is withdrawal then undo withdrawal fee // transaction if any if (savingsAccountTransaction.isWithdrawal()) { final SavingsAccountTransaction nextSavingsAccountTransaction = this.savingsAccountTransactionRepository .findOneByIdAndSavingsAccountId(transactionId + 1, savingsId); if (nextSavingsAccountTransaction != null && nextSavingsAccountTransaction.isWithdrawalFeeAndNotReversed()) { account.undoTransaction(transactionId + 1); } } boolean isInterestTransfer = false; LocalDate postInterestOnDate = null; checkClientOrGroupActive(account); if (savingsAccountTransaction.isPostInterestCalculationRequired() && account.isBeforeLastPostingPeriod(savingsAccountTransaction.transactionLocalDate())) { account.postInterest(mc, today, isInterestTransfer, isSavingsInterestPostingAtCurrentPeriodEnd, financialYearBeginningMonth, postInterestOnDate); } else { account.calculateInterestUsing(mc, today, isInterestTransfer, isSavingsInterestPostingAtCurrentPeriodEnd, financialYearBeginningMonth, postInterestOnDate); } List<DepositAccountOnHoldTransaction> depositAccountOnHoldTransactions = null; if (account.getOnHoldFunds().compareTo(BigDecimal.ZERO) == 1) { depositAccountOnHoldTransactions = this.depositAccountOnHoldTransactionRepository .findBySavingsAccountAndReversedFalseOrderByCreatedDateAsc(account); } account.validateAccountBalanceDoesNotBecomeNegative(SavingsApiConstants.undoTransactionAction, depositAccountOnHoldTransactions); account.activateAccountBasedOnBalance(); this.savingAccountRepositoryWrapper.saveAndFlush(account); postJournalEntries(account, existingTransactionIds, existingReversedTransactionIds); return new CommandProcessingResultBuilder() // .withEntityId(savingsId) // .withOfficeId(account.officeId()) // .withClientId(account.clientId()) // .withGroupId(account.groupId()) // .withSavingsId(savingsId) // .build(); } @Override public CommandProcessingResult adjustSavingsTransaction(final Long savingsId, final Long transactionId, final JsonCommand command) { AppUser user = getAppUserIfPresent(); final boolean isSavingsInterestPostingAtCurrentPeriodEnd = this.configurationDomainService .isSavingsInterestPostingAtCurrentPeriodEnd(); final Integer financialYearBeginningMonth = this.configurationDomainService .retrieveFinancialYearBeginningMonth(); final SavingsAccountTransaction savingsAccountTransaction = this.savingsAccountTransactionRepository .findOneByIdAndSavingsAccountId(transactionId, savingsId); if (savingsAccountTransaction == null) { throw new SavingsAccountTransactionNotFoundException(savingsId, transactionId); } if (!(savingsAccountTransaction.isDeposit() || savingsAccountTransaction.isWithdrawal()) || savingsAccountTransaction.isReversed()) { throw new TransactionUpdateNotAllowedException(savingsId, transactionId); } if (this.accountTransfersReadPlatformService.isAccountTransfer(transactionId, PortfolioAccountType.SAVINGS)) { throw new PlatformServiceUnavailableException( "error.msg.saving.account.transfer.transaction.update.not.allowed", "Savings account transaction:" + transactionId + " update not allowed as it involves in account transfer", transactionId); } this.savingsAccountTransactionDataValidator.validate(command); final LocalDate today = DateUtils.getLocalDateOfTenant(); final SavingsAccount account = this.savingAccountAssembler.assembleFrom(savingsId); if (account.isNotActive()) { throwValidationForActiveStatus(SavingsApiConstants.adjustTransactionAction); } if (!account.allowModify()) { throw new PlatformServiceUnavailableException("error.msg.saving.account.transaction.update.not.allowed", "Savings account transaction:" + transactionId + " update not allowed for this savings type", transactionId); } final Set<Long> existingTransactionIds = new HashSet<>(); final Set<Long> existingReversedTransactionIds = new HashSet<>(); updateExistingTransactionsDetails(account, existingTransactionIds, existingReversedTransactionIds); final Locale locale = command.extractLocale(); final DateTimeFormatter fmt = DateTimeFormat.forPattern(command.dateFormat()).withLocale(locale); final LocalDate transactionDate = command .localDateValueOfParameterNamed(SavingsApiConstants.transactionDateParamName); final BigDecimal transactionAmount = command .bigDecimalValueOfParameterNamed(SavingsApiConstants.transactionAmountParamName); final Map<String, Object> changes = new LinkedHashMap<>(); final PaymentDetail paymentDetail = this.paymentDetailWritePlatformService .createAndPersistPaymentDetail(command, changes); final MathContext mc = new MathContext(10, MoneyHelper.getRoundingMode()); account.undoTransaction(transactionId); // for undo withdrawal fee final SavingsAccountTransaction nextSavingsAccountTransaction = this.savingsAccountTransactionRepository .findOneByIdAndSavingsAccountId(transactionId + 1, savingsId); if (nextSavingsAccountTransaction != null && nextSavingsAccountTransaction.isWithdrawalFeeAndNotReversed()) { account.undoTransaction(transactionId + 1); } SavingsAccountTransaction transaction = null; boolean isInterestTransfer = false; final SavingsAccountTransactionDTO transactionDTO = new SavingsAccountTransactionDTO(fmt, transactionDate, transactionAmount, paymentDetail, savingsAccountTransaction.createdDate(), user); if (savingsAccountTransaction.isDeposit()) { transaction = account.deposit(transactionDTO); } else { transaction = account.withdraw(transactionDTO, true); } final Long newtransactionId = saveTransactionToGenerateTransactionId(transaction); final LocalDate postInterestOnDate = null; if (account.isBeforeLastPostingPeriod(transactionDate) || account.isBeforeLastPostingPeriod(savingsAccountTransaction.transactionLocalDate())) { account.postInterest(mc, today, isInterestTransfer, isSavingsInterestPostingAtCurrentPeriodEnd, financialYearBeginningMonth, postInterestOnDate); } else { account.calculateInterestUsing(mc, today, isInterestTransfer, isSavingsInterestPostingAtCurrentPeriodEnd, financialYearBeginningMonth, postInterestOnDate); } List<DepositAccountOnHoldTransaction> depositAccountOnHoldTransactions = null; if (account.getOnHoldFunds().compareTo(BigDecimal.ZERO) == 1) { depositAccountOnHoldTransactions = this.depositAccountOnHoldTransactionRepository .findBySavingsAccountAndReversedFalseOrderByCreatedDateAsc(account); } account.validateAccountBalanceDoesNotBecomeNegative(SavingsApiConstants.adjustTransactionAction, depositAccountOnHoldTransactions); account.activateAccountBasedOnBalance(); this.savingAccountRepositoryWrapper.saveAndFlush(account); postJournalEntries(account, existingTransactionIds, existingReversedTransactionIds); return new CommandProcessingResultBuilder() // .withEntityId(newtransactionId) // .withOfficeId(account.officeId()) // .withClientId(account.clientId()) // .withGroupId(account.groupId()) // .withSavingsId(savingsId) // .with(changes)// .build(); } /** * */ private void throwValidationForActiveStatus(final String actionName) { final List<ApiParameterError> dataValidationErrors = new ArrayList<>(); final DataValidatorBuilder baseDataValidator = new DataValidatorBuilder(dataValidationErrors) .resource(SAVINGS_ACCOUNT_RESOURCE_NAME + actionName); baseDataValidator.reset().failWithCodeNoParameterAddedToErrorCode("account.is.not.active"); throw new PlatformApiDataValidationException(dataValidationErrors); } private void checkClientOrGroupActive(final SavingsAccount account) { final Client client = account.getClient(); if (client != null) { if (client.isNotActive()) { throw new ClientNotActiveException(client.getId()); } } final Group group = account.group(); if (group != null) { if (group.isNotActive()) { throw new GroupNotActiveException(group.getId()); } } } @Override public CommandProcessingResult close(final Long savingsId, final JsonCommand command) { final AppUser user = this.context.authenticatedUser(); this.savingsAccountTransactionDataValidator.validateClosing(command); final SavingsAccount account = this.savingAccountAssembler.assembleFrom(savingsId); final boolean isLinkedWithAnyActiveLoan = this.accountAssociationsReadPlatformService .isLinkedWithAnyActiveAccount(savingsId); if (isLinkedWithAnyActiveLoan) { final String defaultUserMessage = "Closing savings account with id:" + savingsId + " is not allowed, since it is linked with one of the active accounts"; throw new SavingsAccountClosingNotAllowedException("linked", defaultUserMessage, savingsId); } entityDatatableChecksWritePlatformService.runTheCheckForProduct(savingsId, EntityTables.SAVING.getName(), StatusEnum.CLOSE.getCode().longValue(), EntityTables.SAVING.getForeignKeyColumnNameOnDatatable(), account.productId()); final boolean isWithdrawBalance = command.booleanPrimitiveValueOfParameterNamed(withdrawBalanceParamName); final Locale locale = command.extractLocale(); final DateTimeFormatter fmt = DateTimeFormat.forPattern(command.dateFormat()).withLocale(locale); final LocalDate closedDate = command .localDateValueOfParameterNamed(SavingsApiConstants.closedOnDateParamName); final boolean isPostInterest = command .booleanPrimitiveValueOfParameterNamed(SavingsApiConstants.postInterestValidationOnClosure); // postInterest(account,closedDate,flag); if (isPostInterest) { boolean postInterestOnClosingDate = false; List<SavingsAccountTransaction> savingTransactions = account.getTransactions(); for (SavingsAccountTransaction savingTransaction : savingTransactions) { if (savingTransaction.isInterestPosting() && savingTransaction.isNotReversed() && closedDate.isEqual(savingTransaction.getTransactionLocalDate())) { postInterestOnClosingDate = true; break; } } if (postInterestOnClosingDate == false) { throw new PostInterestClosingDateException(); } } final Map<String, Object> changes = new LinkedHashMap<>(); if (isWithdrawBalance && account.getSummary().getAccountBalance(account.getCurrency()).isGreaterThanZero()) { final BigDecimal transactionAmount = account.getSummary().getAccountBalance(); final PaymentDetail paymentDetail = this.paymentDetailWritePlatformService .createAndPersistPaymentDetail(command, changes); final boolean isAccountTransfer = false; final boolean isRegularTransaction = true; final boolean isApplyWithdrawFee = false; final boolean isInterestTransfer = false; final SavingsTransactionBooleanValues transactionBooleanValues = new SavingsTransactionBooleanValues( isAccountTransfer, isRegularTransaction, isApplyWithdrawFee, isInterestTransfer, isWithdrawBalance); this.savingsAccountDomainService.handleWithdrawal(account, fmt, closedDate, transactionAmount, paymentDetail, transactionBooleanValues); } final Map<String, Object> accountChanges = account.close(user, command, DateUtils.getLocalDateOfTenant()); changes.putAll(accountChanges); if (!changes.isEmpty()) { this.savingAccountRepositoryWrapper.save(account); final String noteText = command.stringValueOfParameterNamed("note"); if (StringUtils.isNotBlank(noteText)) { final Note note = Note.savingNote(account, noteText); changes.put("note", noteText); this.noteRepository.save(note); } } // disable all standing orders linked to the savings account this.disableStandingInstructionsLinkedToClosedSavings(account); return new CommandProcessingResultBuilder() // .withEntityId(savingsId) // .withOfficeId(account.officeId()) // .withClientId(account.clientId()) // .withGroupId(account.groupId()) // .withSavingsId(savingsId) // .with(changes) // .build(); } @Override public SavingsAccountTransaction initiateSavingsTransfer(final SavingsAccount savingsAccount, final LocalDate transferDate) { AppUser user = getAppUserIfPresent(); final boolean isSavingsInterestPostingAtCurrentPeriodEnd = this.configurationDomainService .isSavingsInterestPostingAtCurrentPeriodEnd(); final Integer financialYearBeginningMonth = this.configurationDomainService .retrieveFinancialYearBeginningMonth(); this.savingAccountAssembler.setHelpers(savingsAccount); final Set<Long> existingTransactionIds = new HashSet<>(); final Set<Long> existingReversedTransactionIds = new HashSet<>(); updateExistingTransactionsDetails(savingsAccount, existingTransactionIds, existingReversedTransactionIds); final SavingsAccountTransaction newTransferTransaction = SavingsAccountTransaction .initiateTransfer(savingsAccount, savingsAccount.office(), transferDate, user); savingsAccount.addTransaction(newTransferTransaction); savingsAccount.setStatus(SavingsAccountStatusType.TRANSFER_IN_PROGRESS.getValue()); final MathContext mc = MathContext.DECIMAL64; boolean isInterestTransfer = false; LocalDate postInterestOnDate = null; savingsAccount.calculateInterestUsing(mc, transferDate, isInterestTransfer, isSavingsInterestPostingAtCurrentPeriodEnd, financialYearBeginningMonth, postInterestOnDate); this.savingsAccountTransactionRepository.save(newTransferTransaction); this.savingAccountRepositoryWrapper.saveAndFlush(savingsAccount); postJournalEntries(savingsAccount, existingTransactionIds, existingReversedTransactionIds); return newTransferTransaction; } @Override public SavingsAccountTransaction withdrawSavingsTransfer(final SavingsAccount savingsAccount, final LocalDate transferDate) { AppUser user = getAppUserIfPresent(); final boolean isSavingsInterestPostingAtCurrentPeriodEnd = this.configurationDomainService .isSavingsInterestPostingAtCurrentPeriodEnd(); final Integer financialYearBeginningMonth = this.configurationDomainService .retrieveFinancialYearBeginningMonth(); this.savingAccountAssembler.setHelpers(savingsAccount); final Set<Long> existingTransactionIds = new HashSet<>(); final Set<Long> existingReversedTransactionIds = new HashSet<>(); updateExistingTransactionsDetails(savingsAccount, existingTransactionIds, existingReversedTransactionIds); final SavingsAccountTransaction withdrawtransferTransaction = SavingsAccountTransaction .withdrawTransfer(savingsAccount, savingsAccount.office(), transferDate, user); savingsAccount.addTransaction(withdrawtransferTransaction); savingsAccount.setStatus(SavingsAccountStatusType.ACTIVE.getValue()); final MathContext mc = MathContext.DECIMAL64; boolean isInterestTransfer = false; LocalDate postInterestOnDate = null; savingsAccount.calculateInterestUsing(mc, transferDate, isInterestTransfer, isSavingsInterestPostingAtCurrentPeriodEnd, financialYearBeginningMonth, postInterestOnDate); this.savingsAccountTransactionRepository.save(withdrawtransferTransaction); this.savingAccountRepositoryWrapper.saveAndFlush(savingsAccount); postJournalEntries(savingsAccount, existingTransactionIds, existingReversedTransactionIds); return withdrawtransferTransaction; } @Override public void rejectSavingsTransfer(final SavingsAccount savingsAccount) { this.savingAccountAssembler.setHelpers(savingsAccount); savingsAccount.setStatus(SavingsAccountStatusType.TRANSFER_ON_HOLD.getValue()); this.savingAccountRepositoryWrapper.save(savingsAccount); } @Override public SavingsAccountTransaction acceptSavingsTransfer(final SavingsAccount savingsAccount, final LocalDate transferDate, final Office acceptedInOffice, final Staff fieldOfficer) { AppUser user = getAppUserIfPresent(); final boolean isSavingsInterestPostingAtCurrentPeriodEnd = this.configurationDomainService .isSavingsInterestPostingAtCurrentPeriodEnd(); final Integer financialYearBeginningMonth = this.configurationDomainService .retrieveFinancialYearBeginningMonth(); this.savingAccountAssembler.setHelpers(savingsAccount); final Set<Long> existingTransactionIds = new HashSet<>(); final Set<Long> existingReversedTransactionIds = new HashSet<>(); updateExistingTransactionsDetails(savingsAccount, existingTransactionIds, existingReversedTransactionIds); final SavingsAccountTransaction acceptTransferTransaction = SavingsAccountTransaction .approveTransfer(savingsAccount, acceptedInOffice, transferDate, user); savingsAccount.addTransaction(acceptTransferTransaction); savingsAccount.setStatus(SavingsAccountStatusType.ACTIVE.getValue()); if (fieldOfficer != null) { savingsAccount.reassignSavingsOfficer(fieldOfficer, transferDate); } boolean isInterestTransfer = false; final MathContext mc = MathContext.DECIMAL64; LocalDate postInterestOnDate = null; savingsAccount.calculateInterestUsing(mc, transferDate, isInterestTransfer, isSavingsInterestPostingAtCurrentPeriodEnd, financialYearBeginningMonth, postInterestOnDate); this.savingsAccountTransactionRepository.save(acceptTransferTransaction); this.savingAccountRepositoryWrapper.saveAndFlush(savingsAccount); postJournalEntries(savingsAccount, existingTransactionIds, existingReversedTransactionIds); return acceptTransferTransaction; } @Transactional @Override public CommandProcessingResult addSavingsAccountCharge(final JsonCommand command) { this.context.authenticatedUser(); final List<ApiParameterError> dataValidationErrors = new ArrayList<>(); final DataValidatorBuilder baseDataValidator = new DataValidatorBuilder(dataValidationErrors) .resource(SAVINGS_ACCOUNT_RESOURCE_NAME); final Long savingsAccountId = command.getSavingsId(); this.savingsAccountChargeDataValidator.validateAdd(command.json()); final SavingsAccount savingsAccount = this.savingAccountAssembler.assembleFrom(savingsAccountId); checkClientOrGroupActive(savingsAccount); final Locale locale = command.extractLocale(); final String format = command.dateFormat(); final DateTimeFormatter fmt = StringUtils.isNotBlank(format) ? DateTimeFormat.forPattern(format).withLocale(locale) : DateTimeFormat.forPattern("dd MM yyyy"); final Long chargeDefinitionId = command.longValueOfParameterNamed(chargeIdParamName); final Charge chargeDefinition = this.chargeRepository.findOneWithNotFoundDetection(chargeDefinitionId); Integer chargeTimeType = chargeDefinition.getChargeTimeType(); LocalDate dueAsOfDateParam = command.localDateValueOfParameterNamed(dueAsOfDateParamName); if ((chargeTimeType.equals(ChargeTimeType.WITHDRAWAL_FEE.getValue()) || chargeTimeType.equals(ChargeTimeType.SAVINGS_NOACTIVITY_FEE.getValue())) && dueAsOfDateParam != null) { baseDataValidator.reset().parameter(dueAsOfDateParamName).value(dueAsOfDateParam.toString(fmt)) .failWithCodeNoParameterAddedToErrorCode( "charge.due.date.is.invalid.for." + ChargeTimeType.fromInt(chargeTimeType).getCode()); } final SavingsAccountCharge savingsAccountCharge = SavingsAccountCharge.createNewFromJson(savingsAccount, chargeDefinition, command); if (savingsAccountCharge.getDueLocalDate() != null) { // transaction date should not be on a holiday or non working day if (!this.configurationDomainService.allowTransactionsOnHolidayEnabled() && this.holidayRepository .isHoliday(savingsAccount.officeId(), savingsAccountCharge.getDueLocalDate())) { baseDataValidator.reset().parameter(dueAsOfDateParamName) .value(savingsAccountCharge.getDueLocalDate().toString(fmt)) .failWithCodeNoParameterAddedToErrorCode("charge.due.date.is.on.holiday"); } if (!this.configurationDomainService.allowTransactionsOnNonWorkingDayEnabled() && !this.workingDaysRepository.isWorkingDay(savingsAccountCharge.getDueLocalDate())) { baseDataValidator.reset().parameter(dueAsOfDateParamName) .value(savingsAccountCharge.getDueLocalDate().toString(fmt)) .failWithCodeNoParameterAddedToErrorCode("charge.due.date.is.a.nonworking.day"); } } if (!dataValidationErrors.isEmpty()) { throw new PlatformApiDataValidationException(dataValidationErrors); } savingsAccount.addCharge(fmt, savingsAccountCharge, chargeDefinition); this.savingsAccountChargeRepository.save(savingsAccountCharge); this.savingAccountRepositoryWrapper.saveAndFlush(savingsAccount); return new CommandProcessingResultBuilder() // .withEntityId(savingsAccountCharge.getId()) // .withOfficeId(savingsAccount.officeId()) // .withClientId(savingsAccount.clientId()) // .withGroupId(savingsAccount.groupId()) // .withSavingsId(savingsAccountId) // .build(); } @Transactional @Override public CommandProcessingResult updateSavingsAccountCharge(final JsonCommand command) { this.context.authenticatedUser(); this.savingsAccountChargeDataValidator.validateUpdate(command.json()); final List<ApiParameterError> dataValidationErrors = new ArrayList<>(); final DataValidatorBuilder baseDataValidator = new DataValidatorBuilder(dataValidationErrors) .resource(SAVINGS_ACCOUNT_RESOURCE_NAME); final Long savingsAccountId = command.getSavingsId(); // SavingsAccount Charge entity final Long savingsChargeId = command.entityId(); final SavingsAccount savingsAccount = this.savingAccountAssembler.assembleFrom(savingsAccountId); checkClientOrGroupActive(savingsAccount); final SavingsAccountCharge savingsAccountCharge = this.savingsAccountChargeRepository .findOneWithNotFoundDetection(savingsChargeId, savingsAccountId); final Map<String, Object> changes = savingsAccountCharge.update(command); if (savingsAccountCharge.getDueLocalDate() != null) { final Locale locale = command.extractLocale(); final DateTimeFormatter fmt = DateTimeFormat.forPattern(command.dateFormat()).withLocale(locale); // transaction date should not be on a holiday or non working day if (!this.configurationDomainService.allowTransactionsOnHolidayEnabled() && this.holidayRepository .isHoliday(savingsAccount.officeId(), savingsAccountCharge.getDueLocalDate())) { baseDataValidator.reset().parameter(dueAsOfDateParamName) .value(savingsAccountCharge.getDueLocalDate().toString(fmt)) .failWithCodeNoParameterAddedToErrorCode("charge.due.date.is.on.holiday"); if (!dataValidationErrors.isEmpty()) { throw new PlatformApiDataValidationException(dataValidationErrors); } } if (!this.configurationDomainService.allowTransactionsOnNonWorkingDayEnabled() && !this.workingDaysRepository.isWorkingDay(savingsAccountCharge.getDueLocalDate())) { baseDataValidator.reset().parameter(dueAsOfDateParamName) .value(savingsAccountCharge.getDueLocalDate().toString(fmt)) .failWithCodeNoParameterAddedToErrorCode("charge.due.date.is.a.nonworking.day"); if (!dataValidationErrors.isEmpty()) { throw new PlatformApiDataValidationException(dataValidationErrors); } } } this.savingsAccountChargeRepository.saveAndFlush(savingsAccountCharge); return new CommandProcessingResultBuilder() // .withEntityId(savingsAccountCharge.getId()) // .withOfficeId(savingsAccountCharge.savingsAccount().officeId()) // .withClientId(savingsAccountCharge.savingsAccount().clientId()) // .withGroupId(savingsAccountCharge.savingsAccount().groupId()) // .withSavingsId(savingsAccountCharge.savingsAccount().getId()) // .with(changes) // .build(); } @Transactional @Override public CommandProcessingResult waiveCharge(final Long savingsAccountId, final Long savingsAccountChargeId) { AppUser user = getAppUserIfPresent(); final boolean isSavingsInterestPostingAtCurrentPeriodEnd = this.configurationDomainService .isSavingsInterestPostingAtCurrentPeriodEnd(); final Integer financialYearBeginningMonth = this.configurationDomainService .retrieveFinancialYearBeginningMonth(); final SavingsAccountCharge savingsAccountCharge = this.savingsAccountChargeRepository .findOneWithNotFoundDetection(savingsAccountChargeId, savingsAccountId); // Get Savings account from savings charge final SavingsAccount account = savingsAccountCharge.savingsAccount(); this.savingAccountAssembler.assignSavingAccountHelpers(account); final Set<Long> existingTransactionIds = new HashSet<>(); final Set<Long> existingReversedTransactionIds = new HashSet<>(); updateExistingTransactionsDetails(account, existingTransactionIds, existingReversedTransactionIds); account.waiveCharge(savingsAccountChargeId, user); boolean isInterestTransfer = false; LocalDate postInterestOnDate = null; final MathContext mc = MathContext.DECIMAL64; if (account.isBeforeLastPostingPeriod(savingsAccountCharge.getDueLocalDate())) { final LocalDate today = DateUtils.getLocalDateOfTenant(); account.postInterest(mc, today, isInterestTransfer, isSavingsInterestPostingAtCurrentPeriodEnd, financialYearBeginningMonth, postInterestOnDate); } else { final LocalDate today = DateUtils.getLocalDateOfTenant(); account.calculateInterestUsing(mc, today, isInterestTransfer, isSavingsInterestPostingAtCurrentPeriodEnd, financialYearBeginningMonth, postInterestOnDate); } List<DepositAccountOnHoldTransaction> depositAccountOnHoldTransactions = null; if (account.getOnHoldFunds().compareTo(BigDecimal.ZERO) == 1) { depositAccountOnHoldTransactions = this.depositAccountOnHoldTransactionRepository .findBySavingsAccountAndReversedFalseOrderByCreatedDateAsc(account); } account.validateAccountBalanceDoesNotBecomeNegative(SavingsApiConstants.waiveChargeTransactionAction, depositAccountOnHoldTransactions); this.savingAccountRepositoryWrapper.saveAndFlush(account); postJournalEntries(account, existingTransactionIds, existingReversedTransactionIds); return new CommandProcessingResultBuilder() // .withEntityId(savingsAccountChargeId) // .withOfficeId(account.officeId()) // .withClientId(account.clientId()) // .withGroupId(account.groupId()) // .withSavingsId(savingsAccountId) // .build(); } @Transactional @Override public CommandProcessingResult deleteSavingsAccountCharge(final Long savingsAccountId, final Long savingsAccountChargeId, @SuppressWarnings("unused") final JsonCommand command) { this.context.authenticatedUser(); final SavingsAccount savingsAccount = this.savingAccountAssembler.assembleFrom(savingsAccountId); checkClientOrGroupActive(savingsAccount); final SavingsAccountCharge savingsAccountCharge = this.savingsAccountChargeRepository .findOneWithNotFoundDetection(savingsAccountChargeId, savingsAccountId); savingsAccount.removeCharge(savingsAccountCharge); this.savingAccountRepositoryWrapper.saveAndFlush(savingsAccount); return new CommandProcessingResultBuilder() // .withEntityId(savingsAccountChargeId) // .withOfficeId(savingsAccount.officeId()) // .withClientId(savingsAccount.clientId()) // .withGroupId(savingsAccount.groupId()) // .withSavingsId(savingsAccountId) // .build(); } @Override public CommandProcessingResult payCharge(final Long savingsAccountId, final Long savingsAccountChargeId, final JsonCommand command) { AppUser user = getAppUserIfPresent(); this.savingsAccountChargeDataValidator.validatePayCharge(command.json()); final Locale locale = command.extractLocale(); final DateTimeFormatter fmt = DateTimeFormat.forPattern(command.dateFormat()).withLocale(locale); final BigDecimal amountPaid = command.bigDecimalValueOfParameterNamed(amountParamName); final LocalDate transactionDate = command.localDateValueOfParameterNamed(dueAsOfDateParamName); final SavingsAccountCharge savingsAccountCharge = this.savingsAccountChargeRepository .findOneWithNotFoundDetection(savingsAccountChargeId, savingsAccountId); final List<ApiParameterError> dataValidationErrors = new ArrayList<>(); final DataValidatorBuilder baseDataValidator = new DataValidatorBuilder(dataValidationErrors) .resource(SAVINGS_ACCOUNT_RESOURCE_NAME); // transaction date should not be on a holiday or non working day if (!this.configurationDomainService.allowTransactionsOnHolidayEnabled() && this.holidayRepository .isHoliday(savingsAccountCharge.savingsAccount().officeId(), transactionDate)) { baseDataValidator.reset().parameter(dueAsOfDateParamName).value(transactionDate.toString(fmt)) .failWithCodeNoParameterAddedToErrorCode( "transaction.not.allowed.transaction.date.is.on.holiday"); if (!dataValidationErrors.isEmpty()) { throw new PlatformApiDataValidationException(dataValidationErrors); } } if (!this.configurationDomainService.allowTransactionsOnNonWorkingDayEnabled() && !this.workingDaysRepository.isWorkingDay(transactionDate)) { baseDataValidator.reset().parameter(dueAsOfDateParamName).value(transactionDate.toString(fmt)) .failWithCodeNoParameterAddedToErrorCode( "transaction.not.allowed.transaction.date.is.a.nonworking.day"); if (!dataValidationErrors.isEmpty()) { throw new PlatformApiDataValidationException(dataValidationErrors); } } this.payCharge(savingsAccountCharge, transactionDate, amountPaid, fmt, user); return new CommandProcessingResultBuilder() // .withEntityId(savingsAccountCharge.getId()) // .withOfficeId(savingsAccountCharge.savingsAccount().officeId()) // .withClientId(savingsAccountCharge.savingsAccount().clientId()) // .withGroupId(savingsAccountCharge.savingsAccount().groupId()) // .withSavingsId(savingsAccountCharge.savingsAccount().getId()) // .build(); } @Transactional @Override public void applyChargeDue(final Long savingsAccountChargeId, final Long accountId) { // always use current date as transaction date for batch job AppUser user = null; final LocalDate transactionDate = DateUtils.getLocalDateOfTenant(); final SavingsAccountCharge savingsAccountCharge = this.savingsAccountChargeRepository .findOneWithNotFoundDetection(savingsAccountChargeId, accountId); final DateTimeFormatter fmt = DateTimeFormat.forPattern("dd MM yyyy"); fmt.withZone(DateUtils.getDateTimeZoneOfTenant()); while (transactionDate.isAfter(savingsAccountCharge.getDueLocalDate()) && savingsAccountCharge.isNotFullyPaid()) { payCharge(savingsAccountCharge, transactionDate, savingsAccountCharge.amoutOutstanding(), fmt, user); } } @Transactional private void payCharge(final SavingsAccountCharge savingsAccountCharge, final LocalDate transactionDate, final BigDecimal amountPaid, final DateTimeFormatter formatter, final AppUser user) { final boolean isSavingsInterestPostingAtCurrentPeriodEnd = this.configurationDomainService .isSavingsInterestPostingAtCurrentPeriodEnd(); final Integer financialYearBeginningMonth = this.configurationDomainService .retrieveFinancialYearBeginningMonth(); // Get Savings account from savings charge final SavingsAccount account = savingsAccountCharge.savingsAccount(); this.savingAccountAssembler.assignSavingAccountHelpers(account); final Set<Long> existingTransactionIds = new HashSet<>(); final Set<Long> existingReversedTransactionIds = new HashSet<>(); updateExistingTransactionsDetails(account, existingTransactionIds, existingReversedTransactionIds); account.payCharge(savingsAccountCharge, amountPaid, transactionDate, formatter, user); boolean isInterestTransfer = false; LocalDate postInterestOnDate = null; final MathContext mc = MathContext.DECIMAL64; if (account.isBeforeLastPostingPeriod(transactionDate)) { final LocalDate today = DateUtils.getLocalDateOfTenant(); account.postInterest(mc, today, isInterestTransfer, isSavingsInterestPostingAtCurrentPeriodEnd, financialYearBeginningMonth, postInterestOnDate); } else { final LocalDate today = DateUtils.getLocalDateOfTenant(); account.calculateInterestUsing(mc, today, isInterestTransfer, isSavingsInterestPostingAtCurrentPeriodEnd, financialYearBeginningMonth, postInterestOnDate); } List<DepositAccountOnHoldTransaction> depositAccountOnHoldTransactions = null; if (account.getOnHoldFunds().compareTo(BigDecimal.ZERO) == 1) { depositAccountOnHoldTransactions = this.depositAccountOnHoldTransactionRepository .findBySavingsAccountAndReversedFalseOrderByCreatedDateAsc(account); } account.validateAccountBalanceDoesNotBecomeNegative( "." + SavingsAccountTransactionType.PAY_CHARGE.getCode(), depositAccountOnHoldTransactions); this.savingAccountRepositoryWrapper.saveAndFlush(account); postJournalEntries(account, existingTransactionIds, existingReversedTransactionIds); } private void updateExistingTransactionsDetails(SavingsAccount account, Set<Long> existingTransactionIds, Set<Long> existingReversedTransactionIds) { existingTransactionIds.addAll(account.findExistingTransactionIds()); existingReversedTransactionIds.addAll(account.findExistingReversedTransactionIds()); } private void postJournalEntries(final SavingsAccount savingsAccount, final Set<Long> existingTransactionIds, final Set<Long> existingReversedTransactionIds) { final MonetaryCurrency currency = savingsAccount.getCurrency(); final ApplicationCurrency applicationCurrency = this.applicationCurrencyRepositoryWrapper .findOneWithNotFoundDetection(currency); boolean isAccountTransfer = false; final Map<String, Object> accountingBridgeData = savingsAccount.deriveAccountingBridgeData( applicationCurrency.toData(), existingTransactionIds, existingReversedTransactionIds, isAccountTransfer); this.journalEntryWritePlatformService.createJournalEntriesForSavings(accountingBridgeData); } @Override public CommandProcessingResult inactivateCharge(final Long savingsAccountId, final Long savingsAccountChargeId) { this.context.authenticatedUser(); final SavingsAccountCharge savingsAccountCharge = this.savingsAccountChargeRepository .findOneWithNotFoundDetection(savingsAccountChargeId, savingsAccountId); final SavingsAccount account = savingsAccountCharge.savingsAccount(); this.savingAccountAssembler.assignSavingAccountHelpers(account); final LocalDate inactivationOnDate = DateUtils.getLocalDateOfTenant(); final List<ApiParameterError> dataValidationErrors = new ArrayList<>(); final DataValidatorBuilder baseDataValidator = new DataValidatorBuilder(dataValidationErrors) .resource(SAVINGS_ACCOUNT_CHARGE_RESOURCE_NAME); /*** * Only recurring fees are allowed to inactivate */ if (!savingsAccountCharge.isRecurringFee()) { baseDataValidator.reset().parameter(null).value(savingsAccountCharge.getId()) .failWithCodeNoParameterAddedToErrorCode( "charge.inactivation.allowed.only.for.recurring.charges"); if (!dataValidationErrors.isEmpty()) { throw new PlatformApiDataValidationException(dataValidationErrors); } } else { final LocalDate nextDueDate = savingsAccountCharge.getNextDueDateFrom(inactivationOnDate); if (savingsAccountCharge.isChargeIsDue(nextDueDate)) { baseDataValidator.reset().failWithCodeNoParameterAddedToErrorCode( "inactivation.of.charge.not.allowed.when.charge.is.due"); if (!dataValidationErrors.isEmpty()) { throw new PlatformApiDataValidationException(dataValidationErrors); } } else if (savingsAccountCharge.isChargeIsOverPaid(nextDueDate)) { final List<SavingsAccountTransaction> chargePayments = new ArrayList<>(); SavingsAccountCharge updatedCharge = savingsAccountCharge; do { chargePayments.clear(); for (SavingsAccountTransaction transaction : account.getTransactions()) { if (transaction.isPayCharge() && transaction.isNotReversed() && transaction.isPaymentForCurrentCharge(savingsAccountCharge)) { chargePayments.add(transaction); } } /*** * Reverse the excess payments of charge transactions */ SavingsAccountTransaction lastChargePayment = getLastChargePayment(chargePayments); this.undoTransaction(savingsAccountCharge.savingsAccount().getId(), lastChargePayment.getId(), false); updatedCharge = account.getUpdatedChargeDetails(savingsAccountCharge); } while (updatedCharge.isChargeIsOverPaid(nextDueDate)); } account.inactivateCharge(savingsAccountCharge, inactivationOnDate); } return new CommandProcessingResultBuilder() // .withEntityId(savingsAccountCharge.getId()) // .withOfficeId(savingsAccountCharge.savingsAccount().officeId()) // .withClientId(savingsAccountCharge.savingsAccount().clientId()) // .withGroupId(savingsAccountCharge.savingsAccount().groupId()) // .withSavingsId(savingsAccountCharge.savingsAccount().getId()) // .build(); } private SavingsAccountTransaction getLastChargePayment(final List<SavingsAccountTransaction> chargePayments) { if (!CollectionUtils.isEmpty(chargePayments)) { return chargePayments.get(chargePayments.size() - 1); } return null; } @Transactional @Override public CommandProcessingResult assignFieldOfficer(Long savingsAccountId, JsonCommand command) { this.context.authenticatedUser(); final Map<String, Object> actualChanges = new LinkedHashMap<>(5); Staff fromSavingsOfficer = null; Staff toSavingsOfficer = null; this.fromApiJsonDeserializer.validateForAssignSavingsOfficer(command.json()); final SavingsAccount savingsForUpdate = this.savingAccountRepositoryWrapper .findOneWithNotFoundDetection(savingsAccountId); final Long fromSavingsOfficerId = command.longValueOfParameterNamed("fromSavingsOfficerId"); final Long toSavingsOfficerId = command.longValueOfParameterNamed("toSavingsOfficerId"); final LocalDate dateOfSavingsOfficerAssignment = command.localDateValueOfParameterNamed("assignmentDate"); if (fromSavingsOfficerId != null) { fromSavingsOfficer = this.staffRepository.findByOfficeHierarchyWithNotFoundDetection( fromSavingsOfficerId, savingsForUpdate.office().getHierarchy()); } if (toSavingsOfficerId != null) { toSavingsOfficer = this.staffRepository.findByOfficeHierarchyWithNotFoundDetection(toSavingsOfficerId, savingsForUpdate.office().getHierarchy()); actualChanges.put("toSavingsOfficerId", toSavingsOfficer.getId()); } if (!savingsForUpdate.hasSavingsOfficer(fromSavingsOfficer)) { throw new SavingsOfficerAssignmentException(savingsAccountId, fromSavingsOfficerId); } savingsForUpdate.reassignSavingsOfficer(toSavingsOfficer, dateOfSavingsOfficerAssignment); this.savingAccountRepositoryWrapper.saveAndFlush(savingsForUpdate); return new CommandProcessingResultBuilder() // .withCommandId(command.commandId()) // .withOfficeId(savingsForUpdate.officeId()) // .withEntityId(savingsForUpdate.getId()) // .withSavingsId(savingsAccountId) // .with(actualChanges) // .build(); } @Transactional @Override public CommandProcessingResult unassignFieldOfficer(Long savingsAccountId, JsonCommand command) { this.context.authenticatedUser(); final Map<String, Object> actualChanges = new LinkedHashMap<>(5); this.fromApiJsonDeserializer.validateForUnAssignSavingsOfficer(command.json()); final SavingsAccount savingsForUpdate = this.savingAccountRepositoryWrapper .findOneWithNotFoundDetection(savingsAccountId); if (savingsForUpdate.getSavingsOfficer() == null) { throw new SavingsOfficerUnassignmentException(savingsAccountId); } final LocalDate dateOfSavingsOfficerUnassigned = command.localDateValueOfParameterNamed("unassignedDate"); savingsForUpdate.removeSavingsOfficer(dateOfSavingsOfficerUnassigned); this.savingAccountRepositoryWrapper.saveAndFlush(savingsForUpdate); actualChanges.put("toSavingsOfficerId", null); return new CommandProcessingResultBuilder() // .withCommandId(command.commandId()) // .withOfficeId(savingsForUpdate.officeId()) // .withEntityId(savingsForUpdate.getId()) // .withSavingsId(savingsAccountId) // .with(actualChanges) // .build(); } @Override public CommandProcessingResult modifyWithHoldTax(Long savingsAccountId, JsonCommand command) { final Map<String, Object> actualChanges = new HashMap<>(1); final SavingsAccount savingsForUpdate = this.savingAccountRepositoryWrapper .findOneWithNotFoundDetection(savingsAccountId); if (command.isChangeInBooleanParameterNamed(withHoldTaxParamName, savingsForUpdate.withHoldTax())) { final boolean newValue = command.booleanPrimitiveValueOfParameterNamed(withHoldTaxParamName); actualChanges.put(withHoldTaxParamName, newValue); savingsForUpdate.setWithHoldTax(newValue); if (savingsForUpdate.getTaxGroup() == null) { final List<ApiParameterError> dataValidationErrors = new ArrayList<>(); final DataValidatorBuilder baseDataValidator = new DataValidatorBuilder(dataValidationErrors) .resource("account"); baseDataValidator.reset().parameter(withHoldTaxParamName).failWithCode("not.supported"); throw new PlatformApiDataValidationException(dataValidationErrors); } } return new CommandProcessingResultBuilder() // .withCommandId(command.commandId()) // .withEntityId(savingsAccountId) // .withSavingsId(savingsAccountId) // .with(actualChanges) // .build(); } @Override @Transactional public void setSubStatusInactive(Long savingsId) { final SavingsAccount account = this.savingAccountAssembler.assembleFrom(savingsId); final Set<Long> existingTransactionIds = new HashSet<>(); final Set<Long> existingReversedTransactionIds = new HashSet<>(); updateExistingTransactionsDetails(account, existingTransactionIds, existingReversedTransactionIds); account.setSubStatusInactive(appuserRepository.fetchSystemUser()); this.savingAccountRepositoryWrapper.saveAndFlush(account); postJournalEntries(account, existingTransactionIds, existingReversedTransactionIds); } @Override @Transactional public void setSubStatusDormant(Long savingsId) { final SavingsAccount account = this.savingAccountAssembler.assembleFrom(savingsId); account.setSubStatusDormant(); this.savingAccountRepositoryWrapper.save(account); } @Override @Transactional public void escheat(Long savingsId) { final SavingsAccount account = this.savingAccountAssembler.assembleFrom(savingsId); final Set<Long> existingTransactionIds = new HashSet<>(); final Set<Long> existingReversedTransactionIds = new HashSet<>(); updateExistingTransactionsDetails(account, existingTransactionIds, existingReversedTransactionIds); account.escheat(appuserRepository.fetchSystemUser()); this.savingAccountRepositoryWrapper.saveAndFlush(account); postJournalEntries(account, existingTransactionIds, existingReversedTransactionIds); } private AppUser getAppUserIfPresent() { AppUser user = null; if (this.context != null) { user = this.context.getAuthenticatedUserIfPresent(); } return user; } /** * Disable all standing instructions linked to the savings account if the status is "closed" * * @param savingsAccount -- the savings account object * @return None **/ @Transactional private void disableStandingInstructionsLinkedToClosedSavings(final SavingsAccount savingsAccount) { if (savingsAccount != null && savingsAccount.isClosed()) { final Integer standingInstructionStatus = StandingInstructionStatus.ACTIVE.getValue(); final Collection<AccountTransferStandingInstruction> accountTransferStandingInstructions = this.standingInstructionRepository .findBySavingsAccountAndStatus(savingsAccount, standingInstructionStatus); if (!accountTransferStandingInstructions.isEmpty()) { for (AccountTransferStandingInstruction accountTransferStandingInstruction : accountTransferStandingInstructions) { accountTransferStandingInstruction.updateStatus(StandingInstructionStatus.DISABLED.getValue()); this.standingInstructionRepository.save(accountTransferStandingInstruction); } } } } private Map<BUSINESS_ENTITY, Object> constructEntityMap(final BUSINESS_ENTITY entityEvent, Object entity) { Map<BUSINESS_ENTITY, Object> map = new HashMap<>(1); map.put(entityEvent, entity); return map; } }