AddInvoiceForXcom

/**
 *
 */
package org.jleaf.erp.purch.bo.invoice;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map.Entry;
import java.util.concurrent.TimeUnit;

import org.jleaf.common.CommonExceptionConstants;
import org.jleaf.core.BusinessFunction;
import org.jleaf.core.BusinessTransaction;
import org.jleaf.core.CoreException;
import org.jleaf.core.DefaultBusinessTransaction;
import org.jleaf.core.Dto;
import org.jleaf.core.GeneralConstants;
import org.jleaf.core.annotation.ErrorList;
import org.jleaf.core.annotation.Info;
import org.jleaf.core.annotation.InfoIn;
import org.jleaf.core.annotation.InfoOut;
import org.jleaf.erp.master.MasterConstants;
import org.jleaf.erp.master.MasterExceptionConstants;
import org.jleaf.erp.master.bo.admin.GetEarliestYearMonthOfNotYetClosedAdminProcessLedgerByOu;
import org.jleaf.erp.purch.PurchasingConstants;
import org.jleaf.erp.purch.PurchasingExceptionConstants;
import org.jleaf.erp.purch.PurchasingExceptionConstantsForXcom;
import org.jleaf.erp.purch.dao.InvoiceAdvanceDao;
import org.jleaf.erp.purch.dao.InvoiceCostDao;
import org.jleaf.erp.purch.dao.InvoiceDao;
import org.jleaf.erp.purch.dao.InvoiceItemDao;
import org.jleaf.erp.purch.dao.InvoiceTaxDao;
import org.jleaf.erp.purch.dao.PoBalanceAdvanceInvoiceDao;
import org.jleaf.erp.purch.dao.PoBalanceDiscountDao;
import org.jleaf.erp.purch.dao.PurchaseOrderBalanceInvoiceDao;
import org.jleaf.erp.purch.dao.PurchaseOrderBalanceInvoiceTaxDao;
import org.jleaf.erp.purch.entity.Invoice;
import org.jleaf.erp.purch.entity.InvoiceAdvance;
import org.jleaf.erp.purch.entity.InvoiceCost;
import org.jleaf.erp.purch.entity.InvoiceItem;
import org.jleaf.erp.purch.entity.InvoiceTax;
import org.jleaf.erp.purch.entity.PoBalanceAdvanceInvoice;
import org.jleaf.erp.purch.entity.PoBalanceDiscount;
import org.jleaf.erp.purch.entity.PurchaseOrderBalanceInvoice;
import org.jleaf.erp.purch.entity.PurchaseOrderBalanceInvoiceTax;
import org.jleaf.util.Calc;
import org.jleaf.util.DateUtil;
import org.jleaf.util.DtoUtil;
import org.jleaf.util.GsonUtil;
import org.jleaf.util.ValidationUtil;
import org.jleaf.validator.CommonBusinessValidator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;

/**
 *
 * @author unknown
 * modified by fredi, Okt 16th 2014
 * added check from invoice balance advance
 * @see  http://jleaf.org:8181/browse/PURSVC-10
 *
 */
//@formatter:off
@Service("addInvoice")
@InfoIn(value = {
        @Info(name = "docNo", description = "Nomor Transaksi", type = String.class),
        @Info(name = "docDate", description = "Tanggal Transaksi", type = String.class),
        @Info(name = "extDocNo", description = "external document no", type = String.class),
        @Info(name = "extDocDate", description = "external document date", type = String.class),
        @Info(name = "ouLegalId", description = "Organisasi Unit Legal id", type = Long.class),
        @Info(name = "remark", description = "remark", type = String.class),
        @Info(name = "refId", description = "purchase order id", type = Long.class),
        @Info(name = "invoiceItemList", description = "list of invoice item (lineNo, refItemId)", type = List.class),
        @Info(name = "gridCostList", description = "list of cost item", type = List.class, required = false),
        @Info(name = "tenantLoginId", description = "tenant login id", type = Long.class),
        @Info(name = "userLoginId", description = "user login id", type = Long.class),
        @Info(name = "roleLoginId", description = "role login id", type = Long.class),
        @Info(name = "datetime", description = "datetime", type = String.class)
})
@InfoOut(value = {
        @Info(name = "id", description = "invoice id", type = Long.class),
        @Info(name = "docNo", description = "Nomor Transaksi", type = String.class),
        @Info(name = "docDate", description = "Tanggal Transaksi", type = String.class),
        @Info(name = "extDocNo", description = "external document no", type = String.class),
        @Info(name = "extDocDate", description = "external document date", type = String.class),
        @Info(name = "ouLegalId", description = "Organisasi Unit Legal id", type = Long.class),
        @Info(name = "remark", description = "remark", type = String.class),
        @Info(name = "refId", description = "purchase order id", type = Long.class),
        @Info(name = "version", description = "version", type = Long.class)
})
@ErrorList(errorKeys = {
        CommonExceptionConstants.TENANT_LOGIN_CANT_USED,
        CommonExceptionConstants.OU_ID_NOT_FOUND,
        CommonExceptionConstants.OU_NOT_LEGAL_ENTITY,
        CommonExceptionConstants.OULEGAL_ID_NOT_FOUND,
        PurchasingExceptionConstants.INVOICE_ALREADY_EXISTS,
        PurchasingExceptionConstants.PURCHASE_ORDER_ID_NOT_FOUND,
        MasterExceptionConstants.PARTNER_ID_NOT_FOUND,
        MasterExceptionConstants.POLICY_PARTNER_AUTHORIZATION_FAILED,
        PurchasingExceptionConstants.RECEIVE_GOODS_ITEM_ID_NOT_FOUND,
        PurchasingExceptionConstants.PURCHASE_ORDER_BALANCE_INVOICE_NOT_FOUND,
        PurchasingExceptionConstants.PARTNER_NOT_AUTHORIZED_AS_SUPPLIER
})
//@formatter:on
public class AddInvoiceForXcom extends DefaultBusinessTransaction implements BusinessTransaction {

