ReceiptAction.java

/*
 * eGov suite of products aim to improve the internal efficiency,transparency,
 *    accountability and the service delivery of the government  organizations.
 *
 *     Copyright (C) <2015>  eGovernments Foundation
 *
 *     The updated version of eGov suite of products as by eGovernments Foundation
 *     is available at http://www.egovernments.org
 *
 *     This program is free software: you can redistribute it and/or modify
 *     it under the terms of the GNU General Public License as published by
 *     the Free Software Foundation, either version 3 of the License, or
 *     any later version.
 *
 *     This program is distributed in the hope that it will be useful,
 *     but WITHOUT ANY WARRANTY; without even the implied warranty of
 *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *     GNU General Public License for more details.
 *
 *     You should have received a copy of the GNU General Public License
 *     along with this program. If not, see http://www.gnu.org/licenses/ or
 *     http://www.gnu.org/licenses/gpl.html .
 *
 *     In addition to the terms of the GPL license to be adhered to in using this
 *     program, the following additional terms are to be complied with:
 *
 *         1) All versions of this program, verbatim or modified must carry this
 *            Legal Notice.
 *
 *         2) Any misrepresentation of the origin of the material is prohibited. It
 *            is required that all modified versions of this material be marked in
 *            reasonable ways as different from the original version.
 *
 *         3) This license does not grant any rights to any user of the program
 *            with regards to rights under trademark law for use of the trade names
 *            or trademarks of eGovernments Foundation.
 *
 *   In case of any queries, you can reach eGovernments Foundation at contact@egovernments.org.
 */
package org.egov.collection.web.actions.receipts;

import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang.StringEscapeUtils;
import org.apache.log4j.Logger;
import org.apache.struts2.convention.annotation.Action;
import org.apache.struts2.convention.annotation.ParentPackage;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.Results;
import org.egov.collection.constants.CollectionConstants;
import org.egov.collection.entity.AccountPayeeDetail;
import org.egov.collection.entity.ReceiptDetail;
import org.egov.collection.entity.ReceiptDetailInfo;
import org.egov.collection.entity.ReceiptHeader;
import org.egov.collection.entity.ReceiptMisc;
import org.egov.collection.entity.ReceiptVoucher;
import org.egov.collection.handler.BillCollectXmlHandler;
import org.egov.collection.integration.models.BillAccountDetails.PURPOSE;
import org.egov.collection.integration.models.BillInfoImpl;
import org.egov.collection.service.ReceiptHeaderService;
import org.egov.collection.utils.CollectionCommon;
import org.egov.collection.utils.CollectionsUtil;
import org.egov.collection.utils.FinancialsUtil;
import org.egov.commons.Accountdetailkey;
import org.egov.commons.Accountdetailtype;
import org.egov.commons.Bank;
import org.egov.commons.Bankaccount;
import org.egov.commons.Bankbranch;
import org.egov.commons.CChartOfAccountDetail;
import org.egov.commons.CChartOfAccounts;
import org.egov.commons.CFinancialYear;
import org.egov.commons.CFunction;
import org.egov.commons.Functionary;
import org.egov.commons.Fund;
import org.egov.commons.Fundsource;
import org.egov.commons.Scheme;
import org.egov.commons.SubScheme;
import org.egov.commons.dao.BankBranchHibernateDAO;
import org.egov.commons.dao.BankHibernateDAO;
import org.egov.commons.dao.BankaccountHibernateDAO;
import org.egov.commons.dao.ChartOfAccountsHibernateDAO;
import org.egov.commons.dao.EgwStatusHibernateDAO;
import org.egov.commons.dao.FinancialYearDAO;
import org.egov.commons.dao.FunctionHibernateDAO;
import org.egov.commons.dao.FunctionaryHibernateDAO;
import org.egov.commons.dao.FundHibernateDAO;
import org.egov.commons.dao.FundSourceHibernateDAO;
import org.egov.commons.dao.SchemeHibernateDAO;
import org.egov.commons.dao.SubSchemeHibernateDAO;
import org.egov.commons.entity.Source;
import org.egov.infra.admin.master.entity.AppConfigValues;
import org.egov.infra.admin.master.entity.Department;
import org.egov.infra.admin.master.entity.User;
import org.egov.infra.exception.ApplicationRuntimeException;
import org.egov.infra.utils.NumberUtil;
import org.egov.infra.utils.StringUtils;
import org.egov.infra.validation.exception.ValidationError;
import org.egov.infra.validation.exception.ValidationException;
import org.egov.infra.web.struts.actions.BaseFormAction;
import org.egov.infra.web.struts.annotation.ValidationErrorPage;
import org.egov.infstr.models.ServiceCategory;
import org.egov.infstr.models.ServiceDetails;
import org.egov.infstr.services.PersistenceService;
import org.egov.model.instrument.InstrumentHeader;
import org.springframework.beans.factory.annotation.Autowired;

@ParentPackage("egov")
@Results({ @Result(name = ReceiptAction.NEW, location = "receipt-new.jsp"),
        @Result(name = ReceiptAction.EDIT, location = "receipt-edit.jsp"),
        @Result(name = ReceiptAction.INDEX, location = "receipt-index.jsp"),
        @Result(name = CollectionConstants.REPORT, location = "receipt-report.jsp") })
public class ReceiptAction extends BaseFormAction {
    private static final String ACCOUNT_NUMBER_LIST = "accountNumberList";
    private static final Logger LOGGER = Logger.getLogger(ReceiptAction.class);
    private BillInfoImpl collDetails = new BillInfoImpl();
    private static final long serialVersionUID = 1L;
    private static final String CANCEL = "cancel";
    private String reportId;

    /**
     * A <code>String</code> representing the input xml coming from the billing
     * system
     */
    private String collectXML;
    private BillCollectXmlHandler xmlHandler;
    private FinancialsUtil financialsUtil;

    /**
     * A <code>Long</code> array of receipt header ids , which have to be
     * displayed for view/print/cancel purposes
     */
    private Long[] selectedReceipts;

    /**
     * An array of <code>ReceiptHeader</code> instances which have to be
     * displayed for view/print/cancel purposes
     */
    private ReceiptHeader[] receipts;

    private ReceiptHeaderService receiptHeaderService;

    private CollectionsUtil collectionsUtil;

    private List<ReceiptHeader> receiptHeaderValues = new ArrayList<ReceiptHeader>(0);

    // Instrument information derived from UI
    private List<InstrumentHeader> instrumentProxyList;
    private int instrumentCount;

    private BigDecimal cashOrCardInstrumenttotal = BigDecimal.ZERO;
    private BigDecimal chequeInstrumenttotal = BigDecimal.ZERO;
    private BigDecimal instrumenttotal = BigDecimal.ZERO;
    private String reasonForCancellation;
    private String target = "view";
    private String paidBy;
    private ReceiptHeader receiptHeader = new ReceiptHeader();

    /**
     * A <code>Long</code> value representing the receipt header id captured
     * from the front end, which has to be cancelled.
     */
    private Long oldReceiptId;

    private Boolean overrideAccountHeads = Boolean.FALSE;
    private Boolean partPaymentAllowed;
    private Boolean callbackForApportioning = Boolean.FALSE;
    private BigDecimal totalAmountToBeCollected;

    private Boolean cashAllowed = Boolean.TRUE;
    private Boolean cardAllowed = Boolean.TRUE;
    private Boolean chequeAllowed = Boolean.TRUE;
    private Boolean ddAllowed = Boolean.TRUE;
    private Boolean bankAllowed = Boolean.TRUE;

    /**
     * An instance of <code>InstrumentHeader</code> representing the cash
     * instrument details entered by the user during receipt creation
     */
    private InstrumentHeader instrHeaderCash;

    /**
     * An instance of <code>InstrumentHeader</code> representing the card
     * instrument details entered by the user during receipt creation
     */
    private InstrumentHeader instrHeaderCard;

    /**
     * An instance of <code>InstrumentHeader</code> representing the 'bank'
     * instrument details entered by the user during receipt creation
     */
    private InstrumentHeader instrHeaderBank;

    private Date voucherDate;
    private String voucherNum;
    private List<ReceiptDetailInfo> subLedgerlist;
    private List<ReceiptDetailInfo> billCreditDetailslist;
    private List<ReceiptDetailInfo> billRebateDetailslist;
    protected List<String> headerFields;
    protected List<String> mandatoryFields;
    private String billSource = "bill";
    private ReceiptMisc receiptMisc = new ReceiptMisc();
    private String deptId;
    private BigDecimal totalDebitAmount;
    /**
     * A code>String</code> representing the service name
     */
    private String serviceName;

    /**
     * A <code>List</code> of <code>String</code> informations sent by the
     * billing system indicating which are the modes of payment that are not
     * allowed during receipt creation
     */
    private List<String> collectionModesNotAllowed = new ArrayList<String>(0);

    /**
     * The <code>User</code> representing the counter operator who has created
     * the receipt
     */
    private User receiptCreatedByCounterOperator;

    /**
     * A <code>List</code> of <code>ReceiptPayeeDetails</code> representing the
     * model for the action.
     */

    private List<ReceiptDetail> receiptDetailList = new ArrayList<ReceiptDetail>(0);

    private String instrumentTypeCashOrCard;

    private CollectionCommon collectionCommon;

    private Long bankAccountId;

    private Integer bankBranchId;

    private String payeename = "";

    private Date manualReceiptDate;

    private String manualReceiptNumber;

    private Boolean manualReceiptNumberAndDateReq = Boolean.FALSE;

    private Boolean receiptBulkUpload = Boolean.FALSE;

    private PersistenceService<ServiceCategory, Long> serviceCategoryService;

    private PersistenceService<ServiceDetails, Long> serviceDetailsService;

    private Long serviceId;

    @Autowired
    private FundHibernateDAO fundDAO;

    @Autowired
    private FunctionHibernateDAO functionDAO;

    @Autowired
    private FunctionaryHibernateDAO functionaryDAO;

