BT Add DO Receipt

package org.jleaf.erp.inv.bo.doreceipt;

import java.util.ArrayList;
import java.util.List;

import javax.persistence.Query;

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.core.dao.QueryBuilder;
import org.jleaf.erp.inv.InventoryConstants;
import org.jleaf.erp.inv.InventoryExceptionConstants;
import org.jleaf.erp.inv.dao.BalanceDeliveryOrderItemDao;
import org.jleaf.erp.inv.dao.DeliveryOrderReceiptDao;
import org.jleaf.erp.inv.dao.DeliveryOrderReceiptItemDao;
import org.jleaf.erp.inv.dao.DeliveryOrderReceiptProductDao;
import org.jleaf.erp.inv.entity.BalanceDeliveryOrderItem;
import org.jleaf.erp.inv.entity.DeliveryOrderReceipt;
import org.jleaf.erp.inv.entity.DeliveryOrderReceiptItem;
import org.jleaf.erp.inv.entity.DeliveryOrderReceiptProduct;
import org.jleaf.erp.master.MasterExceptionConstants;
import org.jleaf.util.Calc;
import org.jleaf.util.DtoUtil;
import org.jleaf.util.GsonUtil;
import org.jleaf.util.ValidationUtil;
import org.jleaf.validator.CommonBusinessValidator;
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/INVSVC-20
 * @author Fredi, 24 Agustus 2014
 *
 * Validation
 * - val tenant login
 * - val data from same tenant
 * - val
 *
 * Process :
 * - looping trough all do item list'
 * - find every do item in balance do item
 * - check qty return againts balance do item , must be < qty dlv int - balance qty return in every selected item
 * - find if product of do item has serial number,
 * - if not have then
 * -- prepare add to do receipt product with current product balance
 * - if have then
 * -- not need prepare add receipt product
 * - prepare add do receipt item
 * - prepare add do receipt
 * - update balance do item, qty return + = qtyReturn
 * - add do receipt
 * - add do receipt item
 * - add do receipt product if any
 *
 */
//@formatter:off
@Service
@InfoIn(value = {
        @Info(name = "tenantLoginId", description = "Tenant login id", type = Long.class),
        @Info(name = "userLoginId", description = "User login id", type = Long.class),
        @Info(name = "roleLoginId", description = "User login id", type = Long.class),
        @Info(name = "datetime", description = "Datetime", type = String.class),

        @Info(name = "doId", description = "do Id", type = Long.class),
        @Info(name = "warehouseId", description = "Warehouse Id", type = Long.class),
        @Info(name = "docNo", description = "docNo", type = String.class),
        @Info(name = "docDate", description = "doc date", type = String.class),
        @Info(name = "extDocNo", description = "docNo", type = String.class),
        @Info(name = "extDocDate", description = "doc date", type = String.class),
        @Info(name = "remark", description = "Remark", type = String.class),
        @Info(name = "doItemList", description = "List of DO item(doItemId, lineNo, productId, qtyReturn, remark, productStatus)", type = List.class)
})
@InfoOut(value = {
        @Info(name = "id", description = "Id", type = Long.class, required = true),
        @Info(name = "tenantId", description = "Tenant id", type = Long.class, required = true),
        @Info(name = "docTypeId", description = "Doc type id", type = Long.class, required = true),
        @Info(name = "docNo", description = "Doc no", type = String.class, required = true),
        @Info(name = "docDate", description = "Doc date", type = String.class, required = true),
        @Info(name = "ouId", description = "Ou id", type = Long.class, required = true),
        @Info(name = "extDocNo", description = "Ext doc no", type = String.class, required = true),
        @Info(name = "extDocDate", description = "Ext doc date", type = String.class, required = true),
        @Info(name = "refDocTypeId", description = "Ref doc type id", type = Long.class, required = true),
        @Info(name = "refId", description = "Ref id", type = Long.class, required = true),
        @Info(name = "remark", description = "Remark", type = String.class, required = true),
        @Info(name = "warehouseId", description = "Warehouse id", type = Long.class, required = true),
        @Info(name = "statusDoc", description = "Status doc", type = String.class, required = true),
        @Info(name = "workflowStatus", description = "Workflow status", type = String.class, required = true),
        @Info(name = "createUserId", description = "Create user id", type = Long.class, required = true),
        @Info(name = "createDateTime", description = "Create date time", type = String.class, required = true),
        @Info(name = "updateUserId", description = "Update user id", type = Long.class, required = true),
        @Info(name = "updateDateTime", description = "Update date time", type = String.class, required = true),
        @Info(name = "version", description = "Version", type = Long.class, required = true)
})
@ErrorList(errorKeys = {
        CommonExceptionConstants.TENANT_LOGIN_CANT_USED,
        CommonExceptionConstants.DATA_CANT_USE_DIFF_TENANT,
        MasterExceptionConstants.DATA_NOT_ACTIVE
})
//@formatter:on
public class AddDeliveryOrderReceipt extends DefaultBusinessTransaction implements BusinessTransaction {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    @Autowired
    DeliveryOrderReceiptDao deliveryOrderReceiptDao;

