Example usage for org.joda.time LocalDate isBefore

List of usage examples for org.joda.time LocalDate isBefore

  1. HOME
  2. Java
  3. org.joda.time
  4. org.joda.time.*
  5. LocalDate
  6. isBefore

Introduction

In this page you can find the example usage for org.joda.time LocalDate isBefore.

Prototype

public boolean isBefore(ReadablePartial partial)

Source Link

Document

Is this partial earlier than the specified partial.

Usage

From source file:com.gst.portfolio.loanaccount.loanschedule.service.LoanScheduleAssembler.java

License:Apache License

private void validateMinimumDaysBetweenDisbursalAndFirstRepayment(final LocalDate disbursalDate,
        final LocalDate firstRepaymentDate, final Integer minimumDaysBetweenDisbursalAndFirstRepayment) {

    final LocalDate minimumFirstRepaymentDate = disbursalDate
            .plusDays(minimumDaysBetweenDisbursalAndFirstRepayment);
    if (firstRepaymentDate.isBefore(minimumFirstRepaymentDate)) {
        throw new MinDaysBetweenDisbursalAndFirstRepaymentViolationException(disbursalDate, firstRepaymentDate,
                minimumDaysBetweenDisbursalAndFirstRepayment);
    }//from w  w w  .j  a  v  a 2s . co m
}

From source file:com.gst.portfolio.loanaccount.rescheduleloan.data.LoanRescheduleRequestDataValidator.java

License:Apache License

/**
 * Validates the request to create a new loan reschedule entry
 * /*from   ww  w. j  a v  a  2  s . c om*/
 * @param jsonCommand
 *            the JSON command object (instance of the JsonCommand class)
 * @return void
 **/