    @Autowired
    private SchemeHibernateDAO schemeDAO;

    @Autowired
    private FundSourceHibernateDAO fundSourceDAO;

    @Autowired
    private BankBranchHibernateDAO bankBranchDAO;

    @Autowired
    private BankHibernateDAO bankDAO;

    @Autowired
    private BankaccountHibernateDAO bankAccountDAO;

    @Autowired
    private SubSchemeHibernateDAO subSchemeDAO;

    @Autowired
    private ChartOfAccountsHibernateDAO chartOfAccountsDAO;

    @Autowired
    private EgwStatusHibernateDAO statusDAO;

    private List<CChartOfAccounts> bankCOAList;
    private Long functionId;

    @Autowired
    private FinancialYearDAO financialYearDAO;

    private Date financialYearDate;
    
    private String instrumentType;

    @Override
    public void prepare() {
        super.prepare();
        setReceiptCreatedByCounterOperator(collectionsUtil.getLoggedInUser());
        // populates model when request is from the billing system
        if (getCollectXML() != null && !getCollectXML().equals("")) {
            final String decodedCollectXML = decodeBillXML();
            try {
                collDetails = (BillInfoImpl) xmlHandler.toObject(decodedCollectXML);

                final Fund fund = fundDAO.fundByCode(collDetails.getFundCode());
                if (fund == null)
                    addActionError(getText("billreceipt.improperbilldata.missingfund"));

                setFundName(fund.getName());

                final Department dept = (Department) getPersistenceService().findByNamedQuery(
                        CollectionConstants.QUERY_DEPARTMENT_BY_CODE, collDetails.getDepartmentCode());
                if (dept == null)
                    addActionError(getText("billreceipt.improperbilldata.missingdepartment"));

                final ServiceDetails service = (ServiceDetails) getPersistenceService().findByNamedQuery(
                        CollectionConstants.QUERY_SERVICE_BY_CODE, collDetails.getServiceCode());
                setServiceName(service.getName());
                setCollectionModesNotAllowed(collDetails.getCollectionModesNotAllowed());
                setOverrideAccountHeads(collDetails.getOverrideAccountHeadsAllowed());
                setCallbackForApportioning(collDetails.getCallbackForApportioning());
                setPartPaymentAllowed(collDetails.getPartPaymentAllowed());
                totalAmountToBeCollected = BigDecimal.valueOf(0);

                // populate bank account list
                populateBankBranchList(true);

                receiptHeader = collectionCommon.initialiseReceiptModelWithBillInfo(collDetails, fund, dept);

                totalAmountToBeCollected = totalAmountToBeCollected.add(receiptHeader.getTotalAmountToBeCollected());
                for (final ReceiptDetail rDetails : receiptHeader.getReceiptDetails())
                    rDetails.getCramountToBePaid().setScale(CollectionConstants.AMOUNT_PRECISION_DEFAULT,
                            BigDecimal.ROUND_UP);
                setReceiptDetailList(new ArrayList<ReceiptDetail>(receiptHeader.getReceiptDetails()));

                if (totalAmountToBeCollected.compareTo(BigDecimal.ZERO) == -1) {
                    addActionError(getText("billreceipt.totalamountlessthanzero.error"));
                    LOGGER.info(getText("billreceipt.totalamountlessthanzero.error"));
                } else
                    setTotalAmountToBeCollected(totalAmountToBeCollected.setScale(
                            CollectionConstants.AMOUNT_PRECISION_DEFAULT, BigDecimal.ROUND_UP));

            } catch (final Exception e) {
                LOGGER.error(getText("billreceipt.error.improperbilldata") + e.getMessage());
                addActionError(getText("billreceipt.error.improperbilldata"));
            }
        }
        addDropdownData("serviceCategoryList",
                serviceCategoryService.findAllByNamedQuery(CollectionConstants.QUERY_ACTIVE_SERVICE_CATEGORY));
        addDropdownData("serviceList", Collections.EMPTY_LIST);
        if (instrumentProxyList == null)
            instrumentCount = 0;
        else
            instrumentCount = instrumentProxyList.size();
        financialYearDate = financialYearDAO.getFinancialYearByDate(new Date()).getStartingDate();
    }

    private String decodeBillXML() {
        String decodedBillXml = "";
        try {
            decodedBillXml = java.net.URLDecoder.decode(getCollectXML(), "UTF-8");
        } catch (final UnsupportedEncodingException e) {
            throw new RuntimeException(e.getMessage());
        }
        return decodedBillXml;
    }

    /**
     * @param populate
     */
    private void populateBankBranchList(final boolean populate) {
        final AjaxBankRemittanceAction ajaxBankRemittanceAction = new AjaxBankRemittanceAction();
        ajaxBankRemittanceAction.setServiceName(getServiceName());
        ajaxBankRemittanceAction.setPersistenceService(getPersistenceService());

        if (populate) {
            ajaxBankRemittanceAction.setFundName(getFundName());
            ajaxBankRemittanceAction.bankBranchList();
            addDropdownData("bankBranchList", ajaxBankRemittanceAction.getBankBranchArrayList());
            addDropdownData(ACCOUNT_NUMBER_LIST, Collections.EMPTY_LIST);
        } else // to load branch list and account list while returning after an
               // error
        if (getServiceName() != null && receiptMisc.getFund() != null) {
            final Fund fund = fundDAO.fundById(receiptMisc.getFund().getId(), false);
            ajaxBankRemittanceAction.setFundName(fund.getName());
            ajaxBankRemittanceAction.bankBranchList();
            addDropdownData("bankBranchList", ajaxBankRemittanceAction.getBankBranchArrayList());

            // account list should be populated only if bank branch had been
            // chosen
            if (bankBranchId != null && bankBranchId != 0) {
                final Bankbranch branch = (Bankbranch) bankBranchDAO.findById(bankBranchId, false);

                ajaxBankRemittanceAction.setBranchId(branch.getId());
                ajaxBankRemittanceAction.accountList();
                addDropdownData(ACCOUNT_NUMBER_LIST, ajaxBankRemittanceAction.getBankAccountArrayList());
            } else
                addDropdownData(ACCOUNT_NUMBER_LIST, Collections.EMPTY_LIST);
        } else {
            addDropdownData("bankBranchList", Collections.EMPTY_LIST);
            addDropdownData(ACCOUNT_NUMBER_LIST, Collections.EMPTY_LIST);
        }
    }

    /**
     * This method checks for the modes of payment allowed
     */
    private void setCollectionModesNotAllowed() {

        final List<String> modesNotAllowed = collectionsUtil
                .getCollectionModesNotAllowed(getReceiptCreatedByCounterOperator());

        final List<String> collectionModesNotAllowed = getCollectionModesNotAllowed();

        if (modesNotAllowed.contains(CollectionConstants.INSTRUMENTTYPE_CASH) || collectionModesNotAllowed != null
                && collectionModesNotAllowed.contains(CollectionConstants.INSTRUMENTTYPE_CASH))
            setCashAllowed(Boolean.FALSE);

        if (modesNotAllowed.contains(CollectionConstants.INSTRUMENTTYPE_CARD) || collectionModesNotAllowed != null
                && collectionModesNotAllowed.contains(CollectionConstants.INSTRUMENTTYPE_CARD))
            setCardAllowed(Boolean.FALSE);
        if (modesNotAllowed.contains(CollectionConstants.INSTRUMENTTYPE_CHEQUE) || collectionModesNotAllowed != null
                && collectionModesNotAllowed.contains(CollectionConstants.INSTRUMENTTYPE_CHEQUE))
            setChequeAllowed(Boolean.FALSE);

        if (modesNotAllowed.contains(CollectionConstants.INSTRUMENTTYPE_DD) || collectionModesNotAllowed != null
                && collectionModesNotAllowed.contains(CollectionConstants.INSTRUMENTTYPE_DD))
            setDdAllowed(Boolean.FALSE);

        if (modesNotAllowed.contains(CollectionConstants.INSTRUMENTTYPE_BANK) || collectionModesNotAllowed != null
                && collectionModesNotAllowed.contains(CollectionConstants.INSTRUMENTTYPE_BANK))
            setBankAllowed(Boolean.FALSE);
    }

