* This Source Code Form is subject to the terms of the Mozilla Public

* License, v. 2.0. If a copy of the MPL was not distributed with this file,

* You can obtain one at http://mozilla.org/MPL/2.0/.

*/

    private ResponseSpecification responseSpec;

    private RequestSpecification requestSpec;

    private RecurringDepositProductHelper recurringDepositProductHelper;

    private SavingsAccountHelper savingsAccountHelper;

    private AccountHelper accountHelper;

    private RecurringDepositAccountHelper recurringDepositAccountHelper;

    private JournalEntryHelper journalEntryHelper;

    private FinancialActivityAccountHelper financialActivityAccountHelper;

    public static final String WHOLE_TERM = "1";

    private static final String TILL_PREMATURE_WITHDRAWAL = "2";

    private static final String DAILY = "1";

    private static final String MONTHLY = "4";

    private static final String QUARTERLY = "5";

    private static final String BI_ANNUALLY = "6";

    private static final String ANNUALLY = "7";

    private static final String INTEREST_CALCULATION_USING_DAILY_BALANCE = "1";

    private static final String INTEREST_CALCULATION_USING_AVERAGE_DAILY_BALANCE = "2";

    private static final String DAYS_360 = "360";

    private static final String DAYS_365 = "365";

    private static final String NONE = "1";

    private static final String CASH_BASED = "2";

    public static final String MINIMUM_OPENING_BALANCE = "1000.0";

    public static final String ACCOUNT_TYPE_INDIVIDUAL = "INDIVIDUAL";

    public static final String CLOSURE_TYPE_WITHDRAW_DEPOSIT = "100";

    public static final String CLOSURE_TYPE_TRANSFER_TO_SAVINGS = "200";

    public static final String CLOSURE_TYPE_REINVEST = "300";

    public static final Integer DAILY_COMPOUNDING_INTERVAL = 0;

    public static final Integer MONTHLY_INTERVAL = 1;

    public static final Integer QUARTERLY_INTERVAL = 3;

    public static final Integer BIANNULLY_INTERVAL = 6;

    public static final Integer ANNUL_INTERVAL = 12;

    public static final Float DEPOSIT_AMOUNT = 2000.0f;

    @Before

    public void setup() {

        Utils.initializeRESTAssured();

        this.requestSpec = new RequestSpecBuilder().setContentType(ContentType.JSON).build();

        this.requestSpec.header("Authorization", "Basic " + Utils.loginIntoServerAndGetBase64EncodedAuthenticationKey());

        this.requestSpec.header("X-Mifos-Platform-TenantId", "default");

        this.responseSpec = new ResponseSpecBuilder().expectStatusCode(200).build();

        this.journalEntryHelper = new JournalEntryHelper(this.requestSpec, this.responseSpec);

        this.financialActivityAccountHelper = new FinancialActivityAccountHelper(this.requestSpec);

    }

    /***

     * Test case for Recurring Deposit Account premature closure with

     * transaction type withdrawal and Cash Based accounting enabled

     */

    @Test

    public void testRecurringDepositAccountWithPrematureClosureTypeWithdrawal() {

        this.recurringDepositProductHelper = new RecurringDepositProductHelper(this.requestSpec, this.responseSpec);

        this.accountHelper = new AccountHelper(this.requestSpec, this.responseSpec);

        this.recurringDepositAccountHelper = new RecurringDepositAccountHelper(this.requestSpec, this.responseSpec);

        /***

         * Create GL Accounts for product account mapping

         */

        final Account assetAccount = this.accountHelper.createAssetAccount();

        final Account incomeAccount = this.accountHelper.createIncomeAccount();

        final Account expenseAccount = this.accountHelper.createExpenseAccount();

        final Account liabilityAccount = this.accountHelper.createLiabilityAccount();

        DateFormat dateFormat = new SimpleDateFormat("dd MMMM yyyy", Locale.US);

        DateFormat monthDayFormat = new SimpleDateFormat("dd MMM", Locale.US);

        DateFormat currentDateFormat = new SimpleDateFormat("dd");

        Calendar todaysDate = Calendar.getInstance();

        todaysDate.add(Calendar.MONTH, -3);

        final String VALID_FROM = dateFormat.format(todaysDate.getTime());

        todaysDate.add(Calendar.YEAR, 10);

        final String VALID_TO = dateFormat.format(todaysDate.getTime());

        todaysDate = Calendar.getInstance();

        todaysDate.add(Calendar.MONTH, -1);

        final String SUBMITTED_ON_DATE = dateFormat.format(todaysDate.getTime());

        final String APPROVED_ON_DATE = dateFormat.format(todaysDate.getTime());

        final String ACTIVATION_DATE = dateFormat.format(todaysDate.getTime());

        final String EXPECTED_FIRST_DEPOSIT_ON_DATE = dateFormat.format(todaysDate.getTime());

        final String MONTH_DAY = monthDayFormat.format(todaysDate.getTime());

        Integer currentDate = new Integer(currentDateFormat.format(todaysDate.getTime()));

        Integer daysInMonth = todaysDate.getActualMaximum(Calendar.DATE);

        Integer numberOfDaysLeft = (daysInMonth - currentDate) + 1;

        todaysDate.add(Calendar.DATE, numberOfDaysLeft);

        final String INTEREST_POSTED_DATE = dateFormat.format(todaysDate.getTime());

        final String CLOSED_ON_DATE = dateFormat.format(Calendar.getInstance().getTime());

        /***

         * Create client for applying Deposit account

         */

        Integer clientId = ClientHelper.createClient(this.requestSpec, this.responseSpec);

        Assert.assertNotNull(clientId);

        /***

         * Create RD product with CashBased accounting enabled

         */

        final String accountingRule = CASH_BASED;

        Integer recurringDepositProductId = createRecurringDepositProduct(VALID_FROM, VALID_TO, accountingRule, assetAccount,

                liabilityAccount, incomeAccount, expenseAccount);

        Assert.assertNotNull(recurringDepositProductId);

        /***

         * Apply for RD account with created product and verify status

         */

        Integer recurringDepositAccountId = applyForRecurringDepositApplication(clientId.toString(), recurringDepositProductId.toString(),

                VALID_FROM, VALID_TO, SUBMITTED_ON_DATE, WHOLE_TERM, EXPECTED_FIRST_DEPOSIT_ON_DATE);

        Assert.assertNotNull(recurringDepositAccountId);

        HashMap recurringDepositAccountStatusHashMap = RecurringDepositAccountStatusChecker.getStatusOfRecurringDepositAccount(

                this.requestSpec, this.responseSpec, recurringDepositAccountId.toString());

        RecurringDepositAccountStatusChecker.verifyRecurringDepositIsPending(recurringDepositAccountStatusHashMap);

        /***

         * Approve the RD account and verify whether account is approved

         */

        recurringDepositAccountStatusHashMap = this.recurringDepositAccountHelper.approveRecurringDeposit(recurringDepositAccountId,

                APPROVED_ON_DATE);

        RecurringDepositAccountStatusChecker.verifyRecurringDepositIsApproved(recurringDepositAccountStatusHashMap);

        /***

         * Activate the RD Account and verify whether account is activated

         */

        recurringDepositAccountStatusHashMap = this.recurringDepositAccountHelper.activateRecurringDeposit(recurringDepositAccountId,

                ACTIVATION_DATE);

        RecurringDepositAccountStatusChecker.verifyRecurringDepositIsActive(recurringDepositAccountStatusHashMap);

        HashMap recurringDepositAccountData = this.recurringDepositAccountHelper.getRecurringDepositAccountById(this.requestSpec,

                this.responseSpec, recurringDepositAccountId);

        Float depositAmount = (Float) recurringDepositAccountData.get("mandatoryRecommendedDepositAmount");

        /***

         * Perform Deposit transaction and verify journal entries are posted for

         * the transaction

         */

        Integer depositTransactionId = this.recurringDepositAccountHelper.depositToRecurringDepositAccount(recurringDepositAccountId,

                depositAmount, EXPECTED_FIRST_DEPOSIT_ON_DATE);

        Assert.assertNotNull(depositTransactionId);

        this.journalEntryHelper.checkJournalEntryForAssetAccount(assetAccount, EXPECTED_FIRST_DEPOSIT_ON_DATE, new JournalEntry(

                depositAmount, JournalEntry.TransactionType.DEBIT));

        this.journalEntryHelper.checkJournalEntryForLiabilityAccount(liabilityAccount, EXPECTED_FIRST_DEPOSIT_ON_DATE, new JournalEntry(

                depositAmount, JournalEntry.TransactionType.CREDIT));

        /***

         * Update interest earned field for RD account

         */

        recurringDepositAccountId = this.recurringDepositAccountHelper.calculateInterestForRecurringDeposit(recurringDepositAccountId);

        Assert.assertNotNull(recurringDepositAccountId);

        /***

         * Post interest and verify journal entries

         */

        Integer transactionIdForPostInterest = this.recurringDepositAccountHelper

                .postInterestForRecurringDeposit(recurringDepositAccountId);

        Assert.assertNotNull(transactionIdForPostInterest);

        HashMap accountSummary = this.recurringDepositAccountHelper.getRecurringDepositSummary(recurringDepositAccountId);

        Float totalInterestPosted = (Float) accountSummary.get("totalInterestPosted");

        final JournalEntry[] expenseAccountEntry = { new JournalEntry(totalInterestPosted, JournalEntry.TransactionType.DEBIT) };

        final JournalEntry[] liablilityAccountEntry = { new JournalEntry(totalInterestPosted, JournalEntry.TransactionType.CREDIT) };

        this.journalEntryHelper.checkJournalEntryForAssetAccount(expenseAccount, INTEREST_POSTED_DATE, expenseAccountEntry);

        this.journalEntryHelper.checkJournalEntryForLiabilityAccount(liabilityAccount, INTEREST_POSTED_DATE, liablilityAccountEntry);

        /***

         * Calculate expected premature closure amount

         */

        HashMap recurringDepositPrematureData = this.recurringDepositAccountHelper.calculatePrematureAmountForRecurringDeposit(

                recurringDepositAccountId, CLOSED_ON_DATE);

        /***

         * Preclose the RD account verify whether account is preClosed

         */

        Integer prematureClosureTransactionId = (Integer) this.recurringDepositAccountHelper.prematureCloseForRecurringDeposit(

                recurringDepositAccountId, CLOSED_ON_DATE, CLOSURE_TYPE_WITHDRAW_DEPOSIT, null, CommonConstants.RESPONSE_RESOURCE_ID);

        Assert.assertNotNull(prematureClosureTransactionId);

        recurringDepositAccountStatusHashMap = RecurringDepositAccountStatusChecker.getStatusOfRecurringDepositAccount(this.requestSpec,

                this.responseSpec, recurringDepositAccountId.toString());

        RecurringDepositAccountStatusChecker.verifyRecurringDepositAccountIsPrematureClosed(recurringDepositAccountStatusHashMap);

        /***

         * Verify journal entry transactions for preclosure transaction

         */

        recurringDepositAccountData = this.recurringDepositAccountHelper.getRecurringDepositAccountById(this.requestSpec,

                this.responseSpec, recurringDepositAccountId);

        Float maturityAmount = Float.valueOf(recurringDepositAccountData.get("maturityAmount").toString());

        this.journalEntryHelper.checkJournalEntryForAssetAccount(assetAccount, CLOSED_ON_DATE, new JournalEntry(maturityAmount,

                JournalEntry.TransactionType.CREDIT));

        this.journalEntryHelper.checkJournalEntryForLiabilityAccount(liabilityAccount, CLOSED_ON_DATE, new JournalEntry(maturityAmount,

                JournalEntry.TransactionType.DEBIT));

    }

    /***

     * Test case for Recurring Deposit Account premature closure with

     * transaction transfers to savings account and Cash Based accounting

     * enabled

     */

    @Test

    public void testRecurringDepositAccountWithPrematureClosureTypeTransferToSavings() {

        this.recurringDepositProductHelper = new RecurringDepositProductHelper(this.requestSpec, this.responseSpec);

        this.accountHelper = new AccountHelper(this.requestSpec, this.responseSpec);

        this.savingsAccountHelper = new SavingsAccountHelper(this.requestSpec, this.responseSpec);

        this.recurringDepositAccountHelper = new RecurringDepositAccountHelper(this.requestSpec, this.responseSpec);

        /***

         * Create GL Accounts for product account mapping

         */

        final Account assetAccount = this.accountHelper.createAssetAccount();

        final Account incomeAccount = this.accountHelper.createIncomeAccount();

        final Account expenseAccount = this.accountHelper.createExpenseAccount();

        final Account liabilityAccount = this.accountHelper.createLiabilityAccount();

        DateFormat dateFormat = new SimpleDateFormat("dd MMMM yyyy", Locale.US);

        DateFormat monthDayFormat = new SimpleDateFormat("dd MMM", Locale.US);

        DateFormat currentDateFormat = new SimpleDateFormat("dd");

        Calendar todaysDate = Calendar.getInstance();

        todaysDate.add(Calendar.MONTH, -3);

        final String VALID_FROM = dateFormat.format(todaysDate.getTime());

        todaysDate.add(Calendar.YEAR, 10);

        final String VALID_TO = dateFormat.format(todaysDate.getTime());

        todaysDate = Calendar.getInstance();

        todaysDate.add(Calendar.MONTH, -1);

        final String SUBMITTED_ON_DATE = dateFormat.format(todaysDate.getTime());

        final String APPROVED_ON_DATE = dateFormat.format(todaysDate.getTime());

        final String ACTIVATION_DATE = dateFormat.format(todaysDate.getTime());

        final String EXPECTED_FIRST_DEPOSIT_ON_DATE = dateFormat.format(todaysDate.getTime());

        final String MONTH_DAY = monthDayFormat.format(todaysDate.getTime());

        Integer currentDate = new Integer(currentDateFormat.format(todaysDate.getTime()));

        Integer daysInMonth = todaysDate.getActualMaximum(Calendar.DATE);

        Integer numberOfDaysLeft = (daysInMonth - currentDate) + 1;

        todaysDate.add(Calendar.DATE, numberOfDaysLeft);

        final String INTEREST_POSTED_DATE = dateFormat.format(todaysDate.getTime());

        final String CLOSED_ON_DATE = dateFormat.format(Calendar.getInstance().getTime());

        /***

         * Create client for applying Deposit and Savings accounts

         */

        Integer clientId = ClientHelper.createClient(this.requestSpec, this.responseSpec);

        Assert.assertNotNull(clientId);

        /***

         * Create Savings product with CashBased accounting enabled

         */

        final String accountingRule = CASH_BASED;

        final Integer savingsProductID = createSavingsProduct(this.requestSpec, this.responseSpec, MINIMUM_OPENING_BALANCE, accountingRule,

                assetAccount, liabilityAccount, incomeAccount, expenseAccount);

        Assert.assertNotNull(savingsProductID);

        /***

         * Create Savings account and verify status is pending

         */

        final Integer savingsId = this.savingsAccountHelper.applyForSavingsApplication(clientId, savingsProductID, ACCOUNT_TYPE_INDIVIDUAL);

        Assert.assertNotNull(savingsProductID);

        HashMap savingsStatusHashMap = SavingsStatusChecker.getStatusOfSavings(this.requestSpec, this.responseSpec, savingsId);

        SavingsStatusChecker.verifySavingsIsPending(savingsStatusHashMap);

        /***

         * Approve the savings account and verify account is approved

         */

        savingsStatusHashMap = this.savingsAccountHelper.approveSavings(savingsId);

        SavingsStatusChecker.verifySavingsIsApproved(savingsStatusHashMap);

        /***

         * Activate the savings account and verify account is activated

         */

        savingsStatusHashMap = this.savingsAccountHelper.activateSavings(savingsId);

        SavingsStatusChecker.verifySavingsIsActive(savingsStatusHashMap);

        /***

         * Create RD product with CashBased accounting enabled

         */

        Integer recurringDepositProductId = createRecurringDepositProduct(VALID_FROM, VALID_TO, accountingRule, assetAccount,

                liabilityAccount, incomeAccount, expenseAccount);

        Assert.assertNotNull(recurringDepositProductId);

        /***

         * Apply for RD account with created product and verify status

         */

        Integer recurringDepositAccountId = applyForRecurringDepositApplication(clientId.toString(), recurringDepositProductId.toString(),

                VALID_FROM, VALID_TO, SUBMITTED_ON_DATE, WHOLE_TERM, EXPECTED_FIRST_DEPOSIT_ON_DATE);

        Assert.assertNotNull(recurringDepositAccountId);

        HashMap recurringDepositAccountStatusHashMap = RecurringDepositAccountStatusChecker.getStatusOfRecurringDepositAccount(

                this.requestSpec, this.responseSpec, recurringDepositAccountId.toString());

        RecurringDepositAccountStatusChecker.verifyRecurringDepositIsPending(recurringDepositAccountStatusHashMap);

        /***

         * Approve the RD account and verify whether account is approved

         */

        recurringDepositAccountStatusHashMap = this.recurringDepositAccountHelper.approveRecurringDeposit(recurringDepositAccountId,

                APPROVED_ON_DATE);

        RecurringDepositAccountStatusChecker.verifyRecurringDepositIsApproved(recurringDepositAccountStatusHashMap);

        /***

         * Activate the RD Account and verify whether account is activated

         */

        recurringDepositAccountStatusHashMap = this.recurringDepositAccountHelper.activateRecurringDeposit(recurringDepositAccountId,

                ACTIVATION_DATE);

        RecurringDepositAccountStatusChecker.verifyRecurringDepositIsActive(recurringDepositAccountStatusHashMap);

        HashMap recurringDepositAccountData = this.recurringDepositAccountHelper.getRecurringDepositAccountById(this.requestSpec,

                this.responseSpec, recurringDepositAccountId);

        Float depositAmount = (Float) recurringDepositAccountData.get("mandatoryRecommendedDepositAmount");

        /***

         * Perform Deposit transaction and verify journal entries are posted for

         * the transaction

         */

        Integer depositTransactionId = this.recurringDepositAccountHelper.depositToRecurringDepositAccount(recurringDepositAccountId,

                depositAmount, EXPECTED_FIRST_DEPOSIT_ON_DATE);

        Assert.assertNotNull(depositTransactionId);

        this.journalEntryHelper.checkJournalEntryForAssetAccount(assetAccount, EXPECTED_FIRST_DEPOSIT_ON_DATE, new JournalEntry(

                depositAmount, JournalEntry.TransactionType.DEBIT));

        this.journalEntryHelper.checkJournalEntryForLiabilityAccount(liabilityAccount, EXPECTED_FIRST_DEPOSIT_ON_DATE, new JournalEntry(

                depositAmount, JournalEntry.TransactionType.CREDIT));

        /***

         * Update interest earned field for RD account

         */

        recurringDepositAccountId = this.recurringDepositAccountHelper.calculateInterestForRecurringDeposit(recurringDepositAccountId);

        Assert.assertNotNull(recurringDepositAccountId);

        /***

         * Post interest and verify journal entries

         */

        Integer transactionIdForPostInterest = this.recurringDepositAccountHelper

                .postInterestForRecurringDeposit(recurringDepositAccountId);

        Assert.assertNotNull(transactionIdForPostInterest);

        HashMap accountSummary = this.recurringDepositAccountHelper.getRecurringDepositSummary(recurringDepositAccountId);

        Float totalInterestPosted = (Float) accountSummary.get("totalInterestPosted");

        final JournalEntry[] expenseAccountEntry = { new JournalEntry(totalInterestPosted, JournalEntry.TransactionType.DEBIT) };

        final JournalEntry[] liablilityAccountEntry = { new JournalEntry(totalInterestPosted, JournalEntry.TransactionType.CREDIT) };

        this.journalEntryHelper.checkJournalEntryForAssetAccount(expenseAccount, INTEREST_POSTED_DATE, expenseAccountEntry);

        this.journalEntryHelper.checkJournalEntryForLiabilityAccount(liabilityAccount, INTEREST_POSTED_DATE, liablilityAccountEntry);

        /***

         * Get saving account balance before preClosing RD account

         */

        HashMap savingsSummaryBefore = this.savingsAccountHelper.getSavingsSummary(savingsId);

        Float balanceBefore = (Float) savingsSummaryBefore.get("accountBalance");

        HashMap recurringDepositPrematureData = this.recurringDepositAccountHelper.calculatePrematureAmountForRecurringDeposit(

                recurringDepositAccountId, CLOSED_ON_DATE);

        /***

         * Retrieve mapped financial account for liability transfer

         */

        Account financialAccount = getMappedLiabilityFinancialAccount();

        /***

         * Preclose the RD account verify whether account is preClosed

         */

        Integer prematureClosureTransactionId = (Integer) this.recurringDepositAccountHelper.prematureCloseForRecurringDeposit(

                recurringDepositAccountId, CLOSED_ON_DATE, CLOSURE_TYPE_TRANSFER_TO_SAVINGS, savingsId,

                CommonConstants.RESPONSE_RESOURCE_ID);

        Assert.assertNotNull(prematureClosureTransactionId);

        recurringDepositAccountStatusHashMap = RecurringDepositAccountStatusChecker.getStatusOfRecurringDepositAccount(this.requestSpec,

                this.responseSpec, recurringDepositAccountId.toString());

        RecurringDepositAccountStatusChecker.verifyRecurringDepositAccountIsPrematureClosed(recurringDepositAccountStatusHashMap);

        recurringDepositAccountData = this.recurringDepositAccountHelper.getRecurringDepositAccountById(this.requestSpec,

                this.responseSpec, recurringDepositAccountId);

        Float maturityAmount = Float.valueOf(recurringDepositAccountData.get("maturityAmount").toString());

        /***

         * Verify journal entry transactions for preclosure transaction As this

         * transaction is an account transfer you should get financial account

         * mapping details and verify amounts

         */

        this.journalEntryHelper.checkJournalEntryForLiabilityAccount(liabilityAccount, CLOSED_ON_DATE, new JournalEntry(maturityAmount,

                JournalEntry.TransactionType.CREDIT), new JournalEntry(maturityAmount, JournalEntry.TransactionType.DEBIT));

        this.journalEntryHelper.checkJournalEntryForLiabilityAccount(financialAccount, CLOSED_ON_DATE, new JournalEntry(maturityAmount,

                JournalEntry.TransactionType.DEBIT), new JournalEntry(maturityAmount, JournalEntry.TransactionType.CREDIT));

        /***

         * Verify rd account maturity amount and savings account balance

         */

        HashMap recurringDepositData = this.recurringDepositAccountHelper.getRecurringDepositAccountById(this.requestSpec,

                this.responseSpec, recurringDepositAccountId);

        Float prematurityAmount = (Float) recurringDepositData.get("maturityAmount");

        HashMap savingsSummaryAfter = this.savingsAccountHelper.getSavingsSummary(savingsId);

        Float balanceAfter = (Float) savingsSummaryAfter.get("accountBalance");

        Float expectedSavingsBalance = balanceBefore + prematurityAmount;

        DecimalFormat decimalFormat = new DecimalFormat("", new DecimalFormatSymbols(Locale.US));

        decimalFormat.applyPattern(".");

        Assert.assertEquals("Verifying Savings Account Balance after Premature Closure", decimalFormat.format(expectedSavingsBalance),

                decimalFormat.format(balanceAfter));

    }

    /***

     * Test case for Recurring Deposit Account premature closure with

     * transaction type ReInvest and Cash Based accounting enabled

     */

    @Test

    public void testRecurringDepositAccountWithPrematureClosureTypeReinvest() {

        this.recurringDepositProductHelper = new RecurringDepositProductHelper(this.requestSpec, this.responseSpec);

        this.accountHelper = new AccountHelper(this.requestSpec, this.responseSpec);

        this.savingsAccountHelper = new SavingsAccountHelper(this.requestSpec, this.responseSpec);

        this.recurringDepositAccountHelper = new RecurringDepositAccountHelper(this.requestSpec, this.responseSpec);

        RecurringDepositAccountHelper recurringDepositAccountHelperValidationError = new RecurringDepositAccountHelper(this.requestSpec,

                new ResponseSpecBuilder().build());

        /***

         * Create GL Accounts for product account mapping

         */

        final Account assetAccount = this.accountHelper.createAssetAccount();

        final Account incomeAccount = this.accountHelper.createIncomeAccount();

        final Account expenseAccount = this.accountHelper.createExpenseAccount();

        final Account liabilityAccount = this.accountHelper.createLiabilityAccount();

        DateFormat dateFormat = new SimpleDateFormat("dd MMMM yyyy", Locale.US);

        DateFormat monthDayFormat = new SimpleDateFormat("dd MMM", Locale.US);

        DateFormat currentDateFormat = new SimpleDateFormat("dd");

        Calendar todaysDate = Calendar.getInstance();

        todaysDate.add(Calendar.MONTH, -3);

        final String VALID_FROM = dateFormat.format(todaysDate.getTime());

        todaysDate.add(Calendar.YEAR, 10);

        final String VALID_TO = dateFormat.format(todaysDate.getTime());

        todaysDate = Calendar.getInstance();

        todaysDate.add(Calendar.MONTH, -1);

        final String SUBMITTED_ON_DATE = dateFormat.format(todaysDate.getTime());

        final String APPROVED_ON_DATE = dateFormat.format(todaysDate.getTime());

        final String ACTIVATION_DATE = dateFormat.format(todaysDate.getTime());

        final String EXPECTED_FIRST_DEPOSIT_ON_DATE = dateFormat.format(todaysDate.getTime());

        final String MONTH_DAY = monthDayFormat.format(todaysDate.getTime());

        Integer currentDate = new Integer(currentDateFormat.format(todaysDate.getTime()));

        Integer daysInMonth = todaysDate.getActualMaximum(Calendar.DATE);

        Integer numberOfDaysLeft = (daysInMonth - currentDate) + 1;

        todaysDate.add(Calendar.DATE, numberOfDaysLeft);

        final String INTEREST_POSTED_DATE = dateFormat.format(todaysDate.getTime());

        final String CLOSED_ON_DATE = dateFormat.format(Calendar.getInstance().getTime());

        /***

         * Create client for applying Deposit account

         */

        Integer clientId = ClientHelper.createClient(this.requestSpec, this.responseSpec);

        Assert.assertNotNull(clientId);

        /***

         * Create RD product with CashBased accounting enabled

         */

        final String accountingRule = CASH_BASED;

        Integer recurringDepositProductId = createRecurringDepositProduct(VALID_FROM, VALID_TO, accountingRule, assetAccount,

                liabilityAccount, incomeAccount, expenseAccount);

        Assert.assertNotNull(recurringDepositProductId);

        ArrayList<HashMap> allRecurringDepositProductsData = this.recurringDepositProductHelper.retrieveAllRecurringDepositProducts(

                this.requestSpec, this.responseSpec);

        HashMap recurringDepositProductData = this.recurringDepositProductHelper.retrieveRecurringDepositProductById(this.requestSpec,

                this.responseSpec, recurringDepositProductId.toString());

        /***

         * Apply for RD account with created product and verify status

         */

        Integer recurringDepositAccountId = applyForRecurringDepositApplication(clientId.toString(), recurringDepositProductId.toString(),

                VALID_FROM, VALID_TO, SUBMITTED_ON_DATE, WHOLE_TERM, EXPECTED_FIRST_DEPOSIT_ON_DATE);

        Assert.assertNotNull(recurringDepositAccountId);

        HashMap recurringDepositAccountStatusHashMap = RecurringDepositAccountStatusChecker.getStatusOfRecurringDepositAccount(

                this.requestSpec, this.responseSpec, recurringDepositAccountId.toString());

        RecurringDepositAccountStatusChecker.verifyRecurringDepositIsPending(recurringDepositAccountStatusHashMap);

        /***

         * Approve the RD account and verify whether account is approved

         */

        recurringDepositAccountStatusHashMap = this.recurringDepositAccountHelper.approveRecurringDeposit(recurringDepositAccountId,

                APPROVED_ON_DATE);

        RecurringDepositAccountStatusChecker.verifyRecurringDepositIsApproved(recurringDepositAccountStatusHashMap);

        /***

         * Activate the RD Account and verify whether account is activated

         */

        recurringDepositAccountStatusHashMap = this.recurringDepositAccountHelper.activateRecurringDeposit(recurringDepositAccountId,

                ACTIVATION_DATE);

        RecurringDepositAccountStatusChecker.verifyRecurringDepositIsActive(recurringDepositAccountStatusHashMap);

        HashMap recurringDepositAccountData = this.recurringDepositAccountHelper.getRecurringDepositAccountById(this.requestSpec,

                this.responseSpec, recurringDepositAccountId);

        Float depositAmount = (Float) recurringDepositAccountData.get("mandatoryRecommendedDepositAmount");

        /***

         * Perform Deposit transaction and verify journal entries are posted for

         * the transaction

         */

        Integer depositTransactionId = this.recurringDepositAccountHelper.depositToRecurringDepositAccount(recurringDepositAccountId,

                DEPOSIT_AMOUNT, EXPECTED_FIRST_DEPOSIT_ON_DATE);

        Assert.assertNotNull(depositTransactionId);

        this.journalEntryHelper.checkJournalEntryForAssetAccount(assetAccount, EXPECTED_FIRST_DEPOSIT_ON_DATE, new JournalEntry(

                depositAmount, JournalEntry.TransactionType.DEBIT));

        this.journalEntryHelper.checkJournalEntryForLiabilityAccount(liabilityAccount, EXPECTED_FIRST_DEPOSIT_ON_DATE, new JournalEntry(

                depositAmount, JournalEntry.TransactionType.CREDIT));

        /***

         * Update interest earned field for RD account

         */

        recurringDepositAccountId = this.recurringDepositAccountHelper.calculateInterestForRecurringDeposit(recurringDepositAccountId);

        Assert.assertNotNull(recurringDepositAccountId);

        /***

         * Post interest and verify journal entries

         */

        Integer transactionIdForPostInterest = this.recurringDepositAccountHelper

                .postInterestForRecurringDeposit(recurringDepositAccountId);

        Assert.assertNotNull(transactionIdForPostInterest);

        HashMap accountSummary = this.recurringDepositAccountHelper.getRecurringDepositSummary(recurringDepositAccountId);

        Float totalInterestPosted = (Float) accountSummary.get("totalInterestPosted");

        final JournalEntry[] expenseAccountEntry = { new JournalEntry(totalInterestPosted, JournalEntry.TransactionType.DEBIT) };

        final JournalEntry[] liablilityAccountEntry = { new JournalEntry(totalInterestPosted, JournalEntry.TransactionType.CREDIT) };

        this.journalEntryHelper.checkJournalEntryForAssetAccount(expenseAccount, INTEREST_POSTED_DATE, expenseAccountEntry);

        this.journalEntryHelper.checkJournalEntryForLiabilityAccount(liabilityAccount, INTEREST_POSTED_DATE, liablilityAccountEntry);

        /***

         * Calculate expected premature closure amount

         */

        HashMap recurringDepositPrematureData = this.recurringDepositAccountHelper.calculatePrematureAmountForRecurringDeposit(

                recurringDepositAccountId, CLOSED_ON_DATE);

        /***

         * Expected to get an error response from api because re-invest option

         * is not supported for account preClosure

         */

        ArrayList<HashMap> errorResponse = (ArrayList<HashMap>) recurringDepositAccountHelperValidationError

                .prematureCloseForRecurringDeposit(recurringDepositAccountId, CLOSED_ON_DATE, CLOSURE_TYPE_REINVEST, null,

                        CommonConstants.RESPONSE_ERROR);

        assertEquals("validation.msg.recurringdepositaccount.onAccountClosureId.reinvest.not.allowed",

                errorResponse.get(0).get(CommonConstants.RESPONSE_ERROR_MESSAGE_CODE));

    }

    /***

     * Test case for Update Recurring Deposit Account details

     */

    @Test

    public void testRecurringDepositAccountUpdation() {

        this.recurringDepositProductHelper = new RecurringDepositProductHelper(this.requestSpec, this.responseSpec);

        this.recurringDepositAccountHelper = new RecurringDepositAccountHelper(this.requestSpec, this.responseSpec);

        DateFormat dateFormat = new SimpleDateFormat("dd MMMM yyyy", Locale.US);

        DateFormat monthDayFormat = new SimpleDateFormat("dd MMM", Locale.US);

        Calendar todaysDate = Calendar.getInstance();

        todaysDate.add(Calendar.MONTH, -3);

        final String VALID_FROM = dateFormat.format(todaysDate.getTime());

        todaysDate.add(Calendar.YEAR, 10);

        final String VALID_TO = dateFormat.format(todaysDate.getTime());

        todaysDate = Calendar.getInstance();

        todaysDate.add(Calendar.MONTH, -1);

        final String SUBMITTED_ON_DATE = dateFormat.format(todaysDate.getTime());

        final String EXPECTED_FIRST_DEPOSIT_ON_DATE = dateFormat.format(todaysDate.getTime());

        final String MONTH_DAY = monthDayFormat.format(todaysDate.getTime());

        Integer clientId = ClientHelper.createClient(this.requestSpec, this.responseSpec);

        Assert.assertNotNull(clientId);

        final String accountingRule = NONE;

        Integer recurringDepositProductId = createRecurringDepositProduct(VALID_FROM, VALID_TO, accountingRule);

        Assert.assertNotNull(recurringDepositProductId);

        Integer recurringDepositAccountId = applyForRecurringDepositApplication(clientId.toString(), recurringDepositProductId.toString(),

                VALID_FROM, VALID_TO, SUBMITTED_ON_DATE, WHOLE_TERM, EXPECTED_FIRST_DEPOSIT_ON_DATE);

        Assert.assertNotNull(recurringDepositAccountId);

        todaysDate.add(Calendar.DATE, -1);

        HashMap modificationsHashMap = this.recurringDepositAccountHelper.updateRecurringDepositAccount(clientId.toString(),

                recurringDepositProductId.toString(), recurringDepositAccountId.toString(), VALID_FROM, VALID_TO, WHOLE_TERM,

                SUBMITTED_ON_DATE);

        Assert.assertTrue(modificationsHashMap.containsKey("submittedOnDate"));

    }

    /***

     * Test case for Approve and Undo Approval of Recurring Deposit Account

     */

    @Test

    public void testRecurringDepositAccountUndoApproval() {

        this.recurringDepositProductHelper = new RecurringDepositProductHelper(this.requestSpec, this.responseSpec);

        this.recurringDepositAccountHelper = new RecurringDepositAccountHelper(this.requestSpec, this.responseSpec);

        DateFormat dateFormat = new SimpleDateFormat("dd MMMM yyyy", Locale.US);

        DateFormat monthDayFormat = new SimpleDateFormat("dd MMM", Locale.US);

        Calendar todaysDate = Calendar.getInstance();

        todaysDate.add(Calendar.MONTH, -3);

        final String VALID_FROM = dateFormat.format(todaysDate.getTime());

        todaysDate.add(Calendar.YEAR, 10);

        final String VALID_TO = dateFormat.format(todaysDate.getTime());

        todaysDate = Calendar.getInstance();