    private static final Logger log = LoggerFactory.getLogger(AddInvoice.class);

    @Autowired
    InvoiceDao invoiceDao;

    @Autowired
    InvoiceItemDao invoiceItemDao;

    @Autowired
    InvoiceTaxDao invoiceTaxDao;

    @Autowired
    InvoiceCostDao invoiceCostDao;

    @Autowired
    PoBalanceDiscountDao poBalanceDiscountDao;

    @Autowired
    PurchaseOrderBalanceInvoiceTaxDao purchaseOrderBalanceInvoiceTaxDao;

    @Autowired
    PurchaseOrderBalanceInvoiceDao purchaseOrderBalanceInvoiceDao;

    @Autowired
    PoBalanceAdvanceInvoiceDao poBalanceAdvanceInvoiceDao;

    @Autowired
    InvoiceAdvanceDao invoiceAdvanceDao;

    @Autowired
    @Qualifier("valTenantLoginCanUse")
    BusinessFunction valTenantLoginCanUse;

    @Autowired
    @Qualifier("findOULegalById")
    BusinessFunction findOULegalById;

    @Autowired
    @Qualifier("valOUAsLegal")
    BusinessFunction valOUAsLegal;

    @Autowired
    @Qualifier("isInvoiceExistsByIndex")
    BusinessFunction isInvoiceExistsByIndex;

    @Autowired
    @Qualifier("findPartnerById")
    BusinessFunction findPartnerById;

    @Autowired
    @Qualifier("findPurchaseOrderById")
    BusinessFunction findPurchaseOrderById;

    @Autowired
    @Qualifier("isPartnerTypeExistsByIndex")
    BusinessFunction isPartnerTypeExistsByIndex;

    @Autowired
    @Qualifier("valAuthorizedPolicyPartner")
    BusinessFunction valAuthorizedPolicyPartner;

    @Autowired
    @Qualifier("findReceiveGoodsItemById")
    BusinessFunction findReceiveGoodsItemById;

    @Autowired
    @Qualifier("findReceiveGoodsById")
    BusinessFunction findReceiveGoodsById;

    @Autowired
    @Qualifier("findPurchaseOrderBalanceInvoiceByIndex")
    BusinessFunction findPurchaseOrderBalanceInvoiceByIndex;

    @Autowired
    @Qualifier("getPurchaseOrderBalanceInvoiceTaxListByReceiveGoodsItem")
    BusinessFunction getPurchaseOrderBalanceInvoiceTaxListByReceiveGoodsItem;

    @Autowired
    @Qualifier("getRoundingParameter")
    BusinessFunction getRoundingParameter;

    @Autowired
    @Qualifier("isPoBalanceAdvanceInvoiceExistsByPurchaseOrder")
    BusinessFunction isPoBalanceAdvanceInvoiceExistsByPurchaseOrder;

    @Autowired
    @Qualifier("findSystemConfigByParamCode")
    private BusinessFunction findSystemConfigByParamCode;

    @Autowired
    @Qualifier("findExchangeRateByDate")
    private BusinessFunction findExchangeRateByDate;

    @Autowired
    @Qualifier("findPoBalanceDiscountByIndex")
    private BusinessFunction findPoBalanceDiscountByIndex;

    @Autowired
    @Qualifier("findInvoiceCostLastLineNo")
    private BusinessFunction findInvoiceCostLastLineNo;

    @Override
    public String getDescription() {
        return "Add invoice";
    }