    /**
     * To set the receiptpayee details for misc receipts
     */
    private boolean setMiscReceiptDetails() {
        if (CollectionConstants.BLANK.equals(payeename))
            payeename = collectionsUtil.getAppConfigValue(CollectionConstants.MODULE_NAME_COLLECTIONS_CONFIG,
                    CollectionConstants.APPCONFIG_VALUE_PAYEEFORMISCRECEIPTS);

        ServiceDetails service = (ServiceDetails) getPersistenceService().findByNamedQuery(
                CollectionConstants.QUERY_SERVICE_BY_CODE, CollectionConstants.SERVICE_CODE_COLLECTIONS);
        if (null != serviceId && serviceId != -1)
            service = serviceDetailsService.findById(serviceId, false);
        receiptHeader.setPartPaymentAllowed(false);
        receiptHeader.setService(service);
        final Fund fund = fundDAO.fundById(receiptMisc.getFund().getId(), false);
        Functionary functionary = null;
        Scheme scheme = null;
        SubScheme subscheme = null;
        try {
            if (receiptMisc.getIdFunctionary() != null)
                functionary = functionaryDAO.functionaryById(receiptMisc.getIdFunctionary().getId());
            if (receiptMisc.getScheme() != null && receiptMisc.getScheme().getId() != -1)
                scheme = schemeDAO.getSchemeById(receiptMisc.getScheme().getId());
            if (receiptMisc.getSubscheme() != null && receiptMisc.getSubscheme().getId() != -1)
                subscheme = subSchemeDAO.getSubSchemeById(receiptMisc.getSubscheme().getId());
        } catch (final Exception e) {
            LOGGER.error("Error in getting functionary for id [" + receiptMisc.getIdFunctionary().getId() + "]", e);
        }

        Fundsource fundSource = null;
        if (receiptMisc.getFundsource() != null && receiptMisc.getFundsource().getId() != null)
            fundSource = fundSourceDAO.fundsourceById(receiptMisc.getFundsource().getId().intValue());
        final Department dept = (Department) getPersistenceService().findByNamedQuery(
                CollectionConstants.QUERY_DEPARTMENT_BY_ID, Long.valueOf(deptId));

        final ReceiptMisc receiptMisc = new ReceiptMisc(null, fund, functionary, fundSource, dept, receiptHeader,
                scheme, subscheme, null);
        receiptHeader.setReceiptMisc(receiptMisc);

        totalAmountToBeCollected = BigDecimal.valueOf(0);
        int m = 0;
        BigDecimal debitamount = BigDecimal.ZERO;
        removeEmptyRows(billCreditDetailslist);
        removeEmptyRows(billRebateDetailslist);
        removeEmptyRows(subLedgerlist);
        if (validateData(billCreditDetailslist, subLedgerlist))
            for (final ReceiptDetailInfo voucherDetails : billCreditDetailslist) {
                final CChartOfAccounts account = chartOfAccountsDAO.getCChartOfAccountsByGlCode(voucherDetails
                        .getGlcodeDetail());
                CFunction function = null;
                if (functionId != null)
                    function = functionDAO.getFunctionById(functionId);
                ReceiptDetail receiptDetail = new ReceiptDetail(account, function,
                        voucherDetails.getCreditAmountDetail(), voucherDetails.getDebitAmountDetail(), BigDecimal.ZERO,
                        Long.valueOf(m), null, true, receiptHeader, PURPOSE.OTHERS.toString());

                if (voucherDetails.getCreditAmountDetail() == null)
                    receiptDetail.setCramount(BigDecimal.ZERO);
                else
                    receiptDetail.setCramount(voucherDetails.getCreditAmountDetail());

                if (voucherDetails.getDebitAmountDetail() == null)
                    receiptDetail.setDramount(BigDecimal.ZERO);
                else
                    receiptDetail.setDramount(voucherDetails.getDebitAmountDetail());

                receiptDetail = setAccountPayeeDetails(subLedgerlist, receiptDetail);
                receiptHeader.addReceiptDetail(receiptDetail);
                debitamount = debitamount.add(voucherDetails.getCreditAmountDetail());
                debitamount = debitamount.subtract(voucherDetails.getDebitAmountDetail());
                m++;
            }
        else
            return false;
        if (validateRebateData(billRebateDetailslist, subLedgerlist)) {
            for (final ReceiptDetailInfo voucherDetails : billRebateDetailslist)
                if (voucherDetails.getGlcodeDetail() != null
                        && org.apache.commons.lang.StringUtils.isNotBlank(voucherDetails.getGlcodeDetail())) {
                    final CChartOfAccounts account = chartOfAccountsDAO.getCChartOfAccountsByGlCode(voucherDetails
                            .getGlcodeDetail());
                    CFunction function = null;
                    if (voucherDetails.getFunctionIdDetail() != null)
                        function = functionDAO.getFunctionById(voucherDetails.getFunctionIdDetail());
                    ReceiptDetail receiptDetail = new ReceiptDetail(account, function,
                            voucherDetails.getCreditAmountDetail(), voucherDetails.getDebitAmountDetail(),
                            BigDecimal.ZERO, Long.valueOf(m), null, true, receiptHeader, PURPOSE.OTHERS.toString());

                    if (voucherDetails.getDebitAmountDetail() == null)
                        receiptDetail.setDramount(BigDecimal.ZERO);
                    else
                        receiptDetail.setDramount(voucherDetails.getDebitAmountDetail());
                    if (voucherDetails.getCreditAmountDetail() == null)
                        receiptDetail.setCramount(BigDecimal.ZERO);
                    else
                        receiptDetail.setCramount(voucherDetails.getCreditAmountDetail());

                    receiptDetail = setAccountPayeeDetails(subLedgerlist, receiptDetail);
                    receiptHeader.addReceiptDetail(receiptDetail);
                    debitamount = debitamount.add(voucherDetails.getCreditAmountDetail());
                    debitamount = debitamount.subtract(voucherDetails.getDebitAmountDetail());
                    m++;
                }
        } else
            return false;
        setTotalDebitAmount(debitamount);
        return true;
    }

    public ReceiptDetail setAccountPayeeDetails(final List<ReceiptDetailInfo> subLedgerlist,
            final ReceiptDetail receiptDetail) {
        for (final ReceiptDetailInfo subvoucherDetails : subLedgerlist)
            if (subvoucherDetails.getGlcode() != null && subvoucherDetails.getGlcode().getId() != 0
                    && subvoucherDetails.getGlcode().getId().equals(receiptDetail.getAccounthead().getId())) {

                final Accountdetailtype accdetailtype = (Accountdetailtype) getPersistenceService().findByNamedQuery(
                        CollectionConstants.QUERY_ACCOUNTDETAILTYPE_BY_ID, subvoucherDetails.getDetailType().getId());
                final Accountdetailkey accdetailkey = (Accountdetailkey) getPersistenceService().findByNamedQuery(
                        CollectionConstants.QUERY_ACCOUNTDETAILKEY_BY_DETAILKEY, subvoucherDetails.getDetailKeyId(),
                        subvoucherDetails.getDetailType().getId());

                final AccountPayeeDetail accPayeeDetail = new AccountPayeeDetail(accdetailtype, accdetailkey,
                        subvoucherDetails.getAmount(), receiptDetail);

                receiptDetail.addAccountPayeeDetail(accPayeeDetail);
            }
        return receiptDetail;
    }

    @ValidationErrorPage(value = "new")
    @Action(value = "/receipts/receipt-newform")
    public String newform() {

        final String manualReceiptInfoRequired = collectionsUtil.getAppConfigValue(
                CollectionConstants.MODULE_NAME_COLLECTIONS_CONFIG, CollectionConstants.MANUALRECEIPTINFOREQUIRED);
        if (CollectionConstants.YES.equalsIgnoreCase(manualReceiptInfoRequired))
            setManualReceiptNumberAndDateReq(Boolean.TRUE);

        final String[] receiptType = parameters.get("Receipt");
        if (receiptType != null && receiptType[0].equalsIgnoreCase("Misc"))
            createMisc();
        // set collection modes allowed rule through script
        setCollectionModesNotAllowed();
        return NEW;
    }

