AddSalesInvoiceForXcom

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

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.concurrent.TimeUnit;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

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.sls.SalesConstants;
import org.jleaf.erp.sls.SalesConstantsForXcom;
import org.jleaf.erp.sls.SalesExceptionConstants;
import org.jleaf.erp.sls.SalesExceptionConstantsForXcom;
import org.jleaf.erp.sls.dao.SalesInvoiceAdvanceDao;
import org.jleaf.erp.sls.dao.SalesInvoiceCostDao;
import org.jleaf.erp.sls.dao.SalesInvoiceDao;
import org.jleaf.erp.sls.dao.SalesInvoiceItemDao;
import org.jleaf.erp.sls.dao.SalesInvoiceTaxDao;
import org.jleaf.erp.sls.dao.SalesOrderBalanceInvoiceDao;
import org.jleaf.erp.sls.dao.SalesOrderBalanceInvoiceTaxDao;
import org.jleaf.erp.sls.dao.SoBalanceAdvanceInvoiceDao;
import org.jleaf.erp.sls.entity.SalesInvoice;
import org.jleaf.erp.sls.entity.SalesInvoiceAdvance;
import org.jleaf.erp.sls.entity.SalesInvoiceCost;
import org.jleaf.erp.sls.entity.SalesInvoiceItem;
import org.jleaf.erp.sls.entity.SalesInvoiceTax;
import org.jleaf.erp.sls.entity.SalesOrderBalanceInvoice;
import org.jleaf.erp.sls.entity.SalesOrderBalanceInvoiceTax;
import org.jleaf.erp.sls.entity.SoBalanceAdvanceInvoice;
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;

/**
 * AddSalesInvoiceForXcom
 * Hanya boleh ada satu DO dalam Sales Invoice
 * Nomor Sales Invoice berdasarkan DO
 * @author Adrian
 * Nov 30, 2017
 */

//@formatter:off
@Service("addSalesInvoice")
@InfoIn(value = {
        @Info(name = "docNo", description = "Nomor Transaksi", type = String.class),
        @Info(name = "docDate", description = "Tanggal Transaksi", 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 = "sales order id", type = Long.class),
        @Info(name = "invoiceItemList", description = "list of sales invoice item (lineNo, refItemId,doDocNo,doDocDate,productName,qtyDlvSo,soUomName,currCode,itemAmount)", type = List.class),
        @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 = "id", type = Long.class),
        @Info(name = "tenantId", description = "tenant id", type = Long.class),
        @Info(name = "docTypeId", description = "Jenis transaksi", type = Long.class),
        @Info(name = "docNo", description = "No Transaksi", type = String.class),
        @Info(name = "docDate", description = "Tanggal Transaksi", type = String.class),
        @Info(name = "ouId", description = "Organisasi Unit id", type = Long.class),
        @Info(name = "extDocNo", description = "external document no", type = String.class),
        @Info(name = "extDocDate", description = "external document date", type = String.class),
        @Info(name = "refDocTypeId", description = "ref doc type id", type = Long.class),
        @Info(name = "refId", description = "ref id", type = Long.class),
        @Info(name = "remark", description = "remark", type = String.class),
        @Info(name = "partnerId", description = "partner / supplier id", type = Long.class),
        @Info(name = "ouLegalId", description = "ou legal id", type = Long.class),
        @Info(name = "dueDate", description = "due date", type = String.class),
        @Info(name = "salesmanId", description = "salesman id", type = Long.class),
        @Info(name = "currCode", description = "currency code", type = String.class),
        @Info(name = "grossAmount", description = "gross amount", type = Double.class),
        @Info(name = "advanceAmount", description = "advance amount", type = Double.class),
        @Info(name = "taxAmount", description = "tax amount", type = Double.class),
        @Info(name = "addAmount", description = "add amount", type = Double.class),
        @Info(name = "totalAmount", description = "total amount", type = Double.class),
        @Info(name = "discountAmount", description = "discount amount", type = Double.class),
        @Info(name = "statusDoc", description = "status dokumen", type = String.class),
        @Info(name = "workflowStatus", description = "status workflow", type = String.class),
        @Info(name = "version", description = "version", type = Long.class),
        @Info(name = "createDateTime", description = "create date time", type = String.class),
        @Info(name = "createUserId", description = "create user id", type = Long.class),
        @Info(name = "updateDateTime", description = "update date time", type = String.class),
        @Info(name = "updateUserId", description = "update user id", 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,
        SalesExceptionConstants.INVOICE_ALREADY_EXISTS,
        SalesExceptionConstants.SALES_ORDER_ID_NOT_FOUND,
        MasterExceptionConstants.PARTNER_ID_NOT_FOUND,
        MasterExceptionConstants.POLICY_PARTNER_AUTHORIZATION_FAILED,
        SalesExceptionConstants.DELIVERY_ORDER_ITEM_ID_NOT_FOUND,
        SalesExceptionConstants.DELIVERY_ORDER_ID_NOT_FOUND,
        SalesExceptionConstants.SALES_ORDER_BALANCE_INVOICE_NOT_FOUND,
        SalesExceptionConstants.PARTNER_NOT_AUTHORIZED_AS_CUSTOMER
})
//@formatter:on
public class AddSalesInvoiceForXcom extends DefaultBusinessTransaction implements BusinessTransaction {
    private static final Logger log = LoggerFactory
            .getLogger(AddSalesInvoiceForXcom.class);