public void validateForCreateAction(final JsonCommand jsonCommand, final Loan loan) {

    final String jsonString = jsonCommand.json();

    if (StringUtils.isBlank(jsonString)) {
        throw new InvalidJsonException();
    }

    final Type typeToken = new TypeToken<Map<String, Object>>() {
    }.getType();
    this.fromJsonHelper.checkForUnsupportedParameters(typeToken, jsonString,
            RescheduleLoansApiConstants.CREATE_REQUEST_DATA_PARAMETERS);

    final List<ApiParameterError> dataValidationErrors = new ArrayList<>();
    final DataValidatorBuilder dataValidatorBuilder = new DataValidatorBuilder(dataValidationErrors)
            .resource(StringUtils.lowerCase(RescheduleLoansApiConstants.ENTITY_NAME));

    final JsonElement jsonElement = jsonCommand.parsedJson();

    if (!loan.status().isActive()) {
        dataValidatorBuilder.reset().failWithCodeNoParameterAddedToErrorCode("loan.is.not.active",
                "Loan is not active");
    }

    final Long loanId = this.fromJsonHelper.extractLongNamed(RescheduleLoansApiConstants.loanIdParamName,
            jsonElement);
    dataValidatorBuilder.reset().parameter(RescheduleLoansApiConstants.loanIdParamName).value(loanId).notNull()
            .integerGreaterThanZero();

    final LocalDate submittedOnDate = this.fromJsonHelper
            .extractLocalDateNamed(RescheduleLoansApiConstants.submittedOnDateParamName, jsonElement);
    dataValidatorBuilder.reset().parameter(RescheduleLoansApiConstants.submittedOnDateParamName)
            .value(submittedOnDate).notNull();

    if (submittedOnDate != null && loan.getDisbursementDate().isAfter(submittedOnDate)) {
        dataValidatorBuilder.reset().parameter(RescheduleLoansApiConstants.submittedOnDateParamName)
                .failWithCode("before.loan.disbursement.date",
                        "Submission date cannot be before the loan disbursement date");
    }

    final LocalDate rescheduleFromDate = this.fromJsonHelper
            .extractLocalDateNamed(RescheduleLoansApiConstants.rescheduleFromDateParamName, jsonElement);
    dataValidatorBuilder.reset().parameter(RescheduleLoansApiConstants.rescheduleFromDateParamName)
            .value(rescheduleFromDate).notNull();

    final Integer graceOnPrincipal = this.fromJsonHelper
            .extractIntegerWithLocaleNamed(RescheduleLoansApiConstants.graceOnPrincipalParamName, jsonElement);
    dataValidatorBuilder.reset().parameter(RescheduleLoansApiConstants.graceOnPrincipalParamName)
            .value(graceOnPrincipal).ignoreIfNull().integerGreaterThanZero();

    final Integer graceOnInterest = this.fromJsonHelper
            .extractIntegerWithLocaleNamed(RescheduleLoansApiConstants.graceOnInterestParamName, jsonElement);
    dataValidatorBuilder.reset().parameter(RescheduleLoansApiConstants.graceOnInterestParamName)
            .value(graceOnInterest).ignoreIfNull().integerGreaterThanZero();

    final Integer extraTerms = this.fromJsonHelper
            .extractIntegerWithLocaleNamed(RescheduleLoansApiConstants.extraTermsParamName, jsonElement);
    dataValidatorBuilder.reset().parameter(RescheduleLoansApiConstants.extraTermsParamName).value(extraTerms)
            .ignoreIfNull().integerGreaterThanZero();

    final Long rescheduleReasonId = this.fromJsonHelper
            .extractLongNamed(RescheduleLoansApiConstants.rescheduleReasonIdParamName, jsonElement);
    dataValidatorBuilder.reset().parameter(RescheduleLoansApiConstants.rescheduleReasonIdParamName)
            .value(rescheduleReasonId).notNull().integerGreaterThanZero();

    final String rescheduleReasonComment = this.fromJsonHelper
            .extractStringNamed(RescheduleLoansApiConstants.rescheduleReasonCommentParamName, jsonElement);
    dataValidatorBuilder.reset().parameter(RescheduleLoansApiConstants.rescheduleReasonCommentParamName)
            .value(rescheduleReasonComment).ignoreIfNull().notExceedingLengthOf(500);

    final LocalDate adjustedDueDate = this.fromJsonHelper
            .extractLocalDateNamed(RescheduleLoansApiConstants.adjustedDueDateParamName, jsonElement);

    if (adjustedDueDate != null && rescheduleFromDate != null && adjustedDueDate.isBefore(rescheduleFromDate)) {
        dataValidatorBuilder.reset().parameter(RescheduleLoansApiConstants.rescheduleFromDateParamName)
                .failWithCode("adjustedDueDate.before.rescheduleFromDate",
                        "Adjusted due date cannot be before the reschedule from date");
    }

    // at least one of the following must be provided => graceOnPrincipal,
    // graceOnInterest, extraTerms, newInterestRate
    if (!this.fromJsonHelper.parameterExists(RescheduleLoansApiConstants.graceOnPrincipalParamName, jsonElement)
            && !this.fromJsonHelper.parameterExists(RescheduleLoansApiConstants.graceOnInterestParamName,
                    jsonElement)
            && !this.fromJsonHelper.parameterExists(RescheduleLoansApiConstants.extraTermsParamName,
                    jsonElement)
            && !this.fromJsonHelper.parameterExists(RescheduleLoansApiConstants.newInterestRateParamName,
                    jsonElement)
            && !this.fromJsonHelper.parameterExists(RescheduleLoansApiConstants.adjustedDueDateParamName,
                    jsonElement)) {
        dataValidatorBuilder.reset().parameter(RescheduleLoansApiConstants.graceOnPrincipalParamName).notNull();
    }
    LoanRepaymentScheduleInstallment installment = null;
    if (rescheduleFromDate != null) {
        installment = loan.getRepaymentScheduleInstallment(rescheduleFromDate);

        if (installment == null) {
            dataValidatorBuilder.reset().parameter(RescheduleLoansApiConstants.rescheduleFromDateParamName)
                    .failWithCode("repayment.schedule.installment.does.not.exist",
                            "Repayment schedule installment does not exist");
        }

        if (installment != null && installment.isObligationsMet()) {
            dataValidatorBuilder.reset().parameter(RescheduleLoansApiConstants.rescheduleFromDateParamName)
                    .failWithCode("repayment.schedule.installment.obligation.met",
                            "Repayment schedule installment obligation met");
        }

    }

    if (loan.isMultiDisburmentLoan()) {
        dataValidatorBuilder.reset().failWithCodeNoParameterAddedToErrorCode(
                RescheduleLoansApiConstants.resheduleForMultiDisbursementNotSupportedErrorCode,
                "Loan rescheduling is not supported for multidisbursement loans");
    }

    if (loan.isInterestRecalculationEnabledForProduct()) {
        dataValidatorBuilder.reset().failWithCodeNoParameterAddedToErrorCode(
                RescheduleLoansApiConstants.resheduleWithInterestRecalculationNotSupportedErrorCode,
                "Loan rescheduling is not supported for the loan product with interest recalculation enabled");
    }
    validateForOverdueCharges(dataValidatorBuilder, loan, installment);
    if (!dataValidationErrors.isEmpty()) {
        throw new PlatformApiDataValidationException(dataValidationErrors);
    }
}

From source file:com.gst.portfolio.loanaccount.rescheduleloan.service.LoanReschedulePreviewPlatformServiceImpl.java

License:Apache License