    @SuppressWarnings({"unchecked", "rawtypes"})
    @Override
    public Dto prepare(Dto inputDto, Dto originalDto) throws Exception {
        Dto inputDtoForRoundingParameter = new Dto();
        inputDtoForRoundingParameter.put("tenantId", inputDto.getLong("tenantLoginId"));
        Dto resultDtoForRoundingParameter = getRoundingParameter.execute(inputDtoForRoundingParameter);

//      int scaleNonTax = resultDtoForRoundingParameter.getInteger("scaleNonTax");
//      int roundingModeNonTax = resultDtoForRoundingParameter.getInteger("roundingModeNonTax");
        int scaleTax = resultDtoForRoundingParameter.getInteger("scaleTax");
        int roundingModeTax = resultDtoForRoundingParameter.getInteger("roundingModeTax");

        // Validation tenant login id can be use
        Dto loginDto = new Dto();
        loginDto.put("tenantLoginId", inputDto.getLong("tenantLoginId"));
        loginDto.put("userLoginId", inputDto.getLong("userLoginId"));
        loginDto.put("roleLoginId", inputDto.getLong("roleLoginId"));
        valTenantLoginCanUse.execute(loginDto);

        this.prepareInsertAudit(inputDto, inputDto.getLong("userLoginId"), inputDto.getString("datetime"));
        this.prepareUpdateAudit(inputDto, inputDto.getLong("userLoginId"), inputDto.getString("datetime"));

        // Validation tidak boleh kosong / null / tanggal / etc
        ValidationUtil.valBlankOrNull(inputDto.getString("docNo"), "Document No");
        ValidationUtil.valBlankOrNull(inputDto.getString("docDate"), "Document Date");
        ValidationUtil.valBlankOrNull(inputDto.getString("extDocDate"), "Ext Document Date");
        ValidationUtil.valBlankOrNull(inputDto.getString("extDocNo"), "Ext Document No");
        ValidationUtil.valDate(inputDto.getString("docDate"), "Document Date");
        ValidationUtil.valDate(inputDto.getString("extDocDate"), "Ext Document Date");

        if (!GeneralConstants.NULL_REF_VALUE_LONG.equals(inputDto.getLong("ouLegalId"))) {
            Dto ouLegalDto = findOULegalById.execute(new Dto().put("id", inputDto.getLong("ouLegalId")));
            valOUAsLegal.execute(new Dto().put("id", ouLegalDto.getLong("ouId")));
        }

        Dto purchaseOrderDto = findPurchaseOrderById.execute(new Dto().put("id", inputDto.getLong("refId"))); // TODO

        // Validasi tanggal Purchase Invoice >= dari tanggal PO
        CommonBusinessValidator.valCompareDate(inputDto.getString("docDate"), purchaseOrderDto.getString("docDate"), CommonBusinessValidator.COMPARE_GREATER_EQUAL, "Purchase Invoice Document Date", "Purchase Order Document Date");
        CommonBusinessValidator.valCompareDate(inputDto.getString("extDocDate"), inputDto.getString("docDate"), CommonBusinessValidator.COMPARE_LESS_EQUAL, "Supplier Document Date", "Purchase Invoice Document Date");
        CommonBusinessValidator.valCompareDate(inputDto.getString("extDocDate"), purchaseOrderDto.getString("docDate"), CommonBusinessValidator.COMPARE_GREATER_EQUAL, "Supplier Document Date", "Purchase Order Document Date");

        Dto partnerDto = findPartnerById.execute(new Dto().put("id", purchaseOrderDto.getLong("partnerId")));

        // partner harus supplier
        Dto paramPartnerMustSupplier = new Dto();
        paramPartnerMustSupplier.put("tenantId", inputDto.getLong("tenantLoginId"));
        paramPartnerMustSupplier.put("partnerId", partnerDto.getLong("id"));
        paramPartnerMustSupplier.put("groupPartner", MasterConstants.GROUP_PARTNER_CODE_SUPPLIER);
        Dto resultPartnerMustSupplier = isPartnerTypeExistsByIndex.execute(paramPartnerMustSupplier);

        if (!resultPartnerMustSupplier.getBoolean("exists")) {
            throw new CoreException(PurchasingExceptionConstants.PARTNER_NOT_AUTHORIZED_AS_SUPPLIER, partnerDto.getLong("id"), partnerDto.getString("code"),
                    partnerDto.getString("name"));
        }

        Dto paramAuthorizedPolicyPartner = new Dto();
        paramAuthorizedPolicyPartner.put("userLoginId", inputDto.getLong("userLoginId"));
        paramAuthorizedPolicyPartner.put("roleLoginId", inputDto.getLong("roleLoginId"));
        paramAuthorizedPolicyPartner.put("partnerId", partnerDto.getLong("id"));
        paramAuthorizedPolicyPartner.put("varName", "Supplier");
        valAuthorizedPolicyPartner.execute(paramAuthorizedPolicyPartner);

        // Validation data (business key) is not exists yet in db (add)
        Dto paramCheckUniqueDto = new Dto();
        paramCheckUniqueDto.put("tenantId", inputDto.getLong("tenantLoginId"));
        paramCheckUniqueDto.put("docTypeId", PurchasingConstants.DOCUMENT_PURCH_INVOICE);
        paramCheckUniqueDto.put("docDate", inputDto.getString("docDate"));
        paramCheckUniqueDto.put("docNo", inputDto.getString("docNo"));
        paramCheckUniqueDto.put("ouId", purchaseOrderDto.getLong("ouId"));
        Dto resultCheckUniqueDto = isInvoiceExistsByIndex.execute(paramCheckUniqueDto);

        if (resultCheckUniqueDto.getBoolean("exists")) {
            throw new CoreException(PurchasingExceptionConstants.INVOICE_ALREADY_EXISTS, inputDto.getString("docDate"), inputDto.getString("docNo"),
                    purchaseOrderDto.getLong("ouId"));
        }

        inputDto.put("tenantId", inputDto.getLong("tenantLoginId"));
        inputDto.put("docTypeId", PurchasingConstants.DOCUMENT_PURCH_INVOICE);
        inputDto.put("ouId", purchaseOrderDto.getLong("ouId"));
        inputDto.put("refDocTypeId", PurchasingConstants.DOCUMENT_PURCHASE_ORDER);
        inputDto.put("partnerId", purchaseOrderDto.getLong("partnerId"));
        inputDto.put("purchaserId", purchaseOrderDto.getLong("purchaserId"));
        inputDto.put("currCode", purchaseOrderDto.getString("currCode"));
        inputDto.put("dueDate", DateUtil.addDate(inputDto.getString("docDate"), TimeUnit.MILLISECONDS.convert(resultPartnerMustSupplier.getLong("partnerTypeDto.dueDate"), TimeUnit.DAYS)));
        inputDto.put("grossAmount", new Double(0));
        inputDto.put("advanceAmount", new Double(0));
        inputDto.put("taxAmount", new Double(0));
        inputDto.put("addAmount", new Double(0));
        inputDto.put("totalAmount", new Double(0));
        inputDto.put("statusDoc", PurchasingConstants.DRAFT_TRANSACTION);
        inputDto.put("workflowStatus", PurchasingConstants.WORKFLOW_STATUS_DRAFT);


        // prepare detail for add item
        List<Dto> invoiceItemList = inputDto.getList("invoiceItemList");
        List<Dto> resultInvoiceItemList = new ArrayList<Dto>();
        List<Dto> gridCostList = inputDto.getList("gridCostList");
        List<Dto> resultPoBalanceInvoiceList = new ArrayList<Dto>();
        List<Dto> resultPoBalanceInvoiceTaxList = new ArrayList<Dto>();
        List<Dto> failList = new ArrayList<Dto>();
        Dto mapInvoiceTax = new Dto();
        Calc calcTaxAmount = new Calc(0);
        Calc calcNettAmount = new Calc(0);

        /*
         * Modified By Sarah 05 Oktober 2017
         * Tambahkan Cost dari discout PO kalau ada discount nya.
         * Nilai amount nya dari discout amount di balance discount, ambil nilai current, lalu update nilai balance nya.
         *
         */

        Dto balanceDiscountDto = new Dto();
        Double addAmount = 0D;

        if (gridCostList != null){
            // prepare data untuk mengurangi current amount dari cost amount data
            Dto filterFindPoBalanceDiscount = new Dto();
            filterFindPoBalanceDiscount.put("tenantId", inputDto.get("tenantLoginId"));
            filterFindPoBalanceDiscount.put("ouId", purchaseOrderDto.getLong("ouId"));
            filterFindPoBalanceDiscount.put("poId", purchaseOrderDto.getLong("id"));
            balanceDiscountDto = findPoBalanceDiscountByIndex.execute(filterFindPoBalanceDiscount);

            Double currentAmount = balanceDiscountDto.getDouble("currentAmount");

            // cek status jika I maka tidak bisa di save // I = sedang di pakai di dokumen lain
            if (!balanceDiscountDto.get("status").equals(GeneralConstants.NO)){
                throw new CoreException(PurchasingExceptionConstantsForXcom.DISCOUNT_CANNOT_USED,
                        new Calc(balanceDiscountDto.getDouble("currentAmount")).subtract(currentAmount).doubleValue());
            }

            // prepare data untuk menambahkan cost
            for(Dto costDto : gridCostList) {
                costDto.put("tenantId", inputDto.getLong("tenantLoginId"));
                costDto.put("refDocTypeId", PurchasingConstants.DOCUMENT_PURCHASE_ORDER);
                costDto.put("refId", balanceDiscountDto.get("id"));
                costDto.put("taxId", GeneralConstants.NULL_REF_VALUE_LONG);
                costDto.put("taxPercentage", new Double(0));
                costDto.put("taxAmount", new Double(0));
                costDto.put("remark", GeneralConstants.EMPTY_VALUE);

                addAmount = Double.valueOf(costDto.getString("addAmount"));

                this.prepareInsertAudit(costDto, inputDto.getLong("userLoginId"), inputDto.getString("datetime"));
                this.prepareUpdateAudit(costDto, inputDto.getLong("userLoginId"), inputDto.getString("datetime"));

                // current amount di kurangkan hasil add amount
                currentAmount = new Calc(currentAmount).add(addAmount).doubleValue();
            }

            balanceDiscountDto.put("currentAmount", currentAmount);
            balanceDiscountDto.put("status", PurchasingConstants.IN_PROGRESS_TRANSACTION); // status di ubah menjadi I karna sedang di pakai
            inputDto.put("balanceDiscountDto", balanceDiscountDto);
            this.prepareUpdateAudit(balanceDiscountDto, inputDto.getLong("userLoginId"), inputDto.getString("datetime"));
        } else {

            inputDto.put("balanceDiscountDto", null);
        }



        // Get valuta gov
        Dto inputCurrCodeGovDto = new Dto();
        inputCurrCodeGovDto.put("tenantId", inputDto.getLong("tenantLoginId"));
        inputCurrCodeGovDto.put("parameterCode", MasterConstants.PARAMETER_CODE_VALUTA_RESMI);

        Dto outputCurrCodeGovDto = findSystemConfigByParamCode.execute(inputCurrCodeGovDto);
        String currCodeGov = outputCurrCodeGovDto.getString("value");

        if (invoiceItemList != null && !invoiceItemList.isEmpty()) {
            for (Dto invoiceItemDto : invoiceItemList) {
                try {
                    Dto receiveGoodsItemDto = findReceiveGoodsItemById.execute(new Dto().put("id", Long.valueOf(invoiceItemDto.getString("refItemId"))));
                    Dto receiveGoodsDto = findReceiveGoodsById.execute(new Dto().put("id", Long.valueOf(receiveGoodsItemDto.getString("receiveGoodsId"))));

                    // Validasi tanggal Purchase Invoice >= tanggal Receive Goods
                    CommonBusinessValidator.valCompareDate(inputDto.getString("docDate"), receiveGoodsDto.getString("docDate"), CommonBusinessValidator.COMPARE_GREATER_EQUAL, "Purchase Invoice Document Date", "Receive Goods Document Date");
                    CommonBusinessValidator.valCompareDate(inputDto.getString("extDocDate"), receiveGoodsDto.getString("docDate"), CommonBusinessValidator.COMPARE_GREATER_EQUAL, "Supplier Document Date", "Receive Goods Document Date");

                    Dto paramPoBalanceInvoiceDto = new Dto();
                    paramPoBalanceInvoiceDto.put("tenantId", inputDto.getLong("tenantLoginId"));
                    paramPoBalanceInvoiceDto.put("ouId", purchaseOrderDto.getLong("ouId"));
                    paramPoBalanceInvoiceDto.put("poId", purchaseOrderDto.getLong("id"));
                    paramPoBalanceInvoiceDto.put("refDocTypeId", PurchasingConstants.DOCUMENT_RECEIVE_GOODS);
                    paramPoBalanceInvoiceDto.put("refId", receiveGoodsItemDto.getLong("receiveGoodsId"));
                    paramPoBalanceInvoiceDto.put("refItemId", Long.valueOf(invoiceItemDto.getString("refItemId")));
                    Dto poBalanceInvoiceDto = findPurchaseOrderBalanceInvoiceByIndex.execute(paramPoBalanceInvoiceDto);

                    invoiceItemDto.put("tenantId", inputDto.getLong("tenantLoginId"));
                    invoiceItemDto.put("lineNo", Long.valueOf(invoiceItemDto.getString("lineNo")));
                    invoiceItemDto.put("refDocTypeId", PurchasingConstants.DOCUMENT_RECEIVE_GOODS);
                    invoiceItemDto.put("refId", receiveGoodsItemDto.getLong("receiveGoodsId"));
                    invoiceItemDto.put("refItemId", Long.valueOf(invoiceItemDto.getString("refItemId")));
                    invoiceItemDto.put("refItemAmount", poBalanceInvoiceDto.getDouble("itemAmount"));
                    invoiceItemDto.put("remark", GeneralConstants.EMPTY_VALUE);
                    this.prepareInsertAudit(invoiceItemDto, inputDto.getLong("userLoginId"), inputDto.getString("datetime"));
                    this.prepareUpdateAudit(invoiceItemDto, inputDto.getLong("userLoginId"), inputDto.getString("datetime"));

                    calcNettAmount = calcNettAmount.add(invoiceItemDto.getDouble("refItemAmount"));

                    poBalanceInvoiceDto.put("flgInvoice", PurchasingConstants.IN_PROGRESS_TRANSACTION);
                    this.prepareUpdateAudit(poBalanceInvoiceDto, inputDto.getLong("userLoginId"), inputDto.getString("datetime"));

                    Dto paramPoBalanceInvoiceTax = new Dto();
                    paramPoBalanceInvoiceTax.put("tenantId", inputDto.getLong("tenantLoginId"));
                    paramPoBalanceInvoiceTax.put("ouId", purchaseOrderDto.getLong("ouId"));
                    paramPoBalanceInvoiceTax.put("poId", purchaseOrderDto.getLong("id"));
                    paramPoBalanceInvoiceTax.put("refDocTypeId", PurchasingConstants.DOCUMENT_RECEIVE_GOODS);
                    paramPoBalanceInvoiceTax.put("refId", invoiceItemDto.getLong("refId"));
                    paramPoBalanceInvoiceTax.put("refItemId", invoiceItemDto.getLong("refItemId"));
                    Dto poBalanceInvoiceTaxListDto = getPurchaseOrderBalanceInvoiceTaxListByReceiveGoodsItem.execute(paramPoBalanceInvoiceTax);

                    List<Dto> poBalanceInvoiceTaxList = poBalanceInvoiceTaxListDto.getList("purchaseOrderBalanceInvoiceTaxList");


                    log.debug("============================== ini poBalanceInvoiceTaxList " + poBalanceInvoiceTaxList);
                    if (poBalanceInvoiceTaxList != null && !poBalanceInvoiceTaxList.isEmpty()) { // TODO
                        for (Dto poBalanceInvoiceTaxDto : poBalanceInvoiceTaxList) {
                            Dto invoiceTaxDto = new Dto();

//                          invoice tax akan di ambil dari nilai nett amount yang sudah di kurangi diskon, bukan dari per item lagi
//                          By : Sarah

                            if (mapInvoiceTax.containsKey(poBalanceInvoiceTaxDto.get("taxId").toString())) {
                                invoiceTaxDto = (Dto)mapInvoiceTax.get(poBalanceInvoiceTaxDto.get("taxId").toString());

                                invoiceTaxDto.put("baseAmount",
                                        new Calc(invoiceTaxDto.getDouble("baseAmount")).add(poBalanceInvoiceTaxDto.getDouble("baseAmount")).doubleValue());
                                invoiceTaxDto.put("taxAmount",
                                        new Calc(invoiceTaxDto.getDouble("taxAmount")).add(poBalanceInvoiceTaxDto.getDouble("taxAmount")).doubleValue());
                                log.debug("============================== invoiceTaxDto.getDouble(\"taxAmount\") " + invoiceTaxDto.getDouble("taxAmount"));

                            } else {
                                invoiceTaxDto.put("tenantId", inputDto.getLong("tenantLoginId"));
                                invoiceTaxDto.put("taxId", Long.valueOf(poBalanceInvoiceTaxDto.get("taxId").toString()));
                                invoiceTaxDto.put("flgAmount", poBalanceInvoiceTaxDto.get("flgAmount").toString());
                                invoiceTaxDto.put("taxPercentage", Double.valueOf(poBalanceInvoiceTaxDto.get("taxPercentage").toString()));
                                invoiceTaxDto.put("taxCurrCode", currCodeGov); // WTC, 20141115, fix bug, seharusnya diisi dengan valuta resmi
                                invoiceTaxDto.put("taxNo", GeneralConstants.EMPTY_VALUE);
                                invoiceTaxDto.put("taxDate", GeneralConstants.EMPTY_VALUE);
                                invoiceTaxDto.put("govTaxAmount", new Double(0));
                                invoiceTaxDto.put("baseAmount", poBalanceInvoiceTaxDto.getDouble("baseAmount"));
                                invoiceTaxDto.put("advanceAmount", 0d);
                                invoiceTaxDto.put("taxAmount", poBalanceInvoiceTaxDto.getDouble("taxAmount"));
                            }

                            mapInvoiceTax.put(poBalanceInvoiceTaxDto.get("taxId").toString(), invoiceTaxDto);

                            poBalanceInvoiceTaxDto.put("flgInvoice", PurchasingConstants.IN_PROGRESS_TRANSACTION);
                            if (!resultPoBalanceInvoiceTaxList.contains(poBalanceInvoiceTaxDto)) {
                                resultPoBalanceInvoiceTaxList.add(poBalanceInvoiceTaxDto);
                            }
                        }
                    }

                    resultInvoiceItemList.add(invoiceItemDto);
                    resultPoBalanceInvoiceList.add(poBalanceInvoiceDto);
                } catch (CoreException e) {
                    invoiceItemDto.put("errorKey", e.getErrorKey());

                    List<Object> argsList = new ArrayList<Object>();
                    if (e.getParamValues() != null && e.getParamValues().length > 0) {
                        for (Object paramValue : e.getParamValues()) {
                            argsList.add(paramValue);
                        }
                    }
                    invoiceItemDto.put("args", argsList);

                    failList.add(invoiceItemDto);
                }
            }
        }

        // check so balance advance invoice
        Dto outputIsPoBalanceAdvanceInvoiceExistsByPurchaseOrderDto = isPoBalanceAdvanceInvoiceExistsByPurchaseOrder.execute(new Dto()
                .put("poId", inputDto.get("refId")));

        log.debug("outputIsPoBalanceAdvanceInvoiceExistsByPurchaseOrderDto : "+outputIsPoBalanceAdvanceInvoiceExistsByPurchaseOrderDto);

        Dto poBalanceAdvanceInvoiceDto = new Dto();
        boolean isAddInvoiceAdvance = false;
        Dto invoiceAdvanceDto = new Dto();
        Double advanceAmount = 0d;
        if(outputIsPoBalanceAdvanceInvoiceExistsByPurchaseOrderDto.getBoolean("exists")){
            isAddInvoiceAdvance = true;

            poBalanceAdvanceInvoiceDto = outputIsPoBalanceAdvanceInvoiceExistsByPurchaseOrderDto.getDto("poBalanceAdvanceInvoiceDto");
            advanceAmount = poBalanceAdvanceInvoiceDto.getDouble("advanceAmount");
            Long invoiceAdvanceLastLineNo = 1L;

            invoiceAdvanceDto.put("tenantId", inputDto.get("tenantLoginId"));
            invoiceAdvanceDto.put("invoiceId", GeneralConstants.NULL_REF_VALUE_LONG);
            invoiceAdvanceDto.put("lineNo", invoiceAdvanceLastLineNo);
            invoiceAdvanceDto.put("refDocTypeId", poBalanceAdvanceInvoiceDto.get("refDocTypeId"));
            invoiceAdvanceDto.put("refId", poBalanceAdvanceInvoiceDto.get("refId"));
            invoiceAdvanceDto.put("advanceCurrCode", poBalanceAdvanceInvoiceDto.get("advanceCurrCode"));
            invoiceAdvanceDto.put("advanceAmount", advanceAmount);
            invoiceAdvanceDto.put("allocAmount", advanceAmount);
            invoiceAdvanceDto.put("remark", GeneralConstants.EMPTY_VALUE);

            this.prepareInsertAudit(invoiceAdvanceDto, inputDto.getLong("userLoginId"), inputDto.getString("datetime"));
            this.prepareUpdateAudit(invoiceAdvanceDto, inputDto.getLong("userLoginId"), inputDto.getString("datetime"));

            // update SoBalanceAdvanceInvoiceList
            poBalanceAdvanceInvoiceDto.put("flgInvoice", PurchasingConstants.IN_PROGRESS_TRANSACTION);
            poBalanceAdvanceInvoiceDto.put("invoiceId", GeneralConstants.NULL_REF_VALUE_LONG);
            this.prepareUpdateAudit(poBalanceAdvanceInvoiceDto, inputDto.getLong("userLoginId"), inputDto.getString("datetime"));

            // Update ke invoice tax, jika taxId <> -99
            if (!GeneralConstants.NULL_REF_VALUE_LONG.equals(poBalanceAdvanceInvoiceDto.getLong("taxId"))) {
                Dto taxDto = (Dto)mapInvoiceTax.get(poBalanceAdvanceInvoiceDto.getLong("taxId").toString());
                taxDto.put("advanceAmount", new Calc(taxDto.getDouble("advanceAmount")).add(advanceAmount).doubleValue());

                log.debug("tax after add advance amount : "+taxDto);
            }
        }

        calcNettAmount = calcNettAmount.subtract(addAmount); // total item - diskon

        Iterator iter = mapInvoiceTax.entrySet().iterator();
        while (iter.hasNext()) {
            Entry entry = (Entry)iter.next();
            Dto invoiceTaxDto = (Dto)entry.getValue();
//          Double baseAmount = invoiceTaxDto.getDouble("baseAmount");
            Double taxAdvanceAmount = invoiceTaxDto.getDouble("advanceAmount");
            Double taxPercentage = invoiceTaxDto.getDouble("taxPercentage");
            log.debug("taxAdvanceAmount : " + taxAdvanceAmount);

            // karena mapInvoiceTax ini datanya selalu 1, maka dapat di lakukan seperti ini
            // base amount nya langsung di ambil dari total item - diskon, bukan total item lagi.
            invoiceTaxDto.put("baseAmount", calcNettAmount.getValue());
            invoiceTaxDto.put("taxAmount", new Calc(calcNettAmount.subtract(taxAdvanceAmount).getValue())
                                            .multiply(taxPercentage).divide(100, scaleTax, roundingModeTax).doubleValue());
            invoiceTaxDto.put("taxDate", inputDto.getString("docDate"));

            calcTaxAmount = calcTaxAmount.add(invoiceTaxDto.getDouble("taxAmount"));

            if (inputDto.get("currCode").equals(currCodeGov)) {
                // Hans 22 Apr 2016, No need to calculate, since it has the same currency code
                invoiceTaxDto.put("govTaxAmount", invoiceTaxDto.getDouble("taxAmount"));

            } else {

                Dto inputCurrExcRateDto = new Dto();
                inputCurrExcRateDto.put("tenantId", inputDto.get("tenantLoginId"));
                inputCurrExcRateDto.put("date", invoiceTaxDto.get("taxDate"));
                inputCurrExcRateDto.put("currencyCodeFrom", inputDto.get("currCode"));
                inputCurrExcRateDto.put("type", MasterConstants.EXCHANGE_RATE_TYPE_TAX);

                Dto outputCurrExcRateDto = findExchangeRateByDate.execute(inputCurrExcRateDto);

                String amountTo = outputCurrExcRateDto.getString("amountTo");
                String amountFrom = outputCurrExcRateDto.getString("amountFrom");

                // Calculate using exchange rate
                invoiceTaxDto.put("govTaxAmount", calcNettAmount.subtract(taxAdvanceAmount).multiply(Double.valueOf(amountTo))
                .divide(Double.valueOf(amountFrom)).multiply(taxPercentage).divide(100, scaleTax, roundingModeTax).doubleValue());
            }
        }

        if (!failList.isEmpty()) {
            Dto errorParamDto = new Dto();
            DtoUtil.putInErrorParamDto(errorParamDto, "failList",
                    new String[] {"lineNo", "refItemId", "errorKey", "args"}, failList);
            throw new CoreException(PurchasingExceptionConstants.INVOICE_ITEMS_ERROR, errorParamDto);
        }

        inputDto.put("resultCost", gridCostList);
        inputDto.put("grossAmount", calcNettAmount.add(calcTaxAmount).doubleValue()); // ini nettItem(sudah di kurangkan diskon) + tax
        inputDto.put("advanceAmount", advanceAmount);
        inputDto.put("taxAmount", calcTaxAmount.doubleValue());
        inputDto.put("totalAmount", calcNettAmount.subtract(advanceAmount).doubleValue());

        inputDto.put("mapInvoiceTax", mapInvoiceTax);
        inputDto.put("resultInvoiceItemList", resultInvoiceItemList);
        inputDto.put("resultPoBalanceInvoiceList", resultPoBalanceInvoiceList);
        inputDto.put("resultPoBalanceInvoiceTaxList", resultPoBalanceInvoiceTaxList);

        inputDto.put("isAddInvoiceAdvance", isAddInvoiceAdvance);
        inputDto.put("invoiceAdvanceDto", invoiceAdvanceDto);
        inputDto.put("poBalanceAdvanceInvoiceDto", poBalanceAdvanceInvoiceDto);

        log.debug("============================== return inputDto " + inputDto);
        return null;
    }

