AddSalesInvoiceTemp

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

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 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.SalesExceptionConstants;
import org.jleaf.erp.sls.dao.SalesInvoiceTempAdvanceDao;
import org.jleaf.erp.sls.dao.SalesInvoiceTempCostDao;
import org.jleaf.erp.sls.dao.SalesInvoiceTempDao;
import org.jleaf.erp.sls.dao.SalesInvoiceTempItemDao;
import org.jleaf.erp.sls.dao.SalesInvoiceTempTaxDao;
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.SalesInvoiceTemp;
import org.jleaf.erp.sls.entity.SalesInvoiceTempAdvance;
import org.jleaf.erp.sls.entity.SalesInvoiceTempCost;
import org.jleaf.erp.sls.entity.SalesInvoiceTempItem;
import org.jleaf.erp.sls.entity.SalesInvoiceTempTax;
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;

/**
 * @see http://jleaf.org:8181/browse/SLSSVC-85
 * @author Fredi, Aug 11th, 2014
 *
 */
//@formatter:off
@Service
@InfoIn(value = {
        @Info(name = "docNo", description = "Nomor Transaksi", type = String.class),
        @Info(name = "docDate", description = "Tanggal Transaksi", type = String.class),
        @Info(name = "invDocNo", description = "Nomor Transaksi Invoice", type = String.class),
        @Info(name = "invDocDate", description = "Tanggal Transaksi Invoice", 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 = "invoiceTempItemList", description = "list of sales invoice item (lineNo, refItemId,doDocNo,doDocDate,productName,qtyDlvSo,soUomName,currCode,itemAmount,doReceiptItemId)", 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 = "invDocNo", description = "No Transaksi Invoice", type = String.class),
        @Info(name = "invDocDate", description = "Tanggal Transaksi Invoice", 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_TEMPORER_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 AddSalesInvoiceTemp extends DefaultBusinessTransaction implements BusinessTransaction {
    private static final Logger log = LoggerFactory.getLogger(AddSalesInvoiceTemp.class);

    @Autowired
    private SalesInvoiceTempDao salesInvoiceTempDao;

    @Autowired
    private SalesInvoiceTempItemDao salesInvoiceTempItemDao;

    @Autowired
    private SalesInvoiceTempTaxDao salesInvoiceTempTaxDao;

    @Autowired
    private SalesOrderBalanceInvoiceTaxDao salesOrderBalanceInvoiceTaxDao;

    @Autowired
    private SalesOrderBalanceInvoiceDao salesOrderBalanceInvoiceDao;

    @Autowired
    SalesInvoiceTempAdvanceDao invoiceTempAdvanceDao;

    @Autowired
    SoBalanceAdvanceInvoiceDao soBalanceAdvanceInvoiceDao;

    @Autowired
    SalesInvoiceTempCostDao salesInvoiceTempCostDao;

    @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("isSalesInvoiceTempExistsByIndex")
    private BusinessFunction isSalesInvoiceTempExistsByIndex;

    @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("findCustPaymentByIndex")
    BusinessFunction findCustPaymentByIndex;

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

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

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

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

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

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

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

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

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

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

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

    @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");
        String invDocDate = inputDto.getString("invDocDate");
        String invDocNo = inputDto.getString("invDocNo");

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

        ValidationUtil.valBlankOrNull(invDocNo, "Invoice No");
        ValidationUtil.valBlankOrNull(invDocDate, "Invoice Date");
        ValidationUtil.valDate(invDocDate, "Invoice 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")));

        // partner harus supplier
        //      Dto paramPartnerMustCustomer = new Dto();
        //      paramPartnerMustCustomer.put("tenantId", inputDto.getLong("tenantLoginId"));
        //      paramPartnerMustCustomer.put("partnerId", partnerDto.getLong("id"));
        //      paramPartnerMustCustomer.put("groupPartner", MasterConstants.GROUP_PARTNER_CODE_CUSTOMER);
        //      Dto resultPartnerMustCustomer = isPartnerTypeExistsByIndex.execute(paramPartnerMustCustomer);
        //
        //      if (!resultPartnerMustCustomer.getBoolean("exists")) {
        //          throw new CoreException(SalesExceptionConstants.PARTNER_NOT_AUTHORIZED_AS_CUSTOMER, 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", "Customer");
        valAuthorizedPolicyPartner.execute(paramAuthorizedPolicyPartner);

        // validate others activate temp sales invoice for so
        log.debug(">> ValCanAddTempInvoice : ");
        valCanAddTempInvoice.execute(new Dto().put("tenantId", inputDto.getLong("tenantLoginId"))
            .put("ouId", salesOrderDto.getLong("ouId")).put("soId", salesOrderDto.getLong("id")));

        // val inv doc no
        valInvDocNoExistsForAddTempInv.execute(new Dto().put("tenantId", inputDto.getLong("tenantLoginId"))
            .put("ouId", salesOrderDto.getLong("ouId")).put("invDocNo", invDocNo));


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

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

        // Validation data (business key) sales invoice is not exists yet in db (add)
        paramCheckUniqueDto.put("docDate", invDocDate);
        paramCheckUniqueDto.put("docNo", invDocNo);
        resultCheckUniqueDto = isSalesInvoiceExistsByIndex.execute(paramCheckUniqueDto);

        if (resultCheckUniqueDto.getBoolean("exists")) {
            throw new CoreException(SalesExceptionConstants.INVOICE_ALREADY_EXISTS, invDocDate, invDocNo,
                    salesOrderDto.getLong("ouId"));
        }

        // inv date >= doc date
        CommonBusinessValidator.valCompareDate(invDocDate, docDate, CommonBusinessValidator.COMPARE_GREATER_EQUAL,
                "Invoice Document Date", "Document Date");

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

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

        inputDto.put("tenantId", inputDto.getLong("tenantLoginId"));
        inputDto.put("docTypeId", SalesConstants.DOCUMENT_SALES_INVOICE_TEMP);
        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", 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("invoiceTempItemList");
        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);
        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", 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"));

                    // updating flag invoice temporary, not flag invoice
                    // @see http://jleaf.org:8181/browse/SLSSVC-192
                    //                  soBalanceInvoiceDto.put("flgInvoice", SalesConstants.IN_PROGRESS_TRANSACTION);
                    soBalanceInvoiceDto.put("flgInvoiceTemp", 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"));

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

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

                    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, 20141119, 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);
                            }
                        }
                    }

                    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);
                }
            }
        } else {
            throw new CoreException(SalesExceptionConstants.INVOICE_TEMPORER_MUST_HAVE_AT_LEAST_ONE_DETAIL_ITEM);
        }

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

            soBalanceAdvanceInvoiceDto = outputIsSoBalanceAdvanceInvoiceExistsBySalesOrderDto
                    .getDto("soBalanceAdvanceInvoiceDto");
            advanceAmount = soBalanceAdvanceInvoiceDto.getDouble("advanceAmount");
            Long invoiceAdvanceLastLineNo = 1L;

            invoiceTempAdvanceDto.put("tenantId", inputDto.get("tenantLoginId"));
            invoiceTempAdvanceDto.put("invoiceTempId", GeneralConstants.NULL_REF_VALUE_LONG);
            invoiceTempAdvanceDto.put("lineNo", invoiceAdvanceLastLineNo);
            invoiceTempAdvanceDto.put("refDocTypeId", soBalanceAdvanceInvoiceDto.get("refDocTypeId"));
            invoiceTempAdvanceDto.put("refId", soBalanceAdvanceInvoiceDto.get("refId"));
            invoiceTempAdvanceDto.put("advanceCurrCode", soBalanceAdvanceInvoiceDto.get("advanceCurrCode"));
            invoiceTempAdvanceDto.put("advanceAmount", advanceAmount);
            invoiceTempAdvanceDto.put("allocAmount", advanceAmount);
            invoiceTempAdvanceDto.put("remark", GeneralConstants.EMPTY_VALUE);

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

            // update SoBalanceAdvanceInvoiceList
            soBalanceAdvanceInvoiceDto.put("flgInvoiceTemp", 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());

            // modified 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_TEMP_ITEMS_ERROR, errorParamDto);
        }

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

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

            salesInvoiceTempCostList.add(salesInvoiceTempCostDto);
        }

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

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

            salesInvoiceTempCostList.add(salesInvoiceTempCostDto);
        }

        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("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("invoiceTempAdvanceDto", invoiceTempAdvanceDto);
        inputDto.put("soBalanceAdvanceInvoiceDto", soBalanceAdvanceInvoiceDto);
        inputDto.put("salesInvoiceTempCostList", salesInvoiceTempCostList);

        return null;
    }

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

        SalesInvoiceTemp invoice = GsonUtil.fromDto(inputDto, SalesInvoiceTemp.class);
        salesInvoiceTempDao.persist(invoice);

        List<Dto> resultInvoiceItemList = inputDto.getList("resultInvoiceItemList");
        //      List<Dto> successListDto = new ArrayList<Dto>();
        for (Dto invoiceItemDto : resultInvoiceItemList) {
            invoiceItemDto.put("invoiceTempId", invoice.getId());
            SalesInvoiceTempItem invoiceItem = GsonUtil.fromDto(invoiceItemDto, SalesInvoiceTempItem.class);
            salesInvoiceTempItemDao.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("invoiceTempId", invoice.getId());
                    SalesInvoiceTempTax invoiceTax = GsonUtil.fromDto(invoiceTaxDto, SalesInvoiceTempTax.class);
                    salesInvoiceTempTaxDao.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);
        }

        if (inputDto.getBoolean("isAddInvoiceAdvance")) {
            Dto invoiceTempAdvanceDto = inputDto.getDto("invoiceTempAdvanceDto");
            invoiceTempAdvanceDto.put("invoiceTempId", invoice.getId());
            SalesInvoiceTempAdvance invoiceTempAdvance = GsonUtil.fromDto(invoiceTempAdvanceDto, SalesInvoiceTempAdvance.class);
            invoiceTempAdvanceDao.persist(invoiceTempAdvance);

            // 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> salesInvoiceTempCostList = inputDto.getList("salesInvoiceTempCostList");
        if (salesInvoiceTempCostList != null && !salesInvoiceTempCostList.isEmpty()) {
            for (Dto salesInvoiceTempCostDto : salesInvoiceTempCostList) {
                SalesInvoiceTempCost salesInvoiceTempCost = GsonUtil.fromDto(salesInvoiceTempCostDto, SalesInvoiceTempCost.class);
                salesInvoiceTempCost.setInvoiceTempId(invoice.getId());
                salesInvoiceTempCostDao.persist(salesInvoiceTempCost);
            }
        }

        return new Dto(invoice);
    }
}