@Override
public LoanScheduleModel previewLoanReschedule(Long requestId) {
    final LoanRescheduleRequest loanRescheduleRequest = this.loanRescheduleRequestRepository.findOne(requestId);

    if (loanRescheduleRequest == null) {
        throw new LoanRescheduleRequestNotFoundException(requestId);
    }/*from  www .j ava  2s. c  o  m*/

    Loan loan = loanRescheduleRequest.getLoan();

    ScheduleGeneratorDTO scheduleGeneratorDTO = this.loanUtilService.buildScheduleGeneratorDTO(loan,
            loanRescheduleRequest.getRescheduleFromDate());
    LocalDate rescheduleFromDate = null;
    List<LoanTermVariationsData> removeLoanTermVariationsData = new ArrayList<>();
    final LoanApplicationTerms loanApplicationTerms = loan.constructLoanApplicationTerms(scheduleGeneratorDTO);
    LoanTermVariations dueDateVariationInCurrentRequest = loanRescheduleRequest
            .getDueDateTermVariationIfExists();
    if (dueDateVariationInCurrentRequest != null) {
        for (LoanTermVariationsData loanTermVariation : loanApplicationTerms.getLoanTermVariations()
                .getDueDateVariation()) {
            if (loanTermVariation.getDateValue()
                    .equals(dueDateVariationInCurrentRequest.fetchTermApplicaDate())) {
                rescheduleFromDate = loanTermVariation.getTermApplicableFrom();
                removeLoanTermVariationsData.add(loanTermVariation);
            }
        }
    }
    loanApplicationTerms.getLoanTermVariations().getDueDateVariation().removeAll(removeLoanTermVariationsData);
    if (rescheduleFromDate == null) {
        rescheduleFromDate = loanRescheduleRequest.getRescheduleFromDate();
    }
    List<LoanTermVariationsData> loanTermVariationsData = new ArrayList<>();
    LocalDate adjustedApplicableDate = null;
    Set<LoanRescheduleRequestToTermVariationMapping> loanRescheduleRequestToTermVariationMappings = loanRescheduleRequest
            .getLoanRescheduleRequestToTermVariationMappings();
    if (!loanRescheduleRequestToTermVariationMappings.isEmpty()) {
        for (LoanRescheduleRequestToTermVariationMapping loanRescheduleRequestToTermVariationMapping : loanRescheduleRequestToTermVariationMappings) {
            if (loanRescheduleRequestToTermVariationMapping.getLoanTermVariations().getTermType()
                    .isDueDateVariation() && rescheduleFromDate != null) {
                adjustedApplicableDate = loanRescheduleRequestToTermVariationMapping.getLoanTermVariations()
                        .fetchDateValue();
                loanRescheduleRequestToTermVariationMapping.getLoanTermVariations()
                        .setTermApplicableFrom(rescheduleFromDate.toDate());
            }
            loanTermVariationsData
                    .add(loanRescheduleRequestToTermVariationMapping.getLoanTermVariations().toData());
        }
    }

    for (LoanTermVariationsData loanTermVariation : loanApplicationTerms.getLoanTermVariations()
            .getDueDateVariation()) {
        if (rescheduleFromDate.isBefore(loanTermVariation.getTermApplicableFrom())) {
            LocalDate applicableDate = this.scheduledDateGenerator.generateNextRepaymentDate(rescheduleFromDate,
                    loanApplicationTerms, false, loanApplicationTerms.getHolidayDetailDTO());
            if (loanTermVariation.getTermApplicableFrom().equals(applicableDate)) {
                LocalDate adjustedDate = this.scheduledDateGenerator.generateNextRepaymentDate(
                        adjustedApplicableDate, loanApplicationTerms, false,
                        loanApplicationTerms.getHolidayDetailDTO());
                loanTermVariation.setApplicableFromDate(adjustedDate);
                loanTermVariationsData.add(loanTermVariation);
            }
        }
    }

    loanApplicationTerms.getLoanTermVariations().updateLoanTermVariationsData(loanTermVariationsData);
    final RoundingMode roundingMode = MoneyHelper.getRoundingMode();
    final MathContext mathContext = new MathContext(8, roundingMode);
    final LoanRepaymentScheduleTransactionProcessor loanRepaymentScheduleTransactionProcessor = this.loanRepaymentScheduleTransactionProcessorFactory
            .determineProcessor(loan.transactionProcessingStrategy());
    final LoanScheduleGenerator loanScheduleGenerator = this.loanScheduleFactory
            .create(loanApplicationTerms.getInterestMethod());
    final LoanLifecycleStateMachine loanLifecycleStateMachine = null;
    loan.setHelpers(loanLifecycleStateMachine, this.loanSummaryWrapper,
            this.loanRepaymentScheduleTransactionProcessorFactory);
    final LoanScheduleDTO loanSchedule = loanScheduleGenerator.rescheduleNextInstallments(mathContext,
            loanApplicationTerms, loan, loanApplicationTerms.getHolidayDetailDTO(),
            loanRepaymentScheduleTransactionProcessor, rescheduleFromDate);
    final LoanScheduleModel loanScheduleModel = loanSchedule.getLoanScheduleModel();
    LoanScheduleModel loanScheduleModels = LoanScheduleModel
            .withLoanScheduleModelPeriods(loanScheduleModel.getPeriods(), loanScheduleModel);

    return loanScheduleModels;
}

From source file:com.gst.portfolio.loanaccount.rescheduleloan.service.LoanRescheduleRequestWritePlatformServiceImpl.java

License:Apache License