    @SuppressWarnings({"unchecked", "rawtypes"})
    @Override
    public Dto process(Dto inputDto, Dto originalDto) throws Exception {
        Invoice invoice = GsonUtil.fromDto(inputDto, Invoice.class);
        invoiceDao.persist(invoice);

        List<Dto> resultInvoiceItemList = inputDto.getList("resultInvoiceItemList");
        List<Dto> successListDto = new ArrayList<Dto>();
        for (Dto invoiceItemDto : resultInvoiceItemList) {
            invoiceItemDto.put("invoiceId", invoice.getId());
            InvoiceItem invoiceItem = GsonUtil.fromDto(invoiceItemDto, InvoiceItem.class);
            invoiceItemDao.persist(invoiceItem);

            Dto successDto = new Dto(invoiceItem);
            successListDto.add(successDto);
        }


        Dto mapInvoiceTax = inputDto.getDto("mapInvoiceTax");
        Iterator iter = mapInvoiceTax.entrySet().iterator();
        while (iter.hasNext()) {
            Entry entry = (Entry)iter.next();
            Dto invoiceTaxDto = (Dto)entry.getValue();
            //Hans, 11 Apr 2016 tambah validasi jika tax amount 0 tidak perlu buat invoice taxnya
            if(!invoiceTaxDto.getDouble("taxAmount").equals(new Double(0))){
                invoiceTaxDto.put("invoiceId", invoice.getId());
                InvoiceTax invoiceTax = GsonUtil.fromDto(invoiceTaxDto, InvoiceTax.class);
                invoiceTaxDao.persist(invoiceTax);
            }
        }

        List<Dto> resultPoBalanceInvoiceList = inputDto.getList("resultPoBalanceInvoiceList");
        for (Dto poBalanceInvoiceDto : resultPoBalanceInvoiceList) {
            poBalanceInvoiceDto.put("invoiceId", invoice.getId());
            PurchaseOrderBalanceInvoice poBalanceInvoice = GsonUtil.fromDto(poBalanceInvoiceDto, PurchaseOrderBalanceInvoice.class);
            poBalanceInvoice = purchaseOrderBalanceInvoiceDao.merge(poBalanceInvoiceDto.getLong("id"), poBalanceInvoice);
        }

        List<Dto> resultPoBalanceInvoiceTaxList = inputDto.getList("resultPoBalanceInvoiceTaxList");
        for (Dto poBalanceInvoiceTaxDto : resultPoBalanceInvoiceTaxList) {
            poBalanceInvoiceTaxDto.put("invoiceId", invoice.getId());
            PurchaseOrderBalanceInvoiceTax poBalanceInvoiceTax = GsonUtil.fromDto(poBalanceInvoiceTaxDto, PurchaseOrderBalanceInvoiceTax.class);
            poBalanceInvoiceTax = purchaseOrderBalanceInvoiceTaxDao.merge(poBalanceInvoiceTaxDto.getLong("id"), poBalanceInvoiceTax);
        }

        log.info("inputDto.getBoolean(\"isAddInvoiceAdvance\") : "+inputDto.getBoolean("isAddInvoiceAdvance"));
        if(inputDto.getBoolean("isAddInvoiceAdvance")){
            Dto invoiceAdvanceDto = inputDto.getDto("invoiceAdvanceDto");
            invoiceAdvanceDto.put("invoiceId", invoice.getId());
            InvoiceAdvance invoiceAdvance = GsonUtil.fromDto(invoiceAdvanceDto, InvoiceAdvance.class);
            invoiceAdvanceDao.persist(invoiceAdvance);
            log.debug("inserted invoice advance : "+new Dto(invoiceAdvance));

            // update so balance
            Dto poBalanceAdvanceInvoiceDto = inputDto.getDto("poBalanceAdvanceInvoiceDto");
            poBalanceAdvanceInvoiceDto.put("invoiceId", invoice.getId());
            PoBalanceAdvanceInvoice poBalanceAdvanceInvoice = GsonUtil.fromDto(poBalanceAdvanceInvoiceDto, PoBalanceAdvanceInvoice.class);
            poBalanceAdvanceInvoice = poBalanceAdvanceInvoiceDao.merge(poBalanceAdvanceInvoice.getId(), poBalanceAdvanceInvoice);
            log.debug("poBalanceAdvanceInvoice : "+new Dto(poBalanceAdvanceInvoice));
        }

        // insert invoice cost from Dto
        List<Dto> invoiceCostList = inputDto.getList("resultCost");
        if(invoiceCostList != null){
            for(Dto invoiceCostDto : invoiceCostList){
                invoiceCostDto.put("invoiceId", invoice.getId());
                InvoiceCost invoiceCost = GsonUtil.fromDto(invoiceCostDto, InvoiceCost.class);
                invoiceCostDao.persist(invoiceCost);
            }
        }

        // update current amount hasil akhir nya di kurang add amount dari cost
        Dto balanceDiscountDto = inputDto.getDto("balanceDiscountDto");
        if(balanceDiscountDto != null){
            PoBalanceDiscount poBalanceDiscount = GsonUtil.fromDto(balanceDiscountDto, PoBalanceDiscount.class);
            poBalanceDiscountDao.merge(poBalanceDiscount.getId(), poBalanceDiscount);
        }



        return  new Dto(invoice);
    }
}