    @Autowired
    private SalesInvoiceDao salesInvoiceDao;

    @Autowired
    private SalesInvoiceItemDao salesInvoiceItemDao;

    @Autowired
    private SalesInvoiceTaxDao salesInvoiceTaxDao;

    @Autowired
    private SalesOrderBalanceInvoiceTaxDao salesOrderBalanceInvoiceTaxDao;

    @Autowired
    private SalesOrderBalanceInvoiceDao salesOrderBalanceInvoiceDao;

    @Autowired
    SalesInvoiceAdvanceDao salesInvoiceAdvanceDao;

    @Autowired
    SoBalanceAdvanceInvoiceDao soBalanceAdvanceInvoiceDao;

    @Autowired
    SalesInvoiceCostDao salesInvoiceCostDao;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    @SuppressWarnings({ "unchecked"})
    @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"));

        String docDate = inputDto.getString("docDate");

        // Validation tidak boleh kosong / null / tanggal / etc
        ValidationUtil.valBlankOrNull(inputDto.getString("docNo"), "Document No");
        ValidationUtil.valBlankOrNull(docDate, "Document Date");
        ValidationUtil.valDate(docDate, "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 salesOrderDto = findSalesOrderById.execute(new Dto().put("id", inputDto.getLong("refId")));

        Dto partnerDto = findPartnerById.execute(new Dto().put("id", salesOrderDto.getLong("partnerBillToId")));

        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", "Customer");
        valAuthorizedPolicyPartner.execute(paramAuthorizedPolicyPartner);

        // get due date
        String dueDate = docDate;
        Dto custPaymentDto = findCustPaymentByIndex.execute(new Dto()
                .put("tenantId", inputDto.get("tenantLoginId"))
                .put("partnerId", salesOrderDto.get("partnerBillToId")));

        dueDate = DateUtil.addDate(dueDate, TimeUnit.MILLISECONDS.convert(custPaymentDto.getLong("duePaymentDays"), TimeUnit.DAYS));

        inputDto.put("tenantId", inputDto.getLong("tenantLoginId"));
        inputDto.put("docTypeId", SalesConstants.DOCUMENT_SALES_INVOICE);
        inputDto.put("ouId", salesOrderDto.getLong("ouId"));
        inputDto.put("refDocTypeId", SalesConstants.DOCUMENT_SALES_ORDER);
        inputDto.put("partnerId", salesOrderDto.getLong("partnerBillToId"));
        inputDto.put("salesmanId", salesOrderDto.getLong("salesmanId"));
        inputDto.put("currCode", salesOrderDto.getString("currCode"));
        inputDto.put("extDocNo", salesOrderDto.getString("extDocNo"));
        inputDto.put("extDocDate", salesOrderDto.getString("extDocDate"));
//      inputDto.put("dueDate",
//              DateUtil.addDate(docDate, TimeUnit.MILLISECONDS.convert(resultPartnerMustSupplier.getLong("partnerTypeDto.dueDate"), TimeUnit.DAYS)));
        inputDto.put("dueDate", dueDate);
        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", SalesConstants.DRAFT_TRANSACTION);
        inputDto.put("workflowStatus", SalesConstants.WORKFLOW_STATUS_DRAFT);

        // 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");

        // get activity g/l regular disc for invoice cost
        Dto inputRegularDiscDto = new Dto();
        inputRegularDiscDto.put("tenantId", inputDto.getLong("tenantLoginId"));
        inputRegularDiscDto.put("code", SalesConstants.REGULAR_DISC);

        // activity harus terdaftar di master activity
        Dto activityRegularDiscDto = findActivityByIndex.execute(inputRegularDiscDto);
        // Tidak perlu validasi otorisasi terhadap activity GL discount, serta tidak perlu validasi doc type vs act GL discount (WTC, 151209)

        if (GeneralConstants.NO.equals(activityRegularDiscDto.getString("active"))) {
            throw new CoreException(MasterExceptionConstants.DATA_NOT_ACTIVE, "Activity GL of Regular discount");
        }

        // get activity g/l promo disc for invoice cost
        Dto inputPromoDiscDto = new Dto();
        inputPromoDiscDto.put("tenantId", inputDto.getLong("tenantLoginId"));
        inputPromoDiscDto.put("code", SalesConstants.PROMO_DISC);

        // activity harus terdaftar di master activity
        Dto activityPromoDiscDto = findActivityByIndex.execute(inputPromoDiscDto);

        if (GeneralConstants.NO.equals(activityPromoDiscDto.getString("active"))) {
            throw new CoreException(MasterExceptionConstants.DATA_NOT_ACTIVE, "Activity GL of Promo discount");
        }

        Dto paramTax = new Dto();
        paramTax.put("tenantId", inputDto.getLong("tenantLoginId"));
        Dto taxListDto = getTaxListAdvance.execute(paramTax);

        log.info("taxListDto = " + taxListDto);

        List<Dto> taxList = taxListDto.getList("taxList");
        Dto taxDto = taxList.get(0);

        if (GeneralConstants.NO.equals(taxDto.getString("active"))) {
            throw new CoreException(MasterExceptionConstants.DATA_NOT_ACTIVE, "Tax");
        }

        // prepare detail for add item
        List<Dto> invoiceItemList = inputDto.getList("invoiceItemList");
        List<Dto> resultInvoiceItemList = new ArrayList<Dto>();
        List<Dto> resultSoBalanceInvoiceList = new ArrayList<Dto>();
        List<Dto> resultSoBalanceInvoiceTaxList = new ArrayList<Dto>();
//      List<Dto> successList = new ArrayList<Dto>();
        List<Dto> failList = new ArrayList<Dto>();
        Map<String, Dto> mapInvoiceTax = new HashMap<String, Dto>();
        Calc calcTaxAmount = new Calc(0);
        Calc calcNettAmount = new Calc(0);
        Calc totalRegularDiscAmount = new Calc(0);
        Calc totalPromoDiscAmount = new Calc(0);
        String doDocNo = GeneralConstants.EMPTY_VALUE;
        if (invoiceItemList != null && !invoiceItemList.isEmpty()) {
            for (Dto invoiceItemDto : invoiceItemList) {
                try {
                    Dto deliveryOrderItemDto = findDeliveryOrderItemById.execute(new Dto().put("id", Long.valueOf(invoiceItemDto.getString("refItemId"))));
                    Dto deliveryOrderDto = findDeliveryOrderById.execute(new Dto().put("id", deliveryOrderItemDto.getLong("doId")));
                    CommonBusinessValidator.valCompareDate(docDate, deliveryOrderDto.getString("docDate"), CommonBusinessValidator.COMPARE_GREATER_EQUAL,
                            "Document Date", "Delivery Order Date");

                    Long doReceiptItemId = Long.valueOf(invoiceItemDto.getString("doReceiptItemId"));
                    if (!GeneralConstants.NULL_REF_VALUE_LONG.equals(doReceiptItemId)) {
                        Dto deliveryOrderItemReceiptDto = findDeliveryOrderReceiptItemById.execute(new Dto().put("id", doReceiptItemId));
                        Dto deliveryOrderReceiptDto = findDeliveryOrderReceiptById.execute(new Dto().put("id", deliveryOrderItemReceiptDto.getLong("doReceiptId")));
                        CommonBusinessValidator.valCompareDate(docDate, deliveryOrderReceiptDto.getString("docDate"), CommonBusinessValidator.COMPARE_GREATER_EQUAL,
                                "Document Date", "Delivery Order Receipt Date");
                    }


                    Dto paramSoBalanceInvoiceDto = new Dto();
                    paramSoBalanceInvoiceDto.put("tenantId", inputDto.getLong("tenantLoginId"));
                    paramSoBalanceInvoiceDto.put("ouId", salesOrderDto.getLong("ouId"));
                    paramSoBalanceInvoiceDto.put("soId", salesOrderDto.getLong("id"));
                    paramSoBalanceInvoiceDto.put("refDocTypeId", SalesConstants.DOCUMENT_DELIVERY_ORDER);
                    paramSoBalanceInvoiceDto.put("refId", deliveryOrderItemDto.getLong("doId"));
                    paramSoBalanceInvoiceDto.put("refItemId", Long.valueOf(invoiceItemDto.getString("refItemId")));
                    paramSoBalanceInvoiceDto.put("doReceiptItemId", doReceiptItemId);
                    Dto soBalanceInvoiceDto = findSalesOrderBalanceInvoiceByIndex.execute(paramSoBalanceInvoiceDto);

                    // validate flg inv temp
                    if(!GeneralConstants.NO.equals(soBalanceInvoiceDto.get("flgInvoiceTemp"))){
                        throw new CoreException(SalesExceptionConstants.BALANCE_DELIVERY_ORDER_ITEM_ALREADY_USED_IN_OTHER_TRANSACTION, invoiceItemDto.get("doDocNo"), invoiceItemDto.get("doDocDate"), invoiceItemDto.get("productName"));
                    }

                    // validate flg inv
                    if(!GeneralConstants.NO.equals(soBalanceInvoiceDto.get("flgInvoice"))){
                        throw new CoreException(SalesExceptionConstants.BALANCE_DELIVERY_ORDER_ITEM_ALREADY_USED_IN_OTHER_TRANSACTION, invoiceItemDto.get("doDocNo"), invoiceItemDto.get("doDocDate"), invoiceItemDto.get("productName"));
                    }

                    Dto paramValOutstandingDoReceiptItemForInvoicingDto = new Dto();
                    paramValOutstandingDoReceiptItemForInvoicingDto.put("doItemId", deliveryOrderItemDto.getLong("id"));
                    valOutstandingDoReceiptItemForInvoicing.execute(paramValOutstandingDoReceiptItemForInvoicingDto);

                    invoiceItemDto.put("tenantId", inputDto.getLong("tenantLoginId"));
                    invoiceItemDto.put("lineNo", Long.valueOf(invoiceItemDto.getString("lineNo")));
                    invoiceItemDto.put("refDocTypeId", SalesConstants.DOCUMENT_DELIVERY_ORDER);
                    invoiceItemDto.put("refId", deliveryOrderItemDto.getLong("doId"));
                    invoiceItemDto.put("refItemId", Long.valueOf(invoiceItemDto.getString("refItemId")));
                    invoiceItemDto.put("refItemAmount", soBalanceInvoiceDto.getDouble("itemAmount"));
                    invoiceItemDto.put("remark", GeneralConstants.EMPTY_VALUE);
                    invoiceItemDto.put("doReceiptItemId", Long.valueOf(invoiceItemDto.getString("doReceiptItemId")));
                    this.prepareInsertAudit(invoiceItemDto, inputDto.getLong("userLoginId"), inputDto.getString("datetime"));
                    this.prepareUpdateAudit(invoiceItemDto, inputDto.getLong("userLoginId"), inputDto.getString("datetime"));

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

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

                    totalRegularDiscAmount = totalRegularDiscAmount.add(soBalanceInvoiceDto.getDouble("regularDiscAmount"));
                    totalPromoDiscAmount = totalPromoDiscAmount.add(soBalanceInvoiceDto.getDouble("promoDiscAmount"));

                    //Validasi hanya boleh ada satu DO
                    if (!doDocNo.isEmpty() && !doDocNo.equals(invoiceItemDto.getString("doDocNo"))) {
                        throw new CoreException(SalesExceptionConstantsForXcom.ONLY_ONE_DO_IS_ALLOWED_IN_SALES_INVOICE);
                    }

                    doDocNo = invoiceItemDto.getString("doDocNo");

                    Dto paramSoBalanceInvoiceTax = new Dto();
                    paramSoBalanceInvoiceTax.put("tenantId", inputDto.getLong("tenantLoginId"));
                    paramSoBalanceInvoiceTax.put("ouId", salesOrderDto.getLong("ouId"));
                    paramSoBalanceInvoiceTax.put("soId", salesOrderDto.getLong("id"));
                    paramSoBalanceInvoiceTax.put("refDocTypeId", SalesConstants.DOCUMENT_DELIVERY_ORDER);
                    paramSoBalanceInvoiceTax.put("refId", invoiceItemDto.getLong("refId"));
                    paramSoBalanceInvoiceTax.put("refItemId", invoiceItemDto.getLong("refItemId"));
                    paramSoBalanceInvoiceTax.put("doReceiptItemId", invoiceItemDto.getLong("doReceiptItemId"));
                    Dto soBalanceInvoiceTaxListDto = getSalesOrderBalanceInvoiceTaxListByDeliveryOrderItem.execute(paramSoBalanceInvoiceTax);

                    log.info("soBalanceInvoiceTaxListDto = " + soBalanceInvoiceTaxListDto);

                    List<Dto> soBalanceInvoiceTaxList = soBalanceInvoiceTaxListDto.getList("salesOrderBalanceInvoiceTaxList");

                    log.info("soBalanceInvoiceTaxList = " + soBalanceInvoiceTaxList);

                    if (soBalanceInvoiceTaxList != null && !soBalanceInvoiceTaxList.isEmpty()) {
                        for (Dto soBalanceInvoiceTaxDto : soBalanceInvoiceTaxList) {
                            Dto invoiceTaxDto = new Dto();

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

                                invoiceTaxDto.put("baseAmount",
                                        new Calc(invoiceTaxDto.getDouble("baseAmount")).add(soBalanceInvoiceTaxDto.getDouble("baseAmount")).doubleValue());
                                invoiceTaxDto.put("taxAmount", new Calc(invoiceTaxDto.getDouble("taxAmount"))
                                        .add(soBalanceInvoiceTaxDto.getDouble("taxAmount")).doubleValue());
                            } else {
                                invoiceTaxDto.put("tenantId", inputDto.getLong("tenantLoginId"));
                                invoiceTaxDto.put("taxId", Long.valueOf(soBalanceInvoiceTaxDto.get("taxId").toString()));
                                invoiceTaxDto.put("flgAmount", soBalanceInvoiceTaxDto.get("flgAmount").toString());
                                invoiceTaxDto.put("taxPercentage", Double.valueOf(soBalanceInvoiceTaxDto.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", soBalanceInvoiceTaxDto.getDouble("baseAmount"));
                                invoiceTaxDto.put("advanceAmount", new Double(0));
                                invoiceTaxDto.put("taxAmount", soBalanceInvoiceTaxDto.getDouble("taxAmount"));
                                invoiceTaxDto.put("doReceiptItemId", soBalanceInvoiceTaxDto.getLong("doReceiptItemId"));
                                invoiceTaxDto.put("remark", GeneralConstants.EMPTY_VALUE);
                            }

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

                            soBalanceInvoiceTaxDto.put("flgInvoice", SalesConstants.IN_PROGRESS_TRANSACTION);
                            if (!resultSoBalanceInvoiceTaxList.contains(soBalanceInvoiceTaxDto)) {
                                resultSoBalanceInvoiceTaxList.add(soBalanceInvoiceTaxDto);
                            }
                        }
                    }

                    log.info("resultSoBalanceInvoiceTaxList = " + resultSoBalanceInvoiceTaxList);

                    resultInvoiceItemList.add(invoiceItemDto);
                    resultSoBalanceInvoiceList.add(soBalanceInvoiceDto);
                } catch (CoreException e) {
                    Dto errorDto = new Dto();

                    errorDto.put("id", GeneralConstants.NULL_REF_VALUE_LONG);
                    errorDto.put("version", GeneralConstants.NULL_REF_VALUE_LONG);
                    errorDto.put("lineNo", Long.valueOf(invoiceItemDto.getString("lineNo")));
                    errorDto.put("refItemId", Long.valueOf(invoiceItemDto.getString("refItemId")));
                    errorDto.put("doDocNo", invoiceItemDto.getString("doDocNo"));
                    errorDto.put("doDocDate", invoiceItemDto.getString("doDocDate"));
                    errorDto.put("productName", invoiceItemDto.getString("productName"));
                    errorDto.put("qtyDlvSo", Long.valueOf(invoiceItemDto.getString("qtyDlvSo")));
                    errorDto.put("soUomName", invoiceItemDto.getString("soUomName"));
                    errorDto.put("currCode", invoiceItemDto.getString("currCode"));
                    errorDto.put("itemAmount", invoiceItemDto.getString("itemAmount"));
                    errorDto.put("remark", invoiceItemDto.getString("remark"));
                    errorDto.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);
                        }
                    errorDto.put("args", argsList);

                    failList.add(errorDto);
                }
            }
        }