@Override
@Transactional//from  w  w  w .  j  a  v  a  2s  .  co m
public CommandProcessingResult approve(JsonCommand jsonCommand) {

    try {
        final Long loanRescheduleRequestId = jsonCommand.entityId();

        final LoanRescheduleRequest loanRescheduleRequest = this.loanRescheduleRequestRepository
                .findOne(loanRescheduleRequestId);

        if (loanRescheduleRequest == null) {
            throw new LoanRescheduleRequestNotFoundException(loanRescheduleRequestId);
        }

        // validate the request in the JsonCommand object passed as
        // parameter
        this.loanRescheduleRequestDataValidator.validateForApproveAction(jsonCommand, loanRescheduleRequest);

        final AppUser appUser = this.platformSecurityContext.authenticatedUser();
        final Map<String, Object> changes = new LinkedHashMap<>();

        LocalDate approvedOnDate = jsonCommand.localDateValueOfParameterNamed("approvedOnDate");
        final DateTimeFormatter dateTimeFormatter = DateTimeFormat.forPattern(jsonCommand.dateFormat())
                .withLocale(jsonCommand.extractLocale());

        changes.put("locale", jsonCommand.locale());
        changes.put("dateFormat", jsonCommand.dateFormat());
        changes.put("approvedOnDate", approvedOnDate.toString(dateTimeFormatter));
        changes.put("approvedByUserId", appUser.getId());

        Loan loan = loanRescheduleRequest.getLoan();
        final List<Long> existingTransactionIds = new ArrayList<>(loan.findExistingTransactionIds());
        final List<Long> existingReversedTransactionIds = new ArrayList<>(
                loan.findExistingReversedTransactionIds());

        ScheduleGeneratorDTO scheduleGeneratorDTO = this.loanUtilService.buildScheduleGeneratorDTO(loan,
                loanRescheduleRequest.getRescheduleFromDate());

        Collection<LoanRepaymentScheduleHistory> loanRepaymentScheduleHistoryList = this.loanScheduleHistoryWritePlatformService
                .createLoanScheduleArchive(loan.getRepaymentScheduleInstallments(), loan,
                        loanRescheduleRequest);

        final LoanApplicationTerms loanApplicationTerms = loan
                .constructLoanApplicationTerms(scheduleGeneratorDTO);

        LocalDate rescheduleFromDate = null;
        Set<LoanTermVariations> activeLoanTermVariations = loan.getActiveLoanTermVariations();
        LoanTermVariations dueDateVariationInCurrentRequest = loanRescheduleRequest
                .getDueDateTermVariationIfExists();
        if (dueDateVariationInCurrentRequest != null && activeLoanTermVariations != null) {
            LocalDate fromScheduleDate = dueDateVariationInCurrentRequest.fetchTermApplicaDate();
            LocalDate currentScheduleDate = fromScheduleDate;
            LocalDate modifiedScheduleDate = dueDateVariationInCurrentRequest.fetchDateValue();
            Map<LocalDate, LocalDate> changeMap = new HashMap<>();
            changeMap.put(currentScheduleDate, modifiedScheduleDate);
            for (LoanTermVariations activeLoanTermVariation : activeLoanTermVariations) {
                if (activeLoanTermVariation.getTermType().isDueDateVariation() && activeLoanTermVariation
                        .fetchDateValue().equals(dueDateVariationInCurrentRequest.fetchTermApplicaDate())) {
                    activeLoanTermVariation.markAsInactive();
                    rescheduleFromDate = activeLoanTermVariation.fetchTermApplicaDate();
                    dueDateVariationInCurrentRequest.setTermApplicableFrom(rescheduleFromDate.toDate());
                } else if (!activeLoanTermVariation.fetchTermApplicaDate().isBefore(fromScheduleDate)) {
                    while (currentScheduleDate.isBefore(activeLoanTermVariation.fetchTermApplicaDate())) {
                        currentScheduleDate = this.scheduledDateGenerator.generateNextRepaymentDate(
                                currentScheduleDate, loanApplicationTerms, false,
                                loanApplicationTerms.getHolidayDetailDTO());
                        modifiedScheduleDate = this.scheduledDateGenerator.generateNextRepaymentDate(
                                modifiedScheduleDate, loanApplicationTerms, false,
                                loanApplicationTerms.getHolidayDetailDTO());
                        changeMap.put(currentScheduleDate, modifiedScheduleDate);
                    }
                    if (changeMap.containsKey(activeLoanTermVariation.fetchTermApplicaDate())) {
                        activeLoanTermVariation.setTermApplicableFrom(
                                changeMap.get(activeLoanTermVariation.fetchTermApplicaDate()).toDate());
                    }
                }
            }
        }
        if (rescheduleFromDate == null) {
            rescheduleFromDate = loanRescheduleRequest.getRescheduleFromDate();
        }
        for (LoanRescheduleRequestToTermVariationMapping mapping : loanRescheduleRequest
                .getLoanRescheduleRequestToTermVariationMappings()) {
            mapping.getLoanTermVariations().updateIsActive(true);
        }
        BigDecimal annualNominalInterestRate = null;
        List<LoanTermVariationsData> loanTermVariations = new ArrayList<>();
        loan.constructLoanTermVariations(scheduleGeneratorDTO.getFloatingRateDTO(), annualNominalInterestRate,
                loanTermVariations);
        loanApplicationTerms.getLoanTermVariations().setExceptionData(loanTermVariations);

        /*for (LoanTermVariationsData loanTermVariation : loanApplicationTerms.getLoanTermVariations().getDueDateVariation()) {
        if (rescheduleFromDate.isBefore(loanTermVariation.getTermApplicableFrom())) {
            LocalDate applicableDate = this.scheduledDateGenerator.generateNextRepaymentDate(rescheduleFromDate,
                    loanApplicationTerms, false, loanApplicationTerms.getHolidayDetailDTO());
            if (loanTermVariation.getTermApplicableFrom().equals(applicableDate)) {
                LocalDate adjustedDate = this.scheduledDateGenerator.generateNextRepaymentDate(adjustedApplicableDate,
                        loanApplicationTerms, false, loanApplicationTerms.getHolidayDetailDTO());
                loanTermVariation.setApplicableFromDate(adjustedDate);
            }
        }
        }*/

        final RoundingMode roundingMode = MoneyHelper.getRoundingMode();
        final MathContext mathContext = new MathContext(8, roundingMode);
        final LoanRepaymentScheduleTransactionProcessor loanRepaymentScheduleTransactionProcessor = this.loanRepaymentScheduleTransactionProcessorFactory
                .determineProcessor(loan.transactionProcessingStrategy());
        final LoanScheduleGenerator loanScheduleGenerator = this.loanScheduleFactory
                .create(loanApplicationTerms.getInterestMethod());
        final LoanLifecycleStateMachine loanLifecycleStateMachine = null;
        loan.setHelpers(loanLifecycleStateMachine, this.loanSummaryWrapper,
                this.loanRepaymentScheduleTransactionProcessorFactory);
        final LoanScheduleDTO loanSchedule = loanScheduleGenerator.rescheduleNextInstallments(mathContext,
                loanApplicationTerms, loan, loanApplicationTerms.getHolidayDetailDTO(),
                loanRepaymentScheduleTransactionProcessor, rescheduleFromDate);

        loan.updateLoanSchedule(loanSchedule.getInstallments(), appUser);
        loan.recalculateAllCharges();
        ChangedTransactionDetail changedTransactionDetail = loan.processTransactions();

        for (LoanRepaymentScheduleHistory loanRepaymentScheduleHistory : loanRepaymentScheduleHistoryList) {
            this.loanRepaymentScheduleHistoryRepository.save(loanRepaymentScheduleHistory);
        }

        loan.updateRescheduledByUser(appUser);
        loan.updateRescheduledOnDate(new LocalDate());

        // update the status of the request
        loanRescheduleRequest.approve(appUser, approvedOnDate);

        // update the loan object
        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());
            }
        }
        postJournalEntries(loan, existingTransactionIds, existingReversedTransactionIds);

        this.loanAccountDomainService.recalculateAccruals(loan, true);

        return new CommandProcessingResultBuilder().withCommandId(jsonCommand.commandId())
                .withEntityId(loanRescheduleRequestId).withLoanId(loanRescheduleRequest.getLoan().getId())
                .with(changes).build();
    }

    catch (final DataIntegrityViolationException dve) {
        // handle the data integrity violation
        handleDataIntegrityViolation(dve);

        // return an empty command processing result object
        return CommandProcessingResult.empty();
    }
}