    @Autowired
    DeliveryOrderReceiptItemDao deliveryOrderReceiptItemDao;

    @Autowired
    DeliveryOrderReceiptProductDao deliveryOrderReceiptProductDao;

    @Autowired
    BalanceDeliveryOrderItemDao balanceDeliveryOrderItemDao;

    @Override
    public String getDescription() {
        return "Add delivery order receipt";
    }

    @SuppressWarnings("unchecked")
    @Override
    public Dto prepare(Dto inputDto, Dto originalDto) throws Exception {
        ValidationUtil.valDtoContainsKey(inputDto, "tenantLoginId");
        ValidationUtil.valDtoContainsKey(inputDto, "userLoginId");
        ValidationUtil.valDtoContainsKey(inputDto, "roleLoginId");
        ValidationUtil.valDtoContainsKey(inputDto, "datetime");

        Long tenantLoginId = inputDto.getLong("tenantLoginId");
        Long userLoginId = inputDto.getLong("userLoginId");
        Long roleLoginId = inputDto.getLong("roleLoginId");
        String datetime = inputDto.getString("datetime");

        // - validation: tenant login can use
        Dto inputDtoForValTenantLoginCanUse = new Dto();
        inputDtoForValTenantLoginCanUse.put("tenantLoginId", tenantLoginId);
        inputDtoForValTenantLoginCanUse.put("userLoginId", userLoginId);
        inputDtoForValTenantLoginCanUse.put("roleLoginId", roleLoginId);
        valTenantLoginCanUse.execute(inputDto);

        ValidationUtil.valDtoContainsKey(inputDto, "doId");
//      ValidationUtil.valDtoContainsKey(inputDto, "ouId");
        ValidationUtil.valDtoContainsKey(inputDto, "warehouseId");
        ValidationUtil.valDtoContainsKey(inputDto, "docNo");
        ValidationUtil.valDtoContainsKey(inputDto, "docDate");
        ValidationUtil.valDtoContainsKey(inputDto, "extDocNo");
        ValidationUtil.valDtoContainsKey(inputDto, "extDocDate");
        ValidationUtil.valDtoContainsKey(inputDto, "remark");
        ValidationUtil.valDtoContainsKey(inputDto, "doItemList");

        Long doId = inputDto.getLong("doId");
        Long warehouseId = inputDto.getLong("warehouseId");
        String docNo = inputDto.getString("docNo");
        String docDate = inputDto.getString("docDate");
        String extDocNo = inputDto.getString("extDocNo");
        String extDocDate = inputDto.getString("extDocDate");
        String remark = inputDto.getString("remark");
        List<Dto> doItemList = inputDto.getList("doItemList");

        ValidationUtil.valBlankOrNull(docNo, "Document No");
        ValidationUtil.valBlankOrNull(docDate, "Document Date");
        ValidationUtil.valDate(docDate, "Document Date");

        if(!extDocNo.isEmpty() || !extDocDate.isEmpty()){
            ValidationUtil.valBlankOrNull(extDocNo, "Document External No");
            ValidationUtil.valBlankOrNull(extDocDate, "Document External Date");
            ValidationUtil.valDate(extDocDate, "Document External Date");

            // Validasi docDate harus >= extDocDate
            if (CommonBusinessValidator.compareDate(docDate, extDocDate, CommonBusinessValidator.COMPARE_LESS, "Document Date", "Document External Date")) {
                throw new CoreException(InventoryExceptionConstants.DELIVERY_ORDER_RECEIPT_DOC_DATE_MUST_GREATER_EQUALS_THAN_EXT_DOC_DATE);
            }
        }

        Dto additionalInfoDoDto = findAdditionalInfoDoInBalanceDeliveryOrderItem.execute(new Dto()
                .put("tenantId", tenantLoginId)
                .put("doId", doId));

        Long ouId = additionalInfoDoDto.getLong("ouId");

        // validasi tanggal DO <= tanggal dokumen
        CommonBusinessValidator.valCompareDate(additionalInfoDoDto.getString("docDate"), docDate, CommonBusinessValidator.COMPARE_LESS_EQUAL,
                "DO Date", "Doc Date");

        Dto inputDtoForValAuthorizedPolicyOU = new Dto();
        inputDtoForValAuthorizedPolicyOU.put("userLoginId", userLoginId);
        inputDtoForValAuthorizedPolicyOU.put("roleLoginId", roleLoginId);
        inputDtoForValAuthorizedPolicyOU.put("ouId", ouId);
        inputDtoForValAuthorizedPolicyOU.put("varName", "OU");
        valAuthorizedPolicyOU.execute(inputDtoForValAuthorizedPolicyOU);

        // gudang harus terdaftar dan aktif (pakai findWarehouseById)
        Dto warehouseDto = findWarehouseById.execute(new Dto().put("id", warehouseId));
        if(!warehouseDto.getString("active").equals(GeneralConstants.YES)){
            throw new CoreException(MasterExceptionConstants.DATA_NOT_ACTIVE, "Warehouse");
        }

        // gudang harus termasuk dalam OU yg dipilih (valWarehouseOuExistsByIndex)
        Dto inputDtoForValWarehouseExistsInOu = new Dto();
        inputDtoForValWarehouseExistsInOu.put("warehouseId", warehouseId);
        inputDtoForValWarehouseExistsInOu.put("ouId", ouId);
        valWarehouseExistsInOu.execute(inputDtoForValWarehouseExistsInOu);

        // user dan role login harus berhak untuk warehouse tersebut (valAuthorizedPolicyWarehouse)
        Dto inputDtoForValAuthorizedPolicyWarehouse = new Dto();
        inputDtoForValAuthorizedPolicyWarehouse.put("userLoginId", userLoginId);
        inputDtoForValAuthorizedPolicyWarehouse.put("roleLoginId", roleLoginId);
        inputDtoForValAuthorizedPolicyWarehouse.put("warehouseId", warehouseId);
        inputDtoForValAuthorizedPolicyWarehouse.put("varName", "Warehouse");
        valAuthorizedPolicyWarehouse.execute(inputDtoForValAuthorizedPolicyWarehouse);

        // cek so
        Dto paramSoDto = new Dto();
        paramSoDto.put("tenantId", tenantLoginId);
        paramSoDto.put("ouId", ouId);
        paramSoDto.put("soId", additionalInfoDoDto.getLong("soId"));
        valCanCreateDoReceiptBySalesOrder.execute(paramSoDto);

        // validate per do doc
//      Long lineNo = 0L;
        List<Dto> deliveryOrderReceiptItemList = new ArrayList<Dto>();
        List<Dto> updateBalanceDeliveryOrderItemList = new ArrayList<Dto>();
        List<Dto> failList = new ArrayList<Dto>();
        for (Dto doItemItem : doItemList) {
            try{
                ValidationUtil.valDtoContainsKey(doItemItem, "doItemId");
                ValidationUtil.valDtoContainsKey(doItemItem, "qtyReturn");
                ValidationUtil.valDtoContainsKey(doItemItem, "remark");
                ValidationUtil.valDtoContainsKey(doItemItem, "productId");
                ValidationUtil.valDtoContainsKey(doItemItem, "lineNo");
                ValidationUtil.valBlankOrNull(doItemItem.get("productStatus")==null?null:doItemItem.getString("productStatus"), "Product Status Item");

                Long lineNo = Long.valueOf(doItemItem.get("lineNo").toString());
                Long doItemId = Long.valueOf(doItemItem.get("doItemId").toString());
                Long productId = Long.valueOf(doItemItem.get("productId").toString());
                Double qtyReturn = Double.valueOf(doItemItem.get("qtyReturn").toString());
                String doReceiveItemRemark = doItemItem.getString("remark");
                String productStatus = doItemItem.getString("productStatus");

                Dto balanceDeliveryOrderItemDto = findBalanceDeliveryOrderItemById.execute(new Dto().put("deliveryOrderItemId", doItemId));

                // cek so balance invoice
                Dto paramSoBalanceInvoiceDto = new Dto();
                paramSoBalanceInvoiceDto.put("tenantId", tenantLoginId);
                paramSoBalanceInvoiceDto.put("ouId", ouId);
                paramSoBalanceInvoiceDto.put("soId", balanceDeliveryOrderItemDto.getLong("soId"));
                paramSoBalanceInvoiceDto.put("refDocTypeId", InventoryConstants.DOCUMENT_DELIVERY_ORDER);
                paramSoBalanceInvoiceDto.put("refId", doId);
                paramSoBalanceInvoiceDto.put("refItemId", doItemId);
                paramSoBalanceInvoiceDto.put("doReceiptItemId", GeneralConstants.NULL_REF_VALUE_LONG);
//              Dto soBalanceInvoiceDto = findSalesOrderBalanceInvoiceByIndex.execute(paramSoBalanceInvoiceDto);

                valCanCreateDoReceiptBySalesOrderBalanceInvoice.execute(paramSoBalanceInvoiceDto);

                // cek so balance item
                Dto paramSoBalanceItemDto = new Dto();
                paramSoBalanceItemDto.put("tenantId", tenantLoginId);
                paramSoBalanceItemDto.put("ouId", ouId);
                paramSoBalanceItemDto.put("soItemId", balanceDeliveryOrderItemDto.getLong("soItemId"));
                valCanCreateDoReceiptBySalesOrderBalanceItem.execute(paramSoBalanceItemDto);

                Dto productDto = findProductById.execute(new Dto().put("id", productId));

                valAuthorizedPolicyProduct.execute(new Dto()
                        .put("userLoginId", userLoginId)
                        .put("roleLoginId", roleLoginId)
                        .put("productId", productDto.get("id"))
                        .put("varName", "Product Delivery Order Item"));

                // validate product status
                Dto outputIsProductStatusExistsByIndex = isProductStatusExistsByIndex.execute(new Dto()
                        .put("tenantId", tenantLoginId)
                        .put("productStatusCode", productStatus));

                if(outputIsProductStatusExistsByIndex.getBoolean("exists")){
                    // validate if product status active
                    Dto productStatusDto = outputIsProductStatusExistsByIndex.getDto("productStatusDto");
                    if(!GeneralConstants.YES.equals(productStatusDto.get("active"))){
                        throw new CoreException(InventoryExceptionConstants.DATA_NOT_ACTIVE, "Product Status Item Delivery Order");
                    }
                } else{
                    throw new CoreException(MasterExceptionConstants.PRODUCT_STATUS_NOT_FOUND, tenantLoginId, productStatus);
                }

                // validate qty return <= qtyIntDlv
                CommonBusinessValidator.valCompareNumber(qtyReturn.toString(), balanceDeliveryOrderItemDto.getDouble("qtyIntDlv").toString(), CommonBusinessValidator.COMPARE_LESS_EQUAL,
                        "Quantity Return", "Quantity Delivery");

                // validate qty return > 0
                CommonBusinessValidator.valCompareNumber(qtyReturn.toString(), "0", CommonBusinessValidator.COMPARE_GREATER,
                        "Quantity Return", "0");

                // prepare add product if any
                boolean isDoItemProductHasSerialNumber = true;
                Dto deliveryOrderReceiptProductDto = new Dto();
                Dto outputIsProductHasSerialNumber = isProductHasSerialNumber.execute(new Dto()
                        .put("tenantId", tenantLoginId)
                        .put("productId", productId));
                if(outputIsProductHasSerialNumber.getBoolean("hasSerialNumber")){
                    // do nothing
                } else{
                    isDoItemProductHasSerialNumber = false;

                    // get product for this item
                    Dto outputGetLogProductBalanceStockListForDeliveryOrderReceipt = getLogProductBalanceStockListForDeliveryOrderReceipt.execute(new Dto()
                            .put("doId", doId)
                            .put("productId", productId));

                    // add do receipt product
                    deliveryOrderReceiptProductDto = new Dto();

                    deliveryOrderReceiptProductDto.put("tenantId", tenantLoginId);
                    deliveryOrderReceiptProductDto.put("doReceiptItemId", GeneralConstants.NULL_REF_VALUE_LONG);
                    deliveryOrderReceiptProductDto.put("lineNo", 1L);
                    deliveryOrderReceiptProductDto.put("productId", productId);
                    deliveryOrderReceiptProductDto.put("productBalanceId", outputIsProductHasSerialNumber.get("productBalanceId"));
                    deliveryOrderReceiptProductDto.put("productStatus", productStatus);
                    deliveryOrderReceiptProductDto.put("uomId", productDto.get("baseUomId"));

                    deliveryOrderReceiptProductDto.put("remark", GeneralConstants.EMPTY_VALUE);
                    deliveryOrderReceiptProductDto.put("qtyReturn", qtyReturn);
                    deliveryOrderReceiptProductDto.put("qtyDlv", balanceDeliveryOrderItemDto.getDouble("qtyIntDlv"));
                    this.prepareUpdateAudit(deliveryOrderReceiptProductDto, userLoginId, datetime);
                }

                // prepare add do receipt item
                Dto deliveryOrderReceiptItemDto = new Dto();
                deliveryOrderReceiptItemDto.put("doReceiptId", GeneralConstants.NULL_REF_VALUE_LONG);
                deliveryOrderReceiptItemDto.put("tenantId", tenantLoginId);
                deliveryOrderReceiptItemDto.put("lineNo", lineNo);
                deliveryOrderReceiptItemDto.put("refDocTypeId", InventoryConstants.DOCUMENT_DELIVERY_ORDER);
                deliveryOrderReceiptItemDto.put("refId", doItemId);
                deliveryOrderReceiptItemDto.put("productId", productId);
                deliveryOrderReceiptItemDto.put("qtyDlv", balanceDeliveryOrderItemDto.getDouble("qtyIntDlv"));
                deliveryOrderReceiptItemDto.put("qtyReturn", qtyReturn);
                deliveryOrderReceiptItemDto.put("uomId", balanceDeliveryOrderItemDto.get("baseUomId"));
                deliveryOrderReceiptItemDto.put("remark", doReceiveItemRemark);
                deliveryOrderReceiptItemDto.put("productStatus", productStatus);

                deliveryOrderReceiptItemDto.put("hasSerialNumber", isDoItemProductHasSerialNumber);
                deliveryOrderReceiptItemDto.put("deliveryOrderReceiptProductDto", deliveryOrderReceiptProductDto);

                this.prepareInsertAudit(deliveryOrderReceiptItemDto, userLoginId, datetime);
                this.prepareUpdateAudit(deliveryOrderReceiptItemDto, userLoginId, datetime);

                deliveryOrderReceiptItemList.add(deliveryOrderReceiptItemDto);

                // prepare update balance do item
                balanceDeliveryOrderItemDto.put("statusItem", InventoryConstants.IN_PROGRESS_TRANSACTION);
                this.prepareUpdateAudit(balanceDeliveryOrderItemDto, userLoginId, datetime);

                updateBalanceDeliveryOrderItemList.add(balanceDeliveryOrderItemDto);
            } catch(CoreException ce){
                Dto errorDto = (Dto)doItemItem.clone();
                errorDto.put("errorKey", ce.getErrorKey());

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

                failList.add(errorDto);
            }

        }

        if (!failList.isEmpty()) {
            Dto errorParamDto = new Dto();
            DtoUtil.putInErrorParamDto(errorParamDto, "failList",
                    new String[] {"doItemId", "qtyReturn", "remark", "productStatus", "errorKey", "args"}, failList);
            throw new CoreException(InventoryExceptionConstants.DELIVERY_ORDER_RECEIPT_ITEMS_ERROR, errorParamDto);
        }

        // also update other balance do item
        Dto outputGetBalanceDeliveryOrderItemListByDeliveryOrder = getBalanceDeliveryOrderItemListByDeliveryOrder.execute(new Dto().put("doId", doId));
        List<Dto> balanceDeliveryOrderItemList = outputGetBalanceDeliveryOrderItemListByDeliveryOrder.getList("balanceDeliveryOrderItemList");
        for (Dto balanceDeliveryOrderItemItem : balanceDeliveryOrderItemList) {
            Dto balanceDeliveryOrderItem = findBalanceDeliveryOrderItemById.execute(new Dto().put("deliveryOrderItemId", balanceDeliveryOrderItemItem.get("deliveryOrderItemId")));
            if(isDtoExistsInList(balanceDeliveryOrderItem, updateBalanceDeliveryOrderItemList, "deliveryOrderItemId")){
                // do nothing
            } else{
                // prepare update
                balanceDeliveryOrderItem.put("statusItem", InventoryConstants.IN_PROGRESS_TRANSACTION);
                this.prepareUpdateAudit(balanceDeliveryOrderItem, userLoginId, datetime);
                updateBalanceDeliveryOrderItemList.add(balanceDeliveryOrderItem);
            }
        }

        Dto deliveryOrderReceiptDto = new Dto();
        deliveryOrderReceiptDto.put("tenantId", tenantLoginId);
        deliveryOrderReceiptDto.put("docTypeId", InventoryConstants.DOCUMENT_DELIVERY_ORDER_RECEIPT);
        deliveryOrderReceiptDto.put("docNo", docNo);
        deliveryOrderReceiptDto.put("docDate", additionalInfoDoDto.getString("docDate"));
        deliveryOrderReceiptDto.put("ouId", ouId);
        deliveryOrderReceiptDto.put("extDocNo", extDocNo);
        deliveryOrderReceiptDto.put("extDocDate", extDocDate);
        deliveryOrderReceiptDto.put("refDocTypeId", InventoryConstants.DOCUMENT_DELIVERY_ORDER);
        deliveryOrderReceiptDto.put("refId", doId);
        deliveryOrderReceiptDto.put("remark", remark);
        deliveryOrderReceiptDto.put("warehouseId", warehouseId);
        deliveryOrderReceiptDto.put("statusDoc", InventoryConstants.DRAFT_TRANSACTION);
        deliveryOrderReceiptDto.put("workflowStatus", InventoryConstants.WORKFLOW_STATUS_DRAFT);
        this.prepareInsertAudit(deliveryOrderReceiptDto, userLoginId, datetime);
        this.prepareUpdateAudit(deliveryOrderReceiptDto, userLoginId, datetime);

        inputDto.put("deliveryOrderReceiptDto", deliveryOrderReceiptDto);
        inputDto.put("deliveryOrderReceiptItemList", deliveryOrderReceiptItemList);
        inputDto.put("updateBalanceDeliveryOrderItemList", updateBalanceDeliveryOrderItemList);

        return null;
    }

