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:org.apache.fineract.portfolio.loanaccount.loanschedule.service.LoanScheduleAssembler.java

License:Apache License

private LocalDate deriveFirstRepaymentDateForJLGLoans(final Integer repaymentEvery,
        final LocalDate expectedDisbursementDate, final LocalDate refernceDateForCalculatingFirstRepaymentDate,
        final PeriodFrequencyType repaymentPeriodFrequencyType,
        final Integer minimumDaysBetweenDisbursalAndFirstRepayment, final Calendar calendar) {

    final String frequency = CalendarUtils
            .getMeetingFrequencyFromPeriodFrequencyType(repaymentPeriodFrequencyType);
    final LocalDate derivedFirstRepayment = CalendarUtils.getFirstRepaymentMeetingDate(calendar,
            refernceDateForCalculatingFirstRepaymentDate, repaymentEvery, frequency);
    final LocalDate minimumFirstRepaymentDate = expectedDisbursementDate
            .plusDays(minimumDaysBetweenDisbursalAndFirstRepayment);
    return minimumFirstRepaymentDate.isBefore(derivedFirstRepayment) ? derivedFirstRepayment
            : deriveFirstRepaymentDateForJLGLoans(repaymentEvery, expectedDisbursementDate,
                    derivedFirstRepayment, repaymentPeriodFrequencyType,
                    minimumDaysBetweenDisbursalAndFirstRepayment, calendar);
}

From source file:org.apache.fineract.portfolio.loanaccount.rescheduleloan.data.LoanRescheduleRequestDataValidator.java

License:Apache License

/**
 * Validates the request to create a new loan reschedule entry
 * /*from   w  ww  .j a v a 2  s . c o  m*/
 * @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();
    }

    if (rescheduleFromDate != null) {
        LoanRepaymentScheduleInstallment 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 (installment != null && installment.isPartlyPaid()) {
            dataValidatorBuilder.reset().parameter(RescheduleLoansApiConstants.rescheduleFromDateParamName)
                    .failWithCode("repayment.schedule.installment.partly.paid",
                            "Repayment schedule installment is partly paid");
        }
    }

    if (loanId != null) {
        List<LoanRescheduleRequestData> loanRescheduleRequestData = this.loanRescheduleRequestReadPlatformService
                .readLoanRescheduleRequests(loanId, LoanStatus.APPROVED.getValue());

        if (loanRescheduleRequestData.size() > 0) {
            dataValidatorBuilder.reset().failWithCodeNoParameterAddedToErrorCode("loan.already.rescheduled",
                    "The loan can only be rescheduled once.");
        }
    }
    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");
    }

    if (!dataValidationErrors.isEmpty()) {
        throw new PlatformApiDataValidationException(dataValidationErrors);
    }
}

From source file:org.apache.fineract.portfolio.savings.domain.SavingsAccount.java

License:Apache License