    /**
     * This method is invoked when user creates a receipt.
     *
     * @return
     */
    @ValidationErrorPage(value = "new")
    @Action(value = "/receipts/receipt-save")
    public String save() {
        // try {
        List<InstrumentHeader> receiptInstrList = new ArrayList<InstrumentHeader>(0);
        LOGGER.info("Receipt creation process is started !!!!!!");
        ReceiptHeader rhForValidation = null;
        String returnValue = "";
        final long startTimeMillis = System.currentTimeMillis();
        if (manualReceiptNumber != null && manualReceiptDate != null) {
            final CFinancialYear financialYear = collectionsUtil.getFinancialYearforDate(manualReceiptDate);
            rhForValidation = receiptHeaderService.findByNamedQuery(
                    CollectionConstants.QUERY_RECEIPT_BY_SERVICE_MANUALRECEIPTNO_AND_DATE, manualReceiptNumber,
                    receiptHeader.getService().getCode(), financialYear.getStartingDate(),
                    financialYear.getEndingDate(), CollectionConstants.RECEIPT_STATUS_CODE_CANCELLED);
        }

        if (rhForValidation == null) {
            // For interday cancellation
            if (oldReceiptId != null) {
                final ReceiptHeader receiptHeaderToBeCancelled = receiptHeaderService.findById(oldReceiptId, false);

                receiptHeaderToBeCancelled.setStatus(statusDAO.getStatusByModuleAndCode(
                        CollectionConstants.MODULE_NAME_RECEIPTHEADER,
                        CollectionConstants.RECEIPT_STATUS_CODE_CANCELLED));
                receiptHeaderToBeCancelled.setReasonForCancellation(reasonForCancellation);
                // set isReconciled to false before calling update to
                // billing system for
                // cancel receipt
                receiptHeaderToBeCancelled.setIsReconciled(false);

                receiptHeaderService.persist(receiptHeaderToBeCancelled);
                if (receiptHeaderToBeCancelled.getReceipttype() == CollectionConstants.RECEIPT_TYPE_BILL) {
                    populateReceiptModelWithExistingReceiptInfo(receiptHeaderToBeCancelled);
                    LOGGER.info("Receipt Cancelled with Receipt Number(recreateNewReceiptOnCancellation): "
                            + receiptHeaderToBeCancelled.getReceiptnumber() + "; Consumer Code: "
                            + receiptHeaderToBeCancelled.getConsumerCode());
                }
            }

            if (billSource.equalsIgnoreCase("misc")) {
                createMisc();
                if (!setMiscReceiptDetails())
                    returnValue = NEW;
            } else {
                if (callbackForApportioning && !overrideAccountHeads)
                    apportionBillAmount();
                if (receiptDetailList == null || receiptDetailList.isEmpty() || receiptDetailList.size() == 0)
                    throw new ApplicationRuntimeException(
                            "Receipt could not be created as the apportioned receipt detail list is empty");
                else {
                    BigDecimal totalCreditAmount = BigDecimal.ZERO;
                    for (final ReceiptDetail receiptDetail : receiptDetailList)
                        totalCreditAmount = totalCreditAmount.add(receiptDetail.getCramount());
                    if (totalCreditAmount.intValue() == 0)
                        throw new ApplicationRuntimeException("Apportioning Failed at the Billing System: "
                                + receiptHeader.getService().getCode() + ", for bill number: "
                                + receiptHeader.getReferencenumber());
                    else
                        receiptHeader.setReceiptDetails(new HashSet(receiptDetailList));
                }
            }
            int noOfNewlyCreatedReceipts = 0;
            boolean setInstrument = true;

            // only newly created receipts need to be initialised with the
            // data.
            // The cancelled receipt can be excluded from this processing.
            if (receiptHeader.getStatus() == null) {
                noOfNewlyCreatedReceipts++;
                // Set created by Date as this required to generate receipt
                // number before persist
                if (manualReceiptDate == null)
                    receiptHeader.setReceiptdate(new Date());
                else {
                    // If the receipt has been manually created, the receipt
                    // date is same as the date of manual creation.
                    // set Createdby, in MySavelistner if createdBy is null
                    // it set both createdBy and createdDate with
                    // currentDate.
                    // Thus overridding the manualReceiptDate set above
                    // receiptHeader.setCreatedBy(collectionsUtil.getLoggedInUser());
                    receiptHeader.setManualreceiptdate(manualReceiptDate);
                    receiptHeader.setReceiptdate(manualReceiptDate);
                    receiptHeader.setVoucherDate(manualReceiptDate);
                }
                if (manualReceiptNumber != null)
                    receiptHeader.setManualreceiptnumber(manualReceiptNumber);
                if (isBillSourcemisc()) {
                    receiptHeader.setReceipttype(CollectionConstants.RECEIPT_TYPE_ADHOC);
                    receiptHeader.setVoucherDate(voucherDate);
                    receiptHeader.setReceiptdate(voucherDate);
                    receiptHeader.setVoucherNum(voucherNum);
                    receiptHeader.setIsReconciled(Boolean.TRUE);
                    receiptHeader.setManualreceiptdate(manualReceiptDate);
                    receiptHeader.setPayeeName(StringEscapeUtils.unescapeHtml(paidBy));

                } else {
                    receiptHeader.setReceipttype(CollectionConstants.RECEIPT_TYPE_BILL);
                    receiptHeader.setIsModifiable(Boolean.TRUE);
                    receiptHeader.setIsReconciled(Boolean.FALSE);
                }
                // serviceType =
                // receiptHeader.getService().getServiceType();
                receiptHeader.setCollectiontype(CollectionConstants.COLLECTION_TYPE_COUNTER);
                receiptHeader.setLocation(collectionsUtil.getLocationOfUser(getSession()));
                receiptHeader.setStatus(collectionsUtil.getStatusForModuleAndCode(
                        CollectionConstants.MODULE_NAME_RECEIPTHEADER,
                        CollectionConstants.RECEIPT_STATUS_CODE_TO_BE_SUBMITTED));
                receiptHeader.setPaidBy(StringEscapeUtils.unescapeHtml(paidBy));
                receiptHeader.setSource(Source.SYSTEM.toString());

                // If this is a new receipt in lieu of cancelling old
                // receipt, update
                // old receipt id to the reference collection header id
                // field of this new receipt.
                if (getOldReceiptId() != null)
                    receiptHeader.setReceiptHeader(receiptHeaderService.findById(getOldReceiptId(), false));
                if (setInstrument) {
                    receiptInstrList = populateInstrumentDetails();
                    setInstrument = false;
                }

                receiptHeader.setReceiptInstrument(new HashSet(receiptInstrList));

                BigDecimal debitAmount = BigDecimal.ZERO;

                for (final ReceiptDetail creditChangeReceiptDetail : receiptDetailList)
                    for (final ReceiptDetail receiptDetail : receiptHeader.getReceiptDetails())
                        if (creditChangeReceiptDetail.getReceiptHeader().getReferencenumber()
                                .equals(receiptDetail.getReceiptHeader().getReferencenumber())
                                && receiptDetail.getOrdernumber().equals(creditChangeReceiptDetail.getOrdernumber())) {

                            receiptDetail.setCramount(creditChangeReceiptDetail.getCramount());
                            receiptDetail.setDramount(creditChangeReceiptDetail.getDramount());
                            // calculate sum of creditamounts as a debit
                            // value to create a
                            // debit account head and add to receipt details
                            debitAmount = debitAmount.add(creditChangeReceiptDetail.getCramount());
                            debitAmount = debitAmount.subtract(creditChangeReceiptDetail.getDramount());
                        }

                if (chequeInstrumenttotal != null && chequeInstrumenttotal.compareTo(BigDecimal.ZERO) != 0)
                    receiptHeader.setTotalAmount(chequeInstrumenttotal);

                if (cashOrCardInstrumenttotal != null && cashOrCardInstrumenttotal.compareTo(BigDecimal.ZERO) != 0)
                    receiptHeader.setTotalAmount(cashOrCardInstrumenttotal);
                if (isBillSourcemisc())
                    receiptHeader.addReceiptDetail(collectionCommon.addDebitAccountHeadDetails(totalDebitAmount,
                            receiptHeader, chequeInstrumenttotal, cashOrCardInstrumenttotal, instrumentTypeCashOrCard));
                else
                    receiptHeader.addReceiptDetail(collectionCommon.addDebitAccountHeadDetails(debitAmount,
                            receiptHeader, chequeInstrumenttotal, cashOrCardInstrumenttotal, instrumentTypeCashOrCard));

            }
            // }// end of looping through receipt headers
            // }// end of looping through model receipt payee list

            LOGGER.info("Call back for apportioning is completed");
            // billing system
            receiptHeaderService.populateAndPersistReceipts(receiptHeader, receiptInstrList);

            // populate all receipt header ids except the cancelled receipt
            // (in effect the newly created receipts)
            selectedReceipts = new Long[noOfNewlyCreatedReceipts];
            int i = 0;
            if (!receiptHeader.getId().equals(oldReceiptId)) {
                selectedReceipts[i] = receiptHeader.getId();
                i++;
            }

            // ReceiptHeader rh = null
            // ;//modelPayeeList.get(0).getReceiptHeaders().iterator().next();
            final long elapsedTimeMillis = System.currentTimeMillis() - startTimeMillis;
            LOGGER.info("$$$$$$ Receipt Persisted with Receipt Number: "
                    + receiptHeader.getReceiptnumber()
                    + (receiptHeader.getConsumerCode() != null ? " and consumer code: "
                            + receiptHeader.getConsumerCode() : "") + "; Time taken(ms) = " + elapsedTimeMillis);
            // Do not invoke print receipt in case of bulk upload.
            if (!receiptBulkUpload)
                returnValue = printReceipts();
            else
                returnValue = SUCCESS;
        } else {
            if (rhForValidation.getService().getCode().equals(CollectionConstants.SERVICECODE_PROPERTYTAX))
                addActionError("Entered Manual receipt number already exists for the index number"
                        + rhForValidation.getConsumerCode()
                        + ".Please enter a valid manual receipt number and create the receipt.");
            else
                addActionError("Receipt already exists for the service ");
            returnValue = NEW;
        }

        return returnValue;
    }

    public void createMisc() {
        headerFields = new ArrayList<String>(0);
        mandatoryFields = new ArrayList<String>(0);
        getHeaderMandateFields();
        setupDropdownDataExcluding();

        headerFields.remove(CollectionConstants.FUNDSOURCE);
        headerFields.remove(CollectionConstants.SCHEME);
        headerFields.remove(CollectionConstants.SUBSCHEME);
        if (headerFields.contains(CollectionConstants.DEPARTMENT))
            addDropdownData("departmentList",
                    persistenceService.findAllByNamedQuery(CollectionConstants.QUERY_ALL_DEPARTMENTS));
        if (headerFields.contains(CollectionConstants.FUNCTIONARY))
            addDropdownData("functionaryList",
                    persistenceService.findAllByNamedQuery(CollectionConstants.QUERY_ALL_FUNCTIONARY));
        if (headerFields.contains(CollectionConstants.FUND))
            addDropdownData("fundList", collectionsUtil.getAllFunds());
        if (headerFields.contains(CollectionConstants.FUNCTION))
            addDropdownData("functionList", functionDAO.getAllActiveFunctions());
        if (headerFields.contains(CollectionConstants.FIELD))
            addDropdownData("fieldList", persistenceService.findAllByNamedQuery(CollectionConstants.QUERY_ALL_FIELD));
        if (headerFields.contains(CollectionConstants.FUNDSOURCE))
            addDropdownData("fundsourceList",
                    persistenceService.findAllByNamedQuery(CollectionConstants.QUERY_ALL_FUNDSOURCE));
        if (headerFields.contains(CollectionConstants.SCHEME))
            if (receiptMisc.getFund() == null || receiptMisc.getFund().getId() == null)
                addDropdownData("schemeList", Collections.EMPTY_LIST);
            else
                addDropdownData("schemeList", persistenceService.findAllByNamedQuery(
                        CollectionConstants.QUERY_SCHEME_BY_FUNDID, receiptMisc.getFund().getId()));
        if (headerFields.contains(CollectionConstants.SUBSCHEME))
            if (receiptMisc.getScheme() == null || receiptMisc.getScheme().getId() == null)
                addDropdownData("subschemeList", Collections.EMPTY_LIST);
            else
                addDropdownData("subschemeList", persistenceService.findAllByNamedQuery(
                        CollectionConstants.QUERY_SUBSCHEME_BY_SCHEMEID, receiptMisc.getScheme().getId()));

        if (billCreditDetailslist == null) {
            billCreditDetailslist = new ArrayList<ReceiptDetailInfo>(0);
            billRebateDetailslist = new ArrayList<ReceiptDetailInfo>(0);
            subLedgerlist = new ArrayList<ReceiptDetailInfo>(0);
            billRebateDetailslist.add(new ReceiptDetailInfo());
            billCreditDetailslist.add(new ReceiptDetailInfo());
            subLedgerlist.add(new ReceiptDetailInfo());
        }
        billSource = "misc";
        receiptHeader.setPartPaymentAllowed(false);
        setHeaderFields(headerFields);
        setMandatoryFields(mandatoryFields);
        // this.paidBy = payeename;
        /*
         * if (null != service && null != service.getId() && service.getId() !=
         * -1) setServiceName(serviceDetailsService.findById(service.getId(),
         * false).getName()); else { final ServiceDetails service =
         * (ServiceDetails) getPersistenceService().findByNamedQuery(
         * CollectionConstants.QUERY_SERVICE_BY_CODE,
         * CollectionConstants.SERVICE_CODE_COLLECTIONS);
         * setServiceName(service.getName()); }
         */
        final Department dept = collectionsUtil.getDepartmentOfLoggedInUser();
        if(dept==null)
        {
            throw new ValidationException(Arrays.asList(new ValidationError("Department does not exists",
                    "viewchallan.validation.error.user.notexists"))); 
        }
        if (getDeptId() == null)
            setDeptId(dept.getId().toString());
        populateBankBranchList(false);
    }