From source file:com.gst.portfolio.loanaccount.serialization.LoanApplicationCommandFromApiJsonHelper.java

License:Apache License

public void validateLoanMultiDisbursementdate(final JsonElement element,
        final DataValidatorBuilder baseDataValidator, LocalDate expectedDisbursement,
        BigDecimal totalPrincipal) {

    this.validateDisbursementsAreDatewiseOrdered(element, baseDataValidator);

    final JsonObject topLevelJsonElement = element.getAsJsonObject();
    final Locale locale = this.fromApiJsonHelper.extractLocaleParameter(topLevelJsonElement);
    final String dateFormat = this.fromApiJsonHelper.extractDateFormatParameter(topLevelJsonElement);
    if (this.fromApiJsonHelper.parameterExists(LoanApiConstants.disbursementDataParameterName, element)
            && expectedDisbursement != null && totalPrincipal != null) {
        BigDecimal tatalDisbursement = BigDecimal.ZERO;
        boolean isFirstinstallmentOnExpectedDisbursementDate = false;
        final JsonArray variationArray = this.fromApiJsonHelper
                .extractJsonArrayNamed(LoanApiConstants.disbursementDataParameterName, element);
        List<LocalDate> expectedDisbursementDates = new ArrayList<>();
        if (variationArray != null && variationArray.size() > 0) {
            int i = 0;
            do {/* w  ww.  j a va 2  s  . c  om*/
                final JsonObject jsonObject = variationArray.get(i).getAsJsonObject();
                if (jsonObject.has(LoanApiConstants.disbursementDateParameterName)
                        && jsonObject.has(LoanApiConstants.disbursementPrincipalParameterName)) {
                    LocalDate expectedDisbursementDate = this.fromApiJsonHelper.extractLocalDateNamed(
                            LoanApiConstants.disbursementDateParameterName, jsonObject, dateFormat, locale);
                    if (expectedDisbursementDates.contains(expectedDisbursementDate)) {
                        baseDataValidator.reset().parameter(LoanApiConstants.disbursementDateParameterName)
                                .failWithCode(LoanApiConstants.DISBURSEMENT_DATE_UNIQUE_ERROR);
                    }
                    if (expectedDisbursementDate.isBefore(expectedDisbursement)) {
                        baseDataValidator.reset().parameter(LoanApiConstants.disbursementDataParameterName)
                                .failWithCode(LoanApiConstants.DISBURSEMENT_DATE_BEFORE_ERROR);
                    }
                    expectedDisbursementDates.add(expectedDisbursementDate);

                    BigDecimal principal = this.fromApiJsonHelper.extractBigDecimalNamed(
                            LoanApiConstants.disbursementPrincipalParameterName, jsonObject, locale);
                    baseDataValidator.reset().parameter(LoanApiConstants.disbursementDataParameterName)
                            .parameterAtIndexArray(LoanApiConstants.disbursementPrincipalParameterName, i)
                            .value(principal).notBlank();
                    if (principal != null) {
                        tatalDisbursement = tatalDisbursement.add(principal);
                    }

                    baseDataValidator.reset().parameter(LoanApiConstants.disbursementDataParameterName)
                            .parameterAtIndexArray(LoanApiConstants.disbursementDateParameterName, i)
                            .value(expectedDisbursementDate).notNull();

                    if (expectedDisbursement.equals(expectedDisbursementDate)) {
                        isFirstinstallmentOnExpectedDisbursementDate = true;
                    }

                }
                i++;
            } while (i < variationArray.size());
            if (!isFirstinstallmentOnExpectedDisbursementDate) {
                baseDataValidator.reset().parameter(LoanApiConstants.disbursementDateParameterName)
                        .failWithCode(LoanApiConstants.DISBURSEMENT_DATE_START_WITH_ERROR);
            }

            if (tatalDisbursement.compareTo(totalPrincipal) == 1) {
                baseDataValidator.reset().parameter(LoanApiConstants.disbursementPrincipalParameterName)
                        .failWithCode(LoanApiConstants.APPROVED_AMOUNT_IS_LESS_THAN_SUM_OF_TRANCHES);
            }
            final String interestTypeParameterName = "interestType";
            final Integer interestType = this.fromApiJsonHelper
                    .extractIntegerSansLocaleNamed(interestTypeParameterName, element);
            baseDataValidator.reset().parameter(interestTypeParameterName).value(interestType).ignoreIfNull()
                    .integerSameAsNumber(InterestMethod.DECLINING_BALANCE.getValue());

        }

    }

}

