AddPurchaseOrderForCland

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

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

import javax.persistence.Query;

import org.apache.commons.validator.GenericValidator;
import org.jleaf.common.ComboIdConstants;
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.master.MasterConstants;
import org.jleaf.erp.master.MasterExceptionConstants;
import org.jleaf.erp.master.bo.ComboIdMasterConstants;
import org.jleaf.erp.purch.PurchasingConstants;
import org.jleaf.erp.purch.PurchasingExceptionConstants;
import org.jleaf.erp.purch.dao.PurchaseOrderCodDao;
import org.jleaf.erp.purch.dao.PurchaseOrderDao;
import org.jleaf.erp.purch.dao.PurchaseOrderExtDao;
import org.jleaf.erp.purch.dao.PurchaseOrderItemDao;
import org.jleaf.erp.purch.dao.PurchaseOrderLogisticDao;
import org.jleaf.erp.purch.entity.PurchaseOrder;
import org.jleaf.erp.purch.entity.PurchaseOrderCod;
import org.jleaf.erp.purch.entity.PurchaseOrderExt;
import org.jleaf.erp.purch.entity.PurchaseOrderItem;
import org.jleaf.erp.purch.entity.PurchaseOrderLogistic;
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.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;

/**
 * Add purchase order
 *
 * @author david 13 Sep 2012 modified by fredi <br />
 *         <ul>
 *         <li>add input partnerShipAddressId, partnerShipCpId
 *         purchaseOrderCodList, purchaseOrderItemList</li>
 *         <li>remove validation extDocDate and extDocNo</li>
 *         <li>etc</li>
 *         </ul>
 * @see http://jleaf.org:8181/browse/PURSVC-25
 */