    @SuppressWarnings("unchecked")
    @Override
    public Dto process(Dto inputDto, Dto originalDto) throws Exception {
        // prepare add do receipt
        Dto deliveryOrderReceiptDto = inputDto.getDto("deliveryOrderReceiptDto");
        DeliveryOrderReceipt deliveryOrderReceipt = GsonUtil.fromDto(deliveryOrderReceiptDto, DeliveryOrderReceipt.class);
        deliveryOrderReceiptDao.persist(deliveryOrderReceipt);

        // prepare add do receipt item
        List<Dto> deliveryOrderReceiptItemList = inputDto.getList("deliveryOrderReceiptItemList");
        for (Dto deliveryOrderReceiptItemDto : deliveryOrderReceiptItemList) {
            deliveryOrderReceiptItemDto.put("doReceiptId", deliveryOrderReceipt.getId());
            DeliveryOrderReceiptItem deliveryOrderReceiptItem = GsonUtil.fromDto(deliveryOrderReceiptItemDto, DeliveryOrderReceiptItem.class);
            deliveryOrderReceiptItemDao.persist(deliveryOrderReceiptItem);

            // cek is product has serial number
            if(!deliveryOrderReceiptItemDto.getBoolean("hasSerialNumber")){
                Dto deliveryOrderReceiptProductDto = deliveryOrderReceiptItemDto.getDto("deliveryOrderReceiptProductDto");
                deliveryOrderReceiptProductDto.put("doReceiptItemId", deliveryOrderReceiptItem.getId());
                DeliveryOrderReceiptProduct deliveryOrderReceiptProduct = GsonUtil.fromDto(deliveryOrderReceiptProductDto, DeliveryOrderReceiptProduct.class);
                deliveryOrderReceiptProductDao.persist(deliveryOrderReceiptProduct);
            }
        }

        // prepare update balance do item
        List<Dto> updateBalanceDeliveryOrderItemList = inputDto.getList("updateBalanceDeliveryOrderItemList");
        for (Dto updateBalanceDeliveryOrderItemDto : updateBalanceDeliveryOrderItemList) {
            BalanceDeliveryOrderItem balanceDeliveryOrderItem = GsonUtil.fromDto(updateBalanceDeliveryOrderItemDto, BalanceDeliveryOrderItem.class);
            balanceDeliveryOrderItemDao.merge(balanceDeliveryOrderItem.getDeliveryOrderItemId(), balanceDeliveryOrderItem);
        }


        // update status sl_so, sl_so_balance_item, sl_so_balance_invoice
        QueryBuilder builder = new QueryBuilder();
        builder.add(" SELECT COALESCE(COUNT(1), 0) FROM sl_update_status_so_for_add_do_receipt(:doId, :userId, :datetime)");

        Query q = deliveryOrderReceiptProductDao.createNativeQuery(builder.toString());
        q.setParameter("doId", inputDto.get("doId"));
        q.setParameter("userId", inputDto.get("userLoginId"));
        q.setParameter("datetime", inputDto.get("datetime"));

        Object obj = q.getSingleResult();

        return new Dto(deliveryOrderReceipt);
    }

    private boolean isDtoExistsInList(Dto dto, List<Dto> dtoList, String key){
        for (Dto item : dtoList) {
            if(item.get(key)!=null){
                if(item.get(key).equals(dto.get(key))){
                    return true;
                }
            }
        }

        return false;
    }
}