        //Buat doc no Sales Invoice berdasarkan DO
        String[] doDocNoArray = doDocNo.split(SalesConstantsForXcom.DOC_NO_SPLITTER);
        String[] invoiceDocNoArray = inputDto.getString("docNo").split(SalesConstantsForXcom.DOC_NO_SPLITTER);
        String invDocNo = GeneralConstants.EMPTY_VALUE;

        Pattern lettersPattern = Pattern.compile(SalesConstantsForXcom.LETTERS_REGEX);
        Pattern numbersPattern = Pattern.compile(SalesConstantsForXcom.NUMBERS_REGEX);

        for (int i = 0; i < invoiceDocNoArray.length; i++) {
            Matcher lettersMatcher = lettersPattern.matcher(invoiceDocNoArray[i]);
            if (lettersMatcher.find()){
                if (!invDocNo.isEmpty()) {
                    invDocNo = invDocNo.concat(SalesConstantsForXcom.DOC_NO_SPLITTER);
                }
                invDocNo = invDocNo.concat(invoiceDocNoArray[i]);
            }
        }

        for (int i = 0; i < doDocNoArray.length; i++) {
            Matcher numbersMatcher = numbersPattern.matcher(doDocNoArray[i]);
            if (numbersMatcher.find()){
                invDocNo = invDocNo.concat(SalesConstantsForXcom.DOC_NO_SPLITTER).concat(doDocNoArray[i]);
            }
        }