    public boolean isBillSourcemisc() {
        boolean flag = false;
        if (getBillSource().equalsIgnoreCase("misc"))
            flag = true;
        return flag;
    }

    public boolean isFieldMandatory(final String field) {
        return mandatoryFields.contains(field);
    }

    public boolean shouldShowHeaderField(final String field) {
        return headerFields.contains(field);
    }

    protected void getHeaderMandateFields() {
        final List<AppConfigValues> appConfigValuesList = collectionsUtil.getAppConfigValues(
                CollectionConstants.MISMandatoryAttributesModule, CollectionConstants.MISMandatoryAttributesKey);

        for (final AppConfigValues appConfigVal : appConfigValuesList) {
            final String value = appConfigVal.getValue();
            final String header = value.substring(0, value.indexOf('|'));
            headerFields.add(header);
            final String mandate = value.substring(value.indexOf('|') + 1);
            if (mandate.equalsIgnoreCase("M"))
                mandatoryFields.add(header);
        }
        /*
         * if (!"Auto".equalsIgnoreCase(new
         * VoucherTypeForULB().readVoucherTypes("Receipt"))) {
         * headerFields.add("vouchernumber");
         * mandatoryFields.add("vouchernumber"); }
         */
        mandatoryFields.add("voucherdate");
    }

    private List<InstrumentHeader> populateInstrumentDetails() {
        List<InstrumentHeader> instrumentHeaderList = new ArrayList<InstrumentHeader>(0);

        if (CollectionConstants.INSTRUMENTTYPE_CASH.equals(instrumentTypeCashOrCard)) {
            instrHeaderCash.setInstrumentType(financialsUtil
                    .getInstrumentTypeByType(CollectionConstants.INSTRUMENTTYPE_CASH));

            instrHeaderCash.setIsPayCheque(CollectionConstants.ZERO_INT);
            // the cash amount is set into the object through binding
            // this total is needed for creating debit account head

            cashOrCardInstrumenttotal = cashOrCardInstrumenttotal.add(instrHeaderCash.getInstrumentAmount());

            instrumentHeaderList.add(instrHeaderCash);
        }
        if (CollectionConstants.INSTRUMENTTYPE_CARD.equals(instrumentTypeCashOrCard)) {
            instrHeaderCard.setInstrumentType(financialsUtil
                    .getInstrumentTypeByType(CollectionConstants.INSTRUMENTTYPE_CARD));
            if (instrHeaderCard.getTransactionDate() == null)
                instrHeaderCard.setTransactionDate(new Date());
            instrHeaderCard.setIsPayCheque(CollectionConstants.ZERO_INT);

            // the instrumentNumber, transactionNumber, instrumentAmount are
            // set into the object directly through binding
            cashOrCardInstrumenttotal = cashOrCardInstrumenttotal.add(instrHeaderCard.getInstrumentAmount());

            instrumentHeaderList.add(instrHeaderCard);
        }

        if (CollectionConstants.INSTRUMENTTYPE_BANK.equals(instrumentTypeCashOrCard)) {
            instrHeaderBank.setInstrumentType(financialsUtil
                    .getInstrumentTypeByType(CollectionConstants.INSTRUMENTTYPE_BANK));
            if (instrHeaderBank.getTransactionDate() == null)
                instrHeaderBank.setTransactionDate(new Date());
            instrHeaderBank.setIsPayCheque(CollectionConstants.ZERO_INT);

            final Bankaccount account = (Bankaccount) bankAccountDAO.findById(bankAccountId, false);

            instrHeaderBank.setBankAccountId(account);
            instrHeaderBank.setBankBranchName(account.getBankbranch().getBranchname());

            // the instrumentNumber, transactionNumber, instrumentAmount are
            // set into the object directly through binding
            cashOrCardInstrumenttotal = cashOrCardInstrumenttotal.add(instrHeaderBank.getInstrumentAmount());

            instrumentHeaderList.add(instrHeaderBank);
        }

        // cheque/DD types
        if (instrumentProxyList != null && !CollectionConstants.INSTRUMENTTYPE_CASH.equals(instrumentTypeCashOrCard)
                && !CollectionConstants.INSTRUMENTTYPE_CARD.equals(instrumentTypeCashOrCard)
                && !CollectionConstants.INSTRUMENTTYPE_BANK.equals(instrumentTypeCashOrCard))
            if (getInstrumentType()
                    .equals(CollectionConstants.INSTRUMENTTYPE_CHEQUE)
                    || getInstrumentType()
                            .equals(CollectionConstants.INSTRUMENTTYPE_DD))
                instrumentHeaderList = populateInstrumentHeaderForChequeDD(instrumentHeaderList, instrumentProxyList);
        instrumentHeaderList = receiptHeaderService.createInstrument(instrumentHeaderList);
        return instrumentHeaderList;
    }

    /**
     * This instrument creates instrument header instances for the receipt, when
     * the instrument type is Cheque or DD. The created
     * <code>InstrumentHeader</code> instance is persisted
     *
     * @param k
     *            an int value representing the index of the instrument type as
     *            chosen from the front end
     * @return an <code>InstrumentHeader</code> instance populated with the
     *         instrument details
     */
    private List<InstrumentHeader> populateInstrumentHeaderForChequeDD(
            final List<InstrumentHeader> instrumentHeaderList, final List<InstrumentHeader> instrumentProxyList) {

        for (final InstrumentHeader instrumentHeader : instrumentProxyList) {
            if (getInstrumentType().equals(CollectionConstants.INSTRUMENTTYPE_CHEQUE))
                instrumentHeader.setInstrumentType(financialsUtil
                        .getInstrumentTypeByType(CollectionConstants.INSTRUMENTTYPE_CHEQUE));
            else if (getInstrumentType().equals(CollectionConstants.INSTRUMENTTYPE_DD))
                instrumentHeader.setInstrumentType(financialsUtil
                        .getInstrumentTypeByType(CollectionConstants.INSTRUMENTTYPE_DD));
            if (instrumentHeader.getBankId() != null && instrumentHeader.getBankId().getId() == null) {
                addActionError("Bank is not exist");
                throw new ApplicationRuntimeException("Bank is not exist");

            } else if (instrumentHeader.getBankId() != null && instrumentHeader.getBankId().getId() != null)
                instrumentHeader.setBankId((Bank) bankDAO.findById(
                        Integer.valueOf(instrumentHeader.getBankId().getId()), false));
            chequeInstrumenttotal = chequeInstrumenttotal.add(instrumentHeader.getInstrumentAmount());
            instrumentHeader.setIsPayCheque(CollectionConstants.ZERO_INT);
            instrumentHeaderList.add(instrumentHeader);
        }
        return instrumentHeaderList;
    }

    /**
     * This method create a new receipt header object with details contained in
     * given receipt header object. Both the receipt header objects are added to
     * the same parent <code>ReceiptPayeeDetail</code> object which in turn is
     * added to the model.
     *
     * @param oldReceiptHeader
     *            the instance of <code>ReceiptHeader</code> whose data is to be
     *            copied
     */
    private void populateReceiptModelWithExistingReceiptInfo(final ReceiptHeader oldReceiptHeader) {
        totalAmountToBeCollected = BigDecimal.valueOf(0);

        final ReceiptHeader receiptHeader = new ReceiptHeader(oldReceiptHeader.getReferencenumber(),
                oldReceiptHeader.getReferencedate(), oldReceiptHeader.getConsumerCode(),
                oldReceiptHeader.getReferenceDesc(), oldReceiptHeader.getTotalAmount(),
                oldReceiptHeader.getMinimumAmount(), oldReceiptHeader.getPartPaymentAllowed(),
                oldReceiptHeader.getOverrideAccountHeads(), oldReceiptHeader.getCallbackForApportioning(),
                oldReceiptHeader.getDisplayMsg(), oldReceiptHeader.getService(),
                oldReceiptHeader.getCollModesNotAllwd(), oldReceiptHeader.getPayeeName(),
                oldReceiptHeader.getPayeeAddress(), oldReceiptHeader.getPayeeEmail());
        if (oldReceiptHeader.getCollModesNotAllwd() != null)
            setCollectionModesNotAllowed(Arrays.asList(oldReceiptHeader.getCollModesNotAllwd().split(",")));
        setOverrideAccountHeads(oldReceiptHeader.getOverrideAccountHeads());
        setPartPaymentAllowed(oldReceiptHeader.getPartPaymentAllowed());
        setServiceName(oldReceiptHeader.getService().getName());

        final ReceiptMisc receiptMisc = new ReceiptMisc(oldReceiptHeader.getReceiptMisc().getBoundary(),
                oldReceiptHeader.getReceiptMisc().getFund(), oldReceiptHeader.getReceiptMisc().getIdFunctionary(),
                oldReceiptHeader.getReceiptMisc().getFundsource(), oldReceiptHeader.getReceiptMisc().getDepartment(),
                receiptHeader, oldReceiptHeader.getReceiptMisc().getScheme(), oldReceiptHeader.getReceiptMisc()
                        .getSubscheme(), null);
        receiptHeader.setReceiptMisc(receiptMisc);
        bankCOAList = chartOfAccountsDAO.getBankChartofAccountCodeList();
        for (final ReceiptDetail oldDetail : oldReceiptHeader.getReceiptDetails())
            // debit account heads for revenue accounts should not be considered
            if (oldDetail.getOrdernumber() != null
                    && !FinancialsUtil
                            .isRevenueAccountHead(oldDetail.getAccounthead(), bankCOAList, persistenceService)) {
                final ReceiptDetail receiptDetail = new ReceiptDetail(oldDetail.getAccounthead(),
                        oldDetail.getFunction(), oldDetail.getCramount(), oldDetail.getDramount(),
                        oldDetail.getCramount(), oldDetail.getOrdernumber(), oldDetail.getDescription(),
                        oldDetail.getIsActualDemand(), receiptHeader, oldDetail.getPurpose());
                receiptDetail.setCramountToBePaid(oldDetail.getCramountToBePaid());
                receiptDetail.setCramount(oldDetail.getCramount());
                if (oldDetail.getAccountPayeeDetails() != null)
                    for (final AccountPayeeDetail oldAccountPayeeDetail : oldDetail.getAccountPayeeDetails()) {
                        final AccountPayeeDetail accountPayeeDetail = new AccountPayeeDetail(
                                oldAccountPayeeDetail.getAccountDetailType(),
                                oldAccountPayeeDetail.getAccountDetailKey(), oldAccountPayeeDetail.getAmount(),
                                receiptDetail);
                        receiptDetail.addAccountPayeeDetail(accountPayeeDetail);
                    }

                if (oldDetail.getIsActualDemand())
                    totalAmountToBeCollected = totalAmountToBeCollected.add(oldDetail.getCramountToBePaid())
                            .subtract(oldDetail.getDramount())
                            .setScale(CollectionConstants.AMOUNT_PRECISION_DEFAULT, BigDecimal.ROUND_UP);

                receiptHeader.addReceiptDetail(receiptDetail);
            }

        if (oldReceiptHeader.getReceipttype() == CollectionConstants.RECEIPT_TYPE_ADHOC) {
            loadReceiptDetails(receiptHeader);
            createMisc();
            if (oldReceiptHeader.getVoucherNum() != null)
                setVoucherNum(voucherNum);
        }
        setReceiptDetailList(new ArrayList<ReceiptDetail>(receiptHeader.getReceiptDetails()));
    }