// @formatter:off
@Service("addPurchaseOrder")
@InfoIn(value = {
        @Info(name = "docNo", description = "Nomor 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 = "remark", description = "remark", type = String.class),
        @Info(name = "partnerId", description = "partner / supplier id", type = Long.class),
        @Info(name = "purchaserId", description = "purchase officer id", type = Long.class),
        @Info(name = "warehouseId", description = "received warehouse id", type = Long.class),
        @Info(name = "refDocTypeId", description = "ref doc type id", type = Long.class),
        @Info(name = "refId", description = "ref id", type = Long.class),
        @Info(name = "flgDelivery", description = "flag delivery (pick up or deliver)", type = String.class),
        @Info(name = "currCode", description = "currency code", type = String.class),
        @Info(name = "topCode", description = "term of payment code", type = String.class),
        @Info(name = "flgBuyConsignment", description = "flag buy consignment (yes or no)", type = String.class),
        @Info(name = "purchaseOrderItemList", description = "list of purchase order item (refId, lineNo, productId, productName, flgStock, grossPricePo, flgTaxAmount, taxId, taxName, qtyPo, poUomId, poUomName, qtyInt, activityGlId, activityGlName, ouRcId, ouRcName, segmentId, eta, etaDay, flgIndent, toleranceRcvQty, discountPercentage)", type = List.class),
        @Info(name = "partnerShipAddressId", description = "Partner Ship Address id", type = Long.class),
        @Info(name = "partnerShipCpId", description = "Partner Ship CP id", type = Long.class),
        @Info(name = "purchaseOrderCodList", description = "list of purchase order cod (flgCollection, dueDate, currCode, amount, trxCurrCode, trxAmount, remark)", 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 = "po id", type = Long.class),
        @Info(name = "docNo", description = "Nomor 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 = "remark", description = "remark", type = String.class),
        @Info(name = "partnerId", description = "partner / supplier id", type = Long.class),
        @Info(name = "purchaserId", description = "purchase officer id", type = Long.class),
        @Info(name = "warehouseId", description = "received warehouse id", type = Long.class),
        @Info(name = "flgDelivery", description = "flag delivery (pick up or deliver)", type = String.class),
        @Info(name = "currCode", description = "currency code", type = String.class),
        @Info(name = "topCode", description = "term of payment code", type = String.class),
        @Info(name = "version", description = "version", type = Long.class) })
@ErrorList(errorKeys = { CommonExceptionConstants.TENANT_LOGIN_CANT_USED,
        CommonExceptionConstants.OU_ID_NOT_FOUND,
        CommonExceptionConstants.OUTYPE_ID_NOT_FOUND,
        CommonExceptionConstants.DATA_CANT_USE_DIFF_TENANT,
        CommonExceptionConstants.COMBO_VALUE_NOT_VALID,
        CommonExceptionConstants.DATA_CANT_CHANGE_CAUSE_TENANT,
        MasterExceptionConstants.PURCHASE_OFFICER_ID_NOT_FOUND,
        MasterExceptionConstants.WAREHOUSE_ID_NOT_FOUND,
        MasterExceptionConstants.WAREHOUSE_NOT_BELONG_TO_OU,
        MasterExceptionConstants.PARTNER_ID_NOT_FOUND,
        MasterExceptionConstants.DATA_NOT_ACTIVE,
        MasterExceptionConstants.WAREHOUSE_ID_NOT_FOUND,
        MasterExceptionConstants.ACTIVITY_DOCUMENT_NOT_FOUND,
        MasterExceptionConstants.PRODUCT_ID_NOT_FOUND,
        MasterExceptionConstants.UOM_ID_NOT_FOUND,
        MasterExceptionConstants.GROUP_PRODUCT_ID_NOT_FOUND,
        MasterExceptionConstants.CATEGORY_PRODUCT_ID_NOT_FOUND,
        MasterExceptionConstants.ACTIVITY_ID_NOT_FOUND,
        MasterExceptionConstants.COA_ID_NOT_FOUND,
        MasterExceptionConstants.GROUP_COA_ID_NOT_FOUND,
        MasterExceptionConstants.PRODUCT_NOT_AUTHORIZED_IN_WAREHOUSE,
        PurchasingExceptionConstants.PURCHASE_ORDER_ID_NOT_FOUND,
        PurchasingExceptionConstants.ACTIVITY_GL_PO_ITEM_NOT_COUNT_STOCK,
        PurchasingExceptionConstants.PURCHASE_ORDER_ITEM_PRICE_INCLUDE_TAX,
        PurchasingExceptionConstants.OU_RC_MUST_BE_FILLED,
        PurchasingExceptionConstants.PARTNER_NOT_AUTHORIZED_AS_SUPPLIER,
        PurchasingExceptionConstants.PURCHASE_ORDER_ITEMS_ERROR })
// @formatter:on
public class AddPurchaseOrderForCland extends DefaultBusinessTransaction
        implements BusinessTransaction {

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

    @Autowired
    PurchaseOrderDao purchaseOrderDao;

    @Autowired
    PurchaseOrderExtDao purchaseOrderExtDao;

    @Autowired
    PurchaseOrderItemDao purchaseOrderItemDao;

    @Autowired
    PurchaseOrderLogisticDao purchaseOrderLogisticDao;

    @Autowired
    PurchaseOrderCodDao purchaseOrderCodDao;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    private static List<String> flgCollectionList = new ArrayList<String>() {
        private static final long serialVersionUID = 591510409496989395L;
        {
            add(PurchasingConstants.FLG_COLLECTION_CHANGE);
            add(PurchasingConstants.FLG_COLLECTION_PAYMENT);
        }
    };

    public String getDescription() {
        return "Add purchase order";
    }

    @SuppressWarnings("unchecked")
    @Override
    public Dto prepare(Dto inputDto, Dto originalDto) throws Exception {
        log.info(">>>>>>>>>>>>>>>>>>>>>>>>>>>>> Awas kalo ini aja ga muncul preparenyaaaaaaaaaaaaaaaaa <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");

        log.debug("hasil inputdto : "+inputDto);
        ValidationUtil.valDtoContainsKey(inputDto, "tenantLoginId");
        ValidationUtil.valDtoContainsKey(inputDto, "roleLoginId");
        ValidationUtil.valDtoContainsKey(inputDto, "userLoginId");
        ValidationUtil.valBlankOrNull(inputDto, "datetime");

        String datetime = inputDto.getString("datetime");
        String date = datetime.substring(0, 8);
        String flgBuyConsignment = inputDto.getString("flgBuyConsignment");

        Set<String> tempPoItemList = new HashSet<String>();
        Dto inputDtoForRoundingParameter = new Dto();
        inputDtoForRoundingParameter.put("tenantId",
                inputDto.getLong("tenantLoginId"));
        Dto resultDtoForRoundingParameter = getRoundingParameter
                .execute(inputDtoForRoundingParameter);

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

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

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

        // Validation tidak boleh kosong / null / tanggal / etc
        ValidationUtil.valBlankOrNull(inputDto.getString("docNo"),
                "Document No");
        ValidationUtil.valBlankOrNull(inputDto.getString("docDate"),
                "Document Date");
        // remove validation not blank extDocNo and extDocDate
        // ValidationUtil.valBlankOrNull(inputDto.getString("extDocDate"),
        // "Ext Document Date");
        // ValidationUtil.valBlankOrNull(inputDto.getString("extDocNo"),
        // "Ext Document No");
        ValidationUtil.valDtoContainsKey(inputDto, "extDocDate");
        ValidationUtil.valDtoContainsKey(inputDto, "extDocNo");
        ValidationUtil.valBlankOrNull(inputDto.getString("flgDelivery"),
                "Flag Delivery");
        ValidationUtil.valBlankOrNull(inputDto.getString("currCode"),
                "Currency");
        ValidationUtil.valBlankOrNull(inputDto.getString("topCode"),
                "Term of Payment");
        ValidationUtil.valDate(inputDto.getString("docDate"), "Document Date");
        ValidationUtil.valBlankOrNull("flgKonsinyasiManual", inputDto.getString("flgKonsinyasiManual"));
        // ValidationUtil.valDate(inputDto.getString("extDocDate"),
        // "Ext Document Date");
        ValidationUtil.valDtoContainsKey(inputDto, "partnerShipAddressId");
        ValidationUtil.valDtoContainsKey(inputDto, "partnerShipCpId");
        ValidationUtil.valDtoContainsKey(inputDto, "purchaseOrderCodList");

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

        Long partnerShipAddressId = inputDto.getLong("partnerShipAddressId");
        Long partnerShipCpId = inputDto.getLong("partnerShipCpId");
        Long partnerId = inputDto.getLong("partnerId");
        List<Dto> purchaseOrderCodList = inputDto
                .getList("purchaseOrderCodList");
        String flgDelivery = inputDto.getString("flgDelivery");

        // Validation ou, partner, purchaser, and warehouse must exists and
        // active
        Dto ouDto = findOUById.execute(new Dto().put("id",
                inputDto.getLong("ouId")));
        if (!inputDto.getLong("tenantLoginId")
                .equals(ouDto.getLong("tenantId"))) {
            throw new CoreException(
                    CommonExceptionConstants.DATA_CANT_USE_DIFF_TENANT,
                    "Purchase Order", "OU");
        }

        if (!GeneralConstants.YES.equals(ouDto.getString("active"))) {
            throw new CoreException(MasterExceptionConstants.DATA_NOT_ACTIVE,
                    "OU");
        }

        valOUAsMainBusinessUnit.execute(new Dto().put("id",
                inputDto.getLong("ouId")));

        Dto paramAuthorizedPolicyOU = new Dto();
        paramAuthorizedPolicyOU.put("userLoginId",
                inputDto.getLong("userLoginId"));
        paramAuthorizedPolicyOU.put("roleLoginId",
                inputDto.getLong("roleLoginId"));
        paramAuthorizedPolicyOU.put("ouId", inputDto.getLong("ouId"));
        paramAuthorizedPolicyOU.put("varName", "OU Business Unit");
        valAuthorizedPolicyOU.execute(paramAuthorizedPolicyOU);

        Dto partnerDto = findPartnerById.execute(new Dto().put("id",
                inputDto.getLong("partnerId")));
        if (!inputDto.getLong("tenantLoginId").equals(
                partnerDto.getLong("tenantId"))) {
            throw new CoreException(
                    CommonExceptionConstants.DATA_CANT_USE_DIFF_TENANT,
                    "Purchase Order", "Partner");
        }

        if (!GeneralConstants.YES.equals(partnerDto.getString("active"))) {
            throw new CoreException(MasterExceptionConstants.DATA_NOT_ACTIVE,
                    "Partner");
        }

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

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

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

        Dto purchaserDto = findPurchaseOfficerById.execute(new Dto().put(
                "tenantId", inputDto.getLong("tenantLoginId")).put("id",
                inputDto.getLong("purchaserId")));
        if (!inputDto.getLong("tenantLoginId").equals(
                purchaserDto.getLong("tenantId"))) {
            throw new CoreException(
                    CommonExceptionConstants.DATA_CANT_USE_DIFF_TENANT,
                    "Purchase Order", "Purchaser");
        }

        if (!GeneralConstants.YES.equals(purchaserDto.getString("active"))) {
            throw new CoreException(MasterExceptionConstants.DATA_NOT_ACTIVE,
                    "Purchaser");
        }

        Dto warehouseDto = findWarehouseById.execute(new Dto().put("id",
                inputDto.getLong("warehouseId")));
        if (!inputDto.getLong("tenantLoginId").equals(
                warehouseDto.getLong("tenantId"))) {
            throw new CoreException(
                    CommonExceptionConstants.DATA_CANT_USE_DIFF_TENANT,
                    "Purchase Order", "Warehouse");
        }

        if (!GeneralConstants.YES.equals(warehouseDto.getString("active"))) {
            throw new CoreException(MasterExceptionConstants.DATA_NOT_ACTIVE,
                    "Warehouse");
        }

        Dto paramAuthorizedPolicyWarehouse = new Dto();
        paramAuthorizedPolicyWarehouse.put("userLoginId",
                inputDto.getLong("userLoginId"));
        paramAuthorizedPolicyWarehouse.put("roleLoginId",
                inputDto.getLong("roleLoginId"));
        paramAuthorizedPolicyWarehouse.put("warehouseId",
                warehouseDto.getLong("id"));
        paramAuthorizedPolicyWarehouse.put("varName", "Warehouse");
        valAuthorizedPolicyWarehouse.execute(paramAuthorizedPolicyWarehouse);

        valWarehouseExistsInOu.execute(new Dto().put("warehouseId",
                inputDto.getLong("warehouseId")).put("ouId",
                inputDto.getLong("ouId")));

        // validasi flgDelivery (YES NO), currCode (CURRENCY), topCode (TERM OF
        // PAYMENT), flgKonsinyasiManual (YES NO) harus terdaftar di combo
        Dto paramFlgDeliveryDto = new Dto();
        paramFlgDeliveryDto.put("comboId", ComboIdConstants.COMBO_YES_NO);
        paramFlgDeliveryDto.put("code", inputDto.getString("flgDelivery"));
        paramFlgDeliveryDto.put("varName", "Flag Delivery");
        valComboValueByCode.execute(paramFlgDeliveryDto);

        Dto paramFlgKonsinyasiDto = new Dto();
        paramFlgKonsinyasiDto.put("comboId", ComboIdConstants.COMBO_YES_NO);
        paramFlgKonsinyasiDto.put("code", flgKonsinyasiManual);
        paramFlgKonsinyasiDto.put("varName", "Flag Konsinyasi");
        valComboValueByCode.execute(paramFlgKonsinyasiDto);

        Dto paramCurrencyDto = new Dto();
        paramCurrencyDto.put("comboId", ComboIdMasterConstants.COMBO_CURRENCY);
        paramCurrencyDto.put("code", inputDto.getString("currCode"));
        paramCurrencyDto.put("varName", "Currency");
        valComboValueByCode.execute(paramCurrencyDto);

        Dto paramTopDto = new Dto();
        paramTopDto
                .put("comboId", ComboIdMasterConstants.COMBO_TERM_OF_PAYMENT);
        paramTopDto.put("code", inputDto.getString("topCode"));
        paramTopDto.put("varName", "Term of Payment");
        valComboValueByCode.execute(paramTopDto);

        // cek validasi tanggal dokumen harus >= tanggal dokumen supplier
        if (inputDto.get("extDocDate") == null
                || inputDto.getString("extDocDate").trim().isEmpty())
            inputDto.put("extDocDate", GeneralConstants.EMPTY_VALUE);
        else
            CommonBusinessValidator.valCompareDate(inputDto, "docDate",
                    "extDocDate",
                    CommonBusinessValidator.COMPARE_GREATER_EQUAL, "PO Date",
                    "Supplier Doc Date");

        // cek validasi tanggal dokumen harus >= tanggal referensi SO
        if (!inputDto.getLong("refId").equals(
                GeneralConstants.NULL_REF_VALUE_LONG)) {
            Dto resultFindSoByIdDto = findSalesOrderByIdForRefPo
                    .execute(new Dto().put("id", inputDto.getLong("refId")));

            CommonBusinessValidator.valCompareDate(
                    inputDto.getString("docDate"),
                    resultFindSoByIdDto.getString("docDate"),
                    CommonBusinessValidator.COMPARE_GREATER_EQUAL, "PO Date",
                    "Ref. SO Date");
        }

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

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

        // find partnership address and cp if not Delivery
        List<Dto> purchaseOrderLogisticList = new ArrayList<Dto>();
        if (GeneralConstants.NO.equals(flgDelivery)) {
            // partner address and partner cp must be filled
            if (GeneralConstants.NULL_REF_VALUE_LONG
                    .equals(partnerShipAddressId)
                    || GeneralConstants.NULL_REF_VALUE_LONG
                            .equals(partnerShipCpId)) {

                throw new CoreException(
                        PurchasingExceptionConstants.PARTNER_SHIP_ADDRESS_AND_PARTNER_SHIP_CP_MUST_BE_FILLED_ON_NON_DELIVERY_PURCHASING_ORDER);
            }

            Dto partnerShipAddressDto = findPartnerAddressById
                    .execute(new Dto().put("id", partnerShipAddressId));
            Dto partnerShipCpDto = findPartnerCpById.execute(new Dto().put(
                    "id", partnerShipCpId));

            // partner address must be register as shipping and related to
            // partner and active
            if (!GeneralConstants.YES.equals(partnerShipAddressDto
                    .get("active"))) {
                throw new CoreException(
                        PurchasingExceptionConstants.DATA_NOT_ACTIVE,
                        "Partner Ship Address");
            }

            if (!GeneralConstants.YES.equals(partnerShipAddressDto
                    .get("flgShip"))) {
                throw new CoreException(
                        PurchasingExceptionConstants.PARTNER_ADDRESS_NOT_REGISTERED_ASS_SHIPPING_ADDRESS,
                        partnerShipAddressDto.getString("addressDesc"));
            }

            if (!partnerShipAddressDto.get("partnerId").equals(partnerId)) {
                throw new CoreException(
                        PurchasingExceptionConstants.PARTNER_ADDRESS_NOT_RELATED_TO_PARTNER,
                        partnerShipAddressDto.get("addressDesc"), partnerDto
                                .getString("partnerName"));
            }

            // partner cp must register and active
            if (!GeneralConstants.YES.equals(partnerShipCpDto.get("active"))) {
                throw new CoreException(
                        PurchasingExceptionConstants.DATA_NOT_ACTIVE,
                        "Partner Ship CP");
            }

            log.debug("partnerShipCpDto.get(\"partnerId\") : "
                    + partnerShipCpDto.get("partnerId"));
            log.debug("partnerId : " + partnerId);

            if (!partnerShipCpDto.get("partnerId").equals(partnerId)) {
                throw new CoreException(
                        PurchasingExceptionConstants.PARTNER_CP_NOT_RELATED_TO_PARTNER,
                        partnerShipCpDto.get("cpName"), partnerDto
                                .getString("partnerName"));
            }

            // prepare insert to poLogistic
            Dto purchaseOrderLogisticDto = new Dto();
            purchaseOrderLogisticDto.put("tenantId",
                    inputDto.get("tenantLoginId"));
            purchaseOrderLogisticDto.put("poId",
                    GeneralConstants.NULL_REF_VALUE_LONG);
            purchaseOrderLogisticDto.put("partnerAddressId",
                    partnerShipAddressId);
            purchaseOrderLogisticDto.put("partnerCpId", partnerShipCpId);
            purchaseOrderLogisticDto.put("cpName",
                    partnerShipCpDto.get("cpName"));
            purchaseOrderLogisticDto.put("cpPhone1",
                    partnerShipCpDto.get("phone1"));
            purchaseOrderLogisticDto.put("cpPhone2",
                    partnerShipCpDto.get("phone2"));
            purchaseOrderLogisticDto
                    .put("remark", GeneralConstants.EMPTY_VALUE);

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

            purchaseOrderLogisticList.add(purchaseOrderLogisticDto);
        }

        inputDto.put("tenantId", inputDto.getLong("tenantLoginId"));
        inputDto.put("docTypeId", PurchasingConstants.DOCUMENT_PURCHASE_ORDER);
        // inputDto.put("refDocTypeId", GeneralConstants.NULL_REF_VALUE_LONG);
        // inputDto.put("refId", GeneralConstants.NULL_REF_VALUE_LONG);
        inputDto.put("addDiscountPercentage", new Double(0));
        inputDto.put("addDiscountAmount", new Double(0));
        inputDto.put("statusDoc", PurchasingConstants.DRAFT_TRANSACTION);
        inputDto.put("workflowStatus",
                PurchasingConstants.WORKFLOW_STATUS_DRAFT);

        // prepare detail for add item
        List<Dto> purchaseOrderItemList = inputDto
                .getList("purchaseOrderItemList");
        List<Dto> resultPurchaseOrderItemList = new ArrayList<Dto>();
        List<Dto> failList = new ArrayList<Dto>();
        List<Dto> failListDuplicateProduct = new ArrayList<Dto>();

        Dto paramDigitDecimalCurrency = new Dto();
        paramDigitDecimalCurrency.put("tenantId",
                inputDto.getLong("tenantLoginId"));
        paramDigitDecimalCurrency.put("docTypeId",
                PurchasingConstants.DOCUMENT_PURCHASE_ORDER);
        paramDigitDecimalCurrency.put("currCode",
                inputDto.getString("currCode"));
        Dto resultDigitDecimalCurrency = getDigitDecimalCurrencyByDocType
                .execute(paramDigitDecimalCurrency);

        Integer decimalForRounding = resultDigitDecimalCurrency
                .getInteger("digit");

        for (Dto purchaseOrderItemDto : purchaseOrderItemList) {

            log.info("======================================================== ini jalan loh else nya ========================================================");

            if(flgKonsinyasiManual.equals(GeneralConstants.YES)) {

                log.info(" ini bro masuk validasi flg consigmnet manual product terebut ");

                Dto valProductCanOnlyInOnePoConsignmentManualDto = new Dto();
                valProductCanOnlyInOnePoConsignmentManualDto.put("productId", Long.valueOf(purchaseOrderItemDto.getString("productId")));

                valProductCanOnlyInOnePoConsignmentManual.execute(valProductCanOnlyInOnePoConsignmentManualDto);
            }

            try {
                Calc.rounding(purchaseOrderItemDto, decimalForRounding,
                        roundingModeNonTax, "grossPricePo");

                // Copy process date and userId
                this.prepareInsertAudit(purchaseOrderItemDto,
                        inputDto.getLong("userLoginId"),
                        inputDto.getString("datetime"));
                this.prepareUpdateAudit(purchaseOrderItemDto,
                        inputDto.getLong("userLoginId"),
                        inputDto.getString("datetime"));

                // Validation tidak boleh kosong / null / tanggal / etc
                ValidationUtil.valBlankOrNull(
                        purchaseOrderItemDto.getString("flgStock"),
                        "Flag Stock");
                ValidationUtil.valBlankOrNull(
                        purchaseOrderItemDto.getString("flgTaxAmount"),
                        "Flag Tax Amount");
                ValidationUtil.valDate(purchaseOrderItemDto.getString("eta"),
                        "ETA");

                ValidationUtil
                        .valDtoContainsKey(purchaseOrderItemDto, "etaDay");
                ValidationUtil.valBlankOrNull(
                        purchaseOrderItemDto.get("flgIndent") == null ? null
                                : purchaseOrderItemDto.getString("flgIndent"),
                        "Item flag Indent");
                ValidationUtil.valDtoContainsKey(purchaseOrderItemDto, "refId");

                String etaDay = purchaseOrderItemDto.getString("etaDay");
                String flgIndent = purchaseOrderItemDto.getString("flgIndent");
                Long refId = Long.valueOf(purchaseOrderItemDto
                        .getString("refId"));

                // validate combo etaday and flgIndent
                if (!GenericValidator.isBlankOrNull(etaDay)) {
                    valComboValueByCode
                            .execute(new Dto()
                                    .put("comboId",
                                            ComboIdMasterConstants.COMBO_ETADAY)
                                    .put("code", etaDay)
                                    .put("varName", "ETA day item"));
                }

                valComboValueByCode.execute(new Dto()
                        .put("comboId", ComboIdConstants.COMBO_YES_NO)
                        .put("code", flgIndent).put("varName", "Flag Indent"));

                CommonBusinessValidator.valCompareNumber(
                        purchaseOrderItemDto.getString("qtyPo"), "0",
                        CommonBusinessValidator.COMPARE_GREATER,
                        "Item Qty (in PO UoM)", "0");
                CommonBusinessValidator.valCompareNumber(
                        purchaseOrderItemDto.getString("qtyInt"), "0",
                        CommonBusinessValidator.COMPARE_GREATER,
                        "Item Qty (in Base UoM)", "0");

                // Validation product must exists and active
                Dto productDto = findProductById.execute(new Dto().put("id",
                        Long.valueOf(purchaseOrderItemDto
                                .getString("productId"))));
                if (!inputDto.getLong("tenantLoginId").equals(
                        productDto.getLong("tenantId"))) {
                    throw new CoreException(
                            CommonExceptionConstants.DATA_CANT_USE_DIFF_TENANT,
                            "Purchase Order Item", "Product");
                }

                if (!GeneralConstants.YES
                        .equals(productDto.getString("active"))) {
                    throw new CoreException(
                            MasterExceptionConstants.DATA_NOT_ACTIVE, "Product");
                }

                Dto paramAuthorizedPolicyProduct = new Dto();
                paramAuthorizedPolicyProduct.put("userLoginId",
                        inputDto.getLong("userLoginId"));
                paramAuthorizedPolicyProduct.put("roleLoginId",
                        inputDto.getLong("roleLoginId"));
                paramAuthorizedPolicyProduct.put("productId",
                        productDto.getLong("id"));
                paramAuthorizedPolicyProduct.put("varName", "Product");
                valAuthorizedPolicyProduct
                        .execute(paramAuthorizedPolicyProduct);

                Dto paramValSubCtgrProductAuthorizedInItemWarehouse = new Dto();
                paramValSubCtgrProductAuthorizedInItemWarehouse.put("tenantId",
                        inputDto.getLong("tenantLoginId"));
                paramValSubCtgrProductAuthorizedInItemWarehouse.put(
                        "warehouseId", inputDto.getLong("warehouseId"));
                paramValSubCtgrProductAuthorizedInItemWarehouse.put(
                        "subCtgrProductId",
                        productDto.getLong("subCtgrProductId"));
                Dto resultItemWarehouseDto = isItemWarehouseExistsByIndex
                        .execute(paramValSubCtgrProductAuthorizedInItemWarehouse);

                if (!resultItemWarehouseDto.getBoolean("exists")) {
                    throw new CoreException(
                            MasterExceptionConstants.PRODUCT_NOT_AUTHORIZED_IN_WAREHOUSE,
                            productDto.getLong("id"), inputDto
                                    .getLong("warehouseId"));
                }

                Dto ctgrProductDto = findCtgrProductById.execute(new Dto().put(
                        "id", productDto.getLong("ctgrProductId")));
                Dto groupProductDto = findGroupProductById.execute(new Dto()
                        .put("id", ctgrProductDto.getLong("groupProductId")));

                // come here
                // hans
                // validasi tidak boleh ada product_id yang duplikat dalam po yg
                // sama
                log.info("ini isinya si tempPoItemList >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
                        + tempPoItemList.toString()
                        + "<<<<<<<<<<<<<<"
                        + "<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<");
                log.info("ini dianya si product id >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>"
                        + purchaseOrderItemDto.getString("productId"));
                if (tempPoItemList.contains(purchaseOrderItemDto
                        .getString("productId"))) {
                    log.info("======================================================== ini jalan loh if nya ========================================================");
                    throw new CoreException(
                            PurchasingExceptionConstants.PRODUCT_IS_ALREADY_EXIST_IN_CURRENT_PURCHASE_ORDER,
                            purchaseOrderItemDto.getString("productName"));
                }

                tempPoItemList.add(purchaseOrderItemDto.getString("productId"));

                // KoAli
                // Added by Ali, untuk PO Konsinyasi, tidak boleh ada produk
                // yang sama di PO lain
                // Hanya validasi untuk PO konsinyasi
                if (flgBuyConsignment.equals(GeneralConstants.YES)) {
                    valNoProductConsignmentItemDuplicate.execute(
                            new Dto()
                            .put("currentPoId", GeneralConstants.NULL_REF_VALUE_LONG)
                            .put("productId", Long.valueOf(purchaseOrderItemDto.getString("productId"))));
                }

                // if PO from sales check qtyPo <= qtySo item
                if (!GeneralConstants.NULL_REF_VALUE_LONG.equals(inputDto
                        .get("refId"))) {
                    // if from so flgStock = Y, activityGlId = -99, ouRcId =
                    // -99
                    // segmentId = -99
                    purchaseOrderItemDto.put("flgStock", GeneralConstants.YES);
                    purchaseOrderItemDto.put("activityGlId",
                            GeneralConstants.NULL_REF_VALUE_LONG.toString());
                    purchaseOrderItemDto.put("ouRcId",
                            GeneralConstants.NULL_REF_VALUE_LONG.toString());
                    purchaseOrderItemDto.put("segmentId",
                            GeneralConstants.NULL_REF_VALUE_LONG.toString());
                }

                // validasi flgStock harus terdaftar di combo yes no, jika
                // diisi No, harus isi activity gl id
                Dto paramFlagStockDto = new Dto();
                paramFlagStockDto.put("comboId", ComboIdConstants.COMBO_YES_NO);
                paramFlagStockDto.put("code",
                        purchaseOrderItemDto.getString("flgStock"));
                paramFlagStockDto.put("varName", "Flag Stock");
                valComboValueByCode.execute(paramFlagStockDto);

                if (GeneralConstants.NO.equals(purchaseOrderItemDto
                        .getString("flgStock"))) {
                    if (GeneralConstants.NULL_REF_VALUE_LONG.equals(Long
                            .valueOf(purchaseOrderItemDto
                                    .getString("activityGlId")))) {
                        throw new CoreException(
                                PurchasingExceptionConstants.ACTIVITY_GL_PO_ITEM_NOT_COUNT_STOCK);
                    } else {
                        // activity harus terdaftar di master activity
                        Dto activityDto = findActivityById.execute(new Dto()
                                .put("id", Long.valueOf(purchaseOrderItemDto
                                        .getString("activityGlId"))));

                        // activity harus terdaftar di master activity
                        // document dengan jenis trx purchase order dan
                        // aktif
                        Dto paramActivityDocumentDto = new Dto();
                        paramActivityDocumentDto.put("documentTypeId",
                                PurchasingConstants.DOCUMENT_PURCHASE_ORDER);
                        paramActivityDocumentDto.put("activityId", Long
                                .valueOf(purchaseOrderItemDto
                                        .getString("activityGlId")));
                        Dto resultActivityDocumentDto = findActivityDocumentById
                                .execute(paramActivityDocumentDto);

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

                        Dto paramAuthorizedPolicyActivity = new Dto();
                        paramAuthorizedPolicyActivity.put("userLoginId",
                                inputDto.getLong("userLoginId"));
                        paramAuthorizedPolicyActivity.put("roleLoginId",
                                inputDto.getLong("roleLoginId"));
                        paramAuthorizedPolicyActivity.put("activityId", Long
                                .valueOf(purchaseOrderItemDto
                                        .getString("activityGlId")));
                        paramAuthorizedPolicyActivity
                                .put("varName", "Activity");
                        valAuthorizedPolicyActivity
                                .execute(paramAuthorizedPolicyActivity);

                        Dto coaDto = findCoaById.execute(new Dto().put("id",
                                activityDto.getLong("coaId")));
                        Dto groupCoaDto = findGroupCoaById.execute(new Dto()
                                .put("id", coaDto.getLong("groupCoaId")));

                        // validasi harus memilih ou rc, ou rc harus
                        // terdaftar sebagai sub accounting di ou dan aktif
                        if (GeneralConstants.YES.equals(groupCoaDto
                                .getString("flagSubRc"))) {
                            if (!GeneralConstants.NULL_REF_VALUE_LONG
                                    .equals(inputDto.getLong("ouRcId"))) {
                                Dto ouRcDto = findOUById.execute(new Dto().put(
                                        "id", Long.valueOf(purchaseOrderItemDto
                                                .getString("ouRcId"))));

                                if (!inputDto.getLong("tenantLoginId").equals(
                                        ouRcDto.getLong("tenantId"))) {
                                    throw new CoreException(
                                            CommonExceptionConstants.DATA_CANT_USE_DIFF_TENANT,
                                            "Purchase Order Item", "OU RC");
                                }

                                if (!GeneralConstants.YES.equals(ouRcDto
                                        .getString("active"))) {
                                    throw new CoreException(
                                            MasterExceptionConstants.DATA_NOT_ACTIVE,
                                            "OU RC");
                                }

                                // ou yang dipilih harus merupakan ou RC
                                // (accounting flag = YES)
                                valOUAsSubAccounting.execute(new Dto().put(
                                        "id", ouRcDto.getLong("id")));
                            } else {
                                throw new CoreException(
                                        PurchasingExceptionConstants.OU_RC_MUST_BE_FILLED);
                            }
                        }

                        // validasi segment coa
                        if (GeneralConstants.YES.equals(groupCoaDto
                                .getString("flagSubSegment"))) {
                            if (!GeneralConstants.NULL_REF_VALUE_LONG
                                    .equals(inputDto.getLong("segmentId"))) {
                                Dto segmentCoaDto = findSegmentCoaById
                                        .execute(new Dto().put(
                                                "id",
                                                Long.valueOf(purchaseOrderItemDto
                                                        .getString("segmentId"))));

                                if (!inputDto.getLong("tenantLoginId").equals(
                                        segmentCoaDto.getLong("tenantId"))) {
                                    throw new CoreException(
                                            CommonExceptionConstants.DATA_CANT_USE_DIFF_TENANT,
                                            "Purchase Order", "Segment");
                                }

                                if (!GeneralConstants.YES.equals(segmentCoaDto
                                        .getString("active"))) {
                                    throw new CoreException(
                                            MasterExceptionConstants.DATA_NOT_ACTIVE,
                                            "Segment");
                                }
                            } else {
                                throw new CoreException(
                                        PurchasingExceptionConstants.SEGMENT_MUST_BE_FILLED);
                            }
                        }
                    }
                } else {
                    purchaseOrderItemDto.put("activityGlId",
                            GeneralConstants.NULL_REF_VALUE_LONG);
                }

                // validation ou PKP
                Dto outputIsOULegalExistsByIndex = isOULegalExistsByIndex
                        .execute(new Dto().put("ouId", inputDto.get("ouId"))
                                .put("tenantId", inputDto.get("tenantLoginId")));
                if (outputIsOULegalExistsByIndex.getBoolean("exists")) {
                    Dto ouLegalDto = outputIsOULegalExistsByIndex
                            .getDto("ouLegalDto");
                    // if not pkpOu
                    if (GeneralConstants.NO.equals(ouLegalDto.get("flgPkp"))) {
                        log.debug("not pkp ou, unset flgTaxAmount and taxId");
                        purchaseOrderItemDto.put("flgTaxAmount",
                                GeneralConstants.NO);
                        purchaseOrderItemDto.put("taxId",
                                GeneralConstants.NULL_REF_VALUE_LONG);
                    }
                } else {
                    // if not pkp Ou
                    log.debug("not pkp ou, unset flgTaxAmount and taxId");
                    purchaseOrderItemDto.put("flgTaxAmount",
                            GeneralConstants.NO);
                    purchaseOrderItemDto.put("taxId",
                            GeneralConstants.NULL_REF_VALUE_LONG);
                }

                // validasi flgTaxAmount harus terdaftar di combo yes no
                Dto paramFlagTaxAmountDto = new Dto();
                paramFlagTaxAmountDto.put("comboId",
                        ComboIdConstants.COMBO_YES_NO);
                paramFlagTaxAmountDto.put("code",
                        purchaseOrderItemDto.getString("flgTaxAmount"));
                paramFlagTaxAmountDto.put("varName", "Flag Tax Amount");
                valComboValueByCode.execute(paramFlagTaxAmountDto);

                // Untuk flag tax amount (flag mempengaruhi pajak) : Y / YES
                // harus memilih tax nya, jika tidak memilih tax maka error
                // tax price po = (gross price po – discount) * 100 / (100 +
                // tax percentage value) * (tax percentage value / 100)
                // rounding ke atas sampai 1 rupiah
                // Nett price po = (gross price po – discount) – tax price
                // Untuk flag tax amount (flag mempengaruhi pajak) : N / NO
                // nett price po = (gross price po – discount)
                // jika memilih tax, maka tax price = (gross price po –
                // discount) * (tax percentage value / 100) rounding ke atas
                // sampai 1 rupiah
                // tidak memilih tax maka tax percentage dan tax price = 0
                // Gross Item Amount = gross price po * qty po
                // Nett item amount = nett price po * qty po
                // Tax Amount = tax price * qty po

                Double grossPricePo = Double.valueOf(purchaseOrderItemDto
                        .getString("grossPricePo"));
                Double qtyPo = Double.valueOf(purchaseOrderItemDto
                        .getString("qtyPo"));
                String flgTaxAmount = purchaseOrderItemDto
                        .getString("flgTaxAmount");
                Long taxId = Long.valueOf(purchaseOrderItemDto
                        .getString("taxId"));

                if (grossPricePo.doubleValue() < 0) {
                    throw new CoreException(
                            PurchasingExceptionConstants.INPUT_MUST_BE_POSITIVE_VALUE,
                            "Gross Price PO");
                }

                Double discountPercentage = Double.valueOf(purchaseOrderItemDto.get("discountPercentage").toString());
                Double discountAmount = new Double(0);
                Double nettPricePo = new Double(0);
                Double taxPrice = new Double(0);
                Double grossItemAmount = new Double(0);
                Double nettItemAmount = new Double(0);
                Double taxAmount = new Double(0);
                Double taxPercentage = new Double(0);

                // hitung discount amount
                discountAmount = new Calc(grossPricePo).multiply(discountPercentage).divide(100).doubleValue();

                Dto paramCalculatePriceDto = new Dto();
                paramCalculatePriceDto.put("grossPrice", grossPricePo);
                paramCalculatePriceDto.put("qty", qtyPo);
                paramCalculatePriceDto.put("flgTaxAmount", flgTaxAmount);
                paramCalculatePriceDto.put("discountPercentage", discountPercentage);
                paramCalculatePriceDto.put("discountAmount", discountAmount);
                paramCalculatePriceDto.put("decimalForRounding", decimalForRounding);
                paramCalculatePriceDto.put("roundingMode", roundingModeNonTax);
                paramCalculatePriceDto.put("taxId", taxId);

                Dto calculatePriceDto = calculateAmountFromGrossPrice
                        .execute(paramCalculatePriceDto);

                grossPricePo = calculatePriceDto.getDouble("grossPrice");
                nettPricePo = calculatePriceDto.getDouble("nettPrice");
                taxPrice = calculatePriceDto.getDouble("taxPrice");
                grossItemAmount = calculatePriceDto.getDouble("grossAmount");
                nettItemAmount = calculatePriceDto.getDouble("nettAmount");
                taxAmount = calculatePriceDto.getDouble("taxAmount");
                discountPercentage = calculatePriceDto.getDouble("discountPercentage");
                discountAmount = calculatePriceDto.getDouble("discountAmount");
                taxPercentage = calculatePriceDto.getDouble("taxPercentage");

                // if
                // (GeneralConstants.YES.equals(purchaseOrderItemDto.getString("flgTaxAmount")))
                // {
                // if
                // (!CommonConstants.ID_NOT_USED.equals(Long.valueOf(purchaseOrderItemDto.getString("taxId"))))
                // {
                // Dto taxDto = findTaxDto(inputDto, purchaseOrderItemDto);
                // // tax_amount = ROUND(nett_item_amount * (tax_percentage
                // / (100 + tax_percentage)))
                // taxPercentage = taxDto.getDouble("percentage");
                // taxPrice = new
                // Calc(nettPricePo).multiply(taxPercentage).divide(100 +
                // taxPercentage, decimalForRounding,
                // BigDecimal.ROUND_DOWN).doubleValue();
                // taxAmount = new
                // Calc(nettItemAmount).multiply(taxPercentage).divide(100 +
                // taxPercentage, decimalForRounding,
                // BigDecimal.ROUND_DOWN).doubleValue();
                //
                // nettPricePo = new
                // Calc(nettPricePo).subtract(taxPrice).doubleValue();
                // nettItemAmount = new
                // Calc(nettItemAmount).subtract(taxAmount).doubleValue();
                // } else {
                // throw new
                // CoreException(PurchasingExceptionConstants.PURCHASE_ORDER_ITEM_PRICE_INCLUDE_TAX);
                // }
                // } else {
                // if
                // (!CommonConstants.ID_NOT_USED.equals(Long.valueOf(purchaseOrderItemDto.getString("taxId"))))
                // {
                // Dto taxDto = findTaxDto(inputDto, purchaseOrderItemDto);
                // // tax_amount = nett_item_amount * tax_percentage / 100
                // taxPercentage = taxDto.getDouble("percentage");
                // taxPrice = new
                // Calc(nettPricePo).multiply(taxPercentage).divide(100,
                // decimalForRounding, BigDecimal.ROUND_DOWN).doubleValue();
                // taxAmount = new
                // Calc(nettItemAmount).multiply(taxPercentage).divide(100,
                // decimalForRounding, BigDecimal.ROUND_DOWN).doubleValue();
                // }
                // }

                // PO Uom must exists
                Dto poUomDto = findUomById
                        .execute(new Dto().put("id", Long
                                .valueOf(purchaseOrderItemDto
                                        .getString("poUomId"))));

                if (!inputDto.getLong("tenantLoginId").equals(
                        poUomDto.getLong("tenantId"))) {
                    throw new CoreException(
                            CommonExceptionConstants.DATA_CANT_USE_DIFF_TENANT,
                            "Purchase Order Item", "PO Uom");
                }

                if (!GeneralConstants.YES.equals(poUomDto.getString("active"))) {
                    throw new CoreException(
                            MasterExceptionConstants.DATA_NOT_ACTIVE, "PO Uom");
                }

                // if PO from sales check qtyPo <= qtySo item
                if (!GeneralConstants.NULL_REF_VALUE_LONG.equals(inputDto
                        .get("refId"))) {
                    Dto soItemDto = findSalesOrderItemByIdForPo
                            .execute(new Dto().put("soItemId", refId));
                    purchaseOrderItemDto.put("lineNo", soItemDto.get("lineNo")
                            .toString());

                    log.debug("soItemDto : " + soItemDto);
                    if (!soItemDto
                            .get("productId")
                            .toString()
                            .equals(purchaseOrderItemDto.get("productId")
                                    .toString())) {
                        throw new CoreException(
                                PurchasingExceptionConstants.PURCHASE_ORDER_ITEM_NOT_FROM_REFERENCE_SALES_ORDER_ITEM,
                                purchaseOrderItemDto.get("productId"));
                    }
                    //
                    // log.debug("purchaseOrderItemDto.getString(\"qtyInt\") : "+purchaseOrderItemDto.getString("qtyInt"));
                    // log.debug("soItemDto.get(\"qtyInt\").toString() : "+soItemDto.get("qtyInt").toString());
                    //
                    // CommonBusinessValidator.valCompareNumber(purchaseOrderItemDto.getString("qtyInt"),
                    // soItemDto.get("qtyInt").toString(),
                    // CommonBusinessValidator.COMPARE_LESS_EQUAL,
                    // "Item Qty PO Internal", "Item Qty SO Internal");

                    Dto soPoBalanceItemDto = findSoPoBalanceItemByIdForPo
                            .execute(new Dto().put("soItemId", refId));

                    // validate status item
                    if (!PurchasingConstants.RELEASED_TRANSACTION
                            .equals(soPoBalanceItemDto.get("statusItem"))) {
                        throw new CoreException(
                                PurchasingExceptionConstants.SALES_ORDER_ITEM_HAS_BEEN_USED_BY_OTHER_TRANSACTION,
                                soItemDto.get("lineNo"));
                    }

                    Double qtyInt = Double.valueOf(purchaseOrderItemDto.get(
                            "qtyPo").toString());

                    if (!Long.valueOf(
                            purchaseOrderItemDto.get("poUomId").toString())
                            .equals(productDto.getLong("baseUomId"))) {
                        qtyInt = Double.valueOf(purchaseOrderItemDto.get(
                                "qtyInt").toString());
                    }

                    CommonBusinessValidator.valCompareNumber(qtyInt.toString(),
                            soPoBalanceItemDto.getDouble("qtyOsPo").toString(),
                            CommonBusinessValidator.COMPARE_LESS_EQUAL,
                            "Item Qty PO Internal", "Balance Qty PO Internal");

                }

                /*************************************************************************************************/
                // validasi setiap item product punya supplier harus cocok
                // dengan supplier dari PO
                if (inputDto.get("flgBuyConsignment").equals(
                        GeneralConstants.YES)) {
                    Query query = purchaseOrderExtDao
                            .createNativeQuery("SELECT COUNT(*) FROM m_product_consignment_supp_info e WHERE e.product_id = :productId AND e.supplier_id = :partnerId");

                    query.setParameter("productId", Long
                            .valueOf(purchaseOrderItemDto
                                    .getString("productId")));
                    query.setParameter("partnerId",
                            Long.valueOf(inputDto.getString("partnerId")));

                    Long count = Long.valueOf(query.getSingleResult()
                            .toString());

                    if (count == 0) {
                        throw new CoreException(
                                PurchasingExceptionConstants.PRODUCT_NOT_FROM_SUPPLIER,
                                inputDto.getString("productId"), inputDto
                                        .getString("partnerId"));
                    }
                }

                /*************************************************************************************************/

                purchaseOrderItemDto.put("tenantId",
                        inputDto.getLong("tenantLoginId"));
                purchaseOrderItemDto.put("lineNo",
                        Long.valueOf(purchaseOrderItemDto.getString("lineNo")));
                purchaseOrderItemDto.put("refDocTypeId",
                        PurchasingConstants.DOCUMENT_SALES_ORDER);
                purchaseOrderItemDto.put("refId", refId);
                purchaseOrderItemDto.put("warehouseId",
                        inputDto.getString("warehouseId"));
                purchaseOrderItemDto.put("productId", Long
                        .valueOf(purchaseOrderItemDto.getString("productId")));
                purchaseOrderItemDto.put("flgStock",
                        purchaseOrderItemDto.getString("flgStock"));
                purchaseOrderItemDto.put("currCode",
                        inputDto.getString("currCode"));
                purchaseOrderItemDto.put("flgTaxAmount",
                        purchaseOrderItemDto.getString("flgTaxAmount"));
                purchaseOrderItemDto.put("taxId",
                        Long.valueOf(purchaseOrderItemDto.getString("taxId")));
                purchaseOrderItemDto
                        .put("qtyPo", Double.valueOf(purchaseOrderItemDto
                                .getString("qtyPo")));
                purchaseOrderItemDto
                        .put("poUomId", Long.valueOf(purchaseOrderItemDto
                                .getString("poUomId")));
                if (Long.valueOf(purchaseOrderItemDto.getString("poUomId"))
                        .equals(productDto.getLong("baseUomId"))) {
                    purchaseOrderItemDto.put("qtyInt", Double
                            .valueOf(purchaseOrderItemDto.getString("qtyPo")));
                } else {
                    purchaseOrderItemDto.put("qtyInt", Double
                            .valueOf(purchaseOrderItemDto.getString("qtyInt")));
                }
                purchaseOrderItemDto.put("baseUomId",
                        productDto.getLong("baseUomId"));

                purchaseOrderItemDto.put("activityGlId",
                        Long.valueOf(purchaseOrderItemDto
                                .getString("activityGlId")));
                purchaseOrderItemDto.put("productCoaId",
                        groupProductDto.getLong("coaId"));
                purchaseOrderItemDto.put("segmentId", Long
                        .valueOf(purchaseOrderItemDto.getString("segmentId")));
                purchaseOrderItemDto.put("ouRcId",
                        Long.valueOf(purchaseOrderItemDto.getString("ouRcId")));
                purchaseOrderItemDto.put("eta",
                        purchaseOrderItemDto.getString("eta"));
                purchaseOrderItemDto.put("toleranceRcvQty", Double
                        .valueOf(purchaseOrderItemDto
                                .getString("toleranceRcvQty")));
                purchaseOrderItemDto
                        .put("remark", GeneralConstants.EMPTY_VALUE);

                purchaseOrderItemDto.put("discountPercentage",
                        discountPercentage);
                purchaseOrderItemDto.put("discountAmount", discountAmount);
                purchaseOrderItemDto.put("taxPrice", taxPrice);

                purchaseOrderItemDto.put("grossPricePo", grossPricePo);
                purchaseOrderItemDto.put("nettPricePo", nettPricePo);
                purchaseOrderItemDto.put("grossItemAmount", grossItemAmount);

//              // Untuk nettItemAmount harus dikurangi dengan nilai discAmount*qty =>> nettItemAmount-(discountAmount*qtyPo)
//              Double totalDiscAmount = new Calc(discountAmount).multiply(qtyPo).doubleValue();
//              nettItemAmount = new Calc(grossItemAmount).subtract(totalDiscAmount).doubleValue();

                purchaseOrderItemDto.put("nettItemAmount", nettItemAmount);
                purchaseOrderItemDto.put("taxAmount", taxAmount);
                purchaseOrderItemDto.put("taxPercentage", taxPercentage);

                resultPurchaseOrderItemList.add(purchaseOrderItemDto);
            } catch (CoreException e) {
                log.error(e.getErrorKey(), e);
                purchaseOrderItemDto.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);
                    }
                purchaseOrderItemDto.put("args", argsList);

                failList.add(purchaseOrderItemDto);
            }

        }
        ///Ujung for

        if (!failList.isEmpty()) {
            Dto errorParamDto = new Dto();
            DtoUtil.putInErrorParamDto(errorParamDto, "failList", new String[] {
                    "lineNo", "productCode", "productName", "flgStock", "grossPricePo",
                    "flgTaxAmount", "taxName", "qtyPo", "poUomName", "qtyInt",
                    "activityGlName", "ouRcName", "eta", "etaDay", "flgIndent",
                    "toleranceRcvQty", "errorKey", "args" }, failList);
            throw new CoreException(
                    PurchasingExceptionConstants.PURCHASE_ORDER_ITEMS_ERROR,
                    errorParamDto);
        }

        // process cod
        long lineNoCode = 0;
        List<Dto> insertedPurchaseOrderCodList = new ArrayList<Dto>();
        List<Dto> failListCod = new ArrayList<Dto>();
        if (purchaseOrderCodList != null && purchaseOrderCodList.size() > 0) {
            for (Dto purchaseOrderCodItemDto : purchaseOrderCodList) {
                try {
                    // validate cod item key
                    // flgCollection, dueDate, currCode, amount,
                    // trxCurrCode, trxAmount, remark
                    ValidationUtil
                            .valBlankOrNull(
                                    purchaseOrderCodItemDto
                                            .get("flgCollection") == null ? null
                                            : purchaseOrderCodItemDto
                                                    .getString("flgCollection"),
                                    "Flg Collection");
                    ValidationUtil.valBlankOrNull(purchaseOrderCodItemDto
                            .get("dueDate") == null ? null
                            : purchaseOrderCodItemDto.getString("dueDate"),
                            "Due Date");
                    ValidationUtil.valDate(
                            purchaseOrderCodItemDto.getString("dueDate"),
                            "Due Date");
                    ValidationUtil.valBlankOrNull(purchaseOrderCodItemDto
                            .get("currCode") == null ? null
                            : purchaseOrderCodItemDto.getString("currCode"),
                            "Curr Code");
                    ValidationUtil.valDtoContainsKey(purchaseOrderCodItemDto,
                            "amount");
                    ValidationUtil.valBlankOrNull(purchaseOrderCodItemDto
                            .get("trxCurrCode") == null ? null
                            : purchaseOrderCodItemDto.getString("trxCurrCode"),
                            "Curr Code Transaction");
                    ValidationUtil.valDtoContainsKey(purchaseOrderCodItemDto,
                            "trxAmount");
                    ValidationUtil.valDtoContainsKey(purchaseOrderCodItemDto,
                            "remark");

                    String flgCollection = purchaseOrderCodItemDto
                            .getString("flgCollection");
                    String dueDate = purchaseOrderCodItemDto
                            .getString("dueDate");
                    String currCode = purchaseOrderCodItemDto
                            .getString("currCode");
                    String trxCurrCode = purchaseOrderCodItemDto
                            .getString("trxCurrCode");
                    String remarkCod = purchaseOrderCodItemDto
                            .getString("remark");
                    Double amount = Double.valueOf(purchaseOrderCodItemDto.get(
                            "amount").toString());
                    Double trxAmount = Double.valueOf(purchaseOrderCodItemDto
                            .get("trxAmount").toString());

                    // validate flg collection
                    valFlgCollection(flgCollection);

                    // combo currCode and trxCurrCode
                    valComboValueByCode.execute(new Dto()
                            .put("comboId",
                                    ComboIdMasterConstants.COMBO_CURRENCY)
                            .put("code", currCode)
                            .put("varName", "Currency COD"));

                    valComboValueByCode.execute(new Dto()
                            .put("comboId",
                                    ComboIdMasterConstants.COMBO_CURRENCY)
                            .put("code", trxCurrCode)
                            .put("varName", "Trx Currency COD"));

                    // dueDate >= system date and dueDate >= doc date
                    CommonBusinessValidator.valCompareDate(dueDate, date,
                            CommonBusinessValidator.COMPARE_GREATER_EQUAL,
                            "Due Date COD", "System Date");

                    CommonBusinessValidator.valCompareDate(dueDate,
                            inputDto.getString("docDate"),
                            CommonBusinessValidator.COMPARE_GREATER_EQUAL,
                            "Due Date COD", "Document Date");

                    // amount > 0
                    CommonBusinessValidator.valCompareNumber(amount.toString(),
                            "0", CommonBusinessValidator.COMPARE_GREATER,
                            "Amount", "0");

                    // trxAmount > 0 when currCode != trxCurrCode
                    if (!currCode.equals(trxCurrCode)) {
                        // amount > 0
                        CommonBusinessValidator.valCompareNumber(
                                trxAmount.toString(), "0",
                                CommonBusinessValidator.COMPARE_GREATER,
                                "Trx Amount COD", "0");
                    } else {
                        trxAmount = amount;
                    }

                    Dto purchaseOrderCodDto = new Dto();
                    purchaseOrderCodDto.put("tenantId",
                            inputDto.get("tenantLoginId"));
                    purchaseOrderCodDto.put("poId",
                            GeneralConstants.NULL_REF_VALUE_LONG);
                    purchaseOrderCodDto.put("lineNo", new Long(++lineNoCode));
                    purchaseOrderCodDto.put("flgCollection", flgCollection);
                    purchaseOrderCodDto.put("currCode", currCode);
                    purchaseOrderCodDto.put("dueDate", dueDate);
                    purchaseOrderCodDto.put("amount", amount);
                    purchaseOrderCodDto.put("trxCurrCode", trxCurrCode);
                    purchaseOrderCodDto.put("trxAmount", trxAmount);
                    purchaseOrderCodDto.put("remark", remarkCod);

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

                    insertedPurchaseOrderCodList.add(purchaseOrderCodDto);
                } catch (CoreException e) {
                    log.error(e.getErrorKey(), e);
                    purchaseOrderCodItemDto.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);
                        }
                    purchaseOrderCodItemDto.put("args", argsList);

                    failListCod.add(purchaseOrderCodItemDto);
                }
            }
        }

        if (!failListCod.isEmpty()) {
            Dto errorParamDto = new Dto();
            DtoUtil.putInErrorParamDto(errorParamDto, "failListCod",
                    new String[] { "flgCollection", "dueDate", "currCode",
                            "amount", "trxCurrCode", "trxAmount", "remark",
                            "errorKey", "args" }, failListCod);
            throw new CoreException(
                    PurchasingExceptionConstants.PURCHASE_ORDER_COD_ITEMS_ERROR,
                    errorParamDto);
        }

        inputDto.put("resultPurchaseOrderItemList", resultPurchaseOrderItemList);
        inputDto.put("purchaseOrderLogisticList", purchaseOrderLogisticList);
        inputDto.put("insertedPurchaseOrderCodList",
                insertedPurchaseOrderCodList);

        log.debug("hasil input dto 2 : "+inputDto);
        return null;

    }

    @SuppressWarnings("unchecked")
    @Override
    public Dto process(Dto inputDto, Dto originalDto) throws Exception {
        log.debug("hasil input Dto 3 : "+inputDto);
        PurchaseOrder purchaseOrder = GsonUtil.fromDto(inputDto,
                PurchaseOrder.class);
        String datetime = inputDto.getString("datetime");
        purchaseOrderDao.persist(purchaseOrder);

        List<Dto> resultPurchaseOrderItemList = inputDto
                .getList("resultPurchaseOrderItemList");
        for (Dto purchaseOrderItemDto : resultPurchaseOrderItemList) {
            // Add purchaseOrderItemDto
            purchaseOrderItemDto.put("poId", purchaseOrder.getId());
            PurchaseOrderItem purchaseOrderItem = GsonUtil.fromDto(
                    purchaseOrderItemDto, PurchaseOrderItem.class);
            purchaseOrderItemDao.persist(purchaseOrderItem);

            // update so po balance item
            if (!GeneralConstants.NULL_REF_VALUE_LONG.equals(inputDto
                    .get("refId"))) {
                QueryBuilder builder = new QueryBuilder();
                builder.add(" SELECT COALESCE(COUNT(1), 0) FROM sl_update_status_so_po_balance_item(:tenantId, :userId, :datetime, :soItemId, :statusItem )");

                Query q = purchaseOrderItemDao.createNativeQuery(builder
                        .toString());
                q.setParameter("tenantId", inputDto.get("tenantLoginId"));
                q.setParameter("userId", inputDto.get("userLoginId"));
                q.setParameter("datetime", inputDto.get("datetime"));
                q.setParameter("soItemId", purchaseOrderItem.getRefId());
                q.setParameter("statusItem",
                        PurchasingConstants.IN_PROGRESS_TRANSACTION);

                Object obj = q.getSingleResult();
                log.debug("Result Update status so po balance item : " + obj);
            }
        }

        // insert logistic
        List<Dto> purchaseOrderLogisticList = inputDto
                .getList("purchaseOrderLogisticList");
        for (Dto purchaseOrderLogisticDto : purchaseOrderLogisticList) {
            purchaseOrderLogisticDto.put("poId", purchaseOrder.getId());
            PurchaseOrderLogistic purchaseOrderLogistic = GsonUtil.fromDto(
                    purchaseOrderLogisticDto, PurchaseOrderLogistic.class);
            purchaseOrderLogisticDao.persist(purchaseOrderLogistic);
        }

        // insert po cod
        List<Dto> insertedPurchaseOrderCodList = inputDto
                .getList("insertedPurchaseOrderCodList");
        for (Dto purchaseOrderCodDto : insertedPurchaseOrderCodList) {
            purchaseOrderCodDto.put("poId", purchaseOrder.getId());
            PurchaseOrderCod purchaseOrderCod = GsonUtil.fromDto(
                    purchaseOrderCodDto, PurchaseOrderCod.class);
            purchaseOrderCodDao.persist(purchaseOrderCod);
        }

        // insert PurchaseOrder Ext
        Dto purchaseOrderExtDto = new Dto();
        purchaseOrderExtDto.put("poId", purchaseOrder.getId());
        purchaseOrderExtDto.put("flgBuyConsignment",
                inputDto.get("flgBuyConsignment"));
        purchaseOrderExtDto.put("flgKonsinyasiManual",inputDto.get("flgKonsinyasiManual"));
        log.debug("hasil dto : "+purchaseOrderExtDto);
        this.prepareInsertAudit(purchaseOrderExtDto,
                inputDto.getLong("userLoginId"), datetime);

        PurchaseOrderExt pox = GsonUtil.fromDto(purchaseOrderExtDto,
                PurchaseOrderExt.class);
        purchaseOrderExtDao.persist(pox);

        return new Dto(purchaseOrder);
    }

    private void valFlgCollection(String flgCollection) throws CoreException {
        if (!flgCollectionList.contains(flgCollection)) {
            throw new CoreException(
                    PurchasingExceptionConstants.FLAG_COLLECTION_MUST_BE_B_OR_K);
        }
    }

    // private Dto findTaxDto(Dto inputDto, Dto purchaseOrderItemDto) throws
    // Exception {
    // Dto taxDto = findTaxById.execute(new Dto().put("id",
    // Long.valueOf(purchaseOrderItemDto.getString("taxId"))));
    //
    // if
    // (!inputDto.getLong("tenantLoginId").equals(taxDto.getLong("tenantId"))) {
    // throw new
    // CoreException(CommonExceptionConstants.DATA_CANT_USE_DIFF_TENANT,
    // "Purchase Order Item", "Tax");
    // }
    //
    // if (!GeneralConstants.YES.equals(taxDto.getString("active"))) {
    // throw new CoreException(MasterExceptionConstants.DATA_NOT_ACTIVE, "Tax");
    // }
    // return taxDto;
    // }
}