        inputDto.put("docNo", invDocNo);

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

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

        // check so balance advance invoice
        Dto outputIsSoBalanceAdvanceInvoiceExistsBySalesOrderDto = isSoBalanceAdvanceInvoiceExistsBySalesOrder.execute(new Dto()
                .put("soId", inputDto.get("refId")));
        Dto soBalanceAdvanceInvoiceDto = new Dto();
        boolean isAddInvoiceAdvance = false;
        Dto invoiceAdvanceDto = new Dto();
        Double advanceAmount = 0d;
        if(outputIsSoBalanceAdvanceInvoiceExistsBySalesOrderDto.getBoolean("exists")){
            isAddInvoiceAdvance = true;

            soBalanceAdvanceInvoiceDto = outputIsSoBalanceAdvanceInvoiceExistsBySalesOrderDto.getDto("soBalanceAdvanceInvoiceDto");
            advanceAmount = soBalanceAdvanceInvoiceDto.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", soBalanceAdvanceInvoiceDto.get("refDocTypeId"));
            invoiceAdvanceDto.put("refId", soBalanceAdvanceInvoiceDto.get("refId"));
            invoiceAdvanceDto.put("advanceCurrCode", soBalanceAdvanceInvoiceDto.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
            soBalanceAdvanceInvoiceDto.put("flgInvoice", SalesConstants.IN_PROGRESS_TRANSACTION);
            soBalanceAdvanceInvoiceDto.put("invoiceId", GeneralConstants.NULL_REF_VALUE_LONG);
            this.prepareUpdateAudit(soBalanceAdvanceInvoiceDto, inputDto.getLong("userLoginId"), inputDto.getString("datetime"));

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

        for (Entry<String, Dto> entry : mapInvoiceTax.entrySet()) {
            Dto invoiceTaxDto = entry.getValue();
            Double baseAmount = invoiceTaxDto.getDouble("baseAmount");
            Double baseAmountAfterDisc = new Calc(baseAmount).subtract(totalRegularDiscAmount).subtract(totalPromoDiscAmount).doubleValue();
            Double taxAdvanceAmount = invoiceTaxDto.getDouble("advanceAmount");
            Double taxPercentage = invoiceTaxDto.getDouble("taxPercentage");
            invoiceTaxDto.put("taxAmount", new Calc(new Calc(baseAmountAfterDisc).subtract(taxAdvanceAmount).getValue())
                                            .multiply(taxPercentage).divide(100, scaleTax, roundingModeTax).doubleValue());
            calcTaxAmount = calcTaxAmount.add(invoiceTaxDto.getDouble("taxAmount"));

            invoiceTaxDto.put("totalTaxDiscAmount", totalRegularDiscAmount.add(totalPromoDiscAmount)
                    .multiply(taxDto.getDouble("percentage")).divide(100, scaleTax, roundingModeTax).doubleValue());

            // add by: Ping An 30 Juni 2015, set default tanggal faktur ambil dari tanggal dokumen
            // dan gov tax amountnya langsung di simpankan juga = DPP Rupiah * 10% (pembulatan kebawah)
            invoiceTaxDto.put("taxDate", docDate);

            if (inputDto.get("currCode").equals(currCodeGov)) {
                    // 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", new Calc(baseAmountAfterDisc).subtract(taxAdvanceAmount)
                .multiply(Double.valueOf(amountTo))
                .divide(Double.valueOf(amountFrom))
                .multiply(taxPercentage)
                .divide(100, scaleTax, roundingModeTax)
                .doubleValue());
            }

            // end add by: Ping An
        }

        if (!failList.isEmpty()) {
            Dto errorParamDto = new Dto();
            DtoUtil.putInErrorParamDto(errorParamDto, "failList",
                    new String[] {"lineNo","doDocNo","doDocDate","productName","qtyDlvSo","soUomName","currCode","itemAmount", "errorKey", "args" }, failList);
            throw new CoreException(SalesExceptionConstants.SALES_INVOICE_ITEMS_ERROR, errorParamDto);
        }

        Long lineNo = 1L;
        List<Dto> salesInvoiceCostList = new ArrayList<Dto>();
        if (CommonBusinessValidator.compareNumber(totalRegularDiscAmount.toString(), "0",
                CommonBusinessValidator.COMPARE_GREATER, "Total Regular Discount Amount", "Zero")) {
            SalesInvoiceCost salesInvoiceCost = new SalesInvoiceCost();
            salesInvoiceCost.setTenantId(inputDto.getLong("tenantLoginId"));
            salesInvoiceCost.setLineNo(lineNo++);
            salesInvoiceCost.setRefDocTypeId(GeneralConstants.NULL_REF_VALUE_LONG);
            salesInvoiceCost.setRefId(GeneralConstants.NULL_REF_VALUE_LONG);
            salesInvoiceCost.setActivityGlId(activityRegularDiscDto.getLong("id"));
            salesInvoiceCost.setOuRcId(GeneralConstants.NULL_REF_VALUE_LONG);
            salesInvoiceCost.setCurrCode(inputDto.getString("currCode"));
            salesInvoiceCost.setAddAmount(totalRegularDiscAmount.multiply(-1).doubleValue());
            salesInvoiceCost.setTaxId(taxDto.getLong("id"));
            salesInvoiceCost.setTaxPercentage(taxDto.getDouble("percentage"));
            salesInvoiceCost.setTaxAmount(totalRegularDiscAmount.multiply(taxDto.getDouble("percentage"))
                    .divide(100, scaleTax, roundingModeTax).doubleValue());
            salesInvoiceCost.setRemark(GeneralConstants.EMPTY_VALUE);
            salesInvoiceCost.setSegmentId(GeneralConstants.NULL_REF_VALUE_LONG);

            Dto salesInvoiceCostDto = new Dto(salesInvoiceCost);
            this.prepareInsertAudit(salesInvoiceCostDto, inputDto.getLong("userLoginId"), inputDto.getString("datetime"));
            this.prepareUpdateAudit(salesInvoiceCostDto, inputDto.getLong("userLoginId"), inputDto.getString("datetime"));

            salesInvoiceCostList.add(salesInvoiceCostDto);
        }

        if (CommonBusinessValidator.compareNumber(totalPromoDiscAmount.toString(), "0",
                CommonBusinessValidator.COMPARE_GREATER, "Total Promo Discount Amount", "Zero")) {
            SalesInvoiceCost salesInvoiceCost = new SalesInvoiceCost();
            salesInvoiceCost.setTenantId(inputDto.getLong("tenantLoginId"));
            salesInvoiceCost.setLineNo(lineNo);
            salesInvoiceCost.setRefDocTypeId(GeneralConstants.NULL_REF_VALUE_LONG);
            salesInvoiceCost.setRefId(GeneralConstants.NULL_REF_VALUE_LONG);
            salesInvoiceCost.setActivityGlId(activityPromoDiscDto.getLong("id"));
            salesInvoiceCost.setOuRcId(GeneralConstants.NULL_REF_VALUE_LONG);
            salesInvoiceCost.setCurrCode(inputDto.getString("currCode"));
            salesInvoiceCost.setAddAmount(totalPromoDiscAmount.multiply(-1).doubleValue());
            salesInvoiceCost.setTaxId(taxDto.getLong("id"));
            salesInvoiceCost.setTaxPercentage(taxDto.getDouble("percentage"));
            salesInvoiceCost.setTaxAmount(totalPromoDiscAmount.multiply(taxDto.getDouble("percentage"))
                    .divide(100, scaleTax, roundingModeTax).doubleValue());
            salesInvoiceCost.setRemark(GeneralConstants.EMPTY_VALUE);
            salesInvoiceCost.setSegmentId(GeneralConstants.NULL_REF_VALUE_LONG);

            Dto salesInvoiceCostDto = new Dto(salesInvoiceCost);
            this.prepareInsertAudit(salesInvoiceCostDto, inputDto.getLong("userLoginId"), inputDto.getString("datetime"));
            this.prepareUpdateAudit(salesInvoiceCostDto, inputDto.getLong("userLoginId"), inputDto.getString("datetime"));

            salesInvoiceCostList.add(salesInvoiceCostDto);
        }

        inputDto.put("grossAmount", calcNettAmount.subtract(totalRegularDiscAmount).subtract(totalPromoDiscAmount).add(calcTaxAmount).doubleValue());
        inputDto.put("advanceAmount", advanceAmount);
        inputDto.put("taxAmount", calcTaxAmount.doubleValue());
        inputDto.put("totalAmount", calcNettAmount.subtract(advanceAmount).subtract(totalRegularDiscAmount).subtract(totalPromoDiscAmount).doubleValue());
        inputDto.put("refInvTempId", GeneralConstants.NULL_REF_VALUE_LONG);
        inputDto.put("discountAmount", totalRegularDiscAmount.add(totalPromoDiscAmount).doubleValue());

        inputDto.put("mapInvoiceTax", mapInvoiceTax);
        inputDto.put("resultInvoiceItemList", resultInvoiceItemList);
        inputDto.put("resultSoBalanceInvoiceList", resultSoBalanceInvoiceList);
        inputDto.put("resultSoBalanceInvoiceTaxList", resultSoBalanceInvoiceTaxList);

        inputDto.put("isAddInvoiceAdvance", isAddInvoiceAdvance);
        inputDto.put("invoiceAdvanceDto", invoiceAdvanceDto);
        inputDto.put("soBalanceAdvanceInvoiceDto", soBalanceAdvanceInvoiceDto);
        inputDto.put("salesInvoiceCostList", salesInvoiceCostList);

        return null;
    }