From source file:com.gst.portfolio.loanaccount.service.LoanAccrualWritePlatformServiceImpl.java

License:Apache License

@Override
@Transactional/*from  www  . ja  v a  2s.com*/
public void addPeriodicAccruals(final LocalDate tilldate, Long loanId,
        Collection<LoanScheduleAccrualData> loanScheduleAccrualDatas) throws Exception {
    boolean firstTime = true;
    LocalDate accruredTill = null;
    Collection<LoanChargeData> chargeData = this.loanChargeReadPlatformService
            .retrieveLoanChargesForAccural(loanId);
    Collection<LoanSchedulePeriodData> loanWaiverScheduleData = new ArrayList<>(1);
    Collection<LoanTransactionData> loanWaiverTansactionData = new ArrayList<>(1);
    for (final LoanScheduleAccrualData accrualData : loanScheduleAccrualDatas) {
        if (accrualData.getWaivedInterestIncome() != null && loanWaiverScheduleData.isEmpty()) {
            loanWaiverScheduleData = this.loanReadPlatformService
                    .fetchWaiverInterestRepaymentData(accrualData.getLoanId());
            loanWaiverTansactionData = this.loanReadPlatformService
                    .retrieveWaiverLoanTransactions(accrualData.getLoanId());
        }

        if (accrualData.getDueDateAsLocaldate().isAfter(tilldate)) {
            if (accruredTill == null || firstTime) {
                accruredTill = accrualData.getAccruedTill();
                firstTime = false;
            }
            if (accruredTill == null || accruredTill.isBefore(tilldate)) {
                updateCharges(chargeData, accrualData, accrualData.getFromDateAsLocaldate(), tilldate);
                updateInterestIncome(accrualData, loanWaiverTansactionData, loanWaiverScheduleData, tilldate);
                addAccrualTillSpecificDate(tilldate, accrualData);
            }
        } else {
            updateCharges(chargeData, accrualData, accrualData.getFromDateAsLocaldate(),
                    accrualData.getDueDateAsLocaldate());
            updateInterestIncome(accrualData, loanWaiverTansactionData, loanWaiverScheduleData, tilldate);
            addAccrualAccounting(accrualData);
            accruredTill = accrualData.getDueDateAsLocaldate();
        }
    }
}

From source file:com.gst.portfolio.loanaccount.service.LoanAccrualWritePlatformServiceImpl.java

License:Apache License

