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.loanaccount.service; import java.math.BigDecimal; import java.util.*; import org.apache.commons.lang.StringUtils; import com.gst.accounting.journalentry.service.JournalEntryWritePlatformService; import com.gst.infrastructure.codes.domain.CodeValue; import com.gst.infrastructure.codes.domain.CodeValueRepositoryWrapper; 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.GeneralPlatformDomainRuleException; import com.gst.infrastructure.core.exception.PlatformApiDataValidationException; import com.gst.infrastructure.core.exception.PlatformServiceUnavailableException; import com.gst.infrastructure.core.serialization.FromJsonHelper; 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.jobs.annotation.CronTarget; import com.gst.infrastructure.jobs.exception.JobExecutionException; import com.gst.infrastructure.jobs.service.JobName; import com.gst.infrastructure.security.service.PlatformSecurityContext; import com.gst.organisation.holiday.domain.Holiday; import com.gst.organisation.holiday.domain.HolidayRepositoryWrapper; import com.gst.organisation.monetary.domain.ApplicationCurrency; import com.gst.organisation.monetary.domain.ApplicationCurrencyRepositoryWrapper; import com.gst.organisation.monetary.domain.MonetaryCurrency; import com.gst.organisation.monetary.domain.Money; import com.gst.organisation.office.domain.Office; import com.gst.organisation.staff.domain.Staff; import com.gst.organisation.workingdays.domain.WorkingDays; import com.gst.organisation.workingdays.domain.WorkingDaysRepositoryWrapper; import com.gst.portfolio.account.PortfolioAccountType; import com.gst.portfolio.account.data.AccountTransferDTO; import com.gst.portfolio.account.data.PortfolioAccountData; import com.gst.portfolio.account.domain.*; import com.gst.portfolio.account.service.AccountAssociationsReadPlatformService; import com.gst.portfolio.account.service.AccountTransfersReadPlatformService; import com.gst.portfolio.account.service.AccountTransfersWritePlatformService; import com.gst.portfolio.accountdetails.domain.AccountType; import com.gst.portfolio.calendar.domain.*; import com.gst.portfolio.calendar.domain.Calendar; import com.gst.portfolio.calendar.exception.CalendarParameterUpdateNotSupportedException; import com.gst.portfolio.charge.domain.Charge; import com.gst.portfolio.charge.domain.ChargePaymentMode; import com.gst.portfolio.charge.domain.ChargeRepositoryWrapper; import com.gst.portfolio.charge.exception.*; import com.gst.portfolio.charge.exception.LoanChargeCannotBeDeletedException.LOAN_CHARGE_CANNOT_BE_DELETED_REASON; import com.gst.portfolio.charge.exception.LoanChargeCannotBePayedException.LOAN_CHARGE_CANNOT_BE_PAYED_REASON; import com.gst.portfolio.charge.exception.LoanChargeCannotBeUpdatedException.LOAN_CHARGE_CANNOT_BE_UPDATED_REASON; import com.gst.portfolio.charge.exception.LoanChargeCannotBeWaivedException.LOAN_CHARGE_CANNOT_BE_WAIVED_REASON; import com.gst.portfolio.client.domain.Client; import com.gst.portfolio.client.exception.ClientNotActiveException; import com.gst.portfolio.collectionsheet.command.CollectionSheetBulkDisbursalCommand; import com.gst.portfolio.collectionsheet.command.CollectionSheetBulkRepaymentCommand; import com.gst.portfolio.collectionsheet.command.SingleDisbursalCommand; import com.gst.portfolio.collectionsheet.command.SingleRepaymentCommand; import com.gst.portfolio.common.BusinessEventNotificationConstants.BUSINESS_ENTITY; import com.gst.portfolio.common.BusinessEventNotificationConstants.BUSINESS_EVENTS; import com.gst.portfolio.common.domain.PeriodFrequencyType; 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.loanaccount.api.LoanApiConstants; import com.gst.portfolio.loanaccount.command.LoanUpdateCommand; import com.gst.portfolio.loanaccount.data.*; import com.gst.portfolio.loanaccount.domain.*; import com.gst.portfolio.loanaccount.exception.*; import com.gst.portfolio.loanaccount.guarantor.service.GuarantorDomainService; import com.gst.portfolio.loanaccount.loanschedule.data.OverdueLoanScheduleData; import com.gst.portfolio.loanaccount.loanschedule.domain.DefaultScheduledDateGenerator; import com.gst.portfolio.loanaccount.loanschedule.domain.LoanScheduleModel; import com.gst.portfolio.loanaccount.loanschedule.domain.LoanScheduleModelPeriod; import com.gst.portfolio.loanaccount.loanschedule.domain.ScheduledDateGenerator; import com.gst.portfolio.loanaccount.loanschedule.service.LoanScheduleHistoryWritePlatformService; import com.gst.portfolio.loanaccount.rescheduleloan.domain.LoanRescheduleRequest; import com.gst.portfolio.loanaccount.serialization.LoanApplicationCommandFromApiJsonHelper; import com.gst.portfolio.loanaccount.serialization.LoanEventApiJsonValidator; import com.gst.portfolio.loanaccount.serialization.LoanUpdateCommandFromApiJsonDeserializer; import com.gst.portfolio.loanproduct.data.LoanOverdueDTO; import com.gst.portfolio.loanproduct.data.LoanProductData; import com.gst.portfolio.loanproduct.domain.LoanProduct; import com.gst.portfolio.loanproduct.exception.InvalidCurrencyException; import com.gst.portfolio.loanproduct.exception.LinkedAccountRequiredException; import com.gst.portfolio.loanproduct.service.LoanProductReadPlatformService; 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.domain.SavingsAccount; import com.gst.portfolio.savings.exception.InsufficientAccountBalanceException; import com.gst.useradministration.domain.AppUser; import org.joda.time.LocalDate; import org.joda.time.format.DateTimeFormat; import org.joda.time.format.DateTimeFormatter; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.dao.DataIntegrityViolationException; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import org.springframework.util.CollectionUtils; import com.google.gson.JsonArray; import com.google.gson.JsonElement; @Service public class LoanWritePlatformServiceJpaRepositoryImpl implements LoanWritePlatformService { private final static Logger logger = LoggerFactory.getLogger(LoanWritePlatformServiceJpaRepositoryImpl.class); private final PlatformSecurityContext context; private final LoanEventApiJsonValidator loanEventApiJsonValidator; private final LoanUpdateCommandFromApiJsonDeserializer loanUpdateCommandFromApiJsonDeserializer; private final LoanRepositoryWrapper loanRepositoryWrapper; private final LoanAccountDomainService loanAccountDomainService; private final NoteRepository noteRepository; private final LoanTransactionRepository loanTransactionRepository; private final LoanAssembler loanAssembler; private final ChargeRepositoryWrapper chargeRepository; private final LoanChargeRepository loanChargeRepository; private final ApplicationCurrencyRepositoryWrapper applicationCurrencyRepository; private final JournalEntryWritePlatformService journalEntryWritePlatformService; private final CalendarInstanceRepository calendarInstanceRepository; private final PaymentDetailWritePlatformService paymentDetailWritePlatformService; private final HolidayRepositoryWrapper holidayRepository; private final ConfigurationDomainService configurationDomainService; private final WorkingDaysRepositoryWrapper workingDaysRepository; private final LoanProductReadPlatformService loanProductReadPlatformService; private final AccountTransfersWritePlatformService accountTransfersWritePlatformService; private final AccountTransfersReadPlatformService accountTransfersReadPlatformService; private final AccountAssociationsReadPlatformService accountAssociationsReadPlatformService; private final LoanChargeReadPlatformService loanChargeReadPlatformService; private final LoanReadPlatformService loanReadPlatformService; private final FromJsonHelper fromApiJsonHelper; private final AccountTransferRepository accountTransferRepository; private final CalendarRepository calendarRepository; private final LoanRepaymentScheduleInstallmentRepository repaymentScheduleInstallmentRepository; private final LoanScheduleHistoryWritePlatformService loanScheduleHistoryWritePlatformService; private final LoanApplicationCommandFromApiJsonHelper loanApplicationCommandFromApiJsonHelper; private final AccountAssociationsRepository accountAssociationRepository; private final AccountTransferDetailRepository accountTransferDetailRepository; private final BusinessEventNotifierService businessEventNotifierService; private final GuarantorDomainService guarantorDomainService; private final LoanUtilService loanUtilService; private final LoanSummaryWrapper loanSummaryWrapper; private final EntityDatatableChecksWritePlatformService entityDatatableChecksWritePlatformService; private final LoanRepaymentScheduleTransactionProcessorFactory transactionProcessingStrategy; private final CodeValueRepositoryWrapper codeValueRepository; @Autowired public LoanWritePlatformServiceJpaRepositoryImpl(final PlatformSecurityContext context, final LoanEventApiJsonValidator loanEventApiJsonValidator, final LoanUpdateCommandFromApiJsonDeserializer loanUpdateCommandFromApiJsonDeserializer, final LoanAssembler loanAssembler, final LoanAccountDomainService loanAccountDomainService, final LoanTransactionRepository loanTransactionRepository, final NoteRepository noteRepository, final ChargeRepositoryWrapper chargeRepository, final LoanChargeRepository loanChargeRepository, final ApplicationCurrencyRepositoryWrapper applicationCurrencyRepository, final JournalEntryWritePlatformService journalEntryWritePlatformService, final CalendarInstanceRepository calendarInstanceRepository, final PaymentDetailWritePlatformService paymentDetailWritePlatformService, final HolidayRepositoryWrapper holidayRepository, final ConfigurationDomainService configurationDomainService, final WorkingDaysRepositoryWrapper workingDaysRepository, final LoanProductReadPlatformService loanProductReadPlatformService, final AccountTransfersWritePlatformService accountTransfersWritePlatformService, final AccountTransfersReadPlatformService accountTransfersReadPlatformService, final AccountAssociationsReadPlatformService accountAssociationsReadPlatformService, final LoanChargeReadPlatformService loanChargeReadPlatformService, final LoanReadPlatformService loanReadPlatformService, final FromJsonHelper fromApiJsonHelper, final AccountTransferRepository accountTransferRepository, final CalendarRepository calendarRepository, final LoanRepaymentScheduleInstallmentRepository repaymentScheduleInstallmentRepository, final LoanScheduleHistoryWritePlatformService loanScheduleHistoryWritePlatformService, final LoanApplicationCommandFromApiJsonHelper loanApplicationCommandFromApiJsonHelper, final AccountAssociationsRepository accountAssociationRepository, final AccountTransferDetailRepository accountTransferDetailRepository, final BusinessEventNotifierService businessEventNotifierService, final GuarantorDomainService guarantorDomainService, final LoanUtilService loanUtilService, final LoanSummaryWrapper loanSummaryWrapper, final EntityDatatableChecksWritePlatformService entityDatatableChecksWritePlatformService, final LoanRepaymentScheduleTransactionProcessorFactory transactionProcessingStrategy, final CodeValueRepositoryWrapper codeValueRepository, final LoanRepositoryWrapper loanRepositoryWrapper) { this.context = context; this.loanEventApiJsonValidator = loanEventApiJsonValidator; this.loanAssembler = loanAssembler; this.loanRepositoryWrapper = loanRepositoryWrapper; this.loanAccountDomainService = loanAccountDomainService; this.loanTransactionRepository = loanTransactionRepository; this.noteRepository = noteRepository; this.chargeRepository = chargeRepository; this.loanChargeRepository = loanChargeRepository; this.applicationCurrencyRepository = applicationCurrencyRepository; this.journalEntryWritePlatformService = journalEntryWritePlatformService; this.loanUpdateCommandFromApiJsonDeserializer = loanUpdateCommandFromApiJsonDeserializer; this.calendarInstanceRepository = calendarInstanceRepository; this.paymentDetailWritePlatformService = paymentDetailWritePlatformService; this.holidayRepository = holidayRepository; this.configurationDomainService = configurationDomainService; this.workingDaysRepository = workingDaysRepository; this.loanProductReadPlatformService = loanProductReadPlatformService; this.accountTransfersWritePlatformService = accountTransfersWritePlatformService; this.accountTransfersReadPlatformService = accountTransfersReadPlatformService; this.accountAssociationsReadPlatformService = accountAssociationsReadPlatformService; this.loanChargeReadPlatformService = loanChargeReadPlatformService; this.loanReadPlatformService = loanReadPlatformService; this.fromApiJsonHelper = fromApiJsonHelper; this.accountTransferRepository = accountTransferRepository; this.calendarRepository = calendarRepository; this.repaymentScheduleInstallmentRepository = repaymentScheduleInstallmentRepository; this.loanScheduleHistoryWritePlatformService = loanScheduleHistoryWritePlatformService; this.loanApplicationCommandFromApiJsonHelper = loanApplicationCommandFromApiJsonHelper; this.accountAssociationRepository = accountAssociationRepository; this.accountTransferDetailRepository = accountTransferDetailRepository; this.businessEventNotifierService = businessEventNotifierService; this.guarantorDomainService = guarantorDomainService; this.loanUtilService = loanUtilService; this.loanSummaryWrapper = loanSummaryWrapper; this.transactionProcessingStrategy = transactionProcessingStrategy; this.entityDatatableChecksWritePlatformService = entityDatatableChecksWritePlatformService; this.codeValueRepository = codeValueRepository; } private LoanLifecycleStateMachine defaultLoanLifecycleStateMachine() { final List<LoanStatus> allowedLoanStatuses = Arrays.asList(LoanStatus.values()); return new DefaultLoanLifecycleStateMachine(allowedLoanStatuses); } @Transactional @Override public CommandProcessingResult disburseLoan(final Long loanId, final JsonCommand command, Boolean isAccountTransfer) { final AppUser currentUser = getAppUserIfPresent(); this.loanEventApiJsonValidator.validateDisbursement(command.json(), isAccountTransfer); final Loan loan = this.loanAssembler.assembleFrom(loanId); final LocalDate actualDisbursementDate = command.localDateValueOfParameterNamed("actualDisbursementDate"); // validate ActualDisbursement Date Against Expected Disbursement Date LoanProduct loanProduct = loan.loanProduct(); if (loanProduct.syncExpectedWithDisbursementDate()) { syncExpectedDateWithActualDisbursementDate(loan, actualDisbursementDate); } checkClientOrGroupActive(loan); final LocalDate nextPossibleRepaymentDate = loan.getNextPossibleRepaymentDateForRescheduling(); final Date rescheduledRepaymentDate = command.DateValueOfParameterNamed("adjustRepaymentDate"); entityDatatableChecksWritePlatformService.runTheCheckForProduct(loanId, EntityTables.LOAN.getName(), StatusEnum.DISBURSE.getCode().longValue(), EntityTables.LOAN.getForeignKeyColumnNameOnDatatable(), loan.productId()); // check for product mix validations checkForProductMixRestrictions(loan); LocalDate recalculateFrom = null; ScheduleGeneratorDTO scheduleGeneratorDTO = this.loanUtilService.buildScheduleGeneratorDTO(loan, recalculateFrom); // validate actual disbursement date against meeting date final CalendarInstance calendarInstance = this.calendarInstanceRepository .findCalendarInstaneByEntityId(loan.getId(), CalendarEntityType.LOANS.getValue()); if (loan.isSyncDisbursementWithMeeting()) { this.loanEventApiJsonValidator.validateDisbursementDateWithMeetingDate(actualDisbursementDate, calendarInstance, scheduleGeneratorDTO.isSkipRepaymentOnFirstDayofMonth(), scheduleGeneratorDTO.getNumberOfdays()); } this.businessEventNotifierService.notifyBusinessEventToBeExecuted(BUSINESS_EVENTS.LOAN_DISBURSAL, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); final List<Long> existingTransactionIds = new ArrayList<>(); final List<Long> existingReversedTransactionIds = new ArrayList<>(); final Map<String, Object> changes = new LinkedHashMap<>(); final PaymentDetail paymentDetail = this.paymentDetailWritePlatformService .createAndPersistPaymentDetail(command, changes); final Boolean isPaymnetypeApplicableforDisbursementCharge = configurationDomainService .isPaymnetypeApplicableforDisbursementCharge(); // Recalculate first repayment date based in actual disbursement date. updateLoanCounters(loan, actualDisbursementDate); Money amountBeforeAdjust = loan.getPrincpal(); loan.validateAccountStatus(LoanEvent.LOAN_DISBURSED); boolean canDisburse = loan.canDisburse(actualDisbursementDate); ChangedTransactionDetail changedTransactionDetail = null; if (canDisburse) { Money disburseAmount = loan.adjustDisburseAmount(command, actualDisbursementDate); Money amountToDisburse = disburseAmount.copy(); boolean recalculateSchedule = amountBeforeAdjust.isNotEqualTo(loan.getPrincpal()); final String txnExternalId = command.stringValueOfParameterNamedAllowingNull("externalId"); if (loan.isTopup() && loan.getClientId() != null) { final Long loanIdToClose = loan.getTopupLoanDetails().getLoanIdToClose(); final Loan loanToClose = this.loanRepositoryWrapper .findNonClosedLoanThatBelongsToClient(loanIdToClose, loan.getClientId()); if (loanToClose == null) { throw new GeneralPlatformDomainRuleException( "error.msg.loan.to.be.closed.with.topup.is.not.active", "Loan to be closed with this topup is not active."); } final LocalDate lastUserTransactionOnLoanToClose = loanToClose.getLastUserTransactionDate(); if (!loan.getDisbursementDate().isAfter(lastUserTransactionOnLoanToClose)) { throw new GeneralPlatformDomainRuleException( "error.msg.loan.disbursal.date.should.be.after.last.transaction.date.of.loan.to.be.closed", "Disbursal date of this loan application " + loan.getDisbursementDate() + " should be after last transaction date of loan to be closed " + lastUserTransactionOnLoanToClose); } BigDecimal loanOutstanding = this.loanReadPlatformService .retrieveLoanPrePaymentTemplate(loanIdToClose, actualDisbursementDate).getAmount(); final BigDecimal firstDisbursalAmount = loan.getFirstDisbursalAmount(); if (loanOutstanding.compareTo(firstDisbursalAmount) > 0) { throw new GeneralPlatformDomainRuleException( "error.msg.loan.amount.less.than.outstanding.of.loan.to.be.closed", "Topup loan amount should be greater than outstanding amount of loan to be closed."); } amountToDisburse = disburseAmount.minus(loanOutstanding); disburseLoanToLoan(loan, command, loanOutstanding); } if (isAccountTransfer) { disburseLoanToSavings(loan, command, amountToDisburse, paymentDetail); existingTransactionIds.addAll(loan.findExistingTransactionIds()); existingReversedTransactionIds.addAll(loan.findExistingReversedTransactionIds()); } else { existingTransactionIds.addAll(loan.findExistingTransactionIds()); existingReversedTransactionIds.addAll(loan.findExistingReversedTransactionIds()); LoanTransaction disbursementTransaction = LoanTransaction.disbursement(loan.getOffice(), amountToDisburse, paymentDetail, actualDisbursementDate, txnExternalId, DateUtils.getLocalDateTimeOfTenant(), currentUser); disbursementTransaction.updateLoan(loan); loan.addLoanTransaction(disbursementTransaction); } regenerateScheduleOnDisbursement(command, loan, recalculateSchedule, scheduleGeneratorDTO, nextPossibleRepaymentDate, rescheduledRepaymentDate); if (loan.repaymentScheduleDetail().isInterestRecalculationEnabled()) { createAndSaveLoanScheduleArchive(loan, scheduleGeneratorDTO); } if (isPaymnetypeApplicableforDisbursementCharge) { changedTransactionDetail = loan.disburse(currentUser, command, changes, scheduleGeneratorDTO, paymentDetail); } else { changedTransactionDetail = loan.disburse(currentUser, command, changes, scheduleGeneratorDTO, null); } } if (!changes.isEmpty()) { saveAndFlushLoanWithDataIntegrityViolationChecks(loan); final String noteText = command.stringValueOfParameterNamed("note"); if (StringUtils.isNotBlank(noteText)) { final Note note = Note.loanNote(loan, noteText); this.noteRepository.save(note); } if (changedTransactionDetail != null) { for (final Map.Entry<Long, LoanTransaction> mapEntry : changedTransactionDetail .getNewTransactionMappings().entrySet()) { this.loanTransactionRepository.save(mapEntry.getValue()); this.accountTransfersWritePlatformService.updateLoanTransaction(mapEntry.getKey(), mapEntry.getValue()); } } // auto create standing instruction createStandingInstruction(loan); postJournalEntries(loan, existingTransactionIds, existingReversedTransactionIds); } final Set<LoanCharge> loanCharges = loan.charges(); final Map<Long, BigDecimal> disBuLoanCharges = new HashMap<>(); for (final LoanCharge loanCharge : loanCharges) { if (loanCharge.isDueAtDisbursement() && loanCharge.getChargePaymentMode().isPaymentModeAccountTransfer() && loanCharge.isChargePending()) { disBuLoanCharges.put(loanCharge.getId(), loanCharge.amountOutstanding()); } } final Locale locale = command.extractLocale(); final DateTimeFormatter fmt = DateTimeFormat.forPattern(command.dateFormat()).withLocale(locale); for (final Map.Entry<Long, BigDecimal> entrySet : disBuLoanCharges.entrySet()) { final PortfolioAccountData savingAccountData = this.accountAssociationsReadPlatformService .retriveLoanLinkedAssociation(loanId); final SavingsAccount fromSavingsAccount = null; final boolean isRegularTransaction = true; final boolean isExceptionForBalanceCheck = false; final AccountTransferDTO accountTransferDTO = new AccountTransferDTO(actualDisbursementDate, entrySet.getValue(), PortfolioAccountType.SAVINGS, PortfolioAccountType.LOAN, savingAccountData.accountId(), loanId, "Loan Charge Payment", locale, fmt, null, null, LoanTransactionType.REPAYMENT_AT_DISBURSEMENT.getValue(), entrySet.getKey(), null, AccountTransferType.CHARGE_PAYMENT.getValue(), null, null, null, null, null, fromSavingsAccount, isRegularTransaction, isExceptionForBalanceCheck); this.accountTransfersWritePlatformService.transferFunds(accountTransferDTO); } updateRecurringCalendarDatesForInterestRecalculation(loan); this.loanAccountDomainService.recalculateAccruals(loan); this.businessEventNotifierService.notifyBusinessEventWasExecuted(BUSINESS_EVENTS.LOAN_DISBURSAL, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); return new CommandProcessingResultBuilder() // .withCommandId(command.commandId()) // .withEntityId(loan.getId()) // .withOfficeId(loan.getOfficeId()) // .withClientId(loan.getClientId()) // .withGroupId(loan.getGroupId()) // .withLoanId(loanId) // .with(changes) // .build(); } private void createAndSaveLoanScheduleArchive(final Loan loan, ScheduleGeneratorDTO scheduleGeneratorDTO) { LoanRescheduleRequest loanRescheduleRequest = null; LoanScheduleModel loanScheduleModel = loan.regenerateScheduleModel(scheduleGeneratorDTO); List<LoanRepaymentScheduleInstallment> installments = retrieveRepaymentScheduleFromModel(loanScheduleModel); this.loanScheduleHistoryWritePlatformService.createAndSaveLoanScheduleArchive(installments, loan, loanRescheduleRequest); } /** * create standing instruction for disbursed loan * * @param loan * the disbursed loan * @return void **/ private void createStandingInstruction(Loan loan) { if (loan.shouldCreateStandingInstructionAtDisbursement()) { AccountAssociations accountAssociations = this.accountAssociationRepository.findByLoanIdAndType( loan.getId(), AccountAssociationType.LINKED_ACCOUNT_ASSOCIATION.getValue()); if (accountAssociations != null) { SavingsAccount linkedSavingsAccount = accountAssociations.linkedSavingsAccount(); // name is auto-generated final String name = "To loan " + loan.getAccountNumber() + " from savings " + linkedSavingsAccount.getAccountNumber(); final Office fromOffice = loan.getOffice(); final Client fromClient = loan.getClient(); final Office toOffice = loan.getOffice(); final Client toClient = loan.getClient(); final Integer priority = StandingInstructionPriority.MEDIUM.getValue(); final Integer transferType = AccountTransferType.LOAN_REPAYMENT.getValue(); final Integer instructionType = StandingInstructionType.DUES.getValue(); final Integer status = StandingInstructionStatus.ACTIVE.getValue(); final Integer recurrenceType = AccountTransferRecurrenceType.AS_PER_DUES.getValue(); final LocalDate validFrom = new LocalDate(); AccountTransferDetails accountTransferDetails = AccountTransferDetails.savingsToLoanTransfer( fromOffice, fromClient, linkedSavingsAccount, toOffice, toClient, loan, transferType); AccountTransferStandingInstruction accountTransferStandingInstruction = AccountTransferStandingInstruction .create(accountTransferDetails, name, priority, instructionType, status, null, validFrom, null, recurrenceType, null, null, null); accountTransferDetails.updateAccountTransferStandingInstruction(accountTransferStandingInstruction); this.accountTransferDetailRepository.save(accountTransferDetails); } } } private void updateRecurringCalendarDatesForInterestRecalculation(final Loan loan) { if (loan.repaymentScheduleDetail().isInterestRecalculationEnabled() && loan.loanInterestRecalculationDetails().getRestFrequencyType().isSameAsRepayment()) { final CalendarInstance calendarInstanceForInterestRecalculation = this.calendarInstanceRepository .findByEntityIdAndEntityTypeIdAndCalendarTypeId(loan.loanInterestRecalculationDetailId(), CalendarEntityType.LOAN_RECALCULATION_REST_DETAIL.getValue(), CalendarType.COLLECTION.getValue()); Calendar calendarForInterestRecalculation = calendarInstanceForInterestRecalculation.getCalendar(); calendarForInterestRecalculation.updateStartAndEndDate(loan.getDisbursementDate(), loan.getMaturityDate()); this.calendarRepository.save(calendarForInterestRecalculation); } } private void saveAndFlushLoanWithDataIntegrityViolationChecks(final Loan loan) { try { List<LoanRepaymentScheduleInstallment> installments = loan.getRepaymentScheduleInstallments(); for (LoanRepaymentScheduleInstallment installment : installments) { if (installment.getId() == null) { this.repaymentScheduleInstallmentRepository.save(installment); } } this.loanRepositoryWrapper.saveAndFlush(loan); } catch (final DataIntegrityViolationException e) { final Throwable realCause = e.getCause(); final List<ApiParameterError> dataValidationErrors = new ArrayList<>(); final DataValidatorBuilder baseDataValidator = new DataValidatorBuilder(dataValidationErrors) .resource("loan.transaction"); if (realCause.getMessage().toLowerCase().contains("external_id_unique")) { baseDataValidator.reset().parameter("externalId").failWithCode("value.must.be.unique"); } if (!dataValidationErrors.isEmpty()) { throw new PlatformApiDataValidationException("validation.msg.validation.errors.exist", "Validation errors exist.", dataValidationErrors); } } } private void saveLoanWithDataIntegrityViolationChecks(final Loan loan) { try { List<LoanRepaymentScheduleInstallment> installments = loan.getRepaymentScheduleInstallments(); for (LoanRepaymentScheduleInstallment installment : installments) { if (installment.getId() == null) { this.repaymentScheduleInstallmentRepository.save(installment); } } this.loanRepositoryWrapper.save(loan); } catch (final DataIntegrityViolationException e) { final Throwable realCause = e.getCause(); final List<ApiParameterError> dataValidationErrors = new ArrayList<>(); final DataValidatorBuilder baseDataValidator = new DataValidatorBuilder(dataValidationErrors) .resource("loan.transaction"); if (realCause.getMessage().toLowerCase().contains("external_id_unique")) { baseDataValidator.reset().parameter("externalId").failWithCode("value.must.be.unique"); } if (!dataValidationErrors.isEmpty()) { throw new PlatformApiDataValidationException("validation.msg.validation.errors.exist", "Validation errors exist.", dataValidationErrors); } } } /**** * TODO Vishwas: Pair with Ashok and re-factor collection sheet code-base * * May of the changes made to disburseLoan aren't being made here, should * refactor to reuse disburseLoan ASAP *****/ @Transactional @Override public Map<String, Object> bulkLoanDisbursal(final JsonCommand command, final CollectionSheetBulkDisbursalCommand bulkDisbursalCommand, Boolean isAccountTransfer) { final AppUser currentUser = getAppUserIfPresent(); final SingleDisbursalCommand[] disbursalCommand = bulkDisbursalCommand.getDisburseTransactions(); final Map<String, Object> changes = new LinkedHashMap<>(); if (disbursalCommand == null) { return changes; } final LocalDate nextPossibleRepaymentDate = null; final Date rescheduledRepaymentDate = null; for (int i = 0; i < disbursalCommand.length; i++) { final SingleDisbursalCommand singleLoanDisbursalCommand = disbursalCommand[i]; final Loan loan = this.loanAssembler.assembleFrom(singleLoanDisbursalCommand.getLoanId()); final LocalDate actualDisbursementDate = command .localDateValueOfParameterNamed("actualDisbursementDate"); // validate ActualDisbursement Date Against Expected Disbursement Date LoanProduct loanProduct = loan.loanProduct(); if (loanProduct.syncExpectedWithDisbursementDate()) { syncExpectedDateWithActualDisbursementDate(loan, actualDisbursementDate); } checkClientOrGroupActive(loan); this.businessEventNotifierService.notifyBusinessEventToBeExecuted(BUSINESS_EVENTS.LOAN_DISBURSAL, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); final List<Long> existingTransactionIds = new ArrayList<>(); final List<Long> existingReversedTransactionIds = new ArrayList<>(); final PaymentDetail paymentDetail = this.paymentDetailWritePlatformService .createAndPersistPaymentDetail(command, changes); // Bulk disbursement should happen on meeting date (mostly from // collection sheet). // FIXME: AA - this should be first meeting date based on // disbursement date and next available meeting dates // assuming repayment schedule won't regenerate because expected // disbursement and actual disbursement happens on same date loan.validateAccountStatus(LoanEvent.LOAN_DISBURSED); updateLoanCounters(loan, actualDisbursementDate); boolean canDisburse = loan.canDisburse(actualDisbursementDate); ChangedTransactionDetail changedTransactionDetail = null; if (canDisburse) { Money amountBeforeAdjust = loan.getPrincpal(); Money disburseAmount = loan.adjustDisburseAmount(command, actualDisbursementDate); boolean recalculateSchedule = amountBeforeAdjust.isNotEqualTo(loan.getPrincpal()); final String txnExternalId = command.stringValueOfParameterNamedAllowingNull("externalId"); if (isAccountTransfer) { disburseLoanToSavings(loan, command, disburseAmount, paymentDetail); existingTransactionIds.addAll(loan.findExistingTransactionIds()); existingReversedTransactionIds.addAll(loan.findExistingReversedTransactionIds()); } else { existingTransactionIds.addAll(loan.findExistingTransactionIds()); existingReversedTransactionIds.addAll(loan.findExistingReversedTransactionIds()); LoanTransaction disbursementTransaction = LoanTransaction.disbursement(loan.getOffice(), disburseAmount, paymentDetail, actualDisbursementDate, txnExternalId, DateUtils.getLocalDateTimeOfTenant(), currentUser); disbursementTransaction.updateLoan(loan); loan.addLoanTransaction(disbursementTransaction); } LocalDate recalculateFrom = null; final ScheduleGeneratorDTO scheduleGeneratorDTO = this.loanUtilService .buildScheduleGeneratorDTO(loan, recalculateFrom); regenerateScheduleOnDisbursement(command, loan, recalculateSchedule, scheduleGeneratorDTO, nextPossibleRepaymentDate, rescheduledRepaymentDate); if (loan.repaymentScheduleDetail().isInterestRecalculationEnabled()) { createAndSaveLoanScheduleArchive(loan, scheduleGeneratorDTO); } if (configurationDomainService.isPaymnetypeApplicableforDisbursementCharge()) { changedTransactionDetail = loan.disburse(currentUser, command, changes, scheduleGeneratorDTO, paymentDetail); } else { changedTransactionDetail = loan.disburse(currentUser, command, changes, scheduleGeneratorDTO, null); } } if (!changes.isEmpty()) { saveAndFlushLoanWithDataIntegrityViolationChecks(loan); final String noteText = command.stringValueOfParameterNamed("note"); if (StringUtils.isNotBlank(noteText)) { final Note note = Note.loanNote(loan, noteText); this.noteRepository.save(note); } if (changedTransactionDetail != null) { for (final Map.Entry<Long, LoanTransaction> mapEntry : changedTransactionDetail .getNewTransactionMappings().entrySet()) { this.loanTransactionRepository.save(mapEntry.getValue()); this.accountTransfersWritePlatformService.updateLoanTransaction(mapEntry.getKey(), mapEntry.getValue()); } } postJournalEntries(loan, existingTransactionIds, existingReversedTransactionIds); } final Set<LoanCharge> loanCharges = loan.charges(); final Map<Long, BigDecimal> disBuLoanCharges = new HashMap<>(); for (final LoanCharge loanCharge : loanCharges) { if (loanCharge.isDueAtDisbursement() && loanCharge.getChargePaymentMode().isPaymentModeAccountTransfer() && loanCharge.isChargePending()) { disBuLoanCharges.put(loanCharge.getId(), loanCharge.amountOutstanding()); } } final Locale locale = command.extractLocale(); final DateTimeFormatter fmt = DateTimeFormat.forPattern(command.dateFormat()).withLocale(locale); for (final Map.Entry<Long, BigDecimal> entrySet : disBuLoanCharges.entrySet()) { final PortfolioAccountData savingAccountData = this.accountAssociationsReadPlatformService .retriveLoanLinkedAssociation(loan.getId()); final SavingsAccount fromSavingsAccount = null; final boolean isRegularTransaction = true; final boolean isExceptionForBalanceCheck = false; final AccountTransferDTO accountTransferDTO = new AccountTransferDTO(actualDisbursementDate, entrySet.getValue(), PortfolioAccountType.SAVINGS, PortfolioAccountType.LOAN, savingAccountData.accountId(), loan.getId(), "Loan Charge Payment", locale, fmt, null, null, LoanTransactionType.REPAYMENT_AT_DISBURSEMENT.getValue(), entrySet.getKey(), null, AccountTransferType.CHARGE_PAYMENT.getValue(), null, null, null, null, null, fromSavingsAccount, isRegularTransaction, isExceptionForBalanceCheck); this.accountTransfersWritePlatformService.transferFunds(accountTransferDTO); } updateRecurringCalendarDatesForInterestRecalculation(loan); this.loanAccountDomainService.recalculateAccruals(loan); this.businessEventNotifierService.notifyBusinessEventWasExecuted(BUSINESS_EVENTS.LOAN_DISBURSAL, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); } return changes; } @Transactional @Override public CommandProcessingResult undoLoanDisbursal(final Long loanId, final JsonCommand command) { final AppUser currentUser = getAppUserIfPresent(); final Loan loan = this.loanAssembler.assembleFrom(loanId); checkClientOrGroupActive(loan); this.businessEventNotifierService.notifyBusinessEventToBeExecuted(BUSINESS_EVENTS.LOAN_UNDO_DISBURSAL, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); removeLoanCycle(loan); final List<Long> existingTransactionIds = new ArrayList<>(); final List<Long> existingReversedTransactionIds = new ArrayList<>(); // final MonetaryCurrency currency = loan.getCurrency(); final ApplicationCurrency applicationCurrency = this.applicationCurrencyRepository .findOneWithNotFoundDetection(currency); final LocalDate recalculateFrom = null; ScheduleGeneratorDTO scheduleGeneratorDTO = this.loanUtilService.buildScheduleGeneratorDTO(loan, recalculateFrom); final Map<String, Object> changes = loan.undoDisbursal(scheduleGeneratorDTO, existingTransactionIds, existingReversedTransactionIds, currentUser); if (!changes.isEmpty()) { saveAndFlushLoanWithDataIntegrityViolationChecks(loan); this.accountTransfersWritePlatformService.reverseAllTransactions(loanId, PortfolioAccountType.LOAN); String noteText = null; if (command.hasParameter("note")) { noteText = command.stringValueOfParameterNamed("note"); if (StringUtils.isNotBlank(noteText)) { final Note note = Note.loanNote(loan, noteText); this.noteRepository.save(note); } } boolean isAccountTransfer = false; final Map<String, Object> accountingBridgeData = loan.deriveAccountingBridgeData( applicationCurrency.toData(), existingTransactionIds, existingReversedTransactionIds, isAccountTransfer); this.journalEntryWritePlatformService.createJournalEntriesForLoan(accountingBridgeData); this.businessEventNotifierService.notifyBusinessEventWasExecuted(BUSINESS_EVENTS.LOAN_UNDO_DISBURSAL, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); } return new CommandProcessingResultBuilder() // .withCommandId(command.commandId()) // .withEntityId(loan.getId()) // .withOfficeId(loan.getOfficeId()) // .withClientId(loan.getClientId()) // .withGroupId(loan.getGroupId()) // .withLoanId(loanId) // .with(changes) // .build(); } @Transactional @Override public CommandProcessingResult makeLoanRepayment(final Long loanId, final JsonCommand command, final boolean isRecoveryRepayment) { this.loanEventApiJsonValidator.validateNewRepaymentTransaction(command.json()); final LocalDate transactionDate = command.localDateValueOfParameterNamed("transactionDate"); final BigDecimal transactionAmount = command.bigDecimalValueOfParameterNamed("transactionAmount"); final String txnExternalId = command.stringValueOfParameterNamedAllowingNull("externalId"); final Map<String, Object> changes = new LinkedHashMap<>(); changes.put("transactionDate", command.stringValueOfParameterNamed("transactionDate")); changes.put("transactionAmount", command.stringValueOfParameterNamed("transactionAmount")); changes.put("locale", command.locale()); changes.put("dateFormat", command.dateFormat()); changes.put("paymentTypeId", command.stringValueOfParameterNamed("paymentTypeId")); final String noteText = command.stringValueOfParameterNamed("note"); if (StringUtils.isNotBlank(noteText)) { changes.put("note", noteText); } final Loan loan = this.loanAssembler.assembleFrom(loanId); final PaymentDetail paymentDetail = this.paymentDetailWritePlatformService .createAndPersistPaymentDetail(command, changes); final Boolean isHolidayValidationDone = false; final HolidayDetailDTO holidayDetailDto = null; boolean isAccountTransfer = false; final CommandProcessingResultBuilder commandProcessingResultBuilder = new CommandProcessingResultBuilder(); this.loanAccountDomainService.makeRepayment(loan, commandProcessingResultBuilder, transactionDate, transactionAmount, paymentDetail, noteText, txnExternalId, isRecoveryRepayment, isAccountTransfer, holidayDetailDto, isHolidayValidationDone); return commandProcessingResultBuilder.withCommandId(command.commandId()) // .withLoanId(loanId) // .with(changes) // .build(); } @Transactional @Override public Map<String, Object> makeLoanBulkRepayment( final CollectionSheetBulkRepaymentCommand bulkRepaymentCommand) { final SingleRepaymentCommand[] repaymentCommand = bulkRepaymentCommand.getLoanTransactions(); final Map<String, Object> changes = new LinkedHashMap<>(); final boolean isRecoveryRepayment = false; if (repaymentCommand == null) { return changes; } List<Long> transactionIds = new ArrayList<>(); boolean isAccountTransfer = false; HolidayDetailDTO holidayDetailDTO = null; Boolean isHolidayValidationDone = false; final boolean allowTransactionsOnHoliday = this.configurationDomainService .allowTransactionsOnHolidayEnabled(); for (final SingleRepaymentCommand singleLoanRepaymentCommand : repaymentCommand) { if (singleLoanRepaymentCommand != null) { Loan loan = this.loanRepositoryWrapper .findOneWithNotFoundDetection(singleLoanRepaymentCommand.getLoanId()); final List<Holiday> holidays = this.holidayRepository.findByOfficeIdAndGreaterThanDate( loan.getOfficeId(), singleLoanRepaymentCommand.getTransactionDate().toDate()); final WorkingDays workingDays = this.workingDaysRepository.findOne(); final boolean allowTransactionsOnNonWorkingDay = this.configurationDomainService .allowTransactionsOnNonWorkingDayEnabled(); boolean isHolidayEnabled = false; isHolidayEnabled = this.configurationDomainService.isRescheduleRepaymentsOnHolidaysEnabled(); holidayDetailDTO = new HolidayDetailDTO(isHolidayEnabled, holidays, workingDays, allowTransactionsOnHoliday, allowTransactionsOnNonWorkingDay); loan.validateRepaymentDateIsOnHoliday(singleLoanRepaymentCommand.getTransactionDate(), holidayDetailDTO.isAllowTransactionsOnHoliday(), holidayDetailDTO.getHolidays()); loan.validateRepaymentDateIsOnNonWorkingDay(singleLoanRepaymentCommand.getTransactionDate(), holidayDetailDTO.getWorkingDays(), holidayDetailDTO.isAllowTransactionsOnNonWorkingDay()); isHolidayValidationDone = true; break; } } for (final SingleRepaymentCommand singleLoanRepaymentCommand : repaymentCommand) { if (singleLoanRepaymentCommand != null) { final Loan loan = this.loanAssembler.assembleFrom(singleLoanRepaymentCommand.getLoanId()); final PaymentDetail paymentDetail = singleLoanRepaymentCommand.getPaymentDetail(); if (paymentDetail != null && paymentDetail.getId() == null) { this.paymentDetailWritePlatformService.persistPaymentDetail(paymentDetail); } final CommandProcessingResultBuilder commandProcessingResultBuilder = new CommandProcessingResultBuilder(); LoanTransaction loanTransaction = this.loanAccountDomainService.makeRepayment(loan, commandProcessingResultBuilder, bulkRepaymentCommand.getTransactionDate(), singleLoanRepaymentCommand.getTransactionAmount(), paymentDetail, bulkRepaymentCommand.getNote(), null, isRecoveryRepayment, isAccountTransfer, holidayDetailDTO, isHolidayValidationDone); transactionIds.add(loanTransaction.getId()); } } changes.put("loanTransactions", transactionIds); return changes; } @Transactional @Override public CommandProcessingResult adjustLoanTransaction(final Long loanId, final Long transactionId, final JsonCommand command) { AppUser currentUser = getAppUserIfPresent(); this.loanEventApiJsonValidator.validateTransaction(command.json()); final Loan loan = this.loanAssembler.assembleFrom(loanId); if (loan.status().isClosed() && loan.getLoanSubStatus() != null && loan.getLoanSubStatus().equals(LoanSubStatus.FORECLOSED.getValue())) { final String defaultUserMessage = "The loan cannot reopend as it is foreclosed."; throw new LoanForeclosureException("loan.cannot.be.reopened.as.it.is.foreclosured", defaultUserMessage, loanId); } checkClientOrGroupActive(loan); final LoanTransaction transactionToAdjust = this.loanTransactionRepository.findOne(transactionId); if (transactionToAdjust == null) { throw new LoanTransactionNotFoundException(transactionId); } this.businessEventNotifierService.notifyBusinessEventToBeExecuted(BUSINESS_EVENTS.LOAN_ADJUST_TRANSACTION, constructEntityMap(BUSINESS_ENTITY.LOAN_ADJUSTED_TRANSACTION, transactionToAdjust)); if (this.accountTransfersReadPlatformService.isAccountTransfer(transactionId, PortfolioAccountType.LOAN)) { throw new PlatformServiceUnavailableException("error.msg.loan.transfer.transaction.update.not.allowed", "Loan transaction:" + transactionId + " update not allowed as it involves in account transfer", transactionId); } if (loan.isClosedWrittenOff()) { throw new PlatformServiceUnavailableException("error.msg.loan.written.off.update.not.allowed", "Loan transaction:" + transactionId + " update not allowed as loan status is written off", transactionId); } final LocalDate transactionDate = command.localDateValueOfParameterNamed("transactionDate"); final BigDecimal transactionAmount = command.bigDecimalValueOfParameterNamed("transactionAmount"); final String txnExternalId = command.stringValueOfParameterNamedAllowingNull("externalId"); final Map<String, Object> changes = new LinkedHashMap<>(); changes.put("transactionDate", command.stringValueOfParameterNamed("transactionDate")); changes.put("transactionAmount", command.stringValueOfParameterNamed("transactionAmount")); changes.put("locale", command.locale()); changes.put("dateFormat", command.dateFormat()); changes.put("paymentTypeId", command.stringValueOfParameterNamed("paymentTypeId")); final List<Long> existingTransactionIds = new ArrayList<>(); final List<Long> existingReversedTransactionIds = new ArrayList<>(); final Money transactionAmountAsMoney = Money.of(loan.getCurrency(), transactionAmount); final PaymentDetail paymentDetail = this.paymentDetailWritePlatformService.createPaymentDetail(command, changes); LoanTransaction newTransactionDetail = LoanTransaction.repayment(loan.getOffice(), transactionAmountAsMoney, paymentDetail, transactionDate, txnExternalId, DateUtils.getLocalDateTimeOfTenant(), currentUser); if (transactionToAdjust.isInterestWaiver()) { Money unrecognizedIncome = transactionAmountAsMoney.zero(); Money interestComponent = transactionAmountAsMoney; if (loan.isPeriodicAccrualAccountingEnabledOnLoanProduct()) { Money receivableInterest = loan.getReceivableInterest(transactionDate); if (transactionAmountAsMoney.isGreaterThan(receivableInterest)) { interestComponent = receivableInterest; unrecognizedIncome = transactionAmountAsMoney.minus(receivableInterest); } } newTransactionDetail = LoanTransaction.waiver(loan.getOffice(), loan, transactionAmountAsMoney, transactionDate, interestComponent, unrecognizedIncome, DateUtils.getLocalDateTimeOfTenant(), currentUser); } LocalDate recalculateFrom = null; if (loan.repaymentScheduleDetail().isInterestRecalculationEnabled()) { recalculateFrom = transactionToAdjust.getTransactionDate().isAfter(transactionDate) ? transactionDate : transactionToAdjust.getTransactionDate(); } ScheduleGeneratorDTO scheduleGeneratorDTO = this.loanUtilService.buildScheduleGeneratorDTO(loan, recalculateFrom); final ChangedTransactionDetail changedTransactionDetail = loan.adjustExistingTransaction( newTransactionDetail, defaultLoanLifecycleStateMachine(), transactionToAdjust, existingTransactionIds, existingReversedTransactionIds, scheduleGeneratorDTO, currentUser); if (newTransactionDetail.isGreaterThanZero(loan.getPrincpal().getCurrency())) { if (paymentDetail != null) { this.paymentDetailWritePlatformService.persistPaymentDetail(paymentDetail); } this.loanTransactionRepository.save(newTransactionDetail); } /*** * TODO Vishwas Batch save is giving me a * HibernateOptimisticLockingFailureException, looping and saving for * the time being, not a major issue for now as this loop is entered * only in edge cases (when a adjustment is made before the latest * payment recorded against the loan) ***/ saveAndFlushLoanWithDataIntegrityViolationChecks(loan); if (changedTransactionDetail != null) { for (final Map.Entry<Long, LoanTransaction> mapEntry : changedTransactionDetail .getNewTransactionMappings().entrySet()) { this.loanTransactionRepository.save(mapEntry.getValue()); // update loan with references to the newly created transactions loan.addLoanTransaction(mapEntry.getValue()); this.accountTransfersWritePlatformService.updateLoanTransaction(mapEntry.getKey(), mapEntry.getValue()); } } final String noteText = command.stringValueOfParameterNamed("note"); if (StringUtils.isNotBlank(noteText)) { changes.put("note", noteText); Note note = null; /** * If a new transaction is not created, associate note with the * transaction to be adjusted **/ if (newTransactionDetail.isGreaterThanZero(loan.getPrincpal().getCurrency())) { note = Note.loanTransactionNote(loan, newTransactionDetail, noteText); } else { note = Note.loanTransactionNote(loan, transactionToAdjust, noteText); } this.noteRepository.save(note); } Collection<Long> transactionIds = new ArrayList<>(); List<LoanTransaction> transactions = loan.getLoanTransactions(); for (LoanTransaction transaction : transactions) { if (transaction.isRefund() && transaction.isNotReversed()) { transactionIds.add(transaction.getId()); } } if (!transactionIds.isEmpty()) { this.accountTransfersWritePlatformService.reverseTransfersWithFromAccountTransactions(transactionIds, PortfolioAccountType.LOAN); loan.updateLoanSummarAndStatus(); } postJournalEntries(loan, existingTransactionIds, existingReversedTransactionIds); this.loanAccountDomainService.recalculateAccruals(loan); Map<BUSINESS_ENTITY, Object> entityMap = constructEntityMap(BUSINESS_ENTITY.LOAN_ADJUSTED_TRANSACTION, transactionToAdjust); if (newTransactionDetail.isRepayment() && newTransactionDetail.isGreaterThanZero(loan.getPrincpal().getCurrency())) { entityMap.put(BUSINESS_ENTITY.LOAN_TRANSACTION, newTransactionDetail); } this.businessEventNotifierService.notifyBusinessEventWasExecuted(BUSINESS_EVENTS.LOAN_ADJUST_TRANSACTION, entityMap); return new CommandProcessingResultBuilder() // .withCommandId(command.commandId()) // .withEntityId(transactionId) // .withOfficeId(loan.getOfficeId()) // .withClientId(loan.getClientId()) // .withGroupId(loan.getGroupId()) // .withLoanId(loanId) // .with(changes) // .build(); } @Transactional @Override public CommandProcessingResult waiveInterestOnLoan(final Long loanId, final JsonCommand command) { AppUser currentUser = getAppUserIfPresent(); this.loanEventApiJsonValidator.validateTransaction(command.json()); final Map<String, Object> changes = new LinkedHashMap<>(); changes.put("transactionDate", command.stringValueOfParameterNamed("transactionDate")); changes.put("transactionAmount", command.stringValueOfParameterNamed("transactionAmount")); changes.put("locale", command.locale()); changes.put("dateFormat", command.dateFormat()); final LocalDate transactionDate = command.localDateValueOfParameterNamed("transactionDate"); final BigDecimal transactionAmount = command.bigDecimalValueOfParameterNamed("transactionAmount"); final Loan loan = this.loanAssembler.assembleFrom(loanId); checkClientOrGroupActive(loan); final List<Long> existingTransactionIds = new ArrayList<>(); final List<Long> existingReversedTransactionIds = new ArrayList<>(); final Money transactionAmountAsMoney = Money.of(loan.getCurrency(), transactionAmount); Money unrecognizedIncome = transactionAmountAsMoney.zero(); Money interestComponent = transactionAmountAsMoney; if (loan.isPeriodicAccrualAccountingEnabledOnLoanProduct()) { Money receivableInterest = loan.getReceivableInterest(transactionDate); if (transactionAmountAsMoney.isGreaterThan(receivableInterest)) { interestComponent = receivableInterest; unrecognizedIncome = transactionAmountAsMoney.minus(receivableInterest); } } final LoanTransaction waiveInterestTransaction = LoanTransaction.waiver(loan.getOffice(), loan, transactionAmountAsMoney, transactionDate, interestComponent, unrecognizedIncome, DateUtils.getLocalDateTimeOfTenant(), currentUser); this.businessEventNotifierService.notifyBusinessEventToBeExecuted(BUSINESS_EVENTS.LOAN_WAIVE_INTEREST, constructEntityMap(BUSINESS_ENTITY.LOAN_TRANSACTION, waiveInterestTransaction)); LocalDate recalculateFrom = null; if (loan.repaymentScheduleDetail().isInterestRecalculationEnabled()) { recalculateFrom = transactionDate; } ScheduleGeneratorDTO scheduleGeneratorDTO = this.loanUtilService.buildScheduleGeneratorDTO(loan, recalculateFrom); final ChangedTransactionDetail changedTransactionDetail = loan.waiveInterest(waiveInterestTransaction, defaultLoanLifecycleStateMachine(), existingTransactionIds, existingReversedTransactionIds, scheduleGeneratorDTO, currentUser); this.loanTransactionRepository.save(waiveInterestTransaction); /*** * TODO Vishwas Batch save is giving me a * HibernateOptimisticLockingFailureException, looping and saving for * the time being, not a major issue for now as this loop is entered * only in edge cases (when a waiver is made before the latest payment * recorded against the loan) ***/ saveAndFlushLoanWithDataIntegrityViolationChecks(loan); if (changedTransactionDetail != null) { for (final Map.Entry<Long, LoanTransaction> mapEntry : changedTransactionDetail .getNewTransactionMappings().entrySet()) { this.loanTransactionRepository.save(mapEntry.getValue()); // update loan with references to the newly created transactions loan.addLoanTransaction(mapEntry.getValue()); this.accountTransfersWritePlatformService.updateLoanTransaction(mapEntry.getKey(), mapEntry.getValue()); } } final String noteText = command.stringValueOfParameterNamed("note"); if (StringUtils.isNotBlank(noteText)) { changes.put("note", noteText); final Note note = Note.loanTransactionNote(loan, waiveInterestTransaction, noteText); this.noteRepository.save(note); } postJournalEntries(loan, existingTransactionIds, existingReversedTransactionIds); this.loanAccountDomainService.recalculateAccruals(loan); this.businessEventNotifierService.notifyBusinessEventWasExecuted(BUSINESS_EVENTS.LOAN_WAIVE_INTEREST, constructEntityMap(BUSINESS_ENTITY.LOAN_TRANSACTION, waiveInterestTransaction)); return new CommandProcessingResultBuilder() // .withCommandId(command.commandId()) // .withEntityId(waiveInterestTransaction.getId()) // .withOfficeId(loan.getOfficeId()) // .withClientId(loan.getClientId()) // .withGroupId(loan.getGroupId()) // .withLoanId(loanId) // .with(changes) // .build(); } @Transactional @Override public CommandProcessingResult writeOff(final Long loanId, final JsonCommand command) { final AppUser currentUser = getAppUserIfPresent(); this.loanEventApiJsonValidator.validateTransactionWithNoAmount(command.json()); final Map<String, Object> changes = new LinkedHashMap<>(); changes.put("transactionDate", command.stringValueOfParameterNamed("transactionDate")); changes.put("locale", command.locale()); changes.put("dateFormat", command.dateFormat()); final Loan loan = this.loanAssembler.assembleFrom(loanId); if (command.hasParameter("writeoffReasonId")) { Long writeoffReasonId = command.longValueOfParameterNamed("writeoffReasonId"); CodeValue writeoffReason = this.codeValueRepository.findOneByCodeNameAndIdWithNotFoundDetection( LoanApiConstants.WRITEOFFREASONS, writeoffReasonId); changes.put("writeoffReasonId", writeoffReasonId); loan.updateWriteOffReason(writeoffReason); } checkClientOrGroupActive(loan); this.businessEventNotifierService.notifyBusinessEventToBeExecuted(BUSINESS_EVENTS.LOAN_WRITTEN_OFF, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); entityDatatableChecksWritePlatformService.runTheCheckForProduct(loanId, EntityTables.LOAN.getName(), StatusEnum.WRITE_OFF.getCode().longValue(), EntityTables.LOAN.getForeignKeyColumnNameOnDatatable(), loan.productId()); removeLoanCycle(loan); final List<Long> existingTransactionIds = new ArrayList<>(); final List<Long> existingReversedTransactionIds = new ArrayList<>(); updateLoanCounters(loan, loan.getDisbursementDate()); LocalDate recalculateFrom = null; if (loan.repaymentScheduleDetail().isInterestRecalculationEnabled()) { recalculateFrom = command.localDateValueOfParameterNamed("transactionDate"); } ScheduleGeneratorDTO scheduleGeneratorDTO = this.loanUtilService.buildScheduleGeneratorDTO(loan, recalculateFrom); final ChangedTransactionDetail changedTransactionDetail = loan.closeAsWrittenOff(command, defaultLoanLifecycleStateMachine(), changes, existingTransactionIds, existingReversedTransactionIds, currentUser, scheduleGeneratorDTO); LoanTransaction writeoff = changedTransactionDetail.getNewTransactionMappings().remove(0L); this.loanTransactionRepository.save(writeoff); for (final Map.Entry<Long, LoanTransaction> mapEntry : changedTransactionDetail.getNewTransactionMappings() .entrySet()) { this.loanTransactionRepository.save(mapEntry.getValue()); this.accountTransfersWritePlatformService.updateLoanTransaction(mapEntry.getKey(), mapEntry.getValue()); } saveLoanWithDataIntegrityViolationChecks(loan); final String noteText = command.stringValueOfParameterNamed("note"); if (StringUtils.isNotBlank(noteText)) { changes.put("note", noteText); final Note note = Note.loanTransactionNote(loan, writeoff, noteText); this.noteRepository.save(note); } postJournalEntries(loan, existingTransactionIds, existingReversedTransactionIds); this.loanAccountDomainService.recalculateAccruals(loan); this.businessEventNotifierService.notifyBusinessEventWasExecuted(BUSINESS_EVENTS.LOAN_WRITTEN_OFF, constructEntityMap(BUSINESS_ENTITY.LOAN_TRANSACTION, writeoff)); return new CommandProcessingResultBuilder() // .withCommandId(command.commandId()) // .withEntityId(writeoff.getId()) // .withOfficeId(loan.getOfficeId()) // .withClientId(loan.getClientId()) // .withGroupId(loan.getGroupId()) // .withLoanId(loanId) // .with(changes) // .build(); } @Transactional @Override public CommandProcessingResult closeLoan(final Long loanId, final JsonCommand command) { AppUser currentUser = getAppUserIfPresent(); this.loanEventApiJsonValidator.validateTransactionWithNoAmount(command.json()); final Loan loan = this.loanAssembler.assembleFrom(loanId); checkClientOrGroupActive(loan); this.businessEventNotifierService.notifyBusinessEventToBeExecuted(BUSINESS_EVENTS.LOAN_CLOSE, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); final Map<String, Object> changes = new LinkedHashMap<>(); changes.put("transactionDate", command.stringValueOfParameterNamed("transactionDate")); changes.put("locale", command.locale()); changes.put("dateFormat", command.dateFormat()); final List<Long> existingTransactionIds = new ArrayList<>(); final List<Long> existingReversedTransactionIds = new ArrayList<>(); updateLoanCounters(loan, loan.getDisbursementDate()); LocalDate recalculateFrom = null; if (loan.repaymentScheduleDetail().isInterestRecalculationEnabled()) { recalculateFrom = command.localDateValueOfParameterNamed("transactionDate"); } ScheduleGeneratorDTO scheduleGeneratorDTO = this.loanUtilService.buildScheduleGeneratorDTO(loan, recalculateFrom); ChangedTransactionDetail changedTransactionDetail = loan.close(command, defaultLoanLifecycleStateMachine(), changes, existingTransactionIds, existingReversedTransactionIds, scheduleGeneratorDTO, currentUser); final LoanTransaction possibleClosingTransaction = changedTransactionDetail.getNewTransactionMappings() .remove(0L); if (possibleClosingTransaction != null) { this.loanTransactionRepository.save(possibleClosingTransaction); } for (final Map.Entry<Long, LoanTransaction> mapEntry : changedTransactionDetail.getNewTransactionMappings() .entrySet()) { this.loanTransactionRepository.save(mapEntry.getValue()); this.accountTransfersWritePlatformService.updateLoanTransaction(mapEntry.getKey(), mapEntry.getValue()); } saveLoanWithDataIntegrityViolationChecks(loan); final String noteText = command.stringValueOfParameterNamed("note"); if (StringUtils.isNotBlank(noteText)) { changes.put("note", noteText); final Note note = Note.loanNote(loan, noteText); this.noteRepository.save(note); } if (possibleClosingTransaction != null) { postJournalEntries(loan, existingTransactionIds, existingReversedTransactionIds); } this.loanAccountDomainService.recalculateAccruals(loan); this.businessEventNotifierService.notifyBusinessEventWasExecuted(BUSINESS_EVENTS.LOAN_CLOSE, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); // disable all active standing instructions linked to the loan this.loanAccountDomainService.disableStandingInstructionsLinkedToClosedLoan(loan); CommandProcessingResult result = null; if (possibleClosingTransaction != null) { result = new CommandProcessingResultBuilder() // .withCommandId(command.commandId()) // .withEntityId(possibleClosingTransaction.getId()) // .withOfficeId(loan.getOfficeId()) // .withClientId(loan.getClientId()) // .withGroupId(loan.getGroupId()) // .withLoanId(loanId) // .with(changes) // .build(); } else { result = new CommandProcessingResultBuilder() // .withCommandId(command.commandId()) // .withEntityId(loanId) // .withOfficeId(loan.getOfficeId()) // .withClientId(loan.getClientId()) // .withGroupId(loan.getGroupId()) // .withLoanId(loanId) // .with(changes) // .build(); } return result; } @Transactional @Override public CommandProcessingResult closeAsRescheduled(final Long loanId, final JsonCommand command) { this.loanEventApiJsonValidator.validateTransactionWithNoAmount(command.json()); final Loan loan = this.loanAssembler.assembleFrom(loanId); checkClientOrGroupActive(loan); removeLoanCycle(loan); this.businessEventNotifierService.notifyBusinessEventToBeExecuted(BUSINESS_EVENTS.LOAN_CLOSE_AS_RESCHEDULE, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); final Map<String, Object> changes = new LinkedHashMap<>(); changes.put("transactionDate", command.stringValueOfParameterNamed("transactionDate")); changes.put("locale", command.locale()); changes.put("dateFormat", command.dateFormat()); loan.closeAsMarkedForReschedule(command, defaultLoanLifecycleStateMachine(), changes); saveLoanWithDataIntegrityViolationChecks(loan); final String noteText = command.stringValueOfParameterNamed("note"); if (StringUtils.isNotBlank(noteText)) { changes.put("note", noteText); final Note note = Note.loanNote(loan, noteText); this.noteRepository.save(note); } this.businessEventNotifierService.notifyBusinessEventWasExecuted(BUSINESS_EVENTS.LOAN_CLOSE_AS_RESCHEDULE, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); // disable all active standing instructions linked to the loan this.loanAccountDomainService.disableStandingInstructionsLinkedToClosedLoan(loan); return new CommandProcessingResultBuilder() // .withCommandId(command.commandId()) // .withEntityId(loanId) // .withOfficeId(loan.getOfficeId()) // .withClientId(loan.getClientId()) // .withGroupId(loan.getGroupId()) // .withLoanId(loanId) // .with(changes) // .build(); } private void validateAddingNewChargeAllowed(List<LoanDisbursementDetails> loanDisburseDetails) { boolean pendingDisbursementAvailable = false; for (LoanDisbursementDetails disbursementDetail : loanDisburseDetails) { if (disbursementDetail.actualDisbursementDate() == null) { pendingDisbursementAvailable = true; break; } } if (!pendingDisbursementAvailable) { throw new ChargeCannotBeUpdatedException( "error.msg.charge.cannot.be.updated.no.pending.disbursements.in.loan", "This charge cannot be added, No disbursement is pending"); } } @Transactional @Override public CommandProcessingResult addLoanCharge(final Long loanId, final JsonCommand command) { this.loanEventApiJsonValidator.validateAddLoanCharge(command.json()); final Loan loan = this.loanAssembler.assembleFrom(loanId); checkClientOrGroupActive(loan); List<LoanDisbursementDetails> loanDisburseDetails = loan.getDisbursementDetails(); final Long chargeDefinitionId = command.longValueOfParameterNamed("chargeId"); final Charge chargeDefinition = this.chargeRepository.findOneWithNotFoundDetection(chargeDefinitionId); if (loan.isDisbursed() && chargeDefinition.isDisbursementCharge()) { validateAddingNewChargeAllowed(loanDisburseDetails); // validates // whether any // pending // disbursements // are // available to // apply this // charge } final List<Long> existingTransactionIds = new ArrayList<>(loan.findExistingTransactionIds()); final List<Long> existingReversedTransactionIds = new ArrayList<>( loan.findExistingReversedTransactionIds()); boolean isAppliedOnBackDate = false; LoanCharge loanCharge = null; LocalDate recalculateFrom = loan.fetchInterestRecalculateFromDate(); if (chargeDefinition.isPercentageOfDisbursementAmount()) { LoanTrancheDisbursementCharge loanTrancheDisbursementCharge = null; for (LoanDisbursementDetails disbursementDetail : loanDisburseDetails) { if (disbursementDetail.actualDisbursementDate() == null) { loanCharge = LoanCharge.createNewWithoutLoan(chargeDefinition, disbursementDetail.principal(), null, null, null, disbursementDetail.expectedDisbursementDateAsLocalDate(), null, null); loanTrancheDisbursementCharge = new LoanTrancheDisbursementCharge(loanCharge, disbursementDetail); loanCharge.updateLoanTrancheDisbursementCharge(loanTrancheDisbursementCharge); this.businessEventNotifierService.notifyBusinessEventToBeExecuted( BUSINESS_EVENTS.LOAN_ADD_CHARGE, constructEntityMap(BUSINESS_ENTITY.LOAN_CHARGE, loanCharge)); validateAddLoanCharge(loan, chargeDefinition, loanCharge); addCharge(loan, chargeDefinition, loanCharge); isAppliedOnBackDate = true; if (recalculateFrom.isAfter(disbursementDetail.expectedDisbursementDateAsLocalDate())) { recalculateFrom = disbursementDetail.expectedDisbursementDateAsLocalDate(); } } } loan.addTrancheLoanCharge(chargeDefinition); } else { loanCharge = LoanCharge.createNewFromJson(loan, chargeDefinition, command); this.businessEventNotifierService.notifyBusinessEventToBeExecuted(BUSINESS_EVENTS.LOAN_ADD_CHARGE, constructEntityMap(BUSINESS_ENTITY.LOAN_CHARGE, loanCharge)); validateAddLoanCharge(loan, chargeDefinition, loanCharge); isAppliedOnBackDate = addCharge(loan, chargeDefinition, loanCharge); if (loanCharge.getDueLocalDate() == null || recalculateFrom.isAfter(loanCharge.getDueLocalDate())) { isAppliedOnBackDate = true; recalculateFrom = loanCharge.getDueLocalDate(); } } boolean reprocessRequired = true; if (loan.repaymentScheduleDetail().isInterestRecalculationEnabled()) { if (isAppliedOnBackDate && loan.isFeeCompoundingEnabledForInterestRecalculation()) { runScheduleRecalculation(loan, recalculateFrom); reprocessRequired = false; } updateOriginalSchedule(loan); } if (reprocessRequired) { ChangedTransactionDetail changedTransactionDetail = loan.reprocessTransactions(); if (changedTransactionDetail != null) { for (final Map.Entry<Long, LoanTransaction> mapEntry : changedTransactionDetail .getNewTransactionMappings().entrySet()) { this.loanTransactionRepository.save(mapEntry.getValue()); // update loan with references to the newly created // transactions loan.addLoanTransaction(mapEntry.getValue()); this.accountTransfersWritePlatformService.updateLoanTransaction(mapEntry.getKey(), mapEntry.getValue()); } } saveLoanWithDataIntegrityViolationChecks(loan); } postJournalEntries(loan, existingTransactionIds, existingReversedTransactionIds); if (loan.repaymentScheduleDetail().isInterestRecalculationEnabled() && isAppliedOnBackDate && loan.isFeeCompoundingEnabledForInterestRecalculation()) { this.loanAccountDomainService.recalculateAccruals(loan); } this.businessEventNotifierService.notifyBusinessEventWasExecuted(BUSINESS_EVENTS.LOAN_ADD_CHARGE, constructEntityMap(BUSINESS_ENTITY.LOAN_CHARGE, loanCharge)); return new CommandProcessingResultBuilder() // .withCommandId(command.commandId()) // .withEntityId(loanCharge.getId()) // .withOfficeId(loan.getOfficeId()) // .withClientId(loan.getClientId()) // .withGroupId(loan.getGroupId()) // .withLoanId(loanId) // .build(); } private void validateAddLoanCharge(final Loan loan, final Charge chargeDefinition, final LoanCharge loanCharge) { if (chargeDefinition.isOverdueInstallment()) { final String defaultUserMessage = "Installment charge cannot be added to the loan."; throw new LoanChargeCannotBeAddedException("loanCharge", "overdue.charge", defaultUserMessage, null, chargeDefinition.getName()); } else if (loanCharge.getDueLocalDate() != null && loanCharge.getDueLocalDate().isBefore(loan.getLastUserTransactionForChargeCalc())) { final String defaultUserMessage = "charge with date before last transaction date can not be added to loan."; throw new LoanChargeCannotBeAddedException("loanCharge", "date.is.before.last.transaction.date", defaultUserMessage, null, chargeDefinition.getName()); } else if (loan.repaymentScheduleDetail().isInterestRecalculationEnabled()) { if (loanCharge.isInstalmentFee() && loan.status().isActive()) { final String defaultUserMessage = "installment charge addition not allowed after disbursement"; throw new LoanChargeCannotBeAddedException("loanCharge", "installment.charge", defaultUserMessage, null, chargeDefinition.getName()); } final List<ApiParameterError> dataValidationErrors = new ArrayList<>(); final Set<LoanCharge> loanCharges = new HashSet<>(1); loanCharges.add(loanCharge); this.loanApplicationCommandFromApiJsonHelper.validateLoanCharges(loanCharges, dataValidationErrors); if (!dataValidationErrors.isEmpty()) { throw new PlatformApiDataValidationException(dataValidationErrors); } } } public void runScheduleRecalculation(final Loan loan, final LocalDate recalculateFrom) { AppUser currentUser = getAppUserIfPresent(); if (loan.repaymentScheduleDetail().isInterestRecalculationEnabled()) { ScheduleGeneratorDTO generatorDTO = this.loanUtilService.buildScheduleGeneratorDTO(loan, recalculateFrom); ChangedTransactionDetail changedTransactionDetail = loan .handleRegenerateRepaymentScheduleWithInterestRecalculation(generatorDTO, currentUser); saveLoanWithDataIntegrityViolationChecks(loan); if (changedTransactionDetail != null) { for (final Map.Entry<Long, LoanTransaction> mapEntry : changedTransactionDetail .getNewTransactionMappings().entrySet()) { this.loanTransactionRepository.save(mapEntry.getValue()); // update loan with references to the newly created // transactions loan.addLoanTransaction(mapEntry.getValue()); this.accountTransfersWritePlatformService.updateLoanTransaction(mapEntry.getKey(), mapEntry.getValue()); } } } } public void updateOriginalSchedule(Loan loan) { if (loan.repaymentScheduleDetail().isInterestRecalculationEnabled()) { final LocalDate recalculateFrom = null; ScheduleGeneratorDTO scheduleGeneratorDTO = this.loanUtilService.buildScheduleGeneratorDTO(loan, recalculateFrom); createLoanScheduleArchive(loan, scheduleGeneratorDTO); } } private boolean addCharge(final Loan loan, final Charge chargeDefinition, final LoanCharge loanCharge) { AppUser currentUser = getAppUserIfPresent(); if (!loan.hasCurrencyCodeOf(chargeDefinition.getCurrencyCode())) { final String errorMessage = "Charge and Loan must have the same currency."; throw new InvalidCurrencyException("loanCharge", "attach.to.loan", errorMessage); } if (loanCharge.getChargePaymentMode().isPaymentModeAccountTransfer()) { final PortfolioAccountData portfolioAccountData = this.accountAssociationsReadPlatformService .retriveLoanLinkedAssociation(loan.getId()); if (portfolioAccountData == null) { final String errorMessage = loanCharge.name() + "Charge requires linked savings account for payment"; throw new LinkedAccountRequiredException("loanCharge.add", errorMessage, loanCharge.name()); } } loan.addLoanCharge(loanCharge); this.loanChargeRepository.save(loanCharge); /** * we want to apply charge transactions only for those loans charges * that are applied when a loan is active and the loan product uses * Upfront Accruals **/ if (loan.status().isActive() && loan.isNoneOrCashOrUpfrontAccrualAccountingEnabledOnLoanProduct()) { final LoanTransaction applyLoanChargeTransaction = loan.handleChargeAppliedTransaction(loanCharge, null, currentUser); this.loanTransactionRepository.save(applyLoanChargeTransaction); } boolean isAppliedOnBackDate = false; if (loanCharge.getDueLocalDate() == null || DateUtils.getLocalDateOfTenant().isAfter(loanCharge.getDueLocalDate())) { isAppliedOnBackDate = true; } return isAppliedOnBackDate; } @Transactional @Override public CommandProcessingResult updateLoanCharge(final Long loanId, final Long loanChargeId, final JsonCommand command) { this.loanEventApiJsonValidator.validateUpdateOfLoanCharge(command.json()); final Loan loan = this.loanAssembler.assembleFrom(loanId); checkClientOrGroupActive(loan); final LoanCharge loanCharge = retrieveLoanChargeBy(loanId, loanChargeId); // Charges may be edited only when the loan associated with them are // yet to be approved (are in submitted and pending status) if (!loan.status().isSubmittedAndPendingApproval()) { throw new LoanChargeCannotBeUpdatedException( LOAN_CHARGE_CANNOT_BE_UPDATED_REASON.LOAN_NOT_IN_SUBMITTED_AND_PENDING_APPROVAL_STAGE, loanCharge.getId()); } this.businessEventNotifierService.notifyBusinessEventToBeExecuted(BUSINESS_EVENTS.LOAN_UPDATE_CHARGE, constructEntityMap(BUSINESS_ENTITY.LOAN_CHARGE, loanCharge)); final Map<String, Object> changes = loan.updateLoanCharge(loanCharge, command); saveLoanWithDataIntegrityViolationChecks(loan); this.businessEventNotifierService.notifyBusinessEventWasExecuted(BUSINESS_EVENTS.LOAN_UPDATE_CHARGE, constructEntityMap(BUSINESS_ENTITY.LOAN_CHARGE, loanCharge)); return new CommandProcessingResultBuilder() // .withCommandId(command.commandId()) // .withEntityId(loanChargeId) // .withOfficeId(loan.getOfficeId()) // .withClientId(loan.getClientId()) // .withGroupId(loan.getGroupId()) // .withLoanId(loanId) // .with(changes) // .build(); } @Transactional @Override public CommandProcessingResult waiveLoanCharge(final Long loanId, final Long loanChargeId, final JsonCommand command) { AppUser currentUser = getAppUserIfPresent(); final Loan loan = this.loanAssembler.assembleFrom(loanId); checkClientOrGroupActive(loan); this.loanEventApiJsonValidator.validateInstallmentChargeTransaction(command.json()); final LoanCharge loanCharge = retrieveLoanChargeBy(loanId, loanChargeId); // Charges may be waived only when the loan associated with them are // active if (!loan.status().isActive()) { throw new LoanChargeCannotBeWaivedException(LOAN_CHARGE_CANNOT_BE_WAIVED_REASON.LOAN_INACTIVE, loanCharge.getId()); } // validate loan charge is not already paid or waived if (loanCharge.isWaived()) { throw new LoanChargeCannotBeWaivedException(LOAN_CHARGE_CANNOT_BE_WAIVED_REASON.ALREADY_WAIVED, loanCharge.getId()); } else if (loanCharge.isPaid()) { throw new LoanChargeCannotBeWaivedException(LOAN_CHARGE_CANNOT_BE_WAIVED_REASON.ALREADY_PAID, loanCharge.getId()); } this.businessEventNotifierService.notifyBusinessEventToBeExecuted(BUSINESS_EVENTS.LOAN_WAIVE_CHARGE, constructEntityMap(BUSINESS_ENTITY.LOAN_CHARGE, loanCharge)); Integer loanInstallmentNumber = null; if (loanCharge.isInstalmentFee()) { LoanInstallmentCharge chargePerInstallment = null; if (!StringUtils.isBlank(command.json())) { final LocalDate dueDate = command.localDateValueOfParameterNamed("dueDate"); final Integer installmentNumber = command.integerValueOfParameterNamed("installmentNumber"); if (dueDate != null) { chargePerInstallment = loanCharge.getInstallmentLoanCharge(dueDate); } else if (installmentNumber != null) { chargePerInstallment = loanCharge.getInstallmentLoanCharge(installmentNumber); } } if (chargePerInstallment == null) { chargePerInstallment = loanCharge.getUnpaidInstallmentLoanCharge(); } if (chargePerInstallment.isWaived()) { throw new LoanChargeCannotBePayedException(LOAN_CHARGE_CANNOT_BE_PAYED_REASON.ALREADY_WAIVED, loanCharge.getId()); } else if (chargePerInstallment.isPaid()) { throw new LoanChargeCannotBePayedException(LOAN_CHARGE_CANNOT_BE_PAYED_REASON.ALREADY_PAID, loanCharge.getId()); } loanInstallmentNumber = chargePerInstallment.getRepaymentInstallment().getInstallmentNumber(); } final Map<String, Object> changes = new LinkedHashMap<>(3); final List<Long> existingTransactionIds = new ArrayList<>(); final List<Long> existingReversedTransactionIds = new ArrayList<>(); LocalDate recalculateFrom = null; ScheduleGeneratorDTO scheduleGeneratorDTO = this.loanUtilService.buildScheduleGeneratorDTO(loan, recalculateFrom); Money accruedCharge = Money.zero(loan.getCurrency()); if (loan.isPeriodicAccrualAccountingEnabledOnLoanProduct()) { Collection<LoanChargePaidByData> chargePaidByDatas = this.loanChargeReadPlatformService .retriveLoanChargesPaidBy(loanCharge.getId(), LoanTransactionType.ACCRUAL, loanInstallmentNumber); for (LoanChargePaidByData chargePaidByData : chargePaidByDatas) { accruedCharge = accruedCharge.plus(chargePaidByData.getAmount()); } } final LoanTransaction waiveTransaction = loan.waiveLoanCharge(loanCharge, defaultLoanLifecycleStateMachine(), changes, existingTransactionIds, existingReversedTransactionIds, loanInstallmentNumber, scheduleGeneratorDTO, accruedCharge, currentUser); this.loanTransactionRepository.save(waiveTransaction); saveLoanWithDataIntegrityViolationChecks(loan); postJournalEntries(loan, existingTransactionIds, existingReversedTransactionIds); this.businessEventNotifierService.notifyBusinessEventWasExecuted(BUSINESS_EVENTS.LOAN_WAIVE_CHARGE, constructEntityMap(BUSINESS_ENTITY.LOAN_CHARGE, loanCharge)); return new CommandProcessingResultBuilder() // .withCommandId(command.commandId()) // .withEntityId(loanChargeId) // .withOfficeId(loan.getOfficeId()) // .withClientId(loan.getClientId()) // .withGroupId(loan.getGroupId()) // .withLoanId(loanId) // .with(changes) // .build(); } @Transactional @Override public CommandProcessingResult deleteLoanCharge(final Long loanId, final Long loanChargeId, final JsonCommand command) { final Loan loan = this.loanAssembler.assembleFrom(loanId); checkClientOrGroupActive(loan); final LoanCharge loanCharge = retrieveLoanChargeBy(loanId, loanChargeId); // Charges may be deleted only when the loan associated with them are // yet to be approved (are in submitted and pending status) if (!loan.status().isSubmittedAndPendingApproval()) { throw new LoanChargeCannotBeDeletedException( LOAN_CHARGE_CANNOT_BE_DELETED_REASON.LOAN_NOT_IN_SUBMITTED_AND_PENDING_APPROVAL_STAGE, loanCharge.getId()); } this.businessEventNotifierService.notifyBusinessEventToBeExecuted(BUSINESS_EVENTS.LOAN_DELETE_CHARGE, constructEntityMap(BUSINESS_ENTITY.LOAN_CHARGE, loanCharge)); loan.removeLoanCharge(loanCharge); saveLoanWithDataIntegrityViolationChecks(loan); this.businessEventNotifierService.notifyBusinessEventWasExecuted(BUSINESS_EVENTS.LOAN_DELETE_CHARGE, constructEntityMap(BUSINESS_ENTITY.LOAN_CHARGE, loanCharge)); return new CommandProcessingResultBuilder() // .withCommandId(command.commandId()) // .withEntityId(loanChargeId) // .withOfficeId(loan.getOfficeId()) // .withClientId(loan.getClientId()) // .withGroupId(loan.getGroupId()) // .withLoanId(loanId) // .build(); } @Override @Transactional public CommandProcessingResult payLoanCharge(final Long loanId, Long loanChargeId, final JsonCommand command, final boolean isChargeIdIncludedInJson) { this.loanEventApiJsonValidator.validateChargePaymentTransaction(command.json(), isChargeIdIncludedInJson); if (isChargeIdIncludedInJson) { loanChargeId = command.longValueOfParameterNamed("chargeId"); } final Loan loan = this.loanAssembler.assembleFrom(loanId); checkClientOrGroupActive(loan); final LoanCharge loanCharge = retrieveLoanChargeBy(loanId, loanChargeId); // Charges may be waived only when the loan associated with them are // active if (!loan.status().isActive()) { throw new LoanChargeCannotBePayedException(LOAN_CHARGE_CANNOT_BE_PAYED_REASON.LOAN_INACTIVE, loanCharge.getId()); } // validate loan charge is not already paid or waived if (loanCharge.isWaived()) { throw new LoanChargeCannotBePayedException(LOAN_CHARGE_CANNOT_BE_PAYED_REASON.ALREADY_WAIVED, loanCharge.getId()); } else if (loanCharge.isPaid()) { throw new LoanChargeCannotBePayedException(LOAN_CHARGE_CANNOT_BE_PAYED_REASON.ALREADY_PAID, loanCharge.getId()); } if (!loanCharge.getChargePaymentMode().isPaymentModeAccountTransfer()) { throw new LoanChargeCannotBePayedException( LOAN_CHARGE_CANNOT_BE_PAYED_REASON.CHARGE_NOT_ACCOUNT_TRANSFER, loanCharge.getId()); } final LocalDate transactionDate = command.localDateValueOfParameterNamed("transactionDate"); final Locale locale = command.extractLocale(); final DateTimeFormatter fmt = DateTimeFormat.forPattern(command.dateFormat()).withLocale(locale); Integer loanInstallmentNumber = null; BigDecimal amount = loanCharge.amountOutstanding(); if (loanCharge.isInstalmentFee()) { LoanInstallmentCharge chargePerInstallment = null; final LocalDate dueDate = command.localDateValueOfParameterNamed("dueDate"); final Integer installmentNumber = command.integerValueOfParameterNamed("installmentNumber"); if (dueDate != null) { chargePerInstallment = loanCharge.getInstallmentLoanCharge(dueDate); } else if (installmentNumber != null) { chargePerInstallment = loanCharge.getInstallmentLoanCharge(installmentNumber); } if (chargePerInstallment == null) { chargePerInstallment = loanCharge.getUnpaidInstallmentLoanCharge(); } if (chargePerInstallment.isWaived()) { throw new LoanChargeCannotBePayedException(LOAN_CHARGE_CANNOT_BE_PAYED_REASON.ALREADY_WAIVED, loanCharge.getId()); } else if (chargePerInstallment.isPaid()) { throw new LoanChargeCannotBePayedException(LOAN_CHARGE_CANNOT_BE_PAYED_REASON.ALREADY_PAID, loanCharge.getId()); } loanInstallmentNumber = chargePerInstallment.getRepaymentInstallment().getInstallmentNumber(); amount = chargePerInstallment.getAmountOutstanding(); } final PortfolioAccountData portfolioAccountData = this.accountAssociationsReadPlatformService .retriveLoanLinkedAssociation(loanId); if (portfolioAccountData == null) { final String errorMessage = "Charge with id:" + loanChargeId + " requires linked savings account for payment"; throw new LinkedAccountRequiredException("loanCharge.pay", errorMessage, loanChargeId); } final SavingsAccount fromSavingsAccount = null; final boolean isRegularTransaction = true; final boolean isExceptionForBalanceCheck = false; final AccountTransferDTO accountTransferDTO = new AccountTransferDTO(transactionDate, amount, PortfolioAccountType.SAVINGS, PortfolioAccountType.LOAN, portfolioAccountData.accountId(), loanId, "Loan Charge Payment", locale, fmt, null, null, LoanTransactionType.CHARGE_PAYMENT.getValue(), loanChargeId, loanInstallmentNumber, AccountTransferType.CHARGE_PAYMENT.getValue(), null, null, null, null, null, fromSavingsAccount, isRegularTransaction, isExceptionForBalanceCheck); this.accountTransfersWritePlatformService.transferFunds(accountTransferDTO); return new CommandProcessingResultBuilder() // .withCommandId(command.commandId()) // .withEntityId(loanChargeId) // .withOfficeId(loan.getOfficeId()) // .withClientId(loan.getClientId()) // .withGroupId(loan.getGroupId()) // .withLoanId(loanId) // .withSavingsId(portfolioAccountData.accountId()).build(); } public void disburseLoanToLoan(final Loan loan, final JsonCommand command, final BigDecimal amount) { final LocalDate transactionDate = command.localDateValueOfParameterNamed("actualDisbursementDate"); final String txnExternalId = command.stringValueOfParameterNamedAllowingNull("externalId"); final Locale locale = command.extractLocale(); final DateTimeFormatter fmt = DateTimeFormat.forPattern(command.dateFormat()).withLocale(locale); final AccountTransferDTO accountTransferDTO = new AccountTransferDTO(transactionDate, amount, PortfolioAccountType.LOAN, PortfolioAccountType.LOAN, loan.getId(), loan.getTopupLoanDetails().getLoanIdToClose(), "Loan Topup", locale, fmt, LoanTransactionType.DISBURSEMENT.getValue(), LoanTransactionType.REPAYMENT.getValue(), txnExternalId, loan, null); AccountTransferDetails accountTransferDetails = this.accountTransfersWritePlatformService .repayLoanWithTopup(accountTransferDTO); loan.getTopupLoanDetails().setAccountTransferDetails(accountTransferDetails.getId()); loan.getTopupLoanDetails().setTopupAmount(amount); } public void disburseLoanToSavings(final Loan loan, final JsonCommand command, final Money amount, final PaymentDetail paymentDetail) { final LocalDate transactionDate = command.localDateValueOfParameterNamed("actualDisbursementDate"); final String txnExternalId = command.stringValueOfParameterNamedAllowingNull("externalId"); final Locale locale = command.extractLocale(); final DateTimeFormatter fmt = DateTimeFormat.forPattern(command.dateFormat()).withLocale(locale); final PortfolioAccountData portfolioAccountData = this.accountAssociationsReadPlatformService .retriveLoanLinkedAssociation(loan.getId()); if (portfolioAccountData == null) { final String errorMessage = "Disburse Loan with id:" + loan.getId() + " requires linked savings account for payment"; throw new LinkedAccountRequiredException("loan.disburse.to.savings", errorMessage, loan.getId()); } final SavingsAccount fromSavingsAccount = null; final boolean isExceptionForBalanceCheck = false; final boolean isRegularTransaction = true; final AccountTransferDTO accountTransferDTO = new AccountTransferDTO(transactionDate, amount.getAmount(), PortfolioAccountType.LOAN, PortfolioAccountType.SAVINGS, loan.getId(), portfolioAccountData.accountId(), "Loan Disbursement", locale, fmt, paymentDetail, LoanTransactionType.DISBURSEMENT.getValue(), null, null, null, AccountTransferType.ACCOUNT_TRANSFER.getValue(), null, null, txnExternalId, loan, null, fromSavingsAccount, isRegularTransaction, isExceptionForBalanceCheck); this.accountTransfersWritePlatformService.transferFunds(accountTransferDTO); } @Override @CronTarget(jobName = JobName.TRANSFER_FEE_CHARGE_FOR_LOANS) public void transferFeeCharges() throws JobExecutionException { final Collection<LoanChargeData> chargeDatas = this.loanChargeReadPlatformService .retrieveLoanChargesForFeePayment(ChargePaymentMode.ACCOUNT_TRANSFER.getValue(), LoanStatus.ACTIVE.getValue()); final boolean isRegularTransaction = true; final StringBuilder sb = new StringBuilder(); if (chargeDatas != null) { for (final LoanChargeData chargeData : chargeDatas) { if (chargeData.isInstallmentFee()) { final Collection<LoanInstallmentChargeData> chargePerInstallments = this.loanChargeReadPlatformService .retrieveInstallmentLoanCharges(chargeData.getId(), true); PortfolioAccountData portfolioAccountData = null; for (final LoanInstallmentChargeData installmentChargeData : chargePerInstallments) { if (!installmentChargeData.getDueDate().isAfter(new LocalDate())) { if (portfolioAccountData == null) { portfolioAccountData = this.accountAssociationsReadPlatformService .retriveLoanLinkedAssociation(chargeData.getLoanId()); } final SavingsAccount fromSavingsAccount = null; final boolean isExceptionForBalanceCheck = false; final AccountTransferDTO accountTransferDTO = new AccountTransferDTO(new LocalDate(), installmentChargeData.getAmountOutstanding(), PortfolioAccountType.SAVINGS, PortfolioAccountType.LOAN, portfolioAccountData.accountId(), chargeData.getLoanId(), "Loan Charge Payment", null, null, null, null, LoanTransactionType.CHARGE_PAYMENT.getValue(), chargeData.getId(), installmentChargeData.getInstallmentNumber(), AccountTransferType.CHARGE_PAYMENT.getValue(), null, null, null, null, null, fromSavingsAccount, isRegularTransaction, isExceptionForBalanceCheck); transferFeeCharge(sb, accountTransferDTO); } } } else if (chargeData.getDueDate() != null && !chargeData.getDueDate().isAfter(new LocalDate())) { final PortfolioAccountData portfolioAccountData = this.accountAssociationsReadPlatformService .retriveLoanLinkedAssociation(chargeData.getLoanId()); final SavingsAccount fromSavingsAccount = null; final boolean isExceptionForBalanceCheck = false; final AccountTransferDTO accountTransferDTO = new AccountTransferDTO(new LocalDate(), chargeData.getAmountOutstanding(), PortfolioAccountType.SAVINGS, PortfolioAccountType.LOAN, portfolioAccountData.accountId(), chargeData.getLoanId(), "Loan Charge Payment", null, null, null, null, LoanTransactionType.CHARGE_PAYMENT.getValue(), chargeData.getId(), null, AccountTransferType.CHARGE_PAYMENT.getValue(), null, null, null, null, null, fromSavingsAccount, isRegularTransaction, isExceptionForBalanceCheck); transferFeeCharge(sb, accountTransferDTO); } } } if (sb.length() > 0) { throw new JobExecutionException(sb.toString()); } } /** * @param sb * @param accountTransferDTO */ private void transferFeeCharge(final StringBuilder sb, final AccountTransferDTO accountTransferDTO) { try { this.accountTransfersWritePlatformService.transferFunds(accountTransferDTO); } catch (final PlatformApiDataValidationException e) { sb.append("Validation exception while paying charge ").append(accountTransferDTO.getChargeId()) .append(" for loan id:").append(accountTransferDTO.getToAccountId()).append("--------"); } catch (final InsufficientAccountBalanceException e) { sb.append("InsufficientAccountBalance Exception while paying charge ") .append(accountTransferDTO.getChargeId()).append("for loan id:") .append(accountTransferDTO.getToAccountId()).append("--------"); } } private LoanCharge retrieveLoanChargeBy(final Long loanId, final Long loanChargeId) { final LoanCharge loanCharge = this.loanChargeRepository.findOne(loanChargeId); if (loanCharge == null) { throw new LoanChargeNotFoundException(loanChargeId); } if (loanCharge.hasNotLoanIdentifiedBy(loanId)) { throw new LoanChargeNotFoundException(loanChargeId, loanId); } return loanCharge; } @Transactional @Override public LoanTransaction initiateLoanTransfer(final Loan loan, final LocalDate transferDate) { AppUser currentUser = getAppUserIfPresent(); this.loanAssembler.setHelpers(loan); checkClientOrGroupActive(loan); this.businessEventNotifierService.notifyBusinessEventToBeExecuted(BUSINESS_EVENTS.LOAN_INITIATE_TRANSFER, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); final List<Long> existingTransactionIds = new ArrayList<>(loan.findExistingTransactionIds()); final List<Long> existingReversedTransactionIds = new ArrayList<>( loan.findExistingReversedTransactionIds()); final LoanTransaction newTransferTransaction = LoanTransaction.initiateTransfer(loan.getOffice(), loan, transferDate, DateUtils.getLocalDateTimeOfTenant(), currentUser); loan.addLoanTransaction(newTransferTransaction); loan.setLoanStatus(LoanStatus.TRANSFER_IN_PROGRESS.getValue()); this.loanTransactionRepository.save(newTransferTransaction); saveLoanWithDataIntegrityViolationChecks(loan); postJournalEntries(loan, existingTransactionIds, existingReversedTransactionIds); this.businessEventNotifierService.notifyBusinessEventWasExecuted(BUSINESS_EVENTS.LOAN_INITIATE_TRANSFER, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); return newTransferTransaction; } @Transactional @Override public LoanTransaction acceptLoanTransfer(final Loan loan, final LocalDate transferDate, final Office acceptedInOffice, final Staff loanOfficer) { AppUser currentUser = getAppUserIfPresent(); this.loanAssembler.setHelpers(loan); this.businessEventNotifierService.notifyBusinessEventToBeExecuted(BUSINESS_EVENTS.LOAN_ACCEPT_TRANSFER, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); final List<Long> existingTransactionIds = new ArrayList<>(loan.findExistingTransactionIds()); final List<Long> existingReversedTransactionIds = new ArrayList<>( loan.findExistingReversedTransactionIds()); final LoanTransaction newTransferAcceptanceTransaction = LoanTransaction.approveTransfer(acceptedInOffice, loan, transferDate, DateUtils.getLocalDateTimeOfTenant(), currentUser); loan.addLoanTransaction(newTransferAcceptanceTransaction); if (loan.getTotalOverpaid() != null) { loan.setLoanStatus(LoanStatus.OVERPAID.getValue()); } else { loan.setLoanStatus(LoanStatus.ACTIVE.getValue()); } if (loanOfficer != null) { loan.reassignLoanOfficer(loanOfficer, transferDate); } this.loanTransactionRepository.save(newTransferAcceptanceTransaction); saveLoanWithDataIntegrityViolationChecks(loan); postJournalEntries(loan, existingTransactionIds, existingReversedTransactionIds); this.businessEventNotifierService.notifyBusinessEventWasExecuted(BUSINESS_EVENTS.LOAN_ACCEPT_TRANSFER, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); return newTransferAcceptanceTransaction; } @Transactional @Override public LoanTransaction withdrawLoanTransfer(final Loan loan, final LocalDate transferDate) { AppUser currentUser = getAppUserIfPresent(); this.loanAssembler.setHelpers(loan); this.businessEventNotifierService.notifyBusinessEventToBeExecuted(BUSINESS_EVENTS.LOAN_WITHDRAW_TRANSFER, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); final List<Long> existingTransactionIds = new ArrayList<>(loan.findExistingTransactionIds()); final List<Long> existingReversedTransactionIds = new ArrayList<>( loan.findExistingReversedTransactionIds()); final LoanTransaction newTransferAcceptanceTransaction = LoanTransaction.withdrawTransfer(loan.getOffice(), loan, transferDate, DateUtils.getLocalDateTimeOfTenant(), currentUser); loan.addLoanTransaction(newTransferAcceptanceTransaction); loan.setLoanStatus(LoanStatus.ACTIVE.getValue()); this.loanTransactionRepository.save(newTransferAcceptanceTransaction); saveLoanWithDataIntegrityViolationChecks(loan); postJournalEntries(loan, existingTransactionIds, existingReversedTransactionIds); this.businessEventNotifierService.notifyBusinessEventWasExecuted(BUSINESS_EVENTS.LOAN_WITHDRAW_TRANSFER, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); return newTransferAcceptanceTransaction; } @Transactional @Override public void rejectLoanTransfer(final Loan loan) { this.loanAssembler.setHelpers(loan); this.businessEventNotifierService.notifyBusinessEventToBeExecuted(BUSINESS_EVENTS.LOAN_REJECT_TRANSFER, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); loan.setLoanStatus(LoanStatus.TRANSFER_ON_HOLD.getValue()); saveLoanWithDataIntegrityViolationChecks(loan); this.businessEventNotifierService.notifyBusinessEventWasExecuted(BUSINESS_EVENTS.LOAN_REJECT_TRANSFER, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); } @Transactional @Override public CommandProcessingResult loanReassignment(final Long loanId, final JsonCommand command) { this.loanEventApiJsonValidator.validateUpdateOfLoanOfficer(command.json()); final Long fromLoanOfficerId = command.longValueOfParameterNamed("fromLoanOfficerId"); final Long toLoanOfficerId = command.longValueOfParameterNamed("toLoanOfficerId"); final Staff fromLoanOfficer = this.loanAssembler.findLoanOfficerByIdIfProvided(fromLoanOfficerId); final Staff toLoanOfficer = this.loanAssembler.findLoanOfficerByIdIfProvided(toLoanOfficerId); final LocalDate dateOfLoanOfficerAssignment = command.localDateValueOfParameterNamed("assignmentDate"); final Loan loan = this.loanAssembler.assembleFrom(loanId); checkClientOrGroupActive(loan); this.businessEventNotifierService.notifyBusinessEventToBeExecuted(BUSINESS_EVENTS.LOAN_REASSIGN_OFFICER, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); if (!loan.hasLoanOfficer(fromLoanOfficer)) { throw new LoanOfficerAssignmentException(loanId, fromLoanOfficerId); } loan.reassignLoanOfficer(toLoanOfficer, dateOfLoanOfficerAssignment); saveLoanWithDataIntegrityViolationChecks(loan); this.businessEventNotifierService.notifyBusinessEventWasExecuted(BUSINESS_EVENTS.LOAN_REASSIGN_OFFICER, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); return new CommandProcessingResultBuilder() // .withCommandId(command.commandId()) // .withEntityId(loanId) // .withOfficeId(loan.getOfficeId()) // .withClientId(loan.getClientId()) // .withGroupId(loan.getGroupId()) // .withLoanId(loanId) // .build(); } @Transactional @Override public CommandProcessingResult bulkLoanReassignment(final JsonCommand command) { this.loanEventApiJsonValidator.validateForBulkLoanReassignment(command.json()); final Long fromLoanOfficerId = command.longValueOfParameterNamed("fromLoanOfficerId"); final Long toLoanOfficerId = command.longValueOfParameterNamed("toLoanOfficerId"); final String[] loanIds = command.arrayValueOfParameterNamed("loans"); final LocalDate dateOfLoanOfficerAssignment = command.localDateValueOfParameterNamed("assignmentDate"); final Staff fromLoanOfficer = this.loanAssembler.findLoanOfficerByIdIfProvided(fromLoanOfficerId); final Staff toLoanOfficer = this.loanAssembler.findLoanOfficerByIdIfProvided(toLoanOfficerId); for (final String loanIdString : loanIds) { final Long loanId = Long.valueOf(loanIdString); final Loan loan = this.loanAssembler.assembleFrom(loanId); this.businessEventNotifierService.notifyBusinessEventToBeExecuted(BUSINESS_EVENTS.LOAN_REASSIGN_OFFICER, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); checkClientOrGroupActive(loan); if (!loan.hasLoanOfficer(fromLoanOfficer)) { throw new LoanOfficerAssignmentException(loanId, fromLoanOfficerId); } loan.reassignLoanOfficer(toLoanOfficer, dateOfLoanOfficerAssignment); saveLoanWithDataIntegrityViolationChecks(loan); this.businessEventNotifierService.notifyBusinessEventWasExecuted(BUSINESS_EVENTS.LOAN_REASSIGN_OFFICER, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); } this.loanRepositoryWrapper.flush(); return new CommandProcessingResultBuilder() // .withCommandId(command.commandId()) // .build(); } @Transactional @Override public CommandProcessingResult removeLoanOfficer(final Long loanId, final JsonCommand command) { final LoanUpdateCommand loanUpdateCommand = this.loanUpdateCommandFromApiJsonDeserializer .commandFromApiJson(command.json()); loanUpdateCommand.validate(); final LocalDate dateOfLoanOfficerunAssigned = command.localDateValueOfParameterNamed("unassignedDate"); final Loan loan = this.loanAssembler.assembleFrom(loanId); checkClientOrGroupActive(loan); if (loan.getLoanOfficer() == null) { throw new LoanOfficerUnassignmentException(loanId); } this.businessEventNotifierService.notifyBusinessEventToBeExecuted(BUSINESS_EVENTS.LOAN_REMOVE_OFFICER, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); loan.removeLoanOfficer(dateOfLoanOfficerunAssigned); saveLoanWithDataIntegrityViolationChecks(loan); this.businessEventNotifierService.notifyBusinessEventWasExecuted(BUSINESS_EVENTS.LOAN_REMOVE_OFFICER, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); return new CommandProcessingResultBuilder() // .withCommandId(command.commandId()) // .withEntityId(loanId) // .withOfficeId(loan.getOfficeId()) // .withClientId(loan.getClientId()) // .withGroupId(loan.getGroupId()) // .withLoanId(loanId) // .build(); } private void postJournalEntries(final Loan loan, final List<Long> existingTransactionIds, final List<Long> existingReversedTransactionIds) { final MonetaryCurrency currency = loan.getCurrency(); final ApplicationCurrency applicationCurrency = this.applicationCurrencyRepository .findOneWithNotFoundDetection(currency); boolean isAccountTransfer = false; final Map<String, Object> accountingBridgeData = loan.deriveAccountingBridgeData( applicationCurrency.toData(), existingTransactionIds, existingReversedTransactionIds, isAccountTransfer); this.journalEntryWritePlatformService.createJournalEntriesForLoan(accountingBridgeData); } @Transactional @Override public void applyMeetingDateChanges(final Calendar calendar, final Collection<CalendarInstance> loanCalendarInstances) { final Boolean reschedulebasedOnMeetingDates = null; final LocalDate presentMeetingDate = null; final LocalDate newMeetingDate = null; applyMeetingDateChanges(calendar, loanCalendarInstances, reschedulebasedOnMeetingDates, presentMeetingDate, newMeetingDate); } @Transactional @Override public void applyMeetingDateChanges(final Calendar calendar, final Collection<CalendarInstance> loanCalendarInstances, final Boolean reschedulebasedOnMeetingDates, final LocalDate presentMeetingDate, final LocalDate newMeetingDate) { final boolean isHolidayEnabled = this.configurationDomainService.isRescheduleRepaymentsOnHolidaysEnabled(); final WorkingDays workingDays = this.workingDaysRepository.findOne(); final AppUser currentUser = getAppUserIfPresent(); final List<Long> existingTransactionIds = new ArrayList<>(); final List<Long> existingReversedTransactionIds = new ArrayList<>(); final Collection<Integer> loanStatuses = new ArrayList<>( Arrays.asList(LoanStatus.SUBMITTED_AND_PENDING_APPROVAL.getValue(), LoanStatus.APPROVED.getValue(), LoanStatus.ACTIVE.getValue())); final Collection<Integer> loanTypes = new ArrayList<>( Arrays.asList(AccountType.GROUP.getValue(), AccountType.JLG.getValue())); final Collection<Long> loanIds = new ArrayList<>(loanCalendarInstances.size()); // loop through loanCalendarInstances to get loan ids for (final CalendarInstance calendarInstance : loanCalendarInstances) { loanIds.add(calendarInstance.getEntityId()); } final List<Loan> loans = this.loanRepositoryWrapper.findByIdsAndLoanStatusAndLoanType(loanIds, loanStatuses, loanTypes); List<Holiday> holidays = null; final LocalDate recalculateFrom = null; // loop through each loan to reschedule the repayment dates for (final Loan loan : loans) { if (loan != null) { if (loan.getExpectedFirstRepaymentOnDate() != null && loan.getExpectedFirstRepaymentOnDate().equals(presentMeetingDate)) { final String defaultUserMessage = "Meeting calendar date update is not supported since its a first repayment date"; throw new CalendarParameterUpdateNotSupportedException("meeting.for.first.repayment.date", defaultUserMessage, loan.getExpectedFirstRepaymentOnDate(), presentMeetingDate); } Boolean isSkipRepaymentOnFirstMonth = false; Integer numberOfDays = 0; boolean isSkipRepaymentOnFirstMonthEnabled = configurationDomainService .isSkippingMeetingOnFirstDayOfMonthEnabled(); if (isSkipRepaymentOnFirstMonthEnabled) { isSkipRepaymentOnFirstMonth = this.loanUtilService.isLoanRepaymentsSyncWithMeeting(loan.group(), calendar); if (isSkipRepaymentOnFirstMonth) { numberOfDays = configurationDomainService.retreivePeroidInNumberOfDaysForSkipMeetingDate() .intValue(); } } holidays = this.holidayRepository.findByOfficeIdAndGreaterThanDate(loan.getOfficeId(), loan.getDisbursementDate().toDate()); if (loan.repaymentScheduleDetail().isInterestRecalculationEnabled()) { ScheduleGeneratorDTO scheduleGeneratorDTO = loanUtilService.buildScheduleGeneratorDTO(loan, recalculateFrom); loan.setHelpers(null, this.loanSummaryWrapper, this.transactionProcessingStrategy); loan.recalculateScheduleFromLastTransaction(scheduleGeneratorDTO, existingTransactionIds, existingReversedTransactionIds, currentUser); createAndSaveLoanScheduleArchive(loan, scheduleGeneratorDTO); } else if (reschedulebasedOnMeetingDates != null && reschedulebasedOnMeetingDates) { loan.updateLoanRepaymentScheduleDates(calendar.getStartDateLocalDate(), calendar.getRecurrence(), isHolidayEnabled, holidays, workingDays, reschedulebasedOnMeetingDates, presentMeetingDate, newMeetingDate, isSkipRepaymentOnFirstMonth, numberOfDays); } else { loan.updateLoanRepaymentScheduleDates(calendar.getStartDateLocalDate(), calendar.getRecurrence(), isHolidayEnabled, holidays, workingDays, isSkipRepaymentOnFirstMonth, numberOfDays); } saveLoanWithDataIntegrityViolationChecks(loan); } } } private void removeLoanCycle(final Loan loan) { final List<Loan> loansToUpdate; if (loan.isGroupLoan()) { if (loan.loanProduct().isIncludeInBorrowerCycle()) { loansToUpdate = this.loanRepositoryWrapper.getGroupLoansToUpdateLoanCounter( loan.getCurrentLoanCounter(), loan.getGroupId(), AccountType.GROUP.getValue()); } else { loansToUpdate = this.loanRepositoryWrapper.getGroupLoansToUpdateLoanProductCounter( loan.getLoanProductLoanCounter(), loan.getGroupId(), AccountType.GROUP.getValue()); } } else { if (loan.loanProduct().isIncludeInBorrowerCycle()) { loansToUpdate = this.loanRepositoryWrapper .getClientOrJLGLoansToUpdateLoanCounter(loan.getCurrentLoanCounter(), loan.getClientId()); } else { loansToUpdate = this.loanRepositoryWrapper.getClientLoansToUpdateLoanProductCounter( loan.getLoanProductLoanCounter(), loan.getClientId()); } } if (loansToUpdate != null) { updateLoanCycleCounter(loansToUpdate, loan); } loan.updateClientLoanCounter(null); loan.updateLoanProductLoanCounter(null); } private void updateLoanCounters(final Loan loan, final LocalDate actualDisbursementDate) { if (loan.isGroupLoan()) { final List<Loan> loansToUpdateForLoanCounter = this.loanRepositoryWrapper.getGroupLoansDisbursedAfter( actualDisbursementDate.toDate(), loan.getGroupId(), AccountType.GROUP.getValue()); final Integer newLoanCounter = getNewGroupLoanCounter(loan); final Integer newLoanProductCounter = getNewGroupLoanProductCounter(loan); updateLoanCounter(loan, loansToUpdateForLoanCounter, newLoanCounter, newLoanProductCounter); } else { final List<Loan> loansToUpdateForLoanCounter = this.loanRepositoryWrapper .getClientOrJLGLoansDisbursedAfter(actualDisbursementDate.toDate(), loan.getClientId()); final Integer newLoanCounter = getNewClientOrJLGLoanCounter(loan); final Integer newLoanProductCounter = getNewClientOrJLGLoanProductCounter(loan); updateLoanCounter(loan, loansToUpdateForLoanCounter, newLoanCounter, newLoanProductCounter); } } private Integer getNewGroupLoanCounter(final Loan loan) { Integer maxClientLoanCounter = this.loanRepositoryWrapper.getMaxGroupLoanCounter(loan.getGroupId(), AccountType.GROUP.getValue()); if (maxClientLoanCounter == null) { maxClientLoanCounter = 1; } else { maxClientLoanCounter = maxClientLoanCounter + 1; } return maxClientLoanCounter; } private Integer getNewGroupLoanProductCounter(final Loan loan) { Integer maxLoanProductLoanCounter = this.loanRepositoryWrapper.getMaxGroupLoanProductCounter( loan.loanProduct().getId(), loan.getGroupId(), AccountType.GROUP.getValue()); if (maxLoanProductLoanCounter == null) { maxLoanProductLoanCounter = 1; } else { maxLoanProductLoanCounter = maxLoanProductLoanCounter + 1; } return maxLoanProductLoanCounter; } private void updateLoanCounter(final Loan loan, final List<Loan> loansToUpdateForLoanCounter, Integer newLoanCounter, Integer newLoanProductCounter) { final boolean includeInBorrowerCycle = loan.loanProduct().isIncludeInBorrowerCycle(); for (final Loan loanToUpdate : loansToUpdateForLoanCounter) { // Update client loan counter if loan product includeInBorrowerCycle // is true if (loanToUpdate.loanProduct().isIncludeInBorrowerCycle()) { Integer currentLoanCounter = loanToUpdate.getCurrentLoanCounter() == null ? 1 : loanToUpdate.getCurrentLoanCounter(); if (newLoanCounter > currentLoanCounter) { newLoanCounter = currentLoanCounter; } loanToUpdate.updateClientLoanCounter(++currentLoanCounter); } if (loanToUpdate.loanProduct().getId().equals(loan.loanProduct().getId())) { Integer loanProductLoanCounter = loanToUpdate.getLoanProductLoanCounter(); if (newLoanProductCounter > loanProductLoanCounter) { newLoanProductCounter = loanProductLoanCounter; } loanToUpdate.updateLoanProductLoanCounter(++loanProductLoanCounter); } } if (includeInBorrowerCycle) { loan.updateClientLoanCounter(newLoanCounter); } else { loan.updateClientLoanCounter(null); } loan.updateLoanProductLoanCounter(newLoanProductCounter); this.loanRepositoryWrapper.save(loansToUpdateForLoanCounter); } private Integer getNewClientOrJLGLoanCounter(final Loan loan) { Integer maxClientLoanCounter = this.loanRepositoryWrapper.getMaxClientOrJLGLoanCounter(loan.getClientId()); if (maxClientLoanCounter == null) { maxClientLoanCounter = 1; } else { maxClientLoanCounter = maxClientLoanCounter + 1; } return maxClientLoanCounter; } private Integer getNewClientOrJLGLoanProductCounter(final Loan loan) { Integer maxLoanProductLoanCounter = this.loanRepositoryWrapper .getMaxClientOrJLGLoanProductCounter(loan.loanProduct().getId(), loan.getClientId()); if (maxLoanProductLoanCounter == null) { maxLoanProductLoanCounter = 1; } else { maxLoanProductLoanCounter = maxLoanProductLoanCounter + 1; } return maxLoanProductLoanCounter; } private void updateLoanCycleCounter(final List<Loan> loansToUpdate, final Loan loan) { final Integer currentLoancounter = loan.getCurrentLoanCounter(); final Integer currentLoanProductCounter = loan.getLoanProductLoanCounter(); for (final Loan loanToUpdate : loansToUpdate) { if (loan.loanProduct().isIncludeInBorrowerCycle()) { Integer runningLoancounter = loanToUpdate.getCurrentLoanCounter(); if (runningLoancounter > currentLoancounter) { loanToUpdate.updateClientLoanCounter(--runningLoancounter); } } if (loan.loanProduct().getId().equals(loanToUpdate.loanProduct().getId())) { Integer runningLoanProductCounter = loanToUpdate.getLoanProductLoanCounter(); if (runningLoanProductCounter > currentLoanProductCounter) { loanToUpdate.updateLoanProductLoanCounter(--runningLoanProductCounter); } } } this.loanRepositoryWrapper.save(loansToUpdate); } @Transactional @Override @CronTarget(jobName = JobName.APPLY_HOLIDAYS_TO_LOANS) public void applyHolidaysToLoans() { final boolean isHolidayEnabled = this.configurationDomainService.isRescheduleRepaymentsOnHolidaysEnabled(); if (!isHolidayEnabled) { return; } final Collection<Integer> loanStatuses = new ArrayList<>( Arrays.asList(LoanStatus.SUBMITTED_AND_PENDING_APPROVAL.getValue(), LoanStatus.APPROVED.getValue(), LoanStatus.ACTIVE.getValue())); // Get all Holidays which are active and not processed final List<Holiday> holidays = this.holidayRepository.findUnprocessed(); // Loop through all holidays for (final Holiday holiday : holidays) { // All offices to which holiday is applied final Set<Office> offices = holiday.getOffices(); final Collection<Long> officeIds = new ArrayList<>(offices.size()); for (final Office office : offices) { officeIds.add(office.getId()); } // get all loans final List<Loan> loans = new ArrayList<>(); // get all individual and jlg loans loans.addAll(this.loanRepositoryWrapper.findByClientOfficeIdsAndLoanStatus(officeIds, loanStatuses)); // FIXME: AA optimize to get all client and group loans belongs to a // office id // get all group loans loans.addAll(this.loanRepositoryWrapper.findByGroupOfficeIdsAndLoanStatus(officeIds, loanStatuses)); for (final Loan loan : loans) { // apply holiday loan.applyHolidayToRepaymentScheduleDates(holiday); } this.loanRepositoryWrapper.save(loans); holiday.processed(); } this.holidayRepository.save(holidays); } private void checkForProductMixRestrictions(final Loan loan) { final List<Long> activeLoansLoanProductIds; final Long productId = loan.loanProduct().getId(); if (loan.isGroupLoan()) { activeLoansLoanProductIds = this.loanRepositoryWrapper .findActiveLoansLoanProductIdsByGroup(loan.getGroupId(), LoanStatus.ACTIVE.getValue()); } else { activeLoansLoanProductIds = this.loanRepositoryWrapper .findActiveLoansLoanProductIdsByClient(loan.getClientId(), LoanStatus.ACTIVE.getValue()); } checkForProductMixRestrictions(activeLoansLoanProductIds, productId, loan.loanProduct().productName()); } private void checkForProductMixRestrictions(final List<Long> activeLoansLoanProductIds, final Long productId, final String productName) { if (!CollectionUtils.isEmpty(activeLoansLoanProductIds)) { final Collection<LoanProductData> restrictedPrdouctsList = this.loanProductReadPlatformService .retrieveRestrictedProductsForMix(productId); for (final LoanProductData restrictedProduct : restrictedPrdouctsList) { if (activeLoansLoanProductIds.contains(restrictedProduct.getId())) { throw new LoanDisbursalException(productName, restrictedProduct.getName()); } } } } private void checkClientOrGroupActive(final Loan loan) { final Client client = loan.client(); if (client != null) { if (client.isNotActive()) { throw new ClientNotActiveException(client.getId()); } } final Group group = loan.group(); if (group != null) { if (group.isNotActive()) { throw new GroupNotActiveException(group.getId()); } } } @Override @Transactional public void applyOverdueChargesForLoan(final Long loanId, Collection<OverdueLoanScheduleData> overdueLoanScheduleDatas) { Loan loan = null; final List<Long> existingTransactionIds = new ArrayList<>(); final List<Long> existingReversedTransactionIds = new ArrayList<>(); boolean runInterestRecalculation = false; LocalDate recalculateFrom = DateUtils.getLocalDateOfTenant(); LocalDate lastChargeDate = null; for (final OverdueLoanScheduleData overdueInstallment : overdueLoanScheduleDatas) { final JsonElement parsedCommand = this.fromApiJsonHelper.parse(overdueInstallment.toString()); final JsonCommand command = JsonCommand.from(overdueInstallment.toString(), parsedCommand, this.fromApiJsonHelper, null, null, null, null, null, loanId, null, null, null, null); LoanOverdueDTO overdueDTO = applyChargeToOverdueLoanInstallment(loanId, overdueInstallment.getChargeId(), overdueInstallment.getPeriodNumber(), command, loan, existingTransactionIds, existingReversedTransactionIds); loan = overdueDTO.getLoan(); runInterestRecalculation = runInterestRecalculation || overdueDTO.isRunInterestRecalculation(); if (recalculateFrom.isAfter(overdueDTO.getRecalculateFrom())) { recalculateFrom = overdueDTO.getRecalculateFrom(); } if (lastChargeDate == null || overdueDTO.getLastChargeAppliedDate().isAfter(lastChargeDate)) { lastChargeDate = overdueDTO.getLastChargeAppliedDate(); } } if (loan != null) { boolean reprocessRequired = true; LocalDate recalculatedTill = loan.fetchInterestRecalculateFromDate(); if (recalculateFrom.isAfter(recalculatedTill)) { recalculateFrom = recalculatedTill; } if (loan.repaymentScheduleDetail().isInterestRecalculationEnabled()) { if (runInterestRecalculation && loan.isFeeCompoundingEnabledForInterestRecalculation()) { runScheduleRecalculation(loan, recalculateFrom); reprocessRequired = false; } updateOriginalSchedule(loan); } if (reprocessRequired) { addInstallmentIfPenaltyAppliedAfterLastDueDate(loan, lastChargeDate); ChangedTransactionDetail changedTransactionDetail = loan.reprocessTransactions(); if (changedTransactionDetail != null) { for (final Map.Entry<Long, LoanTransaction> mapEntry : changedTransactionDetail .getNewTransactionMappings().entrySet()) { this.loanTransactionRepository.save(mapEntry.getValue()); // update loan with references to the newly created // transactions loan.addLoanTransaction(mapEntry.getValue()); this.accountTransfersWritePlatformService.updateLoanTransaction(mapEntry.getKey(), mapEntry.getValue()); } } saveLoanWithDataIntegrityViolationChecks(loan); } postJournalEntries(loan, existingTransactionIds, existingReversedTransactionIds); if (loan.repaymentScheduleDetail().isInterestRecalculationEnabled() && runInterestRecalculation && loan.isFeeCompoundingEnabledForInterestRecalculation()) { this.loanAccountDomainService.recalculateAccruals(loan); } this.businessEventNotifierService.notifyBusinessEventWasExecuted( BUSINESS_EVENTS.LOAN_APPLY_OVERDUE_CHARGE, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); } } private void addInstallmentIfPenaltyAppliedAfterLastDueDate(Loan loan, LocalDate lastChargeDate) { if (lastChargeDate != null) { List<LoanRepaymentScheduleInstallment> installments = loan.getRepaymentScheduleInstallments(); LoanRepaymentScheduleInstallment lastInstallment = loan .fetchRepaymentScheduleInstallment(installments.size()); if (lastChargeDate.isAfter(lastInstallment.getDueDate())) { if (lastInstallment.isRecalculatedInterestComponent()) { installments.remove(lastInstallment); lastInstallment = loan.fetchRepaymentScheduleInstallment(installments.size()); } boolean recalculatedInterestComponent = true; BigDecimal principal = BigDecimal.ZERO; BigDecimal interest = BigDecimal.ZERO; BigDecimal feeCharges = BigDecimal.ZERO; BigDecimal penaltyCharges = BigDecimal.ONE; final Set<LoanInterestRecalcualtionAdditionalDetails> compoundingDetails = null; LoanRepaymentScheduleInstallment newEntry = new LoanRepaymentScheduleInstallment(loan, installments.size() + 1, lastInstallment.getDueDate(), lastChargeDate, principal, interest, feeCharges, penaltyCharges, recalculatedInterestComponent, compoundingDetails); installments.add(newEntry); loan.addLoanRepaymentScheduleInstallment(newEntry); } } } public LoanOverdueDTO applyChargeToOverdueLoanInstallment(final Long loanId, final Long loanChargeId, final Integer periodNumber, final JsonCommand command, Loan loan, final List<Long> existingTransactionIds, final List<Long> existingReversedTransactionIds) { boolean runInterestRecalculation = false; final Charge chargeDefinition = this.chargeRepository.findOneWithNotFoundDetection(loanChargeId); Collection<Integer> frequencyNumbers = loanChargeReadPlatformService .retrieveOverdueInstallmentChargeFrequencyNumber(loanId, chargeDefinition.getId(), periodNumber); Integer feeFrequency = chargeDefinition.feeFrequency(); final ScheduledDateGenerator scheduledDateGenerator = new DefaultScheduledDateGenerator(); Map<Integer, LocalDate> scheduleDates = new HashMap<>(); final Long penaltyWaitPeriodValue = this.configurationDomainService.retrievePenaltyWaitPeriod(); final Long penaltyPostingWaitPeriodValue = this.configurationDomainService .retrieveGraceOnPenaltyPostingPeriod(); final LocalDate dueDate = command.localDateValueOfParameterNamed("dueDate"); Long diff = penaltyWaitPeriodValue + 1 - penaltyPostingWaitPeriodValue; if (diff < 0) { diff = 0L; } LocalDate startDate = dueDate.plusDays(penaltyWaitPeriodValue.intValue() + 1); Integer frequencyNunber = 1; if (feeFrequency == null) { scheduleDates.put(frequencyNunber++, startDate.minusDays(diff.intValue())); } else { while (DateUtils.getLocalDateOfTenant().isAfter(startDate)) { scheduleDates.put(frequencyNunber++, startDate.minusDays(diff.intValue())); LocalDate scheduleDate = scheduledDateGenerator.getRepaymentPeriodDate( PeriodFrequencyType.fromInt(feeFrequency), chargeDefinition.feeInterval(), startDate, null, null); startDate = scheduleDate; } } for (Integer frequency : frequencyNumbers) { scheduleDates.remove(frequency); } LoanRepaymentScheduleInstallment installment = null; LocalDate lastChargeAppliedDate = dueDate; if (!scheduleDates.isEmpty()) { if (loan == null) { loan = this.loanAssembler.assembleFrom(loanId); checkClientOrGroupActive(loan); existingTransactionIds.addAll(loan.findExistingTransactionIds()); existingReversedTransactionIds.addAll(loan.findExistingReversedTransactionIds()); } installment = loan.fetchRepaymentScheduleInstallment(periodNumber); lastChargeAppliedDate = installment.getDueDate(); } LocalDate recalculateFrom = DateUtils.getLocalDateOfTenant(); if (loan != null) { this.businessEventNotifierService.notifyBusinessEventToBeExecuted( BUSINESS_EVENTS.LOAN_APPLY_OVERDUE_CHARGE, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); for (Map.Entry<Integer, LocalDate> entry : scheduleDates.entrySet()) { final LoanCharge loanCharge = LoanCharge.createNewFromJson(loan, chargeDefinition, command, entry.getValue()); LoanOverdueInstallmentCharge overdueInstallmentCharge = new LoanOverdueInstallmentCharge(loanCharge, installment, entry.getKey()); loanCharge.updateOverdueInstallmentCharge(overdueInstallmentCharge); boolean isAppliedOnBackDate = addCharge(loan, chargeDefinition, loanCharge); runInterestRecalculation = runInterestRecalculation || isAppliedOnBackDate; if (entry.getValue().isBefore(recalculateFrom)) { recalculateFrom = entry.getValue(); } if (entry.getValue().isAfter(lastChargeAppliedDate)) { lastChargeAppliedDate = entry.getValue(); } } } return new LoanOverdueDTO(loan, runInterestRecalculation, recalculateFrom, lastChargeAppliedDate); } @Override public CommandProcessingResult undoWriteOff(Long loanId) { final AppUser currentUser = getAppUserIfPresent(); final Loan loan = this.loanAssembler.assembleFrom(loanId); checkClientOrGroupActive(loan); final List<Long> existingTransactionIds = new ArrayList<>(); final List<Long> existingReversedTransactionIds = new ArrayList<>(); if (!loan.isClosedWrittenOff()) { throw new PlatformServiceUnavailableException( "error.msg.loan.status.not.written.off.update.not.allowed", "Loan :" + loanId + " update not allowed as loan status is not written off", loanId); } LocalDate recalculateFrom = null; LoanTransaction writeOffTransaction = loan.findWriteOffTransaction(); this.businessEventNotifierService.notifyBusinessEventToBeExecuted(BUSINESS_EVENTS.LOAN_UNDO_WRITTEN_OFF, constructEntityMap(BUSINESS_ENTITY.LOAN_TRANSACTION, writeOffTransaction)); ScheduleGeneratorDTO scheduleGeneratorDTO = this.loanUtilService.buildScheduleGeneratorDTO(loan, recalculateFrom); ChangedTransactionDetail changedTransactionDetail = loan.undoWrittenOff(existingTransactionIds, existingReversedTransactionIds, scheduleGeneratorDTO, currentUser); if (changedTransactionDetail != null) { for (final Map.Entry<Long, LoanTransaction> mapEntry : changedTransactionDetail .getNewTransactionMappings().entrySet()) { this.loanTransactionRepository.save(mapEntry.getValue()); this.accountTransfersWritePlatformService.updateLoanTransaction(mapEntry.getKey(), mapEntry.getValue()); } } saveLoanWithDataIntegrityViolationChecks(loan); postJournalEntries(loan, existingTransactionIds, existingReversedTransactionIds); this.loanAccountDomainService.recalculateAccruals(loan); if (writeOffTransaction != null) { this.businessEventNotifierService.notifyBusinessEventWasExecuted(BUSINESS_EVENTS.LOAN_UNDO_WRITTEN_OFF, constructEntityMap(BUSINESS_ENTITY.LOAN_TRANSACTION, writeOffTransaction)); } return new CommandProcessingResultBuilder() // .withOfficeId(loan.getOfficeId()) // .withClientId(loan.getClientId()) // .withGroupId(loan.getGroupId()) // .withLoanId(loanId) // .build(); } private void validateMultiDisbursementData(final JsonCommand command, LocalDate expectedDisbursementDate) { final String json = command.json(); final JsonElement element = this.fromApiJsonHelper.parse(json); final List<ApiParameterError> dataValidationErrors = new ArrayList<>(); final DataValidatorBuilder baseDataValidator = new DataValidatorBuilder(dataValidationErrors) .resource("loan"); final JsonArray disbursementDataArray = command .arrayOfParameterNamed(LoanApiConstants.disbursementDataParameterName); if (disbursementDataArray == null || disbursementDataArray.size() == 0) { final String errorMessage = "For this loan product, disbursement details must be provided"; throw new MultiDisbursementDataRequiredException(LoanApiConstants.disbursementDataParameterName, errorMessage); } final BigDecimal principal = this.fromApiJsonHelper.extractBigDecimalWithLocaleNamed("approvedLoanAmount", element); loanApplicationCommandFromApiJsonHelper.validateLoanMultiDisbursementdate(element, baseDataValidator, expectedDisbursementDate, principal); if (!dataValidationErrors.isEmpty()) { throw new PlatformApiDataValidationException(dataValidationErrors); } } private void validateForAddAndDeleteTranche(final Loan loan) { BigDecimal totalDisbursedAmount = BigDecimal.ZERO; Collection<LoanDisbursementDetails> loanDisburseDetails = loan.getDisbursementDetails(); for (LoanDisbursementDetails disbursementDetails : loanDisburseDetails) { if (disbursementDetails.actualDisbursementDate() != null) { totalDisbursedAmount = totalDisbursedAmount.add(disbursementDetails.principal()); } } if (totalDisbursedAmount.compareTo(loan.getApprovedPrincipal()) == 0) { final String errorMessage = "loan.disbursement.cannot.be.a.edited"; throw new LoanMultiDisbursementException(errorMessage); } } @Override @Transactional public CommandProcessingResult addAndDeleteLoanDisburseDetails(Long loanId, JsonCommand command) { final Loan loan = this.loanAssembler.assembleFrom(loanId); checkClientOrGroupActive(loan); final Map<String, Object> actualChanges = new LinkedHashMap<>(); LocalDate expectedDisbursementDate = loan.getExpectedDisbursedOnLocalDate(); if (!loan.loanProduct().isMultiDisburseLoan()) { final String errorMessage = "loan.product.does.not.support.multiple.disbursals"; throw new LoanMultiDisbursementException(errorMessage); } if (loan.isSubmittedAndPendingApproval() || loan.isClosed() || loan.isClosedWrittenOff() || loan.status().isClosedObligationsMet() || loan.status().isOverpaid()) { final String errorMessage = "cannot.modify.tranches.if.loan.is.pendingapproval.closed.overpaid.writtenoff"; throw new LoanMultiDisbursementException(errorMessage); } validateMultiDisbursementData(command, expectedDisbursementDate); this.validateForAddAndDeleteTranche(loan); loan.updateDisbursementDetails(command, actualChanges); if (loan.getDisbursementDetails().isEmpty()) { final String errorMessage = "For this loan product, disbursement details must be provided"; throw new MultiDisbursementDataRequiredException(LoanApiConstants.disbursementDataParameterName, errorMessage); } if (loan.getDisbursementDetails().size() > loan.loanProduct().maxTrancheCount()) { final String errorMessage = "Number of tranche shouldn't be greter than " + loan.loanProduct().maxTrancheCount(); throw new ExceedingTrancheCountException(LoanApiConstants.disbursementDataParameterName, errorMessage, loan.loanProduct().maxTrancheCount(), loan.getDisbursementDetails().size()); } LoanDisbursementDetails updateDetails = null; return processLoanDisbursementDetail(loan, loanId, command, updateDetails); } private CommandProcessingResult processLoanDisbursementDetail(final Loan loan, Long loanId, JsonCommand command, LoanDisbursementDetails loanDisbursementDetails) { final List<Long> existingTransactionIds = new ArrayList<>(); final List<Long> existingReversedTransactionIds = new ArrayList<>(); existingTransactionIds.addAll(loan.findExistingTransactionIds()); existingReversedTransactionIds.addAll(loan.findExistingReversedTransactionIds()); final Map<String, Object> changes = new LinkedHashMap<>(); LocalDate recalculateFrom = null; ScheduleGeneratorDTO scheduleGeneratorDTO = this.loanUtilService.buildScheduleGeneratorDTO(loan, recalculateFrom); ChangedTransactionDetail changedTransactionDetail = null; AppUser currentUser = getAppUserIfPresent(); if (command.entityId() != null) { changedTransactionDetail = loan.updateDisbursementDateAndAmountForTranche(loanDisbursementDetails, command, changes, scheduleGeneratorDTO, currentUser); } else { // BigDecimal setAmount = loan.getApprovedPrincipal(); Collection<LoanDisbursementDetails> loanDisburseDetails = loan.getDisbursementDetails(); BigDecimal setAmount = BigDecimal.ZERO; for (LoanDisbursementDetails details : loanDisburseDetails) { if (details.actualDisbursementDate() != null) { setAmount = setAmount.add(details.principal()); } } loan.repaymentScheduleDetail().setPrincipal(setAmount); if (loan.repaymentScheduleDetail().isInterestRecalculationEnabled()) { loan.regenerateRepaymentScheduleWithInterestRecalculation(scheduleGeneratorDTO, currentUser); } else { loan.regenerateRepaymentSchedule(scheduleGeneratorDTO, currentUser); loan.processPostDisbursementTransactions(); } } saveAndFlushLoanWithDataIntegrityViolationChecks(loan); if (command.entityId() != null && changedTransactionDetail != null) { for (Map.Entry<Long, LoanTransaction> mapEntry : changedTransactionDetail.getNewTransactionMappings() .entrySet()) { updateLoanTransaction(mapEntry.getKey(), mapEntry.getValue()); } } if (loan.repaymentScheduleDetail().isInterestRecalculationEnabled()) { createLoanScheduleArchive(loan, scheduleGeneratorDTO); } postJournalEntries(loan, existingTransactionIds, existingReversedTransactionIds); this.loanAccountDomainService.recalculateAccruals(loan); return new CommandProcessingResultBuilder() // .withOfficeId(loan.getOfficeId()) // .withClientId(loan.getClientId()) // .withGroupId(loan.getGroupId()) // .withLoanId(loanId) // .with(changes).build(); } @Override @Transactional public CommandProcessingResult updateDisbursementDateAndAmountForTranche(final Long loanId, final Long disbursementId, final JsonCommand command) { final Loan loan = this.loanAssembler.assembleFrom(loanId); checkClientOrGroupActive(loan); LoanDisbursementDetails loanDisbursementDetails = loan.fetchLoanDisbursementsById(disbursementId); this.loanEventApiJsonValidator.validateUpdateDisbursementDateAndAmount(command.json(), loanDisbursementDetails); return processLoanDisbursementDetail(loan, loanId, command, loanDisbursementDetails); } public LoanTransaction disburseLoanAmountToSavings(final Long loanId, Long loanChargeId, final JsonCommand command, final boolean isChargeIdIncludedInJson) { LoanTransaction transaction = null; this.loanEventApiJsonValidator.validateChargePaymentTransaction(command.json(), isChargeIdIncludedInJson); if (isChargeIdIncludedInJson) { loanChargeId = command.longValueOfParameterNamed("chargeId"); } final Loan loan = this.loanAssembler.assembleFrom(loanId); checkClientOrGroupActive(loan); final LoanCharge loanCharge = retrieveLoanChargeBy(loanId, loanChargeId); // Charges may be waived only when the loan associated with them are // active if (!loan.status().isActive()) { throw new LoanChargeCannotBePayedException(LOAN_CHARGE_CANNOT_BE_PAYED_REASON.LOAN_INACTIVE, loanCharge.getId()); } // validate loan charge is not already paid or waived if (loanCharge.isWaived()) { throw new LoanChargeCannotBePayedException(LOAN_CHARGE_CANNOT_BE_PAYED_REASON.ALREADY_WAIVED, loanCharge.getId()); } else if (loanCharge.isPaid()) { throw new LoanChargeCannotBePayedException(LOAN_CHARGE_CANNOT_BE_PAYED_REASON.ALREADY_PAID, loanCharge.getId()); } if (!loanCharge.getChargePaymentMode().isPaymentModeAccountTransfer()) { throw new LoanChargeCannotBePayedException( LOAN_CHARGE_CANNOT_BE_PAYED_REASON.CHARGE_NOT_ACCOUNT_TRANSFER, loanCharge.getId()); } final LocalDate transactionDate = command.localDateValueOfParameterNamed("transactionDate"); final Locale locale = command.extractLocale(); final DateTimeFormatter fmt = DateTimeFormat.forPattern(command.dateFormat()).withLocale(locale); Integer loanInstallmentNumber = null; BigDecimal amount = loanCharge.amountOutstanding(); if (loanCharge.isInstalmentFee()) { LoanInstallmentCharge chargePerInstallment = null; final LocalDate dueDate = command.localDateValueOfParameterNamed("dueDate"); final Integer installmentNumber = command.integerValueOfParameterNamed("installmentNumber"); if (dueDate != null) { chargePerInstallment = loanCharge.getInstallmentLoanCharge(dueDate); } else if (installmentNumber != null) { chargePerInstallment = loanCharge.getInstallmentLoanCharge(installmentNumber); } if (chargePerInstallment == null) { chargePerInstallment = loanCharge.getUnpaidInstallmentLoanCharge(); } if (chargePerInstallment.isWaived()) { throw new LoanChargeCannotBePayedException(LOAN_CHARGE_CANNOT_BE_PAYED_REASON.ALREADY_WAIVED, loanCharge.getId()); } else if (chargePerInstallment.isPaid()) { throw new LoanChargeCannotBePayedException(LOAN_CHARGE_CANNOT_BE_PAYED_REASON.ALREADY_PAID, loanCharge.getId()); } loanInstallmentNumber = chargePerInstallment.getRepaymentInstallment().getInstallmentNumber(); amount = chargePerInstallment.getAmountOutstanding(); } final PortfolioAccountData portfolioAccountData = this.accountAssociationsReadPlatformService .retriveLoanLinkedAssociation(loanId); if (portfolioAccountData == null) { final String errorMessage = "Charge with id:" + loanChargeId + " requires linked savings account for payment"; throw new LinkedAccountRequiredException("loanCharge.pay", errorMessage, loanChargeId); } final SavingsAccount fromSavingsAccount = null; final boolean isRegularTransaction = true; final boolean isExceptionForBalanceCheck = false; final AccountTransferDTO accountTransferDTO = new AccountTransferDTO(transactionDate, amount, PortfolioAccountType.SAVINGS, PortfolioAccountType.LOAN, portfolioAccountData.accountId(), loanId, "Loan Charge Payment", locale, fmt, null, null, LoanTransactionType.CHARGE_PAYMENT.getValue(), loanChargeId, loanInstallmentNumber, AccountTransferType.CHARGE_PAYMENT.getValue(), null, null, null, null, null, fromSavingsAccount, isRegularTransaction, isExceptionForBalanceCheck); this.accountTransfersWritePlatformService.transferFunds(accountTransferDTO); return transaction; } @Transactional @Override public void recalculateInterest(final long loanId) { Loan loan = this.loanAssembler.assembleFrom(loanId); LocalDate recalculateFrom = loan.fetchInterestRecalculateFromDate(); AppUser currentUser = getAppUserIfPresent(); this.businessEventNotifierService.notifyBusinessEventToBeExecuted( BUSINESS_EVENTS.LOAN_INTEREST_RECALCULATION, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); final List<Long> existingTransactionIds = new ArrayList<>(); final List<Long> existingReversedTransactionIds = new ArrayList<>(); ScheduleGeneratorDTO generatorDTO = this.loanUtilService.buildScheduleGeneratorDTO(loan, recalculateFrom); ChangedTransactionDetail changedTransactionDetail = loan.recalculateScheduleFromLastTransaction( generatorDTO, existingTransactionIds, existingReversedTransactionIds, currentUser); saveLoanWithDataIntegrityViolationChecks(loan); if (changedTransactionDetail != null) { for (final Map.Entry<Long, LoanTransaction> mapEntry : changedTransactionDetail .getNewTransactionMappings().entrySet()) { this.loanTransactionRepository.save(mapEntry.getValue()); // update loan with references to the newly created // transactions loan.addLoanTransaction(mapEntry.getValue()); this.accountTransfersWritePlatformService.updateLoanTransaction(mapEntry.getKey(), mapEntry.getValue()); } } postJournalEntries(loan, existingTransactionIds, existingReversedTransactionIds); this.loanAccountDomainService.recalculateAccruals(loan); this.businessEventNotifierService.notifyBusinessEventWasExecuted( BUSINESS_EVENTS.LOAN_INTEREST_RECALCULATION, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); } @Override public CommandProcessingResult recoverFromGuarantor(final Long loanId) { final Loan loan = this.loanAssembler.assembleFrom(loanId); this.guarantorDomainService.transaferFundsFromGuarantor(loan); return new CommandProcessingResultBuilder().withLoanId(loanId).build(); } private void updateLoanTransaction(final Long loanTransactionId, final LoanTransaction newLoanTransaction) { final AccountTransferTransaction transferTransaction = this.accountTransferRepository .findByToLoanTransactionId(loanTransactionId); if (transferTransaction != null) { transferTransaction.updateToLoanTransaction(newLoanTransaction); this.accountTransferRepository.save(transferTransaction); } } private void createLoanScheduleArchive(final Loan loan, final ScheduleGeneratorDTO scheduleGeneratorDTO) { createAndSaveLoanScheduleArchive(loan, scheduleGeneratorDTO); } private void regenerateScheduleOnDisbursement(final JsonCommand command, final Loan loan, final boolean recalculateSchedule, final ScheduleGeneratorDTO scheduleGeneratorDTO, final LocalDate nextPossibleRepaymentDate, final Date rescheduledRepaymentDate) { AppUser currentUser = getAppUserIfPresent(); final LocalDate actualDisbursementDate = command.localDateValueOfParameterNamed("actualDisbursementDate"); BigDecimal emiAmount = command.bigDecimalValueOfParameterNamed(LoanApiConstants.emiAmountParameterName); loan.regenerateScheduleOnDisbursement(scheduleGeneratorDTO, recalculateSchedule, actualDisbursementDate, emiAmount, currentUser, nextPossibleRepaymentDate, rescheduledRepaymentDate); } private List<LoanRepaymentScheduleInstallment> retrieveRepaymentScheduleFromModel(LoanScheduleModel model) { final List<LoanRepaymentScheduleInstallment> installments = new ArrayList<>(); for (final LoanScheduleModelPeriod scheduledLoanInstallment : model.getPeriods()) { if (scheduledLoanInstallment.isRepaymentPeriod()) { final LoanRepaymentScheduleInstallment installment = new LoanRepaymentScheduleInstallment(null, scheduledLoanInstallment.periodNumber(), scheduledLoanInstallment.periodFromDate(), scheduledLoanInstallment.periodDueDate(), scheduledLoanInstallment.principalDue(), scheduledLoanInstallment.interestDue(), scheduledLoanInstallment.feeChargesDue(), scheduledLoanInstallment.penaltyChargesDue(), scheduledLoanInstallment.isRecalculatedInterestComponent(), scheduledLoanInstallment.getLoanCompoundingDetails()); installments.add(installment); } } return installments; } @Override @Transactional public CommandProcessingResult makeLoanRefund(Long loanId, JsonCommand command) { // TODO Auto-generated method stub this.loanEventApiJsonValidator.validateNewRefundTransaction(command.json()); final LocalDate transactionDate = command.localDateValueOfParameterNamed("transactionDate"); // checkRefundDateIsAfterAtLeastOneRepayment(loanId, transactionDate); final BigDecimal transactionAmount = command.bigDecimalValueOfParameterNamed("transactionAmount"); checkIfLoanIsPaidInAdvance(loanId, transactionAmount); final Map<String, Object> changes = new LinkedHashMap<>(); changes.put("transactionDate", command.stringValueOfParameterNamed("transactionDate")); changes.put("transactionAmount", command.stringValueOfParameterNamed("transactionAmount")); changes.put("locale", command.locale()); changes.put("dateFormat", command.dateFormat()); final String noteText = command.stringValueOfParameterNamed("note"); if (StringUtils.isNotBlank(noteText)) { changes.put("note", noteText); } final PaymentDetail paymentDetail = null; final CommandProcessingResultBuilder commandProcessingResultBuilder = new CommandProcessingResultBuilder(); this.loanAccountDomainService.makeRefundForActiveLoan(loanId, commandProcessingResultBuilder, transactionDate, transactionAmount, paymentDetail, noteText, null); return commandProcessingResultBuilder.withCommandId(command.commandId()) // .withLoanId(loanId) // .with(changes) // .build(); } private void checkIfLoanIsPaidInAdvance(final Long loanId, final BigDecimal transactionAmount) { BigDecimal overpaid = this.loanReadPlatformService.retrieveTotalPaidInAdvance(loanId).getPaidInAdvance(); if (overpaid == null || overpaid.equals(new BigDecimal(0)) || transactionAmount.floatValue() > overpaid.floatValue()) { if (overpaid == null) overpaid = BigDecimal.ZERO; throw new InvalidPaidInAdvanceAmountException(overpaid.toPlainString()); } } private AppUser getAppUserIfPresent() { AppUser user = null; if (this.context != null) { user = this.context.getAuthenticatedUserIfPresent(); } return user; } 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; } @Override @Transactional public CommandProcessingResult undoLastLoanDisbursal(Long loanId, JsonCommand command) { final AppUser currentUser = getAppUserIfPresent(); final Loan loan = this.loanAssembler.assembleFrom(loanId); final LocalDate recalculateFromDate = loan.getLastRepaymentDate(); validateIsMultiDisbursalLoanAndDisbursedMoreThanOneTranche(loan); checkClientOrGroupActive(loan); this.businessEventNotifierService.notifyBusinessEventToBeExecuted(BUSINESS_EVENTS.LOAN_UNDO_LASTDISBURSAL, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); final MonetaryCurrency currency = loan.getCurrency(); final ApplicationCurrency applicationCurrency = this.applicationCurrencyRepository .findOneWithNotFoundDetection(currency); final List<Long> existingTransactionIds = new ArrayList<>(); final List<Long> existingReversedTransactionIds = new ArrayList<>(); ScheduleGeneratorDTO scheduleGeneratorDTO = this.loanUtilService.buildScheduleGeneratorDTO(loan, recalculateFromDate); final Map<String, Object> changes = loan.undoLastDisbursal(scheduleGeneratorDTO, existingTransactionIds, existingReversedTransactionIds, currentUser, loan); if (!changes.isEmpty()) { saveAndFlushLoanWithDataIntegrityViolationChecks(loan); String noteText = null; if (command.hasParameter("note")) { noteText = command.stringValueOfParameterNamed("note"); if (StringUtils.isNotBlank(noteText)) { final Note note = Note.loanNote(loan, noteText); this.noteRepository.save(note); } } boolean isAccountTransfer = false; final Map<String, Object> accountingBridgeData = loan.deriveAccountingBridgeData( applicationCurrency.toData(), existingTransactionIds, existingReversedTransactionIds, isAccountTransfer); this.journalEntryWritePlatformService.createJournalEntriesForLoan(accountingBridgeData); this.businessEventNotifierService.notifyBusinessEventWasExecuted( BUSINESS_EVENTS.LOAN_UNDO_LASTDISBURSAL, constructEntityMap(BUSINESS_ENTITY.LOAN, loan)); } return new CommandProcessingResultBuilder() // .withCommandId(command.commandId()) // .withEntityId(loan.getId()) // .withOfficeId(loan.getOfficeId()) // .withClientId(loan.getClientId()) // .withGroupId(loan.getGroupId()) // .withLoanId(loanId) // .with(changes) // .build(); } @Override @Transactional public CommandProcessingResult forecloseLoan(final Long loanId, final JsonCommand command) { final String json = command.json(); final JsonElement element = fromApiJsonHelper.parse(json); final Loan loan = this.loanAssembler.assembleFrom(loanId); final LocalDate transactionDate = this.fromApiJsonHelper .extractLocalDateNamed(LoanApiConstants.transactionDateParamName, element); this.loanEventApiJsonValidator.validateLoanForeclosure(command.json()); final Map<String, Object> changes = new LinkedHashMap<>(); changes.put("transactionDate", transactionDate); String noteText = this.fromApiJsonHelper.extractStringNamed(LoanApiConstants.noteParamName, element); LoanRescheduleRequest loanRescheduleRequest = null; for (LoanDisbursementDetails loanDisbursementDetails : loan.getDisbursementDetails()) { if (!loanDisbursementDetails.expectedDisbursementDateAsLocalDate().isAfter(transactionDate) && loanDisbursementDetails.actualDisbursementDate() == null) { final String defaultUserMessage = "The loan with undisbrsed tranche before foreclosure cannot be foreclosed."; throw new LoanForeclosureException( "loan.with.undisbursed.tranche.before.foreclosure.cannot.be.foreclosured", defaultUserMessage, transactionDate); } } this.loanScheduleHistoryWritePlatformService.createAndSaveLoanScheduleArchive( loan.getRepaymentScheduleInstallments(), loan, loanRescheduleRequest); final Map<String, Object> modifications = this.loanAccountDomainService.foreCloseLoan(loan, transactionDate, noteText); changes.putAll(modifications); final CommandProcessingResultBuilder commandProcessingResultBuilder = new CommandProcessingResultBuilder(); return commandProcessingResultBuilder.withLoanId(loanId) // .with(changes) // .build(); } private void validateIsMultiDisbursalLoanAndDisbursedMoreThanOneTranche(Loan loan) { if (!loan.isMultiDisburmentLoan()) { final String errorMessage = "loan.product.does.not.support.multiple.disbursals.cannot.undo.last.disbursal"; throw new LoanMultiDisbursementException(errorMessage); } Integer trancheDisbursedCount = 0; for (LoanDisbursementDetails disbursementDetails : loan.getDisbursementDetails()) { if (disbursementDetails.actualDisbursementDate() != null) { trancheDisbursedCount++; } } if (trancheDisbursedCount <= 1) { final String errorMessage = "tranches.should.be.disbursed.more.than.one.to.undo.last.disbursal"; throw new LoanMultiDisbursementException(errorMessage); } } private void syncExpectedDateWithActualDisbursementDate(final Loan loan, LocalDate actualDisbursementDate) { if (!loan.getExpectedDisbursedOnLocalDate().equals(actualDisbursementDate)) { throw new DateMismatchException(actualDisbursementDate, loan.getExpectedDisbursedOnLocalDate()); } } }