    @SuppressWarnings({ "unchecked", "rawtypes" })
    @Override
    public Dto process(Dto inputDto, Dto originalDto) throws Exception {

        SalesInvoice invoice = GsonUtil.fromDto(inputDto, SalesInvoice.class);
        salesInvoiceDao.persist(invoice);

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

        }

        Dto mapInvoiceTax = inputDto.getDto("mapInvoiceTax");
        Iterator iter = mapInvoiceTax.entrySet().iterator();
        while (iter.hasNext()) {
            Entry entry = (Entry) iter.next();
            Dto invoiceTaxDto = (Dto) entry.getValue();
            if(!invoiceTaxDto.getDouble("taxAmount").equals(new Double(0))){
                invoiceTaxDto.put("invoiceId", invoice.getId());
                SalesInvoiceTax invoiceTax = GsonUtil.fromDto(invoiceTaxDto, SalesInvoiceTax.class);
                salesInvoiceTaxDao.persist(invoiceTax);
            }
        }

        List<Dto> resultSoBalanceInvoiceList = inputDto.getList("resultSoBalanceInvoiceList");
        for (Dto soBalanceInvoiceDto : resultSoBalanceInvoiceList) {
            soBalanceInvoiceDto.put("invoiceId", invoice.getId());
            SalesOrderBalanceInvoice soBalanceInvoice = GsonUtil.fromDto(soBalanceInvoiceDto, SalesOrderBalanceInvoice.class);
            soBalanceInvoice = salesOrderBalanceInvoiceDao.merge(soBalanceInvoiceDto.getLong("id"), soBalanceInvoice);
        }