    private void loadReceiptDetails(final ReceiptHeader receiptHeader) {
        setReceiptMisc(receiptHeader.getReceiptMisc());
        setBillCreditDetailslist(collectionCommon.setReceiptDetailsList(receiptHeader,
                CollectionConstants.COLLECTIONSAMOUNTTPE_CREDIT));
        setBillRebateDetailslist(collectionCommon.setReceiptDetailsList(receiptHeader,
                CollectionConstants.COLLECTIONSAMOUNTTPE_DEBIT));
        setSubLedgerlist(collectionCommon.setAccountPayeeList(receiptHeader));
    }

    /**
     * Same method handles both view and print modes. If print receipts flag is
     * passed as true, the PDF receipt will be generated in such a way that it
     * will show the print dialog box whenever it is opened.
     *
     * @param printReceipts
     *            Flag indicating whether the receipts are to be printed
     * @return Result page ("view")
     */
    private String viewReceipts(final boolean printReceipts) {
        if (selectedReceipts == null || selectedReceipts.length == 0)
            throw new ApplicationRuntimeException("No receipts selected to view!");

        receipts = new ReceiptHeader[selectedReceipts.length];
        for (int i = 0; i < selectedReceipts.length; i++)
            try {
                receipts[i] = receiptHeaderService.findById(selectedReceipts[i], false);
            } catch (final Exception e) {
                LOGGER.error("Error in printReceipts", e);
            }

        try {
            reportId = collectionCommon.generateReport(receipts, printReceipts);
        } catch (final Exception e) {
            final String errMsg = "Error during report generation!";
            LOGGER.error(errMsg, e);
            throw new ApplicationRuntimeException(errMsg, e);
        }

        return CollectionConstants.REPORT;
    }

    @Action(value = "/receipts/receipt-viewReceipts")
    public String viewReceipts() {
        return viewReceipts(false);
    }

    @Action(value = "/receipts/receipt-printReceipts")
    public String printReceipts() {
        return viewReceipts(true);
    }

    @ValidationErrorPage(value = "error")
    @Action(value = "/receipts/receipt-cancel")
    public String cancel() {
        if (getSelectedReceipts() != null && getSelectedReceipts().length > 0) {
            receipts = new ReceiptHeader[selectedReceipts.length];
            for (int i = 0; i < selectedReceipts.length; i++)
                receipts[i] = (ReceiptHeader) getPersistenceService().findByNamedQuery("getReceiptHeaderById",
                        Long.valueOf(selectedReceipts[i]));
        }
        return CANCEL;
    }

    /**
     * This method is invoked when receipt is cancelled
     *
     * @return
     */
    @Action(value = "/receipts/receipt-saveOnCancel")
    public String saveOnCancel() {
        String instrumentType = "";
        boolean isInstrumentDeposited = false;

        final ReceiptHeader receiptHeaderToBeCancelled = receiptHeaderService.findById(oldReceiptId, false);

        LOGGER.info("Receipt Header to be Cancelled : " + receiptHeaderToBeCancelled.getReceiptnumber());

        for (final InstrumentHeader instrumentHeader : receiptHeaderToBeCancelled.getReceiptInstrument())
            if (instrumentHeader.getInstrumentType().getType().equals(CollectionConstants.INSTRUMENTTYPE_CASH)) {
                if (instrumentHeader.getStatusId().getDescription()
                        .equals(CollectionConstants.INSTRUMENT_RECONCILED_STATUS)) {
                    isInstrumentDeposited = true;
                    break;
                }
            } else if (instrumentHeader.getStatusId().getDescription()
                    .equals(CollectionConstants.INSTRUMENT_DEPOSITED_STATUS)) {
                isInstrumentDeposited = true;
                break;
            }

        if (isInstrumentDeposited) {
            // if instrument has been deposited create a new receipt in place of
            // the cancelled

            populateReceiptModelWithExistingReceiptInfo(receiptHeaderToBeCancelled);
            setFundName(receiptHeaderToBeCancelled.getReceiptMisc().getFund().getName());
            setServiceName(receiptHeaderToBeCancelled.getService().getName());
            populateBankBranchList(true);

            // set collection modes allowed rule through script
            setCollectionModesNotAllowed();

            return NEW;
        } else {
            // if instrument has not been deposited, cancel the old instrument,
            // reverse the
            // voucher and persist
            receiptHeaderToBeCancelled.setStatus(statusDAO.getStatusByModuleAndCode(
                    CollectionConstants.MODULE_NAME_RECEIPTHEADER, CollectionConstants.RECEIPT_STATUS_CODE_CANCELLED));
            receiptHeaderToBeCancelled.setIsReconciled(false);
            receiptHeaderToBeCancelled.setReasonForCancellation(reasonForCancellation);

            for (final InstrumentHeader instrumentHeader : receiptHeaderToBeCancelled.getReceiptInstrument()) {
                instrumentHeader.setStatusId(statusDAO.getStatusByModuleAndCode(
                        CollectionConstants.MODULE_NAME_INSTRUMENTHEADER,
                        CollectionConstants.INSTRUMENTHEADER_STATUS_CANCELLED));
                instrumentType = instrumentHeader.getInstrumentType().getType();

            }
            for (final ReceiptVoucher receiptVoucher : receiptHeaderToBeCancelled.getReceiptVoucher())
                receiptHeaderService.createReversalVoucher(receiptVoucher, instrumentType);

            receiptHeaderService.persist(receiptHeaderToBeCancelled);

            receiptHeaderValues.clear();
            receiptHeaderValues.add(receiptHeaderToBeCancelled);
            LOGGER.info("Receipt Cancelled with Receipt Number(saveOnCancel): "
                    + receiptHeaderToBeCancelled.getReceiptnumber() + "; Consumer Code: "
                    + receiptHeaderToBeCancelled.getConsumerCode());
        }
        target = "cancel";
        return INDEX;
    }

    public String amountInWords(final BigDecimal amount) {
        return NumberUtil.amountInWords(amount);
    }

    /**
     * @return the receiptHeaderValues
     */
    public List<ReceiptHeader> getReceiptHeaderValues() {
        return receiptHeaderValues;
    }

    /**
     * @param receiptHeaderValues
     *            the receiptHeaderValues to set
     */
    public void setReceiptHeaderValues(final List<ReceiptHeader> receiptHeaderValues) {
        this.receiptHeaderValues = receiptHeaderValues;
    }

    public String getReasonForCancellation() {
        return reasonForCancellation;
    }

    public void setReasonForCancellation(final String reasonForCancellation) {
        this.reasonForCancellation = reasonForCancellation;
    }

    /**
     * @return the target
     */
    public String getTarget() {
        return target;
    }

    /**
     * @return the paidBy
     */
    public String getPaidBy() {
        return StringUtils.escapeJavaScript(paidBy);
    }

    /**
     * @param paidBy
     *            the paidBy to set
     */
    public void setPaidBy(final String paidBy) {
        this.paidBy = paidBy;
    }

    /**
     * @return the oldReceiptId
     */
    public Long getOldReceiptId() {
        return oldReceiptId;
    }

    /**
     * @param oldReceiptId
     *            the oldReceiptId to set
     */
    public void setOldReceiptId(final Long oldReceiptId) {
        this.oldReceiptId = oldReceiptId;
    }

    public Long getBankAccountId() {
        return bankAccountId;
    }

    public void setBankAccountId(final Long bankAccountId) {
        this.bankAccountId = bankAccountId;
    }

    public BigDecimal getTotalAmountToBeCollected() {
        return totalAmountToBeCollected;
    }

    public void setTotalAmountToBeCollected(final BigDecimal totalAmountToBeCollected) {
        this.totalAmountToBeCollected = totalAmountToBeCollected;
    }