public void addCharge(final DateTimeFormatter formatter, final SavingsAccountCharge savingsAccountCharge,
        final Charge chargeDefinition) {

    final List<ApiParameterError> dataValidationErrors = new ArrayList<>();
    final DataValidatorBuilder baseDataValidator = new DataValidatorBuilder(dataValidationErrors)
            .resource(SAVINGS_ACCOUNT_RESOURCE_NAME);

    if (isClosed()) {
        baseDataValidator.reset()/*from w ww  .  j av a2  s . co  m*/
                .failWithCodeNoParameterAddedToErrorCode("transaction.invalid.account.is.closed");
        if (!dataValidationErrors.isEmpty()) {
            throw new PlatformApiDataValidationException(dataValidationErrors);
        }
    }

    if (!hasCurrencyCodeOf(chargeDefinition.getCurrencyCode())) {
        baseDataValidator.reset().failWithCodeNoParameterAddedToErrorCode(
                "transaction.invalid.account.currency.and.charge.currency.not.same");
        if (!dataValidationErrors.isEmpty()) {
            throw new PlatformApiDataValidationException(dataValidationErrors);
        }
    }

    final LocalDate chargeDueDate = savingsAccountCharge.getDueLocalDate();

    if (savingsAccountCharge.isOnSpecifiedDueDate()) {
        if (getActivationLocalDate() != null && chargeDueDate.isBefore(getActivationLocalDate())) {
            baseDataValidator.reset().parameter(dueAsOfDateParamName)
                    .value(getActivationLocalDate().toString(formatter))
                    .failWithCodeNoParameterAddedToErrorCode("before.activationDate");
            throw new PlatformApiDataValidationException(dataValidationErrors);
        } else if (getSubmittedOnLocalDate() != null && chargeDueDate.isBefore(getSubmittedOnLocalDate())) {
            baseDataValidator.reset().parameter(dueAsOfDateParamName)
                    .value(getSubmittedOnLocalDate().toString(formatter))
                    .failWithCodeNoParameterAddedToErrorCode("before.submittedOnDate");
            throw new PlatformApiDataValidationException(dataValidationErrors);
        }
    }

    if (savingsAccountCharge.isSavingsActivation()
            && !(isSubmittedAndPendingApproval() || (isApproved() && isNotActive()))) {
        baseDataValidator.reset().failWithCodeNoParameterAddedToErrorCode(
                "not.valid.account.status.cannot.add.activation.time.charge");
        throw new PlatformApiDataValidationException(dataValidationErrors);
    }

    // Only one withdrawal fee is supported per account
    if (savingsAccountCharge.isWithdrawalFee()) {
        if (this.isWithDrawalFeeExists()) {
            baseDataValidator.reset().failWithCodeNoParameterAddedToErrorCode(
                    "multiple.withdrawal.fee.per.account.not.supported");
            throw new PlatformApiDataValidationException(dataValidationErrors);
        }
    }

    // Only one annual fee is supported per account
    if (savingsAccountCharge.isAnnualFee()) {
        if (this.isAnnualFeeExists()) {
            baseDataValidator.reset()
                    .failWithCodeNoParameterAddedToErrorCode("multiple.annual.fee.per.account.not.supported");
            throw new PlatformApiDataValidationException(dataValidationErrors);
        }

    }

    if (savingsAccountCharge.isAnnualFee() || savingsAccountCharge.isMonthlyFee()
            || savingsAccountCharge.isWeeklyFee()) {
        // update due date
        if (isActive()) {
            savingsAccountCharge.updateToNextDueDateFrom(getActivationLocalDate());
        } else if (isApproved()) {
            savingsAccountCharge.updateToNextDueDateFrom(getApprovedOnLocalDate());
        }
    }

    // activation charge and withdrawal charges not required this validation
    if (savingsAccountCharge.isOnSpecifiedDueDate()) {
        validateActivityNotBeforeClientOrGroupTransferDate(SavingsEvent.SAVINGS_APPLY_CHARGE, chargeDueDate);
    }

    // add new charge to savings account
    charges().add(savingsAccountCharge);

}

From source file:org.apache.fineract.portfolio.savings.service.SavingsApplicationProcessWritePlatformServiceJpaRepositoryImpl.java

License:Apache License