private void addAccrualTillSpecificDate(final LocalDate tilldate, final LoanScheduleAccrualData accrualData)
        throws Exception {
    LocalDate interestStartDate = accrualData.getFromDateAsLocaldate();
    if (accrualData.getInterestCalculatedFrom() != null
            && accrualData.getFromDateAsLocaldate().isBefore(accrualData.getInterestCalculatedFrom())) {
        if (accrualData.getInterestCalculatedFrom().isBefore(accrualData.getDueDateAsLocaldate())) {
            interestStartDate = accrualData.getInterestCalculatedFrom();
        } else {/*from  www . jav a2  s  . c  o  m*/
            interestStartDate = accrualData.getDueDateAsLocaldate();
        }
    }

    int totalNumberOfDays = Days.daysBetween(interestStartDate, accrualData.getDueDateAsLocaldate()).getDays();
    LocalDate startDate = accrualData.getFromDateAsLocaldate();
    if (accrualData.getInterestCalculatedFrom() != null
            && startDate.isBefore(accrualData.getInterestCalculatedFrom())) {
        if (accrualData.getInterestCalculatedFrom().isBefore(tilldate)) {
            startDate = accrualData.getInterestCalculatedFrom();
        } else {
            startDate = tilldate;
        }
    }
    int daysToBeAccrued = Days.daysBetween(startDate, tilldate).getDays();
    double interestPerDay = accrualData.getAccruableIncome().doubleValue() / totalNumberOfDays;
    BigDecimal amount = BigDecimal.ZERO;
    BigDecimal interestportion = null;
    BigDecimal feeportion = accrualData.getDueDateFeeIncome();
    BigDecimal penaltyportion = accrualData.getDueDatePenaltyIncome();
    if (daysToBeAccrued >= totalNumberOfDays) {
        interestportion = accrualData.getAccruableIncome();
    } else {
        double iterest = interestPerDay * daysToBeAccrued;
        interestportion = BigDecimal.valueOf(iterest);
    }
    interestportion = interestportion.setScale(accrualData.getCurrencyData().decimalPlaces(),
            MoneyHelper.getRoundingMode());

    BigDecimal totalAccInterest = accrualData.getAccruedInterestIncome();
    BigDecimal totalAccPenalty = accrualData.getAccruedPenaltyIncome();
    BigDecimal totalAccFee = accrualData.getAccruedFeeIncome();

    if (interestportion != null) {
        if (totalAccInterest == null) {
            totalAccInterest = BigDecimal.ZERO;
        }
        interestportion = interestportion.subtract(totalAccInterest);
        amount = amount.add(interestportion);
        totalAccInterest = totalAccInterest.add(interestportion);
        if (interestportion.compareTo(BigDecimal.ZERO) == 0) {
            interestportion = null;
        }
    }
    if (feeportion != null) {
        if (totalAccFee == null) {
            totalAccFee = BigDecimal.ZERO;
        }
        feeportion = feeportion.subtract(totalAccFee);
        amount = amount.add(feeportion);
        totalAccFee = totalAccFee.add(feeportion);
        if (feeportion.compareTo(BigDecimal.ZERO) == 0) {
            feeportion = null;
        }
    }

    if (penaltyportion != null) {
        if (totalAccPenalty == null) {
            totalAccPenalty = BigDecimal.ZERO;
        }
        penaltyportion = penaltyportion.subtract(totalAccPenalty);
        amount = amount.add(penaltyportion);
        totalAccPenalty = totalAccPenalty.add(penaltyportion);
        if (penaltyportion.compareTo(BigDecimal.ZERO) == 0) {
            penaltyportion = null;
        }
    }
    if (amount.compareTo(BigDecimal.ZERO) == 1) {
        addAccrualAccounting(accrualData, amount, interestportion, totalAccInterest, feeportion, totalAccFee,
                penaltyportion, totalAccPenalty, tilldate);
    }
}

From source file:com.gst.portfolio.loanaccount.service.LoanApplicationWritePlatformServiceJpaRepositoryImpl.java

License:Apache License

private void validateSubmittedOnDate(final Loan loan) {
    final LocalDate startDate = loan.loanProduct().getStartDate();
    final LocalDate closeDate = loan.loanProduct().getCloseDate();
    final LocalDate expectedFirstRepaymentOnDate = loan.getExpectedFirstRepaymentOnDate();
    final LocalDate submittedOnDate = loan.getSubmittedOnDate();

    String defaultUserMessage = "";
    if (startDate != null && submittedOnDate.isBefore(startDate)) {
        defaultUserMessage = "submittedOnDate cannot be before the loan product startDate.";
        throw new LoanApplicationDateException("submitted.on.date.cannot.be.before.the.loan.product.start.date",
                defaultUserMessage, submittedOnDate.toString(), startDate.toString());
    }//  ww  w. j  a  v  a2  s .c om

    if (closeDate != null && submittedOnDate.isAfter(closeDate)) {
        defaultUserMessage = "submittedOnDate cannot be after the loan product closeDate.";
        throw new LoanApplicationDateException("submitted.on.date.cannot.be.after.the.loan.product.close.date",
                defaultUserMessage, submittedOnDate.toString(), closeDate.toString());
    }

    if (expectedFirstRepaymentOnDate != null && submittedOnDate.isAfter(expectedFirstRepaymentOnDate)) {
        defaultUserMessage = "submittedOnDate cannot be after the loans  expectedFirstRepaymentOnDate.";
        throw new LoanApplicationDateException(
                "submitted.on.date.cannot.be.after.the.loan.expected.first.repayment.date", defaultUserMessage,
                submittedOnDate.toString(), expectedFirstRepaymentOnDate.toString());
    }
}

From source file:com.gst.portfolio.loanproduct.service.LoanProductWritePlatformServiceJpaRepositoryImpl.java

License:Apache License

private void validateInputDates(final JsonCommand command) {
    final LocalDate startDate = command.localDateValueOfParameterNamed("startDate");
    final LocalDate closeDate = command.localDateValueOfParameterNamed("closeDate");

    if (startDate != null && closeDate != null) {
        if (closeDate.isBefore(startDate)) {
            throw new LoanProductDateException(startDate.toString(), closeDate.toString());
        }/*  w ww. j  a va 2 s  .  c o m*/
    }
}