    public InstrumentHeader getInstrHeaderCash() {
        return instrHeaderCash;
    }

    public void setInstrHeaderCash(final InstrumentHeader instrHeaderCash) {
        this.instrHeaderCash = instrHeaderCash;
    }

    public InstrumentHeader getInstrHeaderCard() {
        return instrHeaderCard;
    }

    public void setInstrHeaderCard(final InstrumentHeader instrHeaderCard) {
        this.instrHeaderCard = instrHeaderCard;
    }

    public InstrumentHeader getInstrHeaderBank() {
        return instrHeaderBank;
    }

    public void setInstrHeaderBank(final InstrumentHeader instrHeaderBank) {
        this.instrHeaderBank = instrHeaderBank;
    }

    public List<String> getCollectionModesNotAllowed() {
        return collectionModesNotAllowed;
    }

    public void setCollectionModesNotAllowed(final List<String> collectionModesNotAllowed) {
        this.collectionModesNotAllowed = collectionModesNotAllowed;
    }

    public User getReceiptCreatedByCounterOperator() {
        return receiptCreatedByCounterOperator;
    }

    public void setReceiptCreatedByCounterOperator(final User receiptCreatedByCounterOperator) {
        this.receiptCreatedByCounterOperator = receiptCreatedByCounterOperator;
    }

    public List<ReceiptDetail> getReceiptDetailList() {
        return receiptDetailList;
    }

    public void setReceiptDetailList(final List<ReceiptDetail> receiptDetailList) {
        this.receiptDetailList = receiptDetailList;
    }

    public String getInstrumentTypeCashOrCard() {
        return instrumentTypeCashOrCard;
    }

    public void setInstrumentTypeCashOrCard(final String instrumentTypeCashOrCard) {
        this.instrumentTypeCashOrCard = instrumentTypeCashOrCard;
    }

    /**
     * This getter will be invoked by framework from UI. It returns the total
     * number of bill accounts that are present in the XML arriving from the
     * billing system
     *
     * @return
     */
    public Integer getTotalNoOfAccounts() {
        Integer totalNoOfAccounts = 0;
        totalNoOfAccounts += receiptHeader.getReceiptDetails().size();
        return totalNoOfAccounts;
    }

    /**
     * This getter will be invoked by framework from UI. This value will be used
     * during bill apportioning.
     *
     * @return
     */
    public BigDecimal getMinimumAmount() {
        return null;
    }

    public Boolean getOverrideAccountHeads() {
        return overrideAccountHeads;
    }

    public void setOverrideAccountHeads(final Boolean overrideAccountHeads) {
        this.overrideAccountHeads = overrideAccountHeads;
    }

    public Boolean getCallbackForApportioning() {
        return callbackForApportioning;
    }

    public void setCallbackForApportioning(final Boolean callbackForApportioning) {
        this.callbackForApportioning = callbackForApportioning;
    }

    public Boolean getPartPaymentAllowed() {
        return partPaymentAllowed;
    }

    public void setPartPaymentAllowed(final Boolean partPaymentAllowed) {
        this.partPaymentAllowed = partPaymentAllowed;
    }

    public BigDecimal getCashOrCardInstrumenttotal() {
        return cashOrCardInstrumenttotal;
    }

    public void setCashOrCardInstrumenttotal(final BigDecimal cashOrCardInstrumenttotal) {
        this.cashOrCardInstrumenttotal = cashOrCardInstrumenttotal;
    }

    public String getServiceName() {
        return serviceName;
    }

    public void setServiceName(final String serviceName) {
        this.serviceName = serviceName;
    }

    public void setCollectionsUtil(final CollectionsUtil collectionsUtil) {
        this.collectionsUtil = collectionsUtil;
    }

    public Boolean getCashAllowed() {
        return cashAllowed;
    }

    public void setCashAllowed(final Boolean cashAllowed) {
        this.cashAllowed = cashAllowed;
    }

    public Boolean getCardAllowed() {
        return cardAllowed;
    }

    public void setCardAllowed(final Boolean cardAllowed) {
        this.cardAllowed = cardAllowed;
    }

    public Boolean getChequeAllowed() {
        return chequeAllowed;
    }

    public void setChequeAllowed(final Boolean chequeAllowed) {
        this.chequeAllowed = chequeAllowed;
    }

    public Boolean getDdAllowed() {
        return ddAllowed;
    }

    public void setDdAllowed(final Boolean ddAllowed) {
        this.ddAllowed = ddAllowed;
    }

    public Boolean getBankAllowed() {
        return bankAllowed;
    }

    public void setBankAllowed(final Boolean bankAllowed) {
        this.bankAllowed = bankAllowed;
    }

    /**
     * @return the voucherDate
     */
    public Date getVoucherDate() {
        return voucherDate;
    }

    /**
     * @param voucherDate
     *            the voucherDate to set
     */
    public void setVoucherDate(final Date voucherDate) {
        this.voucherDate = voucherDate;
    }

    /**
     * @return the voucherNumber
     */
    public String getVoucherNum() {
        return voucherNum;
    }

    /**
     * @param voucherNumber
     *            the voucherNumber to set
     */
    public void setVoucherNum(final String voucherNum) {
        this.voucherNum = voucherNum;
    }

    /**
     * This getter will be invoked by framework from UI. This value will be used
     * during misc receipts for account details
     *
     * @return
     */
    public List<ReceiptDetailInfo> getBillCreditDetailslist() {
        return billCreditDetailslist;
    }

    public void setBillCreditDetailslist(final List<ReceiptDetailInfo> billCreditDetailslist) {
        this.billCreditDetailslist = billCreditDetailslist;
    }

    public List<ReceiptDetailInfo> getBillRebateDetailslist() {
        return billRebateDetailslist;
    }

    public void setBillRebateDetailslist(final List<ReceiptDetailInfo> billRebateDetailslist) {
        this.billRebateDetailslist = billRebateDetailslist;
    }

    public List<ReceiptDetailInfo> getSubLedgerlist() {
        return subLedgerlist;
    }

    public void setSubLedgerlist(final List<ReceiptDetailInfo> subLedgerlist) {
        this.subLedgerlist = subLedgerlist;
    }

    public String getBillSource() {
        return billSource;
    }

    public void setBillSource(final String billSource) {
        this.billSource = billSource;
    }

    /**
     * @return the receiptPayeeDetailsService
     */
    public ReceiptMisc getReceiptMisc() {
        return receiptMisc;
    }

    /**
     * @return the reportId
     */
    public String getReportId() {
        return reportId;
    }

    public void setReceiptMisc(final ReceiptMisc receiptMisc) {
        this.receiptMisc = receiptMisc;
    }

    public String getDeptId() {
        return deptId;
    }

    public void setDeptId(final String deptId) {
        this.deptId = deptId;
    }

    public BigDecimal getTotalDebitAmount() {
        return totalDebitAmount;
    }

    public void setTotalDebitAmount(final BigDecimal totalDebitAmount) {
        this.totalDebitAmount = totalDebitAmount;
    }

    protected boolean validateData(final List<ReceiptDetailInfo> billDetailslistd,
            final List<ReceiptDetailInfo> subLedgerList) {
        BigDecimal totalDrAmt = BigDecimal.ZERO;
        BigDecimal totalCrAmt = BigDecimal.ZERO;
        int index = 0;
        boolean isDataValid = true;
        for (final ReceiptDetailInfo rDetails : billDetailslistd) {
            index = index + 1;
            totalDrAmt = totalDrAmt.add(rDetails.getDebitAmountDetail());
            totalCrAmt = totalCrAmt.add(rDetails.getCreditAmountDetail());
            if (rDetails.getDebitAmountDetail().compareTo(BigDecimal.ZERO) == 0
                    && rDetails.getCreditAmountDetail().compareTo(BigDecimal.ZERO) == 0
                    && rDetails.getGlcodeDetail().trim().length() == 0) {

                addActionError(getText("miscreceipt.accdetail.emptyaccrow", new String[] { "" + index }));
                isDataValid = false;
            } else if (rDetails.getDebitAmountDetail().compareTo(BigDecimal.ZERO) == 0
                    && rDetails.getCreditAmountDetail().compareTo(BigDecimal.ZERO) == 0
                    && rDetails.getGlcodeDetail().trim().length() != 0) {
                addActionError(getText("miscreceipt.accdetail.amountZero", new String[] { rDetails.getGlcodeDetail() }));
                isDataValid = false;
            } else if (rDetails.getDebitAmountDetail().compareTo(BigDecimal.ZERO) > 0
                    && rDetails.getCreditAmountDetail().compareTo(BigDecimal.ZERO) > 0) {
                addActionError(getText("miscreceipt.accdetail.amount", new String[] { rDetails.getGlcodeDetail() }));
                isDataValid = false;
            } else if ((rDetails.getDebitAmountDetail().compareTo(BigDecimal.ZERO) > 0 || rDetails
                    .getCreditAmountDetail().compareTo(BigDecimal.ZERO) > 0)
                    && rDetails.getGlcodeDetail().trim().length() == 0) {
                addActionError(getText("miscreceipt.accdetail.accmissing", new String[] { "" + index }));
                isDataValid = false;
            }

        }
        if (isDataValid)
            isDataValid = validateSubledgerDetails(billCreditDetailslist, subLedgerList);
        return isDataValid;
    }

    protected boolean validateRebateData(final List<ReceiptDetailInfo> billDetailslistd,
            final List<ReceiptDetailInfo> subLedgerList) {
        int index = 0;
        boolean isDataValid = true;
        for (final ReceiptDetailInfo rDetails : billDetailslistd) {
            index = index + 1;
            if (rDetails.getDebitAmountDetail().compareTo(BigDecimal.ZERO) == 0
                    && rDetails.getGlcodeDetail().trim().length() != 0) {
                addActionError(getText("miscreceipt.accdetail.amountZero", new String[] { rDetails.getGlcodeDetail() }));
                isDataValid = false;
            } else if (rDetails.getDebitAmountDetail().compareTo(BigDecimal.ZERO) > 0
                    && rDetails.getGlcodeDetail().trim().length() == 0) {
                addActionError(getText("miscreceipt.accdetail.accmissing", new String[] { "" + index }));
                isDataValid = false;
            }

        }
        if (isDataValid)
            isDataValid = validateSubledgerDetails(billRebateDetailslist, subLedgerList);
        return isDataValid;
    }