private void validateSubmittedOnDate(final SavingsAccount savingsAccount) {
    final LocalDate startDate = savingsAccount.savingsProduct().getStartDate();
    final LocalDate closeDate = savingsAccount.savingsProduct().getCloseDate();
    final LocalDate submittedOnDate = savingsAccount.getSubmittedOnDate();

    String defaultUserMessage = "";
    if (startDate != null && submittedOnDate.isBefore(startDate)) {
        defaultUserMessage = "submittedOnDate cannot be before the savings product startDate.";
        throw new SavingsApplicationDateException(
                "submitted.on.date.cannot.be.before.the.savings.product.start.date", defaultUserMessage,
                submittedOnDate.toString(), startDate.toString());
    }/*w  w  w  . j a v  a 2  s  .  c o  m*/

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

From source file:org.apache.fineract.portfolio.shareaccounts.serialization.ShareAccountDataSerializer.java

License:Apache License

@SuppressWarnings("null")
public Map<String, Object> validateAndApprove(JsonCommand jsonCommand, ShareAccount account) {
    Map<String, Object> actualChanges = new HashMap<>();
    if (StringUtils.isBlank(jsonCommand.json())) {
        throw new InvalidJsonException();
    }/*ww  w. j  ava 2s.  c  o  m*/
    final Type typeOfMap = new TypeToken<Map<String, Object>>() {
    }.getType();
    this.fromApiJsonHelper.checkForUnsupportedParameters(typeOfMap, jsonCommand.json(),
            ShareAccountApiConstants.approvalParameters);
    final List<ApiParameterError> dataValidationErrors = new ArrayList<>();
    final DataValidatorBuilder baseDataValidator = new DataValidatorBuilder(dataValidationErrors)
            .resource("sharesaccount");
    JsonElement element = jsonCommand.parsedJson();
    LocalDate approvedDate = this.fromApiJsonHelper
            .extractLocalDateNamed(ShareAccountApiConstants.approveddate_paramname, element);
    final LocalDate submittalDate = new LocalDate(account.getSubmittedDate());
    if (approvedDate != null && approvedDate.isBefore(submittalDate)) {
        final DateTimeFormatter formatter = DateTimeFormat.forPattern(jsonCommand.dateFormat())
                .withLocale(jsonCommand.extractLocale());
        final String submittalDateAsString = formatter.print(submittalDate);
        baseDataValidator.reset().parameter(ShareAccountApiConstants.approveddate_paramname)
                .value(submittalDateAsString)
                .failWithCodeNoParameterAddedToErrorCode("approved.date.cannot.be.before.submitted.date");
    }

    Set<ShareAccountTransaction> transactions = account.getShareAccountTransactions();
    for (ShareAccountTransaction transaction : transactions) {
        if (transaction.isActive() && transaction.isPendingForApprovalTransaction()) {
            validateTotalSubsribedShares(account, transaction, baseDataValidator);
        }
    }

    if (!dataValidationErrors.isEmpty()) {
        throw new PlatformApiDataValidationException(dataValidationErrors);
    }

    AppUser approvedUser = this.platformSecurityContext.authenticatedUser();
    account.approve(approvedDate.toDate(), approvedUser);
    actualChanges.put(ShareAccountApiConstants.id_paramname, account.getId());
    updateTotalChargeDerived(account);
    return actualChanges;
}

From source file:org.apache.fineract.portfolio.shareaccounts.serialization.ShareAccountDataSerializer.java

License:Apache License

@SuppressWarnings("null")
public Map<String, Object> validateAndActivate(JsonCommand jsonCommand, ShareAccount account) {
    Map<String, Object> actualChanges = new HashMap<>();
    if (StringUtils.isBlank(jsonCommand.json())) {
        throw new InvalidJsonException();
    }/*from  w ww .j  a va2 s .com*/
    final Type typeOfMap = new TypeToken<Map<String, Object>>() {
    }.getType();
    this.fromApiJsonHelper.checkForUnsupportedParameters(typeOfMap, jsonCommand.json(),
            ShareAccountApiConstants.activateParameters);
    final List<ApiParameterError> dataValidationErrors = new ArrayList<>();
    final DataValidatorBuilder baseDataValidator = new DataValidatorBuilder(dataValidationErrors)
            .resource("sharesaccount");
    JsonElement element = jsonCommand.parsedJson();
    LocalDate activatedDate = this.fromApiJsonHelper
            .extractLocalDateNamed(ShareAccountApiConstants.activatedate_paramname, element);
    baseDataValidator.reset().parameter(ShareAccountApiConstants.activatedate_paramname).value(activatedDate)
            .notNull();
    final LocalDate approvedDate = new LocalDate(account.getApprovedDate());
    if (activatedDate != null && activatedDate.isBefore(approvedDate)) {
        final DateTimeFormatter formatter = DateTimeFormat.forPattern(jsonCommand.dateFormat())
                .withLocale(jsonCommand.extractLocale());
        final String submittalDateAsString = formatter.print(approvedDate);
        baseDataValidator.reset().parameter(ShareAccountApiConstants.activatedate_paramname)
                .value(submittalDateAsString)
                .failWithCodeNoParameterAddedToErrorCode("cannot.be.before.approved.date");
    }
    if (!dataValidationErrors.isEmpty()) {
        throw new PlatformApiDataValidationException(dataValidationErrors);
    }
    AppUser approvedUser = this.platformSecurityContext.authenticatedUser();
    account.activate(activatedDate.toDate(), approvedUser);
    handlechargesOnActivation(account);
    actualChanges.put(ShareAccountApiConstants.charges_paramname, activatedDate.toDate());
    return actualChanges;
}

From source file:org.apache.fineract.portfolio.shareaccounts.serialization.ShareAccountDataSerializer.java

License:Apache License

public Map<String, Object> validateAndApplyAddtionalShares(JsonCommand jsonCommand, ShareAccount account) {
    Map<String, Object> actualChanges = new HashMap<>();
    if (StringUtils.isBlank(jsonCommand.json())) {
        throw new InvalidJsonException();
    }/*from w w w  .j ava2 s  . com*/
    final Type typeOfMap = new TypeToken<Map<String, Object>>() {
    }.getType();
    this.fromApiJsonHelper.checkForUnsupportedParameters(typeOfMap, jsonCommand.json(),
            ShareAccountApiConstants.addtionalSharesParameters);
    final List<ApiParameterError> dataValidationErrors = new ArrayList<>();
    final DataValidatorBuilder baseDataValidator = new DataValidatorBuilder(dataValidationErrors)
            .resource("sharesaccount");
    JsonElement element = jsonCommand.parsedJson();
    LocalDate requestedDate = this.fromApiJsonHelper
            .extractLocalDateNamed(ShareAccountApiConstants.requesteddate_paramname, element);
    baseDataValidator.reset().parameter(ShareAccountApiConstants.requesteddate_paramname).value(requestedDate)
            .notNull();
    final Long sharesRequested = this.fromApiJsonHelper
            .extractLongNamed(ShareAccountApiConstants.requestedshares_paramname, element);
    baseDataValidator.reset().parameter(ShareAccountApiConstants.requestedshares_paramname)
            .value(sharesRequested).notNull();
    ShareProduct shareProduct = account.getShareProduct();
    if (sharesRequested != null) {
        Long totalSharesAfterapproval = account.getTotalApprovedShares() + sharesRequested;
        if (totalSharesAfterapproval > shareProduct.getMaximumClientShares()) {
            baseDataValidator.reset().parameter(ShareAccountApiConstants.requestedshares_paramname)
                    .value(sharesRequested).failWithCode("exceeding.maximum.limit.defined.in.the.shareproduct",
                            "Existing and requested shares count is more than product definition");
        }
    }
    boolean isTransactionBeforeExistingTransactions = false;
    Set<ShareAccountTransaction> transactions = account.getShareAccountTransactions();
    for (ShareAccountTransaction transaction : transactions) {
        if (!transaction.isChargeTransaction()) {
            LocalDate transactionDate = new LocalDate(transaction.getPurchasedDate());
            if (requestedDate.isBefore(transactionDate)) {
                isTransactionBeforeExistingTransactions = true;
                break;
            }
        }
    }
    if (isTransactionBeforeExistingTransactions) {
        baseDataValidator.reset().parameter(ShareAccountApiConstants.requesteddate_paramname)
                .value(requestedDate).failWithCodeNoParameterAddedToErrorCode(
                        "purchase.transaction.date.cannot.be.before.existing.transactions");
    }

    if (!dataValidationErrors.isEmpty()) {
        throw new PlatformApiDataValidationException(dataValidationErrors);
    }
    final BigDecimal unitPrice = shareProduct.deriveMarketPrice(requestedDate.toDate());
    ShareAccountTransaction purchaseTransaction = new ShareAccountTransaction(requestedDate.toDate(),
            sharesRequested, unitPrice);
    account.addAdditionalPurchasedShares(purchaseTransaction);
    handleAdditionalSharesChargeTransactions(account, purchaseTransaction);
    actualChanges.put(ShareAccountApiConstants.additionalshares_paramname, purchaseTransaction);
    return actualChanges;
}

From source file:org.apache.fineract.portfolio.shareaccounts.serialization.ShareAccountDataSerializer.java

License:Apache License

public Map<String, Object> validateAndRedeemShares(JsonCommand jsonCommand, ShareAccount account) {
    Map<String, Object> actualChanges = new HashMap<>();
    if (StringUtils.isBlank(jsonCommand.json())) {
        throw new InvalidJsonException();
    }//from  w w  w . ja v a2  s  .  c o  m
    final Type typeOfMap = new TypeToken<Map<String, Object>>() {
    }.getType();
    this.fromApiJsonHelper.checkForUnsupportedParameters(typeOfMap, jsonCommand.json(),
            ShareAccountApiConstants.addtionalSharesParameters);
    final List<ApiParameterError> dataValidationErrors = new ArrayList<>();
    final DataValidatorBuilder baseDataValidator = new DataValidatorBuilder(dataValidationErrors)
            .resource("sharesaccount");
    JsonElement element = jsonCommand.parsedJson();
    LocalDate requestedDate = this.fromApiJsonHelper
            .extractLocalDateNamed(ShareAccountApiConstants.requesteddate_paramname, element);
    baseDataValidator.reset().parameter(ShareAccountApiConstants.requesteddate_paramname).value(requestedDate)
            .notNull();
    final Long sharesRequested = this.fromApiJsonHelper
            .extractLongNamed(ShareAccountApiConstants.requestedshares_paramname, element);
    baseDataValidator.reset().parameter(ShareAccountApiConstants.requestedshares_paramname)
            .value(sharesRequested).notNull().longGreaterThanZero();

    final Locale locale = this.fromApiJsonHelper.extractLocaleParameter(element.getAsJsonObject());
    final BigDecimal unitPrice = this.fromApiJsonHelper
            .extractBigDecimalNamed(ShareAccountApiConstants.purchasedprice_paramname, element, locale);
    baseDataValidator.reset().parameter(ShareAccountApiConstants.purchasedprice_paramname).value(unitPrice)
            .notNull().positiveAmount();
    boolean isTransactionBeforeExistingTransactions = false;
    Set<ShareAccountTransaction> transactions = account.getShareAccountTransactions();
    for (ShareAccountTransaction transaction : transactions) {
        if (!transaction.isChargeTransaction() && transaction.isActive()) {
            LocalDate transactionDate = new LocalDate(transaction.getPurchasedDate());
            if (requestedDate.isBefore(transactionDate)) {
                isTransactionBeforeExistingTransactions = true;
                break;
            }
        }
    }
    if (isTransactionBeforeExistingTransactions) {
        baseDataValidator.reset().parameter(ShareAccountApiConstants.requesteddate_paramname)
                .value(requestedDate).failWithCodeNoParameterAddedToErrorCode(
                        "redeem.transaction.date.cannot.be.before.existing.transactions");
    }
    if (!dataValidationErrors.isEmpty()) {
        throw new PlatformApiDataValidationException(dataValidationErrors);
    }
    ShareAccountTransaction transaction = ShareAccountTransaction
            .createRedeemTransaction(requestedDate.toDate(), sharesRequested, unitPrice);
    validateRedeemRequest(account, transaction, baseDataValidator, dataValidationErrors);
    account.addAdditionalPurchasedShares(transaction);
    actualChanges.put(ShareAccountApiConstants.requestedshares_paramname, transaction);

    handleRedeemSharesChargeTransactions(account, transaction);
    return actualChanges;
}

From source file:org.apache.fineract.portfolio.shareaccounts.serialization.ShareAccountDataSerializer.java

License:Apache License

public Map<String, Object> validateAndClose(JsonCommand jsonCommand, ShareAccount account) {
    Map<String, Object> actualChanges = new HashMap<>();
    if (StringUtils.isBlank(jsonCommand.json())) {
        throw new InvalidJsonException();
    }//from www.  j  a  va2  s  .c o m
    final Type typeOfMap = new TypeToken<Map<String, Object>>() {
    }.getType();
    this.fromApiJsonHelper.checkForUnsupportedParameters(typeOfMap, jsonCommand.json(),
            ShareAccountApiConstants.closeParameters);
    final List<ApiParameterError> dataValidationErrors = new ArrayList<>();
    final DataValidatorBuilder baseDataValidator = new DataValidatorBuilder(dataValidationErrors)
            .resource("sharesaccount");
    JsonElement element = jsonCommand.parsedJson();
    LocalDate closedDate = this.fromApiJsonHelper
            .extractLocalDateNamed(ShareAccountApiConstants.closeddate_paramname, element);
    baseDataValidator.reset().parameter(ShareAccountApiConstants.approveddate_paramname).value(closedDate)
            .notNull();
    boolean isTransactionBeforeExistingTransactions = false;
    Set<ShareAccountTransaction> transactions = account.getShareAccountTransactions();
    for (ShareAccountTransaction transaction : transactions) {
        if (!transaction.isChargeTransaction()) {
            LocalDate transactionDate = new LocalDate(transaction.getPurchasedDate());
            if (closedDate.isBefore(transactionDate)) {
                isTransactionBeforeExistingTransactions = true;
                break;
            }
        }
    }
    if (isTransactionBeforeExistingTransactions) {
        baseDataValidator.reset().parameter(ShareAccountApiConstants.closeddate_paramname).value(closedDate)
                .failWithCodeNoParameterAddedToErrorCode(
                        "share.account.cannot.be.closed.before.existing.transactions");
    }

    if (!dataValidationErrors.isEmpty()) {
        throw new PlatformApiDataValidationException(dataValidationErrors);
    }

    AppUser approvedUser = this.platformSecurityContext.authenticatedUser();
    final BigDecimal unitPrice = account.getShareProduct().deriveMarketPrice(DateUtils.getDateOfTenant());
    ShareAccountTransaction transaction = ShareAccountTransaction.createRedeemTransaction(closedDate.toDate(),
            account.getTotalApprovedShares(), unitPrice);
    account.addAdditionalPurchasedShares(transaction);
    account.close(closedDate.toDate(), approvedUser);
    handleRedeemSharesChargeTransactions(account, transaction);
    actualChanges.put(ShareAccountApiConstants.requestedshares_paramname, transaction);
    updateTotalChargeDerived(account);

    return actualChanges;
}

From source file:org.apereo.portlet.hr.demo.timereporting.dao.DemoStaffTimeReportingImpl.java

License:Apache License

private void initializeForEmployeeIfNeeded(String emplId) {
    // All employees have a leave balance and sick balance setup
    if (emplLeaveBalances.get(emplId) == null) {
        List<JobCodeTime> leaveBalances = new ArrayList<JobCodeTime>();
        leaveBalances.add(new JobCodeTime(SICK, 215 * 60 + 4)); // 215 hours, 4 min
        leaveBalances.add(new JobCodeTime(VACATION, 64 * 60 + 10)); //64:10
        emplLeaveBalances.put(emplId, leaveBalances);
    }// ww  w .j  a  v a  2s  .c  o  m

    // Add work entries for the employee.
    if (emplWorkEntries.get(emplId) == null) {
        LocalDate startDate = calculatePayperiodStartDate(new LocalDate());
        LocalDate tomorrow = new LocalDate().plusDays(1);
        List<TimePeriodEntry> items = new ArrayList<TimePeriodEntry>();
        // Create entries for 1 pay period back through current
        for (int i = -DAYS_IN_PAY_PERIOD; i < DAYS_IN_PAY_PERIOD; i++) {
            LocalDate date = startDate.plusDays(i);
            // For previous pay period, worked 7 hours a day. For current pay period, hours is based on
            // day of week + 15 minutes, up through today.  // Skip Sat and Sun since they by default don't display.
            int timeWorked = i < 0 ? 7 * 60 : date.getDayOfWeek() * 60 + 15;
            if (date.getDayOfWeek() < 6 && date.isBefore(tomorrow)) {
                items.add(new TimePeriodEntry(date, WORKED, timeWorked));
            }
        }
        emplWorkEntries.put(emplId, items);
    }

    if (emplLeaveEntries.get(emplId) == null) {
        emplLeaveEntries.put(emplId, new ArrayList<TimePeriodEntry>());
    }
}