From source file:com.gst.portfolio.savings.domain.FixedDepositAccount.java

License:Apache License

public void prematureClosure(final AppUser currentUser, final JsonCommand command,
        final LocalDate tenantsTodayDate, final Map<String, Object> actualChanges) {

    final List<ApiParameterError> dataValidationErrors = new ArrayList<>();
    final DataValidatorBuilder baseDataValidator = new DataValidatorBuilder(dataValidationErrors)
            .resource(FIXED_DEPOSIT_ACCOUNT_RESOURCE_NAME + DepositsApiConstants.preMatureCloseAction);

    final SavingsAccountStatusType currentStatus = SavingsAccountStatusType.fromInt(this.status);
    if (!SavingsAccountStatusType.ACTIVE.hasStateOf(currentStatus)) {
        baseDataValidator.reset().failWithCodeNoParameterAddedToErrorCode("not.in.active.state");
        if (!dataValidationErrors.isEmpty()) {
            throw new PlatformApiDataValidationException(dataValidationErrors);
        }// w w  w . j a v a  2  s . c o m
    }

    final Locale locale = command.extractLocale();
    final DateTimeFormatter fmt = DateTimeFormat.forPattern(command.dateFormat()).withLocale(locale);
    final LocalDate closedDate = command
            .localDateValueOfParameterNamed(SavingsApiConstants.closedOnDateParamName);

    if (closedDate.isBefore(getActivationLocalDate())) {
        baseDataValidator.reset().parameter(SavingsApiConstants.closedOnDateParamName).value(closedDate)
                .failWithCode("must.be.after.activation.date");
        if (!dataValidationErrors.isEmpty()) {
            throw new PlatformApiDataValidationException(dataValidationErrors);
        }
    }

    if (isAccountLocked(closedDate)) {
        baseDataValidator.reset().parameter(SavingsApiConstants.closedOnDateParamName).value(closedDate)
                .failWithCode("must.be.after.lockin.period");
        if (!dataValidationErrors.isEmpty()) {
            throw new PlatformApiDataValidationException(dataValidationErrors);
        }
    }

    if (closedDate.isAfter(maturityDate())) {
        baseDataValidator.reset().parameter(SavingsApiConstants.closedOnDateParamName).value(closedDate)
                .failWithCode("must.be.before.maturity.date");
        if (!dataValidationErrors.isEmpty()) {
            throw new PlatformApiDataValidationException(dataValidationErrors);
        }
    }

    if (closedDate.isAfter(tenantsTodayDate)) {
        baseDataValidator.reset().parameter(SavingsApiConstants.closedOnDateParamName).value(closedDate)
                .failWithCode("cannot.be.a.future.date");
        if (!dataValidationErrors.isEmpty()) {
            throw new PlatformApiDataValidationException(dataValidationErrors);
        }
    }
    final List<SavingsAccountTransaction> savingsAccountTransactions = retreiveListOfTransactions();
    if (savingsAccountTransactions.size() > 0) {
        final SavingsAccountTransaction accountTransaction = savingsAccountTransactions
                .get(savingsAccountTransactions.size() - 1);
        if (accountTransaction.isAfter(closedDate)) {
            baseDataValidator.reset().parameter(SavingsApiConstants.closedOnDateParamName).value(closedDate)
                    .failWithCode("must.be.after.last.transaction.date");
            if (!dataValidationErrors.isEmpty()) {
                throw new PlatformApiDataValidationException(dataValidationErrors);
            }
        }
    }

    validateActivityNotBeforeClientOrGroupTransferDate(SavingsEvent.SAVINGS_CLOSE_ACCOUNT, closedDate);
    this.status = SavingsAccountStatusType.PRE_MATURE_CLOSURE.getValue();

    final Integer onAccountClosureId = command.integerValueOfParameterNamed(onAccountClosureIdParamName);
    final DepositAccountOnClosureType onClosureType = DepositAccountOnClosureType.fromInt(onAccountClosureId);
    this.accountTermAndPreClosure.updateOnAccountClosureStatus(onClosureType);

    /*
     * // withdraw deposit amount before closing the account final Money
     * transactionAmountMoney = Money.of(this.currency,
     * this.getAccountBalance()); final SavingsAccountTransaction withdraw =
     * SavingsAccountTransaction.withdrawal(this, office(), paymentDetail,
     * closedDate, transactionAmountMoney, new Date());
     * this.transactions.add(withdraw);
     */
    actualChanges.put(SavingsApiConstants.statusParamName, SavingsEnumerations.status(this.status));
    actualChanges.put(SavingsApiConstants.localeParamName, command.locale());
    actualChanges.put(SavingsApiConstants.dateFormatParamName, command.dateFormat());
    actualChanges.put(SavingsApiConstants.closedOnDateParamName, closedDate.toString(fmt));

    this.rejectedOnDate = null;
    this.rejectedBy = null;
    this.withdrawnOnDate = null;
    this.withdrawnBy = null;
    this.closedOnDate = closedDate.toDate();
    this.closedBy = currentUser;
    this.summary.updateSummary(this.currency, this.savingsAccountTransactionSummaryWrapper, this.transactions);
}