    protected boolean validateSubledgerDetails(final List<ReceiptDetailInfo> billRebateDetailslist,
            final List<ReceiptDetailInfo> subLedgerlist) {
        Map<String, Object> accountDetailMap;
        final Map<String, BigDecimal> subledAmtmap = new HashMap<String, BigDecimal>(0);
        List<Map<String, Object>> subLegAccMap = null; // this list will contain
        // the details about the
        // account coe those are
        // detail codes.
        for (final ReceiptDetailInfo rDetails : billRebateDetailslist) {
            final CChartOfAccountDetail chartOfAccountDetail = (CChartOfAccountDetail) getPersistenceService().find(
                    " from CChartOfAccountDetail" + " where glCodeId=(select id from CChartOfAccounts where glcode=?)",
                    rDetails.getGlcodeDetail());
            if (null != chartOfAccountDetail) {
                accountDetailMap = new HashMap<String, Object>();
                accountDetailMap.put("glcodeId", rDetails.getGlcodeIdDetail());
                accountDetailMap.put("glcode", rDetails.getGlcodeDetail());
                if (rDetails.getDebitAmountDetail().compareTo(BigDecimal.ZERO) == 0)
                    accountDetailMap.put("amount", rDetails.getCreditAmountDetail());
                else if (rDetails.getCreditAmountDetail().compareTo(BigDecimal.ZERO) == 0)
                    accountDetailMap.put("amount", rDetails.getDebitAmountDetail());
                if (null == subLegAccMap) {
                    subLegAccMap = new ArrayList<Map<String, Object>>();
                    subLegAccMap.add(accountDetailMap);
                } else
                    subLegAccMap.add(accountDetailMap);

            }
        }
        if (null != subLegAccMap) {
            final Map<String, String> subLedgerMap = new HashMap<String, String>();
            for (final ReceiptDetailInfo rDetails : subLedgerlist)
                if (rDetails.getGlcode().getId() != 0) {
                    if (null == subledAmtmap.get(rDetails.getGlcode().getId().toString()))
                        subledAmtmap.put(rDetails.getGlcode().getId().toString(), rDetails.getAmount());
                    else {
                        final BigDecimal debitTotalAmount = subledAmtmap.get(rDetails.getGlcode().getId().toString())
                                .add(rDetails.getAmount());
                        subledAmtmap.put(rDetails.getGlcode().getId().toString(), debitTotalAmount);
                    }
                    final StringBuffer subledgerDetailRow = new StringBuffer();
                    subledgerDetailRow.append(rDetails.getGlcode().getId().toString())
                            .append(rDetails.getDetailType().getId().toString())
                            .append(rDetails.getDetailKeyId().toString());
                    if (null == subLedgerMap.get(subledgerDetailRow.toString()))
                        subLedgerMap.put(subledgerDetailRow.toString(), subledgerDetailRow.toString());
                    else {
                        addActionError(getText("miscreciept.samesubledger.repeated"));
                        return false;
                    }

                }
            for (final Map<String, Object> map : subLegAccMap) {
                final String glcodeId = map.get("glcodeId").toString();
                if (null == subledAmtmap.get(glcodeId)) {
                    addActionError(getText("miscreciept.subledger.entrymissing", new String[] { map.get("glcode")
                            .toString() }));
                    return false;
                } else if (subledAmtmap.get(glcodeId).compareTo(new BigDecimal(map.get("amount").toString()))!=0) {
                    addActionError(getText("miscreciept.subledger.amtnotmatchinng", new String[] { map.get("glcode")
                            .toString() }));
                    return false;
                }
            }
        }
        final List<CFinancialYear> list = persistenceService.findAllBy(
                "from CFinancialYear where isActiveForPosting=true and startingDate <= ? and endingDate >= ?",
                getVoucherDate(), getVoucherDate());
        if (list.isEmpty()) {
            addActionError(getText("miscreciept.fYear.notActive"));
            return false;
        }
        return true;
    }

    public void apportionBillAmount() {
        receiptDetailList = collectionCommon.apportionBillAmount(instrumenttotal, (ArrayList) getReceiptDetailList());
    }

    void removeEmptyRows(final List<ReceiptDetailInfo> list) {
        for (final Iterator<ReceiptDetailInfo> detail = list.iterator(); detail.hasNext();)
            if (detail.next() == null)
                detail.remove();
    }

    public void setFinancialsUtil(final FinancialsUtil financialsUtil) {
        this.financialsUtil = financialsUtil;
    }

    public List<String> getHeaderFields() {
        return headerFields;
    }

    public void setHeaderFields(final List<String> headerFields) {
        this.headerFields = headerFields;
    }

    public List<String> getMandatoryFields() {
        return mandatoryFields;
    }

    public void setMandatoryFields(final List<String> mandatoryFields) {
        this.mandatoryFields = mandatoryFields;
    }

    public Integer getBankBranchId() {
        return bankBranchId;
    }

    public void setBankBranchId(final Integer bankBranchId) {
        this.bankBranchId = bankBranchId;
    }

    private String fundName;

    public String getFundName() {
        return fundName;
    }

    public void setFundName(final String fundName) {
        this.fundName = fundName;
    }

    /**
     * @param collectionCommon
     *            the collectionCommon to set
     */
    public void setCollectionCommon(final CollectionCommon collectionCommon) {
        this.collectionCommon = collectionCommon;
    }

    /**
     * @param receiptHeaderService
     *            The receipt header service to set
     */
    public void setReceiptHeaderService(final ReceiptHeaderService receiptHeaderService) {
        this.receiptHeaderService = receiptHeaderService;
    }

    public String getCollectXML() {
        return collectXML;
    }

    public void setCollectXML(final String collectXML) {
        this.collectXML = collectXML;
    }

    @Override
    public Object getModel() {
        return receiptHeader;
    }

    public ReceiptHeader[] getReceipts() {
        return receipts;
    }

    public void setReceipts(final ReceiptHeader[] receipts) {
        this.receipts = receipts;
    }

    public void setXmlHandler(final BillCollectXmlHandler xmlHandler) {
        this.xmlHandler = xmlHandler;
    }

    public Long[] getSelectedReceipts() {
        return selectedReceipts;
    }

    public void setSelectedReceipts(final Long[] selectedReceipts) {
        this.selectedReceipts = selectedReceipts;
    }

    public void setPayeename(final String payeename) {
        this.payeename = payeename;
    }

    public Date getManualReceiptDate() {
        return manualReceiptDate;
    }

    public void setManualReceiptDate(final Date manualReceiptDate) {
        this.manualReceiptDate = manualReceiptDate;
    }

    public Boolean getReceiptBulkUpload() {
        return receiptBulkUpload;
    }

    public void setReceiptBulkUpload(final Boolean receiptBulkUpload) {
        this.receiptBulkUpload = receiptBulkUpload;
    }

    public BigDecimal getInstrumenttotal() {
        return instrumenttotal;
    }

    public void setInstrumenttotal(final BigDecimal instrumenttotal) {
        this.instrumenttotal = instrumenttotal;
    }

    public void setServiceDetailsService(final PersistenceService<ServiceDetails, Long> serviceDetailsService) {
        this.serviceDetailsService = serviceDetailsService;
    }

    public List<InstrumentHeader> getInstrumentProxyList() {
        return instrumentProxyList;
    }

    public void setInstrumentProxyList(final List<InstrumentHeader> instrumentProxyList) {
        this.instrumentProxyList = instrumentProxyList;
    }

    public int getInstrumentCount() {
        return instrumentCount;
    }

    public void setInstrumentCount(final int instrumentCount) {
        this.instrumentCount = instrumentCount;
    }

    /**
     * @return the manualReceiptNumber
     */
    public String getManualReceiptNumber() {
        return manualReceiptNumber;
    }

    /**
     * @param manualReceiptNumber
     *            the manualReceiptNumber to set
     */
    public void setManualReceiptNumber(final String manualReceiptNumber) {
        this.manualReceiptNumber = manualReceiptNumber;
    }

    /**
     * @return the manualReceiptNumberAndDateReq
     */
    public Boolean getManualReceiptNumberAndDateReq() {
        return manualReceiptNumberAndDateReq;
    }

    /**
     * @param manualReceiptNumberAndDateReq
     *            the manualReceiptNumberAndDateReq to set
     */
    public void setManualReceiptNumberAndDateReq(final Boolean manualReceiptNumberAndDateReq) {
        this.manualReceiptNumberAndDateReq = manualReceiptNumberAndDateReq;
    }

    public ReceiptHeader getReceiptHeader() {
        return receiptHeader;
    }

    public void setReceiptHeader(final ReceiptHeader receiptHeader) {
        this.receiptHeader = receiptHeader;
    }

    public void setServiceCategoryService(final PersistenceService<ServiceCategory, Long> serviceCategoryService) {
        this.serviceCategoryService = serviceCategoryService;
    }

    public Long getFunctionId() {
        return functionId;
    }

    public void setFunctionId(final Long functionId) {
        this.functionId = functionId;
    }

    public Long getServiceId() {
        return serviceId;
    }

    public void setServiceId(Long serviceId) {
        this.serviceId = serviceId;
    }

    public Date getFinancialYearDate() {
        return financialYearDate;
    }

    public void setFinancialYearDate(Date financialYearDate) {
        this.financialYearDate = financialYearDate;
    }

    public String getInstrumentType() {
        return instrumentType;
    }

    public void setInstrumentType(String instrumentType) {
        this.instrumentType = instrumentType;
    }

}