        List<Dto> resultSoBalanceInvoiceTaxList = inputDto.getList("resultSoBalanceInvoiceTaxList");
        for (Dto soBalanceInvoiceTaxDto : resultSoBalanceInvoiceTaxList) {
            soBalanceInvoiceTaxDto.put("invoiceId", invoice.getId());
            SalesOrderBalanceInvoiceTax soBalanceInvoiceTax = GsonUtil.fromDto(soBalanceInvoiceTaxDto, SalesOrderBalanceInvoiceTax.class);
            soBalanceInvoiceTax = salesOrderBalanceInvoiceTaxDao.merge(soBalanceInvoiceTaxDto.getLong("id"), soBalanceInvoiceTax);
        }

        log.info("inputDto.getBoolean(\"isAddInvoiceAdvance\") : "+inputDto.getBoolean("isAddInvoiceAdvance"));
        if(inputDto.getBoolean("isAddInvoiceAdvance")){
            Dto invoiceAdvanceDto = inputDto.getDto("invoiceAdvanceDto");
            invoiceAdvanceDto.put("invoiceId", invoice.getId());
            SalesInvoiceAdvance invoiceAdvance = GsonUtil.fromDto(invoiceAdvanceDto, SalesInvoiceAdvance.class);
            salesInvoiceAdvanceDao.persist(invoiceAdvance);

            // update so balance
            Dto soBalanceAdvanceInvoiceDto = inputDto.getDto("soBalanceAdvanceInvoiceDto");
            soBalanceAdvanceInvoiceDto.put("invoiceId", invoice.getId());
            SoBalanceAdvanceInvoice soBalanceAdvanceInvoice = GsonUtil.fromDto(soBalanceAdvanceInvoiceDto, SoBalanceAdvanceInvoice.class);
            soBalanceAdvanceInvoice = soBalanceAdvanceInvoiceDao.merge(soBalanceAdvanceInvoice.getId(), soBalanceAdvanceInvoice);
        }

        List<Dto> salesInvoiceCostList = inputDto.getList("salesInvoiceCostList");
        if (salesInvoiceCostList != null && !salesInvoiceCostList.isEmpty()) {
            for (Dto salesInvoiceCostDto : salesInvoiceCostList) {
                SalesInvoiceCost salesInvoiceCost = GsonUtil.fromDto(salesInvoiceCostDto, SalesInvoiceCost.class);
                salesInvoiceCost.setInvoiceId(invoice.getId());
                salesInvoiceCostDao.persist(salesInvoiceCost);
            }
        }

        return new Dto(invoice);
    }
}