SubmitPosShop

package org.jleaf.pos.bo.pos;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.persistence.Query;

import org.apache.commons.validator.GenericValidator;
import org.jleaf.erp.master.MasterConstants;
import org.jleaf.erp.master.MasterExceptionConstants;
import org.jleaf.erp.master.bo.ComboIdMasterConstants;
import org.jleaf.pos.ComboIdPosConstants;
import org.jleaf.pos.PosBoConstants;
import org.jleaf.pos.PosBoExceptionConstants;
import org.jleaf.pos.bo.cashbalance.GetEndOfMonthCashBalanceList;
import org.jleaf.pos.dao.CashBalanceDao;
import org.jleaf.pos.dao.LogProductBalanceStockDao;
import org.jleaf.pos.dao.NonCashBalanceDao;
import org.jleaf.pos.dao.PointOfSalesAddCostDao;
import org.jleaf.pos.dao.PointOfSalesAssemblyProductDao;
import org.jleaf.pos.dao.PointOfSalesCashPaymentDao;
import org.jleaf.pos.dao.PointOfSalesDao;
import org.jleaf.pos.dao.PointOfSalesItemDao;
import org.jleaf.pos.dao.PointOfSalesNonCashPaymentDao;
import org.jleaf.pos.dao.PointOfSalesTaxDao;
import org.jleaf.pos.dao.ProductBalanceStockDao;
import org.jleaf.pos.dao.TrxItemLogDao;
import org.jleaf.pos.dao.TrxLogDao;
import org.jleaf.pos.entity.CashBalance;
import org.jleaf.pos.entity.LogProductBalanceStock;
import org.jleaf.pos.entity.NonCashBalance;
import org.jleaf.pos.entity.PointOfSales;
import org.jleaf.pos.entity.PointOfSalesAddCost;
import org.jleaf.pos.entity.PointOfSalesAssemblyProduct;
import org.jleaf.pos.entity.PointOfSalesCashPayment;
import org.jleaf.pos.entity.PointOfSalesItem;
import org.jleaf.pos.entity.PointOfSalesNonCashPayment;
import org.jleaf.pos.entity.PointOfSalesTax;
import org.jleaf.pos.entity.ProductBalanceStock;
import org.jleaf.pos.entity.TrxItemLog;
import org.jleaf.pos.entity.TrxLog;
import org.jleaf.common.CommonConstants;
import org.jleaf.common.CommonExceptionConstants;
import org.jleaf.core.BusinessFunction;
import org.jleaf.core.BusinessTransaction;
import org.jleaf.core.CoreException;
import org.jleaf.core.CoreExceptionConstants;
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.util.Calc;
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;

/**
 * Submit POS Shop
 *
 * @author Daniel, Nov 17, 2012
 * @version 1.0.0
 */
/**
 * Ubah update product balance stock menjadi query
 * modified by Adrian
 * Dec 27, 2017
 */

@Service
//@formatter:off
@InfoIn(value = {
        @Info(name = "docTypeId", description = "document type id", type = Long.class),
        @Info(name = "docNo", description = "document no", type = String.class),
        @Info(name = "docDate", description = "document date", type = String.class),
        @Info(name = "ouId", description = "organization unit id", type = Long.class),
        @Info(name = "extDocNo", description = "external document no", type = String.class),
        @Info(name = "extDocDate", description = "external document date", type = String.class),
        @Info(name = "refDocTypeId", description = "reference doc type id", type = Long.class),
        @Info(name = "refId", description = "reference id", type = Long.class),
        @Info(name = "remark", description = "remark", type = String.class),
        @Info(name = "partnerId", description = "partner id", type = Long.class),
        @Info(name = "partnerBillToId", description = "partner bill to id", type = Long.class),
        @Info(name = "partnerShipToId", description = "partner ship to id", type = Long.class),
        @Info(name = "salesmanId", description = "salesman id", type = Long.class),
        @Info(name = "currCode", description = "salesman id", type = String.class),
        @Info(name = "addDiscountPercentage", description = "add discount percentage", type = Double.class),
        @Info(name = "addDiscountAmount", description = "add discount amount", type = Double.class),
        @Info(name = "grossAmount", description = "gross amount", type = Double.class),
        @Info(name = "nettAmount", description = "nett amount", type = Double.class),
        @Info(name = "taxAmount", description = "tax amount", type = Double.class),
        @Info(name = "addAmount", description = "additional amount", type = Double.class),
        @Info(name = "totalAmount", description = "total amount", type = Double.class),
        @Info(name = "roundingAmount", description = "rounding amount", type = Double.class),
        @Info(name = "totalPayment", description = "total payment", type = Double.class),
        @Info(name = "totalRefund", description = "total refund", type = Double.class),
        @Info(name = "posItemList", description = "list of pos item (warehouseId, lineNo, productId, productBalanceId, productStatus, baseUomId, qty, grossSellPrice, flgTaxAmount, taxId, taxPercentage, taxPrice, promoCode, discountPercentage, discountAmount, nettSellPrice, taxAmount, nettAmountItem, remark, groupProductOuId, posAssemblyProductList)", type = List.class),
        @Info(name = "cashList", description = "list of payment using cash (currPaymentCode, paymentAmount, dateExchangeRate, numeratorRate, denominatorRate, conversionAmount, remark)", type = List.class),
        @Info(name = "nonCashList", description = "list of payment using non cash (lineNo, deviceMerchantId, cardType, bankCardCode, cardNo, currPaymentCode, paymentAmount, remark, percentage, addAmount)", type = List.class),
        @Info(name = "userLoginId", description = "user login id", type = Long.class),
        @Info(name = "roleLoginId", description = "role login id", type = Long.class),
        @Info(name = "tenantLoginId", description = "tenant login id", type = Long.class),
        @Info(name = "datetime", description = "datetime", type = String.class)
})
@InfoOut(value = {
        @Info(name = "id", description = "Point of Sales Id", type = Long.class),
        @Info(name = "tenantId", description = "PT", type = Long.class),
        @Info(name = "docTypeId", description = "Document Type id", type = Long.class),
        @Info(name = "docNo", description = "Document Number (Autogenerate)", type = String.class),
        @Info(name = "docDate", description = "Document Date", type = String.class),
        @Info(name = "ouId", description = "Organization unit Id", type = Long.class),
        @Info(name = "extDocNo", description = "External Document Number", type = String.class),
        @Info(name = "extDocDate", description = "External Document Date", type = String.class),
        @Info(name = "refDocTypeId", description = "Reference document type Id", type = Long.class),
        @Info(name = "refId", description = "Reference Id", type = Long.class),
        @Info(name = "remark", description = "Remark", type = String.class),
        @Info(name = "partnerId", description = "Partner id", type = Long.class),
        @Info(name = "partnerBillToId", description = "Partner bill to Id", type = Long.class),
        @Info(name = "partnerShipToId", description = "Partner ship to Id", type = Long.class),
        @Info(name = "salesmanId", description = "Salesman Id", type = Long.class),
        @Info(name = "currCode", description = "Currency code", type = String.class),
        @Info(name = "addDiscountPercentage", description = "additional Discount percentage", type = Double.class),
        @Info(name = "addDiscountAmount", description = "Additional Discount Amount", type = Double.class),
        @Info(name = "grossAmount", description = "Gross Amount, total nilai netto item (sudah dipotong dengan disc per item belum dipotong pajak)", type = Double.class),
        @Info(name = "nettAmount", description = "Net Amount, Nilai Item - additional discount", type = Double.class),
        @Info(name = "taxAmount", description = "Tax Amount, Nilai Pajak berdasarkan detail tax document", type = Double.class),
        @Info(name = "addAmount", description = "Additional Amount, nilai tambahan biaya yang dibebankan ke customer", type = Double.class),
        @Info(name = "totalAmount", description = "TotalAmount, Net Amount + Nilai Pajak + add amount", type = Double.class),
        @Info(name = "roundingAmount", description = "Rounding Amount, pembulatan nilai netto", type = Double.class),
        @Info(name = "totalPayment", description = "Total Payment, Total Amount_conversion dari table cash dan non_cash", type = Double.class),
        @Info(name = "totalRefund", description = "Total Refund", type = Double.class),
        @Info(name = "status", description = "Status Transaction", type = String.class),
        @Info(name = "version", description = "version", type = Long.class),
        @Info(name = "createDateTime", description = "create date time", type = String.class),
        @Info(name = "createUserId", description = "create user id", type = Long.class),
        @Info(name = "updateDateTime", description = "update date time", type = String.class),
        @Info(name = "updateUserId", description = "update user id", type = Long.class)
})
@ErrorList(errorKeys = {
        CommonExceptionConstants.TENANT_LOGIN_CANT_USED,
        CommonExceptionConstants.OU_ID_NOT_FOUND,
        MasterExceptionConstants.PARTNER_ID_NOT_FOUND,
        CoreExceptionConstants.ID_NOT_FOUND, // for Salesman
        CommonExceptionConstants.COMBO_NOT_FOUND, // for currency, bank, card code
        CommonExceptionConstants.USER_ID_NOT_FOUND,
        MasterExceptionConstants.WAREHOUSE_ID_NOT_FOUND,
        PosBoExceptionConstants.PRODUCT_BALANCE_ID_NOT_FOUND,
        PosBoExceptionConstants.PRODUCT_BALANCE_STOCK_NOT_FOUND,
        MasterExceptionConstants.PROMO_PRICE_PRODUCT_NOT_FOUND,
        MasterExceptionConstants.TAX_ID_NOT_FOUND,
        MasterExceptionConstants.GROUP_PRODUCT_OU_ID_NOT_FOUND,
        MasterExceptionConstants.DEVICE_MERCHANT_ID_NOT_FOUND,
        CommonExceptionConstants.SYSTEM_CONFIG_BY_CODE_NOT_FOUND, // for dbVersion and activity Gl Change
        PosBoExceptionConstants.INCONSISTENT_PRODUCT_ID,
        PosBoExceptionConstants.POS_CASH_NOT_FOUND,
        MasterExceptionConstants.PRODUCT_ASSEMBLY_ID_NOT_FOUND,
        PosBoExceptionConstants.PRODUCT_NOT_LISTED_IN_PRODUCT_ASSEMBLY_PRODUCT,
        PosBoExceptionConstants.REAL_QTY_OVER_FORMULA_PRODUCT_ASSEMBLY,
        PosBoExceptionConstants.REAL_QTY_BELOW_FORMULA_PRODUCT_ASSEMBLY
})
//@formatter:on
public class SubmitPosShop extends DefaultBusinessTransaction implements BusinessTransaction {

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

    @Autowired
    private PointOfSalesDao posDao;

    @Autowired
    private PointOfSalesItemDao posItemDao;

    @Autowired
    private PointOfSalesAssemblyProductDao posAssemblyProductDao;

    @Autowired
    private PointOfSalesCashPaymentDao posCashPaymentDao;

    @Autowired
    private PointOfSalesNonCashPaymentDao posNonCashPaymentDao;

    @Autowired
    private PointOfSalesTaxDao posTaxDao;

    @Autowired
    private PointOfSalesAddCostDao posAddCostDao;

    @Autowired
    private ProductBalanceStockDao productBalanceStockDao;

    @Autowired
    private LogProductBalanceStockDao logProductBalanceStockDao;

    @Autowired
    private CashBalanceDao cashBalanceDao;

    @Autowired
    private NonCashBalanceDao nonCashBalanceDao;

    @Autowired
    private TrxLogDao trxLogDao;

    @Autowired
    private TrxItemLogDao trxItemLogDao;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    @Override
    public String getDescription() {
        return "Submit POS Shop";
    }

    @SuppressWarnings("unchecked")
    @Override
    public Dto prepare(Dto inputDto, Dto originalDto) throws Exception {
        // Standart Validation
        ValidationUtil.valDtoContainsKey(inputDto, "docTypeId");
        ValidationUtil.valBlankOrNull(inputDto, "docNo");
        ValidationUtil.valBlankOrNull(inputDto, "docDate");
        ValidationUtil.valDtoContainsKey(inputDto, "ouId");
        ValidationUtil.valDtoContainsKey(inputDto, "extDocNo");
        ValidationUtil.valDtoContainsKey(inputDto, "extDocDate");
        ValidationUtil.valDtoContainsKey(inputDto, "refDocTypeId");
        ValidationUtil.valDtoContainsKey(inputDto, "refId");
        ValidationUtil.valBlankOrNull(inputDto, "remark");
        ValidationUtil.valDtoContainsKey(inputDto, "partnerId");
        ValidationUtil.valDtoContainsKey(inputDto, "partnerBillToId");
        ValidationUtil.valDtoContainsKey(inputDto, "partnerShipToId");
        ValidationUtil.valDtoContainsKey(inputDto, "salesmanId");
        ValidationUtil.valBlankOrNull(inputDto, "currCode");
        ValidationUtil.valNumber(inputDto, "addDiscountPercentage");
        ValidationUtil.valNumber(inputDto, "addDiscountAmount");
        ValidationUtil.valNumber(inputDto, "grossAmount");
        ValidationUtil.valNumber(inputDto, "nettAmount");
        ValidationUtil.valNumber(inputDto, "taxAmount");
        ValidationUtil.valNumber(inputDto, "addAmount");
        ValidationUtil.valNumber(inputDto, "totalAmount");
        ValidationUtil.valNumber(inputDto, "roundingAmount");
        ValidationUtil.valNumber(inputDto, "totalPayment");
        ValidationUtil.valNumber(inputDto, "totalRefund");
        ValidationUtil.valDtoContainsKey(inputDto, "posItemList");
        ValidationUtil.valDtoContainsKey(inputDto, "cashList");
        ValidationUtil.valDtoContainsKey(inputDto, "nonCashList");
        ValidationUtil.valDtoContainsKey(inputDto, "userLoginId");
        ValidationUtil.valDtoContainsKey(inputDto, "roleLoginId");
        ValidationUtil.valDtoContainsKey(inputDto, "tenantLoginId");
        ValidationUtil.valBlankOrNull(inputDto, "datetime");

        // Preparing input parameters
        Long docTypeId = inputDto.getLong("docTypeId");
        String docNo = inputDto.getString("docNo");
        String docDate = inputDto.getString("docDate");
        Long ouId = inputDto.getLong("ouId");
        // String extDocNo = inputDto.getString("extDocNo");
        // String extDocDate = inputDto.getString("extDocDate");
        // Long refDocTypeId = inputDto.getLong("refDocTypeId");
        // Long refId = inputDto.getLong("refId");
        // String remark = inputDto.getString("remark");
        Long partnerId = inputDto.getLong("partnerId");
        Long partnerBillToId = inputDto.getLong("partnerBillToId");
        Long partnerShipToId = inputDto.getLong("partnerShipToId");
        Long salesmanId = inputDto.getLong("salesmanId");
        String currCode = inputDto.getString("currCode");
        // Double addDiscountPercentage = inputDto.getDouble("addDiscountPercentage");
        // Double addDiscountAmount = inputDto.getDouble("addDiscountAmount");
        // Double grossAmount = inputDto.getDouble("grossAmount");
        // Double nettAmount = inputDto.getDouble("nettAmount");
        // Double taxAmount = inputDto.getDouble("taxAmount");
        Double addAmount = inputDto.getDouble("addAmount");
        Double totalAmount = inputDto.getDouble("totalAmount");
        Double roundingAmount = inputDto.getDouble("roundingAmount");
        Double totalPayment = inputDto.getDouble("totalPayment");
        Double totalRefund = inputDto.getDouble("totalRefund");
        List<Dto> posItemList = inputDto.getList("posItemList");
        List<Dto> cashList = inputDto.getList("cashList");
        List<Dto> nonCashList = inputDto.getList("nonCashList");
        Long userLoginId = inputDto.getLong("userLoginId");
        Long roleLoginId = inputDto.getLong("roleLoginId");
        Long tenantLoginId = inputDto.getLong("tenantLoginId");
        String datetime = inputDto.getString("datetime");

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

        // Validation ou id must exists
        Dto ouDto = new Dto();
        ouDto.put("id", ouId);
        ouDto = findOUById.execute(ouDto);

        if (!ouDto.getLong("tenantId").equals(tenantLoginId)) {
            throw new CoreException(CommonExceptionConstants.DATA_CANT_USE_DIFF_TENANT, "Point of Sales", "OU");
        }

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

        // Validate doc date must be valid
        Dto valDocDateDto = new Dto();
        valDocDateDto.put("tenantId", tenantLoginId);
        valDocDateDto.put("docDate", docDate);
        valDocDateDto.put("ouId", ouId);
        valDocCanInputByDate.execute(valDocDateDto);

        // Validation partner must exists
        if (!partnerId.equals(GeneralConstants.NULL_REF_VALUE_LONG)) {
            Dto partnerDto = new Dto();
            partnerDto.put("id", partnerId);
            partnerDto = findPartnerById.execute(partnerDto);
        }

        if (!partnerBillToId.equals(GeneralConstants.NULL_REF_VALUE_LONG)) {
            Dto partnerBillToDto = new Dto();
            partnerBillToDto.put("id", partnerBillToId);
            partnerBillToDto = findPartnerById.execute(partnerBillToDto);
        }

        if (!partnerShipToId.equals(GeneralConstants.NULL_REF_VALUE_LONG)) {
            Dto partnerShipToDto = new Dto();
            partnerShipToDto.put("id", partnerShipToId);
            partnerShipToDto = findPartnerById.execute(partnerShipToDto);
        }

        // Validation salesman must exists
        Dto salesmanDto = new Dto();
        salesmanDto.put("id", salesmanId);
        salesmanDto.put("tenantId", tenantLoginId);
        salesmanDto = findSalesmanById.execute(salesmanDto);

        // Validation currency must be suitable with combo CURRENCY
        Dto paramCurrencyDto = new Dto();
        paramCurrencyDto.put("comboId", ComboIdMasterConstants.COMBO_CURRENCY);
        paramCurrencyDto.put("code", currCode);
        paramCurrencyDto.put("varName", "Currency");
        valComboValueByCode.execute(paramCurrencyDto);

        // Validating Total Payment must equal or greater than zero
        CommonBusinessValidator.valCompareNumber(totalPayment.toString(), "0",
                CommonBusinessValidator.COMPARE_GREATER_EQUAL, "totalPayment", "0");

        // Validating Total Amount must equal or greater than zero
        CommonBusinessValidator.valCompareNumber(totalAmount.toString(), "0",
                CommonBusinessValidator.COMPARE_GREATER_EQUAL, "totalAmount", "0");

        // Validating Total Payment must equal or greater than total Amount
        CommonBusinessValidator.valCompareNumber(totalPayment.toString(), totalAmount.toString(),
                CommonBusinessValidator.COMPARE_GREATER_EQUAL, "totalPayment", "totalAmount");

        Double totalAmountNeedToPay = new Calc(totalAmount).add(addAmount).doubleValue();

        // Validating Total Payment must equal or greater than total Amount neeed to pay
                CommonBusinessValidator.valCompareNumber(totalPayment.toString(), totalAmountNeedToPay.toString(),
                        CommonBusinessValidator.COMPARE_GREATER_EQUAL, "totalPayment", "totalAmountNeedToPay");

        // Get Username
        Dto userDto = new Dto();
        userDto.put("id", userLoginId);
        userDto = findUserById.execute(userDto);
        String username = userDto.getString("name");

        // Preparing Input Header
        Dto persistPosDto = (Dto) inputDto.clone();
        persistPosDto.put("tenantId", tenantLoginId);
        persistPosDto.put("status", PosBoConstants.SUBMITTED_TRANSACTION);
        persistPosDto.put("createUsername", username);
        persistPosDto.put("updateUsername", username);
        prepareInsertAudit(persistPosDto, userLoginId, datetime);
        prepareUpdateAudit(persistPosDto, userLoginId, datetime);

        // Looping detail item
        List<Dto> persistPosItemList = new ArrayList<Dto>();
        List<Dto> persistPosTaxList = new ArrayList<Dto>();
        Map<Long, Dto> mergeProductBalanceStockList = new HashMap<Long, Dto>();
        if (posItemList != null) {
            for (Dto posItemDto : posItemList) {
                // Standart Validation
                ValidationUtil.valDtoContainsKey(posItemDto, "warehouseId");
                ValidationUtil.valDtoContainsKey(posItemDto, "lineNo");
                ValidationUtil.valDtoContainsKey(posItemDto, "productId");
                ValidationUtil.valDtoContainsKey(posItemDto, "productBalanceId");
                ValidationUtil.valBlankOrNull(posItemDto, "productStatus");
                ValidationUtil.valDtoContainsKey(posItemDto, "baseUomId");
                ValidationUtil.valNumber(posItemDto, "qty");
                ValidationUtil.valNumber(posItemDto, "grossSellPrice");
                ValidationUtil.valDtoContainsKey(posItemDto, "flgTaxAmount");
                ValidationUtil.valDtoContainsKey(posItemDto, "taxId");
                ValidationUtil.valNumber(posItemDto, "taxPercentage");
                ValidationUtil.valNumber(posItemDto, "taxPrice");
                ValidationUtil.valDtoContainsKey(posItemDto, "promoCode");
                ValidationUtil.valNumber(posItemDto, "discountPercentage");
                ValidationUtil.valNumber(posItemDto, "discountAmount");
                ValidationUtil.valNumber(posItemDto, "nettSellPrice");
                ValidationUtil.valNumber(posItemDto, "taxAmount");
                ValidationUtil.valNumber(posItemDto, "nettAmountItem");
                ValidationUtil.valDtoContainsKey(posItemDto, "remark");
                ValidationUtil.valDtoContainsKey(posItemDto, "groupProductOuId");

                // Preparing Variable
                Long warehouseId = posItemDto.getLong("warehouseId");
                Long productId = posItemDto.getLong("productId");
                Long productBalanceId = posItemDto.getLong("productBalanceId");
                String productStatus = posItemDto.getString("productStatus");
                // previously, it's used for writing log product balance stock.
                // But, it already changed so that the base uom id for writing log product balance stock is got from product balance stock.
                //Long baseUomId = posItemDto.getLong("baseUomId");
                Long taxId = posItemDto.getLong("taxId");
                String promoCode = posItemDto.getString("promoCode");
                Long groupProductOuId = posItemDto.getLong("groupProductOuId");
                Double taxAmount = posItemDto.getDouble("taxAmount");
                Double qty = posItemDto.getDouble("qty");
                Double nettAmountItem = posItemDto.getDouble("nettAmountItem");
                String flgTaxAmount = posItemDto.getString("flgTaxAmount");
                Double taxPercentage = posItemDto.getDouble("taxPercentage");

                // Validation warehouse must exists
                Dto warehouseDto = new Dto();
                warehouseDto.put("id", warehouseId);
                warehouseDto = findWarehouseById.execute(warehouseDto);

                Dto mergeProductBalanceStockDto = null;
                List<Dto> persistPosAssemblyProductList = Collections.EMPTY_LIST;
                if (GeneralConstants.NULL_REF_VALUE_LONG.equals(productBalanceId)) {
                    // Validation ext product id must exists
                    Dto productAssemblyDto = new Dto();
                    productAssemblyDto.put("productId", productId);
                    productAssemblyDto = findProductAssemblyById.execute(productAssemblyDto);

                    // Prepare map that contains map of child products of the assembly, with remaining qty needs to be fulfilled
                    List<Dto> assemblyFormulaDetailList = getProductAssemblyDetailListByParentProduct.execute(new Dto().put("tenantId", tenantLoginId).put("parentProductId", productId)).getList("productAssemblyDetailList");
                    Map<Long, Dto> assemblyFormulaDetailMap = new HashMap<Long, Dto>(assemblyFormulaDetailList.size());
                    for (Dto assemblyDetail : assemblyFormulaDetailList) {
                        assemblyDetail.putDouble("remainingQty", assemblyDetail.getDouble("qtyBaseUom"));
                        assemblyFormulaDetailMap.put(assemblyDetail.getLong("childProductId"), assemblyDetail);
                    }

                    // Iterate the assembly product list
                    List<Dto> posAssemblyProductList = posItemDto.getList("posAssemblyProductList");
                    if (posAssemblyProductList != null && !posAssemblyProductList.isEmpty()) {
                        persistPosAssemblyProductList = new ArrayList<Dto>(posAssemblyProductList.size());
                        for (Dto posAssemblyProduct : posAssemblyProductList) {
                            // Validate keys in dto
                            ValidationUtil.valDtoContainsKey(posAssemblyProduct, "lineNo");
                            ValidationUtil.valDtoContainsKey(posAssemblyProduct, "productId");
                            ValidationUtil.valDtoContainsKey(posAssemblyProduct, "productBalanceId");
                            ValidationUtil.valBlankOrNull(posAssemblyProduct, "productStatus");
                            ValidationUtil.valDtoContainsKey(posAssemblyProduct, "baseUomId");
                            ValidationUtil.valNumber(posAssemblyProduct, "qty");
                            ValidationUtil.valDtoContainsKey(posAssemblyProduct, "remark");

                            // Validate product balance
                            Long childProductId = posAssemblyProduct.getLong("productId");
                            mergeProductBalanceStockDto = getMergeProductBalanceStock(tenantLoginId, warehouseId,
                                                                                      childProductId,
                                                                                      posAssemblyProduct.getLong("productBalanceId"),
                                                                                      posAssemblyProduct.getString("productStatus"),
                                                                                      mergeProductBalanceStockList);

                            // Update remaining qty in assembly formula map
                            Dto assemblyFormulaDetail = assemblyFormulaDetailMap.get(childProductId);
                            if (assemblyFormulaDetail == null)
                                throw new CoreException(PosBoExceptionConstants.PRODUCT_NOT_LISTED_IN_PRODUCT_ASSEMBLY_PRODUCT, childProductId, productId);
                            else {
                                assemblyFormulaDetail.put("remainingQty",
                                        new Calc(assemblyFormulaDetail.getDouble("remainingQty")).subtract(posAssemblyProduct.getDouble("qty")).doubleValue());
                            }

                            // create pos assembly product
                            Dto persistPosAssemblyProduct = (Dto) posAssemblyProduct.clone();
                            persistPosAssemblyProduct.put("tenantId", tenantLoginId);
                            if (GenericValidator.isBlankOrNull(persistPosAssemblyProduct.getString("remark")))
                                persistPosAssemblyProduct.putString("remark", GeneralConstants.SPACE_VALUE);
                            prepareInsertAudit(persistPosAssemblyProduct, userLoginId, datetime);
                            prepareUpdateAudit(persistPosAssemblyProduct, userLoginId, datetime);
                            persistPosAssemblyProductList.add(persistPosAssemblyProduct);

                            // Update product balance stock and log product balance stock
                            updateProductBalanceStock(docTypeId, docNo, docDate, ouId, userLoginId,
                                                      tenantLoginId, datetime, posAssemblyProduct.getDouble("qty"), mergeProductBalanceStockDto);
                        }
                    }

                    // Check the map for unfulfilled formula qty
                    for (Dto assemblyFormulaDetail : assemblyFormulaDetailMap.values()) {
                        Double remainingQty = assemblyFormulaDetail.getDouble("remainingQty");
                        int compareResult = remainingQty.compareTo(0d);
                        if (compareResult > 0) {
                            throw new CoreException(PosBoExceptionConstants.REAL_QTY_OVER_FORMULA_PRODUCT_ASSEMBLY,
                                                    assemblyFormulaDetail.getString("childProductName"),
                                                    remainingQty, assemblyFormulaDetail.getDouble("qtyBaseUom"));
                        } else if (compareResult < 0) {
                            throw new CoreException(PosBoExceptionConstants.REAL_QTY_BELOW_FORMULA_PRODUCT_ASSEMBLY,
                                                    assemblyFormulaDetail.getString("childProductName"),
                                                    remainingQty, assemblyFormulaDetail.getDouble("qtyBaseUom"));
                        }
                    }
                } else {
                    mergeProductBalanceStockDto = getMergeProductBalanceStock(tenantLoginId, warehouseId, productId, productBalanceId, productStatus, mergeProductBalanceStockList);

                    updateProductBalanceStock(docTypeId, docNo, docDate, ouId, userLoginId,
                            tenantLoginId, datetime, qty, mergeProductBalanceStockDto);
                }

                // Validation promo code must exists
                if (!GeneralConstants.EMPTY_VALUE.equals(promoCode)) {
                    Dto promoDto = new Dto();
                    promoDto.put("tenantId", tenantLoginId);
                    promoDto.put("code", promoCode);
                    promoDto.put("productId", productId);
                    promoDto.put("ouId", ouId);
                    promoDto = findPromoPriceProductByIndex.execute(promoDto);

                    // dapatkan group product ou id untuk promo (jika tidak ketemu akan dikembalikan sesuai regulernya)
                    Dto paramGroupProductOuPromoDto = new Dto();
                    paramGroupProductOuPromoDto.put("groupProductOuId", groupProductOuId);
                    paramGroupProductOuPromoDto.put("date", docDate);
                    paramGroupProductOuPromoDto.put("promoCode", promoCode);
                    Dto groupProductOuPromoCommissionDto = findGroupProductOuPromoCommisionByDate.execute(paramGroupProductOuPromoDto);

                    // override group product ou id
                    posItemDto.put("groupProductOuId", groupProductOuPromoCommissionDto.getLong("groupProductPromoOuId"));
                } else {
                    // better nanti diisi space saja, apabila promoCode == Empty String (Hasil chat GTalk 26 Nov 2012, 23:03
                    promoCode = GeneralConstants.SPACE_VALUE;
                }

                // Validation Group Product OU Id
                Dto groupProductOuDto = new Dto();
                groupProductOuDto.put("id", groupProductOuId);
                groupProductOuDto = findGroupProductOuById.execute(groupProductOuDto);

                // Preparing for posItem
                Dto persistPosItemDto = (Dto) posItemDto.clone();
                persistPosItemDto.put("tenantId", tenantLoginId);
                persistPosItemDto.put("currCode", currCode);
                persistPosItemDto.put("promoCode", promoCode);
                persistPosItemDto.put("persistPosAssemblyProductList", persistPosAssemblyProductList);
                prepareUpdateAudit(persistPosItemDto, userLoginId, datetime);
                persistPosItemList.add(persistPosItemDto);

                // Validation Tax
                if(!GeneralConstants.NULL_REF_VALUE_LONG.equals(taxId)){
                    Dto taxDto = new Dto();
                    taxDto.put("id", taxId);
                    taxDto = findTaxById.execute(taxDto);

                    // Create Or Replace Pos Tax
                    boolean isCreateNewPosTax = true;

                    // cari nilai nett amount item sebelum tax
                    Double nettAmountItemBeforeTax = new Calc(nettAmountItem).subtract(taxAmount).doubleValue();

                    for (Dto posTax : persistPosTaxList) {
                        // If taxId exists, just add the amount, else create new POSTax
                        if (posTax.getLong("taxId").equals(taxId)) {
                            Double newBaseAmount = new Calc(posTax.getDouble("baseAmount")).add(nettAmountItemBeforeTax).doubleValue();
                            Double newTaxAmount = new Calc(posTax.getDouble("taxAmount")).add(taxAmount).doubleValue();

                            posTax.put("baseAmount", newBaseAmount);
                            posTax.put("taxAmount", newTaxAmount);

                            isCreateNewPosTax = false;
                            break;
                        }
                    }

                    if (isCreateNewPosTax == true) {
                        PointOfSalesTax posTax = new PointOfSalesTax();
                        posTax.setTenantId(tenantLoginId);
                        posTax.setTaxId(taxId);
                        posTax.setFlgAmount(taxDto.getString("flagAmount"));
                        posTax.setTaxPercentage(taxPercentage);
                        posTax.setBaseAmount(nettAmountItemBeforeTax);

                        posTax.setTaxAmount(taxAmount);
                        posTax.setRemark(GeneralConstants.EMPTY_VALUE);

                        Dto posTaxDto = new Dto(posTax);
                        prepareInsertAudit(posTaxDto, userLoginId, datetime);
                        persistPosTaxList.add(posTaxDto);
                    }
                }
            }
        }

        // Looping Cash
        List<Dto> persistCashList = new ArrayList<Dto>();
        List<Dto> persistCashBalanceList = new ArrayList<Dto>();
        List<Dto> mergeCashBalanceList = new ArrayList<Dto>();
        if (cashList != null) {
            for (Dto cashDto : cashList) {
                // Standart Validation
                ValidationUtil.valBlankOrNull(cashDto, "currPaymentCode");
                ValidationUtil.valNumber(cashDto, "paymentAmount");
                ValidationUtil.valBlankOrNull(cashDto, "dateExchangeRate");
                ValidationUtil.valNumber(cashDto, "numeratorRate");
                ValidationUtil.valNumber(cashDto, "denominatorRate");
                ValidationUtil.valNumber(cashDto, "conversionAmount");
                ValidationUtil.valDtoContainsKey(cashDto, "remark");

                // Preparing Variable
                String currPaymentCode = cashDto.getString("currPaymentCode");
                Double paymentAmount = cashDto.getDouble("paymentAmount");
                // String dateExchangeRate = cashDto.getString("dateExchangeRate");
                // Double numeratorRate = cashDto.getDouble("numeratorRate");
                // Double denominatorRate = cashDto.getDouble("denominatorRate");
                // Double conversionAmount = cashDto.getDouble("conversionAmount");

                // Currency must exists
                Dto paramCashCurrencyDto = new Dto();
                paramCashCurrencyDto.put("comboId", ComboIdMasterConstants.COMBO_CURRENCY);
                paramCashCurrencyDto.put("code", currPaymentCode);
                paramCashCurrencyDto.put("varName", "Currency");
                valComboValueByCode.execute(paramCashCurrencyDto);

                // Amount payment must >= 0
                CommonBusinessValidator.valCompareNumber(paymentAmount.toString(), "0", CommonBusinessValidator.COMPARE_GREATER_EQUAL,
                        "CashPayment", "Zero");

                // Preparing for Cash Payment
                Dto persistCashPaymentDto = (Dto) cashDto.clone();
                persistCashPaymentDto.put("tenantId", tenantLoginId);
                prepareInsertAudit(persistCashPaymentDto, userLoginId, datetime);
                prepareUpdateAudit(persistCashPaymentDto, userLoginId, datetime);
                persistCashList.add(persistCashPaymentDto);

                // Check is Cash Balance exists
                Dto cashBalanceDto = new Dto();
                cashBalanceDto.put("tenantId", tenantLoginId);
                cashBalanceDto.put("ouId", ouId);
                cashBalanceDto.put("cashBankId", getCashBankCodeForCash(tenantLoginId, currPaymentCode).getLong("id"));
                cashBalanceDto.put("cashBankDate", docDate);
                cashBalanceDto.put("recType", PosBoConstants.RECORD_TYPE_CASH_BALANCE_DEBT);
                cashBalanceDto = isCashBalanceExistsByIndex.execute(cashBalanceDto);

                // Preparing for Cash Balance
                if (cashBalanceDto.getBoolean("exists")) {
                    // merge cash balance
                    Dto mergeCashBalanceDto = cashBalanceDto.getDto("cashBalanceDto");
                    mergeCashBalanceDto.put("amount", new Calc(Double.valueOf(mergeCashBalanceDto.get("amount").toString())).add(paymentAmount)
                            .doubleValue());
                    prepareUpdateAudit(mergeCashBalanceDto, userLoginId, datetime);

                    mergeCashBalanceList.add(mergeCashBalanceDto);
                } else {
                    // persist cash balance
                    Dto persistCashBalanceDto = new Dto();
                    persistCashBalanceDto.put("tenantId", tenantLoginId);
                    persistCashBalanceDto.put("ouId", ouId);
                    persistCashBalanceDto.put("cashBankId", getCashBankCodeForCash(tenantLoginId, currPaymentCode).getLong("id"));
                    persistCashBalanceDto.put("cashBankDate", docDate);
                    persistCashBalanceDto.put("recType", PosBoConstants.RECORD_TYPE_CASH_BALANCE_DEBT);
                    persistCashBalanceDto.put("currCode", currPaymentCode);
                    persistCashBalanceDto.put("amount", paymentAmount);
                    prepareInsertAudit(persistCashBalanceDto, userLoginId, datetime);
                    prepareUpdateAudit(persistCashBalanceDto, userLoginId, datetime);

                    persistCashBalanceList.add(persistCashBalanceDto);
                }
            }
        }

        // Looping Non Cash
        List<Dto> persistNonCashList = new ArrayList<Dto>();
        List<Dto> persistAddCostList = new ArrayList<Dto>();
        List<Dto> persistNonCashBalanceList = new ArrayList<Dto>();
        List<Dto> mergeNonCashBalanceList = new ArrayList<Dto>();
        if (nonCashList != null) {
            for (Dto nonCashDto : nonCashList) {
                // Standart Validation
                ValidationUtil.valDtoContainsKey(nonCashDto, "lineNo");
                ValidationUtil.valDtoContainsKey(nonCashDto, "deviceMerchantId");
                ValidationUtil.valBlankOrNull(nonCashDto, "cardType");
                ValidationUtil.valBlankOrNull(nonCashDto, "bankCardCode");
                ValidationUtil.valBlankOrNull(nonCashDto, "cardNo");
                ValidationUtil.valBlankOrNull(nonCashDto, "currPaymentCode");
                ValidationUtil.valNumber(nonCashDto, "paymentAmount");
                ValidationUtil.valDtoContainsKey(nonCashDto, "remark");
                ValidationUtil.valNumber(nonCashDto, "percentage");
                ValidationUtil.valNumber(nonCashDto, "addAmount");

                // Preparing Variable
                Long lineNo = nonCashDto.getLong("lineNo");
                Long deviceMerchantId = nonCashDto.getLong("deviceMerchantId");
                String cardType = nonCashDto.getString("cardType");
                String bankCardCode = nonCashDto.getString("bankCardCode");
                String currPaymentCode = nonCashDto.getString("currPaymentCode");
                Double paymentAmount = nonCashDto.getDouble("paymentAmount");
                Double percentage = nonCashDto.getDouble("percentage");
                Double addAmountNonCash = nonCashDto.getDouble("addAmount");

                // Validate device merchant id must exist
                Dto deviceMerchantDto = new Dto();
                deviceMerchantDto.put("id", deviceMerchantId);
                deviceMerchantDto = findDeviceMerchantById.execute(deviceMerchantDto);

                // Validate card Type must exists
                Dto cardTypeDto = new Dto();
                cardTypeDto.put("comboId", ComboIdPosConstants.COMBO_CARD_TYPE);
                cardTypeDto.put("code", cardType);
                cardTypeDto.put("varName", "Card Type");
                valComboValueByCode.execute(cardTypeDto);

                // Validate bank card code must exists
                Dto bankCardDto = new Dto();
                bankCardDto.put("comboId", ComboIdMasterConstants.COMBO_BANK);
                bankCardDto.put("code", bankCardCode);
                bankCardDto.put("varName", "Bank Card Code");
                valComboValueByCode.execute(bankCardDto);

                // Validate curr payment code must exists
                Dto paramCurrencyNonCashDto = new Dto();
                paramCurrencyNonCashDto.put("comboId", ComboIdMasterConstants.COMBO_CURRENCY);
                paramCurrencyNonCashDto.put("code", currPaymentCode);
                paramCurrencyNonCashDto.put("varName", "Currency");
                valComboValueByCode.execute(paramCurrencyNonCashDto);

                // Get Activity Gl Id for Charge
                Dto activityGlIdForChargeDto = new Dto();
                activityGlIdForChargeDto.put("tenantId", tenantLoginId);
                activityGlIdForChargeDto.put("parameterCode", PosBoConstants.PARAM_ACTIVITY_GL_CODE_CHARGE);
                activityGlIdForChargeDto = findSystemConfigByParamCode.execute(activityGlIdForChargeDto);
                String activityGlIdForChargeString = activityGlIdForChargeDto.getString("value");
                Long activityGlIdForCharge = new Long(activityGlIdForChargeString);

                // Preparing for Non Cash Payment
                Dto persistPosNonCashDto = (Dto) nonCashDto.clone();
                persistPosNonCashDto.put("tenantId", tenantLoginId);
                persistPosNonCashDto.put("dateExchangeRate", GeneralConstants.EMPTY_VALUE);
                persistPosNonCashDto.put("numeratorRate", 1D);
                persistPosNonCashDto.put("denominatorRate", 1D);
                persistPosNonCashDto.put("conversionAmount", paymentAmount);
                prepareInsertAudit(persistPosNonCashDto, userLoginId, datetime);
                prepareUpdateAudit(persistPosNonCashDto, userLoginId, datetime);
                persistNonCashList.add(persistPosNonCashDto);

                // Preparing for Additional Cost
                Dto persistPosAddCostDto = new Dto();
                persistPosAddCostDto.put("tenantId", tenantLoginId);
                persistPosAddCostDto.put("lineNo", lineNo);
                persistPosAddCostDto.put("refDocTypeId", docTypeId);
                persistPosAddCostDto.put("activityGlId", activityGlIdForCharge);
                persistPosAddCostDto.put("currCode", currPaymentCode);
                persistPosAddCostDto.put("percentage", percentage);
                persistPosAddCostDto.put("baseAmount", paymentAmount);
                persistPosAddCostDto.put("taxId", GeneralConstants.NULL_REF_VALUE_LONG);
                persistPosAddCostDto.put("taxPercentage", 0D); // tax percentage set 0
                persistPosAddCostDto.put("addAmount", addAmountNonCash);
                persistPosAddCostDto.put("taxAmount", 0D);
                persistPosAddCostDto.put("remark", GeneralConstants.EMPTY_VALUE);
                prepareInsertAudit(persistPosAddCostDto, userLoginId, datetime);
                prepareUpdateAudit(persistPosAddCostDto, userLoginId, datetime);
                persistPosNonCashDto.putDto("posAddCost", persistPosAddCostDto);

                // The non cash balance could be already been persisted or merged.
                // In the matter of reducing database access, try to look it first in lists
                boolean found = false;
                // Try to look in persist non cash balance list
                for (Dto tempDto : persistNonCashBalanceList) {
                    if (deviceMerchantId.equals(tempDto.getLong("deviceMerchantId")) &&
                            cardType.equals(tempDto.getString("cardType")) &&
                            bankCardCode.equals(tempDto.getString("bankCardCode"))) {
                        found = true;
                        tempDto.put("amountPayment",
                                new Calc(tempDto.getDouble("amountPayment")).add(paymentAmount).doubleValue());
                        break;
                    }
                }

                // Haven't found yet
                if (!found) {
                    // Try to look in merge non cash balance list
                    for (Dto tempDto : mergeNonCashBalanceList) {
                        if (deviceMerchantId.equals(tempDto.getLong("deviceMerchantId")) &&
                                cardType.equals(tempDto.getString("cardType")) &&
                                bankCardCode.equals(tempDto.getString("bankCardCode"))) {
                            found = true;
                            tempDto.put("amountPayment",
                                    new Calc(tempDto.getDouble("amountPayment")).add(paymentAmount).doubleValue());
                            break;
                        }
                    }
                }

                // Have been looked it in lists, but still haven't found it yet. Lastly, should check in database,
                // to decide whether should be persist or merge it.
                if (!found) {
                    // Check is Non Cash Balance exists
                    Dto nonCashBalanceDto = new Dto();
                    nonCashBalanceDto.put("tenantId", tenantLoginId);
                    nonCashBalanceDto.put("ouId", ouId);
                    nonCashBalanceDto.put("nonCashBalanceDate", docDate);
                    nonCashBalanceDto.put("deviceMerchantId", deviceMerchantId);
                    nonCashBalanceDto.put("cardType", cardType);
                    nonCashBalanceDto.put("bankCardCode", bankCardCode);
                    nonCashBalanceDto = isNonCashBalanceExistsByIndex.execute(nonCashBalanceDto);

                    // Preparing for Non Cash Balance
                    if (nonCashBalanceDto.getBoolean("exists")) {
                        // merge non cash balance
                        Dto mergeNonCashBalanceDto = nonCashBalanceDto.getDto("nonCashBalanceDto");
                        mergeNonCashBalanceDto.put("amountPayment",
                                new Calc(mergeNonCashBalanceDto.getDouble("amountPayment")).add(paymentAmount).doubleValue());
                        prepareUpdateAudit(mergeNonCashBalanceDto, userLoginId, datetime);

                        mergeNonCashBalanceList.add(mergeNonCashBalanceDto);
                    } else {
                        // persist non cash balance
                        Dto persistNonCashBalanceDto = new Dto();
                        persistNonCashBalanceDto.put("tenantId", tenantLoginId);
                        persistNonCashBalanceDto.put("ouId", ouId);
                        persistNonCashBalanceDto.put("nonCashBalanceDate", docDate);
                        persistNonCashBalanceDto.put("deviceMerchantId", deviceMerchantId);
                        persistNonCashBalanceDto.put("cardType", cardType);
                        persistNonCashBalanceDto.put("bankCardCode", bankCardCode);
                        persistNonCashBalanceDto.put("currPaymentCode", currPaymentCode);
                        persistNonCashBalanceDto.put("amountPayment", paymentAmount);
                        prepareInsertAudit(persistNonCashBalanceDto, userLoginId, datetime);
                        prepareUpdateAudit(persistNonCashBalanceDto, userLoginId, datetime);

                        persistNonCashBalanceList.add(persistNonCashBalanceDto);
                    }
                }
            }
        }

        // Preparing Cash Balance for Refund
        // Check is Cash Balance exists
        Dto cashBalanceDto = new Dto();
        cashBalanceDto.put("tenantId", tenantLoginId);
        cashBalanceDto.put("ouId", ouId);
        cashBalanceDto.put("cashBankId", getCashBankCodeForCash(tenantLoginId, currCode).getLong("id"));
        cashBalanceDto.put("cashBankDate", docDate);
        cashBalanceDto.put("recType", PosBoConstants.RECORD_TYPE_CASH_BALANCE_CREDIT);
        cashBalanceDto = isCashBalanceExistsByIndex.execute(cashBalanceDto);

        // Preparing for Cash Balance
        if (cashBalanceDto.getBoolean("exists")) {
            // merge cash balance
            Dto mergeCashBalanceDto = cashBalanceDto.getDto("cashBalanceDto");
            mergeCashBalanceDto.put("amount", new Calc(Double.valueOf(mergeCashBalanceDto.get("amount").toString())).add(totalRefund).doubleValue());
            prepareUpdateAudit(mergeCashBalanceDto, userLoginId, datetime);

            mergeCashBalanceList.add(mergeCashBalanceDto);
        } else {
            // persist cash balance
            Dto persistCashBalanceDto = new Dto();
            persistCashBalanceDto.put("tenantId", tenantLoginId);
            persistCashBalanceDto.put("ouId", ouId);
            persistCashBalanceDto.put("cashBankId", getCashBankCodeForCash(tenantLoginId, currCode).getLong("id"));
            persistCashBalanceDto.put("cashBankDate", docDate);
            persistCashBalanceDto.put("recType", PosBoConstants.RECORD_TYPE_CASH_BALANCE_CREDIT);
            persistCashBalanceDto.put("currCode", currCode);
            persistCashBalanceDto.put("amount", totalRefund);
            prepareInsertAudit(persistCashBalanceDto, userLoginId, datetime);
            prepareUpdateAudit(persistCashBalanceDto, userLoginId, datetime);

            persistCashBalanceList.add(persistCashBalanceDto);
        }

        // Get Activity Gl Id for Rounding
        Dto activityGlIdForChargeDto = new Dto();
        activityGlIdForChargeDto.put("tenantId", tenantLoginId);
        activityGlIdForChargeDto.put("parameterCode", PosBoConstants.PARAM_ACTIVITY_GL_CODE_ROUNDING);
        activityGlIdForChargeDto = findSystemConfigByParamCode.execute(activityGlIdForChargeDto);
        String activityGlIdForRoundingString = activityGlIdForChargeDto.getString("value");
        Long activityGlIdForRounding = new Long(activityGlIdForRoundingString);

        // Create Pos Add Cost for Rounding
        PointOfSalesAddCost posAddCost = new PointOfSalesAddCost();
        posAddCost.setTenantId(tenantLoginId);
        posAddCost.setLineNo(0L);
        posAddCost.setRefDocTypeId(docTypeId);
        posAddCost.setActivityGlId(activityGlIdForRounding);
        posAddCost.setCurrCode(currCode);
        posAddCost.setPercentage(0D);
        posAddCost.setBaseAmount(totalAmount);
        posAddCost.setTaxId(GeneralConstants.NULL_REF_VALUE_LONG);
        posAddCost.setTaxPercentage(0D);
        posAddCost.setAddAmount(roundingAmount);
        posAddCost.setTaxAmount(0D);
        posAddCost.setRemark(GeneralConstants.EMPTY_VALUE);

        Dto persistPosAddCostDto = new Dto(posAddCost);
        prepareInsertAudit(persistPosAddCostDto, userLoginId, datetime);
        prepareUpdateAudit(persistPosAddCostDto, userLoginId, datetime);
        persistAddCostList.add(persistPosAddCostDto);

        // Get DB Version in Parameter
        Dto dbVersionDto = new Dto();
        dbVersionDto.put("tenantId", tenantLoginId);
        dbVersionDto.put("parameterCode", MasterConstants.PARAMETER_CODE_DB_VERSION);
        dbVersionDto = findSystemConfigByParamCode.execute(dbVersionDto);
        String dbVersionString = dbVersionDto.getString("value");

        // Preparing for Log Transaction Header
        TrxLog trxLog = new TrxLog();
        trxLog.setTenantId(tenantLoginId);
        trxLog.setDocTypeId(docTypeId);
        trxLog.setDocNo(docNo);
        trxLog.setDocDate(docDate);
        trxLog.setOuId(ouId);
        trxLog.setDbVersion(dbVersionString);
        trxLog.setTrfDatetime(GeneralConstants.EMPTY_VALUE);
        trxLog.setTrfUserId(GeneralConstants.NULL_REF_VALUE_LONG);
        trxLog.setTrfCount(0D);
        trxLog.setFileCount(0D);
        trxLog.setRemark(GeneralConstants.EMPTY_VALUE);
        trxLog.setFlagSync(GeneralConstants.NO);
        trxLog.setSyncDatetime(GeneralConstants.EMPTY_VALUE);
        trxLog.setFlagSync(GeneralConstants.NO);
        trxLog.setSyncDatetime(GeneralConstants.EMPTY_VALUE);
        Dto persistTrxLogDto = new Dto(trxLog);
        prepareInsertAudit(persistTrxLogDto, userLoginId, datetime);
        prepareUpdateAudit(persistTrxLogDto, userLoginId, datetime);

        // Set persist Dto to inputDto
        inputDto.putDto("persistPosDto", persistPosDto);
        inputDto.putList("persistPosItemList", persistPosItemList);
        inputDto.putList("persistPosTaxList", persistPosTaxList);
        inputDto.putList("persistCashList", persistCashList);
        inputDto.putList("persistNonCashList", persistNonCashList);
        inputDto.putList("persistAddCostList", persistAddCostList);
        inputDto.putList("mergeProductBalanceStockList", new ArrayList<Dto>(mergeProductBalanceStockList.values()));
        inputDto.putList("persistCashBalanceList", persistCashBalanceList);
        inputDto.putList("mergeCashBalanceList", mergeCashBalanceList);
        inputDto.putList("persistNonCashBalanceList", persistNonCashBalanceList);
        inputDto.putList("mergeNonCashBalanceList", mergeNonCashBalanceList);
        inputDto.putDto("persistTrxLogDto", persistTrxLogDto);

        return null;
    }

    private void updateProductBalanceStock(Long docTypeId, String docNo, String docDate,
            Long ouId, Long userLoginId, Long tenantLoginId, String datetime,
            Double qty,
            Dto mergeProductBalanceStockDto) {

        Dto productBalanceStockDto = mergeProductBalanceStockDto.getDto("productBalanceStock");
        // Product Balance
        // Count qty opname = qty Opname - qty Item
        Double qtyOpname = new Calc(productBalanceStockDto.getDouble("qty")).subtract(qty).doubleValue();
        Double newQtyRealization = new Calc(productBalanceStockDto.getDouble("qtyRealization")).add(qty).doubleValue();

        // Update qty at product balance stock
        productBalanceStockDto.put("qty", qtyOpname);
        productBalanceStockDto.put("qtyRealization", newQtyRealization);

        Dto logProductBalanceStockDto;
        if ((logProductBalanceStockDto = mergeProductBalanceStockDto.getDto("logProductBalanceStock")) == null) {
            // Create Log for product balance stock
            LogProductBalanceStock logProductBalanceStock = new LogProductBalanceStock();
            logProductBalanceStock.setTenantId(tenantLoginId);
            logProductBalanceStock.setOuId(ouId);
            // logProductBalanceStock.setRefId(posItemId);
            logProductBalanceStock.setPartnerId(PosBoConstants.PARTNER_RETAIL);
            logProductBalanceStock.setDocTypeId(docTypeId);
            logProductBalanceStock.setDocNo(docNo);
            logProductBalanceStock.setDocDate(docDate);
            logProductBalanceStock.setProductId(productBalanceStockDto.getLong("productId"));
            logProductBalanceStock.setWarehouseId(productBalanceStockDto.getLong("warehouseId"));
            logProductBalanceStock.setProductBalanceId(productBalanceStockDto.getLong("productBalanceId"));
            logProductBalanceStock.setProductStatus(productBalanceStockDto.getString("productStatus"));
            logProductBalanceStock.setBaseUomId(productBalanceStockDto.getLong("baseUomId"));
            logProductBalanceStock.setQty(new Calc(-1).multiply(qty).doubleValue());

            logProductBalanceStockDto = new Dto(logProductBalanceStock);
            prepareInsertAudit(logProductBalanceStockDto, userLoginId, datetime);
            prepareUpdateAudit(logProductBalanceStockDto, userLoginId, datetime);

            prepareUpdateAudit(logProductBalanceStockDto, userLoginId, datetime);
            mergeProductBalanceStockDto.putDto("logProductBalanceStock", logProductBalanceStockDto);
        } else {
            // Update the qty of log for product balance stock
            logProductBalanceStockDto.put("qty", new Calc(logProductBalanceStockDto.getDouble("qty")).subtract(qty).doubleValue());
        }
    }

    private Dto getMergeProductBalanceStock(Long tenantLoginId, Long warehouseId, Long productId,
                                             Long productBalanceId, String productStatus,
                                             Map<Long, Dto> mergeProductBalanceStockList) throws Exception {

        // Validation product balance id must exists
        Dto productBalanceDto = new Dto();
        productBalanceDto.put("id", productBalanceId);
        productBalanceDto = findProductBalanceById.execute(productBalanceDto);

        // Validation product id = product id in product balance id
        if (!productBalanceDto.getLong("productId").equals(productId)) {
            throw new CoreException(PosBoExceptionConstants.INCONSISTENT_PRODUCT_ID);
        }

        // Validation product balance stock must exists
        Dto productBalanceStockDto = new Dto();
        productBalanceStockDto.put("tenantId", tenantLoginId);
        productBalanceStockDto.put("warehouseId", warehouseId);
        productBalanceStockDto.put("productId", productId);
        productBalanceStockDto.put("productBalanceId", productBalanceId);
        productBalanceStockDto.put("productStatus", productStatus);
        productBalanceStockDto = findProductBalanceStockByIndex.execute(productBalanceStockDto);

        Dto mergeProductBalanceStockDto = mergeProductBalanceStockList.get(productBalanceStockDto.getLong("id"));
        if (mergeProductBalanceStockDto == null) {
            productBalanceStockDto.put("qtyRealization", 0D);
            mergeProductBalanceStockDto = new Dto().put("productBalanceStock", productBalanceStockDto);
            mergeProductBalanceStockList.put(productBalanceStockDto.getLong("id"), mergeProductBalanceStockDto);
        }

        return mergeProductBalanceStockDto;
    }

    @SuppressWarnings("unchecked")
    @Override
    public Dto process(Dto inputDto, Dto originalDto) throws Exception {
        Dto persistPosDto = inputDto.getDto("persistPosDto");
        List<Dto> persistPosItemList = inputDto.getList("persistPosItemList");
        List<Dto> persistPosTaxList = inputDto.getList("persistPosTaxList");
        List<Dto> persistCashList = inputDto.getList("persistCashList");
        List<Dto> persistNonCashList = inputDto.getList("persistNonCashList");
        List<Dto> persistAddCostList = inputDto.getList("persistAddCostList");
        List<Dto> mergeProductBalanceStockList = inputDto.getList("mergeProductBalanceStockList");
        List<Dto> persistCashBalanceList = inputDto.getList("persistCashBalanceList");
        List<Dto> mergeCashBalanceList = inputDto.getList("mergeCashBalanceList");
        List<Dto> persistNonCashBalanceList = inputDto.getList("persistNonCashBalanceList");
        List<Dto> mergeNonCashBalanceList = inputDto.getList("mergeNonCashBalanceList");
        Dto persistTrxLogDto = inputDto.getDto("persistTrxLogDto");
        Long userLoginId = inputDto.getLong("userLoginId");
        String datetime = inputDto.getString("datetime");

        // Variable for Create logging
        Dto posDto = null;
        List<Dto> persistTrxItemLogList = new ArrayList<Dto>();
        TrxItemLog trxItemLog = null;
        Dto persistTrxItemLogDto = null;

        // Insert header data
        PointOfSales pos = GsonUtil.fromDto(persistPosDto, PointOfSales.class);
        posDao.persist(pos);
        posDto = new Dto(pos);

        // Preparing Log for POS Item
        trxItemLog = new TrxItemLog();
        trxItemLog.setTypeData(PosBoConstants.TYPE_DATA_POS);
        trxItemLog.setModeLog(PosBoConstants.LOG_MODE_ADD);
        trxItemLog.setDataLog(posDto.toString());
        trxItemLog.setRemark(GeneralConstants.EMPTY_VALUE);

        persistTrxItemLogDto = new Dto(trxItemLog);
        prepareInsertAudit(persistTrxItemLogDto, userLoginId, datetime);
        prepareUpdateAudit(persistTrxItemLogDto, userLoginId, datetime);
        persistTrxItemLogList.add(persistTrxItemLogDto);

        Long posId = pos.getId();

        // Persist detail item
        for (Dto persistPosItemDto : persistPosItemList) {
            List<Dto> persistPosAssemblyProductList = (List<Dto>) persistPosItemDto.remove("persistPosAssemblyProductList");

            PointOfSalesItem posItem = GsonUtil.fromDto(persistPosItemDto, PointOfSalesItem.class);
            posItem.setPosId(posId);
            posItemDao.persist(posItem);

            Dto posItemDto = new Dto(posItem);

            // Preparing Log for POS Item
            trxItemLog = new TrxItemLog();
            trxItemLog.setTypeData(PosBoConstants.TYPE_DATA_POS_ITEM);
            trxItemLog.setModeLog(PosBoConstants.LOG_MODE_ADD);
            trxItemLog.setDataLog(posItemDto.toString());
            trxItemLog.setRemark(GeneralConstants.EMPTY_VALUE);

            persistTrxItemLogDto = new Dto(trxItemLog);
            prepareInsertAudit(persistTrxItemLogDto, userLoginId, datetime);
            prepareUpdateAudit(persistTrxItemLogDto, userLoginId, datetime);
            persistTrxItemLogList.add(persistTrxItemLogDto);

            Long posItemId = posItem.getId();
            if (persistPosAssemblyProductList != null && !persistPosAssemblyProductList.isEmpty()) {
                // Persist detail assembly product
                for (Dto persistPosAssemblyProductDto : persistPosAssemblyProductList) {
                    PointOfSalesAssemblyProduct posAssemblyProduct = GsonUtil.fromDto(persistPosAssemblyProductDto, PointOfSalesAssemblyProduct.class);
                    posAssemblyProduct.setPosItemId(posItemId);
                    posAssemblyProductDao.persist(posAssemblyProduct);

                    Dto posAssemblyProductDto = new Dto(posAssemblyProduct);
                    posAssemblyProductDto.putLong("refLineNo", posItem.getLineNo()); // Set ref line no, that will be needed in upload data trx
                    posAssemblyProductDto.putLong("posId", posId); // Set posId, that will be needed in upload data trx

                    // Preparing Log for POS Item
                    trxItemLog = new TrxItemLog();
                    trxItemLog.setTypeData(PosBoConstants.TYPE_DATA_POS_ASSEMBLY_PRODUCT);
                    trxItemLog.setModeLog(PosBoConstants.LOG_MODE_ADD);
                    trxItemLog.setDataLog(posAssemblyProductDto.toString());
                    trxItemLog.setRemark(GeneralConstants.EMPTY_VALUE);

                    persistTrxItemLogDto = new Dto(trxItemLog);
                    prepareInsertAudit(persistTrxItemLogDto, userLoginId, datetime);
                    prepareUpdateAudit(persistTrxItemLogDto, userLoginId, datetime);
                    persistTrxItemLogList.add(persistTrxItemLogDto);
                }
            }
        }

        // Persist tax list
        for (Dto persistPosTaxDto : persistPosTaxList) {
            PointOfSalesTax posTax = GsonUtil.fromDto(persistPosTaxDto, PointOfSalesTax.class);
            posTax.setPosId(posId);
            posTaxDao.persist(posTax);

            Dto posTaxDto = new Dto(posTax);

            // Preparing Log for POS Tax
            trxItemLog = new TrxItemLog();
            trxItemLog.setTypeData(PosBoConstants.TYPE_DATA_POS_TAX);
            trxItemLog.setModeLog(PosBoConstants.LOG_MODE_ADD);
            trxItemLog.setDataLog(posTaxDto.toString());
            trxItemLog.setRemark(GeneralConstants.EMPTY_VALUE);

            persistTrxItemLogDto = new Dto(trxItemLog);
            prepareInsertAudit(persistTrxItemLogDto, userLoginId, datetime);
            prepareUpdateAudit(persistTrxItemLogDto, userLoginId, datetime);
            persistTrxItemLogList.add(persistTrxItemLogDto);

        }

        // Persist cash list
        for (Dto persistCashDto : persistCashList) {
            PointOfSalesCashPayment posCashPayment = GsonUtil.fromDto(persistCashDto, PointOfSalesCashPayment.class);
            posCashPayment.setPosId(posId);
            posCashPaymentDao.persist(posCashPayment);

            Dto cashDto = new Dto(posCashPayment);

            // Preparing Log for POS Cash Payment
            trxItemLog = new TrxItemLog();
            trxItemLog.setTypeData(PosBoConstants.TYPE_DATA_POS_CASH_PAYMENT);
            trxItemLog.setModeLog(PosBoConstants.LOG_MODE_ADD);
            trxItemLog.setDataLog(cashDto.toString());
            trxItemLog.setRemark(GeneralConstants.EMPTY_VALUE);

            persistTrxItemLogDto = new Dto(trxItemLog);
            prepareInsertAudit(persistTrxItemLogDto, userLoginId, datetime);
            prepareUpdateAudit(persistTrxItemLogDto, userLoginId, datetime);
            persistTrxItemLogList.add(persistTrxItemLogDto);
        }

        // Persist non cash list
        for (Dto persistNonCashDto : persistNonCashList) {
            Dto posAddCostDto = (Dto) persistNonCashDto.remove("posAddCost");

            PointOfSalesNonCashPayment posNonCashPayment = GsonUtil.fromDto(persistNonCashDto, PointOfSalesNonCashPayment.class);
            posNonCashPayment.setPosId(posId);
            posNonCashPaymentDao.persist(posNonCashPayment);

            PointOfSalesAddCost posAddCost = GsonUtil.fromDto(posAddCostDto, PointOfSalesAddCost.class);
            posAddCost.setRefId(posNonCashPayment.getId());
            posAddCost.setPosId(posId);
            posAddCostDao.persist(posAddCost);

            Dto nonCashDto = new Dto(posNonCashPayment);
            Dto addCostDto = new Dto(posAddCost);

            // Preparing Log for POS Non Cash Payment
            trxItemLog = new TrxItemLog();
            trxItemLog.setTypeData(PosBoConstants.TYPE_DATA_POS_NON_CASH_PAYMENT);
            trxItemLog.setModeLog(PosBoConstants.LOG_MODE_ADD);
            trxItemLog.setDataLog(nonCashDto.toString());
            trxItemLog.setRemark(GeneralConstants.EMPTY_VALUE);

            persistTrxItemLogDto = new Dto(trxItemLog);
            prepareInsertAudit(persistTrxItemLogDto, userLoginId, datetime);
            prepareUpdateAudit(persistTrxItemLogDto, userLoginId, datetime);
            persistTrxItemLogList.add(persistTrxItemLogDto);

            // Preparing Log for POS Additional Cost
            trxItemLog = new TrxItemLog();
            trxItemLog.setTypeData(PosBoConstants.TYPE_DATA_POS_ADD_COST);
            trxItemLog.setModeLog(PosBoConstants.LOG_MODE_ADD);
            trxItemLog.setDataLog(addCostDto.toString());
            trxItemLog.setRemark(GeneralConstants.EMPTY_VALUE);

            persistTrxItemLogDto = new Dto(trxItemLog);
            prepareInsertAudit(persistTrxItemLogDto, userLoginId, datetime);
            prepareUpdateAudit(persistTrxItemLogDto, userLoginId, datetime);
            persistTrxItemLogList.add(persistTrxItemLogDto);
        }

        // Persist additional cost
        for (Dto persistAddCostDto : persistAddCostList) {
            PointOfSalesAddCost posAddCost = GsonUtil.fromDto(persistAddCostDto, PointOfSalesAddCost.class);
            posAddCost.setPosId(posId);
            posAddCost.setRefId(posId);
            posAddCostDao.persist(posAddCost);

            Dto addCostDto = new Dto(posAddCost);

            // Preparing Log for POS Additional Cost
            trxItemLog = new TrxItemLog();
            trxItemLog.setTypeData(PosBoConstants.TYPE_DATA_POS_ADD_COST);
            trxItemLog.setModeLog(PosBoConstants.LOG_MODE_ADD);
            trxItemLog.setDataLog(addCostDto.toString());
            trxItemLog.setRemark(GeneralConstants.EMPTY_VALUE);

            persistTrxItemLogDto = new Dto(trxItemLog);
            prepareInsertAudit(persistTrxItemLogDto, userLoginId, datetime);
            prepareUpdateAudit(persistTrxItemLogDto, userLoginId, datetime);
            persistTrxItemLogList.add(persistTrxItemLogDto);
        }

        QueryBuilder builder;
        Query q;
        // Merge Product Balance Stock
        for (Dto productBalanceStockDto : mergeProductBalanceStockList) {
            /*ProductBalanceStock productBalanceStock = GsonUtil.fromDto(productBalanceStockDto.getDto("productBalanceStock"), ProductBalanceStock.class);
            productBalanceStock = productBalanceStockDao.merge(productBalanceStock.getId(), productBalanceStock);*/

            //log.info(">>>>PRODUCTBALANCESTOCKDTO :"+productBalanceStockDto);

            builder = new QueryBuilder();
            builder.add("UPDATE ").add(ProductBalanceStock.TABLE_NAME)
                   .add(" SET qty = qty - :qtyRealization, ")
                   .add(" update_datetime = :updateDatetime, ")
                   .add(" update_user_id = :updateUserId, ")
                   .add(" version = version+1 ")
                   .add(" WHERE product_balance_stock_id = :id");

            q = productBalanceStockDao.createNativeQuery(builder.toString());


            q.setParameter("updateDatetime", productBalanceStockDto.getDto("productBalanceStock").getString("updateDateTime"));
            q.setParameter("updateUserId", productBalanceStockDto.getDto("productBalanceStock").getLong("updateUserId"));
            q.setParameter("qtyRealization", Double.valueOf(productBalanceStockDto.getDto("productBalanceStock").getString("qtyRealization")));
            q.setParameter("id", productBalanceStockDto.getDto("productBalanceStock").getLong("id"));

            //log.info("querynya:::"+ builder.toString());

            q.executeUpdate();

            // Persist Log Product Balance Stock
            LogProductBalanceStock logProductBalanceStock = GsonUtil.fromDto(productBalanceStockDto.getDto("logProductBalanceStock"),
                    LogProductBalanceStock.class);
            logProductBalanceStock.setRefId(posId);
            logProductBalanceStockDao.persist(logProductBalanceStock);
        }

        // Merge Cash Balance
        for (Dto cashBalanceDto : mergeCashBalanceList) {
            CashBalance cashBalance = GsonUtil.fromDto(cashBalanceDto, CashBalance.class);
            cashBalance = cashBalanceDao.merge(cashBalance.getId(), cashBalance);
        }

        // Persist Cash Balance
        for (Dto cashBalanceDto : persistCashBalanceList) {
            CashBalance cashBalance = GsonUtil.fromDto(cashBalanceDto, CashBalance.class);
            cashBalanceDao.persist(cashBalance);
        }

        // Merge Non Cash Balance
        for (Dto nonCashBalanceDto : mergeNonCashBalanceList) {
            NonCashBalance nonCashBalance = GsonUtil.fromDto(nonCashBalanceDto, NonCashBalance.class);
            nonCashBalance = nonCashBalanceDao.merge(nonCashBalance.getId(), nonCashBalance);
        }

        // Persist Non Cash Balance
        for (Dto nonCashBalanceDto : persistNonCashBalanceList) {
            NonCashBalance nonCashBalance = GsonUtil.fromDto(nonCashBalanceDto, NonCashBalance.class);
            nonCashBalanceDao.persist(nonCashBalance);
        }

        // Create Log Transaction for every list

        // Persist Trx Log Header
        TrxLog trxLog = GsonUtil.fromDto(persistTrxLogDto, TrxLog.class);
        trxLogDao.persist(trxLog);
        Long trxLogId = trxLog.getId();

        // Persist Trx Item Log
        for (Dto persisttrxLogItemDto : persistTrxItemLogList) {
            TrxItemLog persisttrxItemLog = GsonUtil.fromDto(persisttrxLogItemDto, TrxItemLog.class);
            persisttrxItemLog.setTrxLogId(trxLogId);

            trxItemLogDao.persist(persisttrxItemLog);
        }

        return posDto;
    }

    /**
     * Get cash bank code for flag cash bank = CASH from a currency
     *
     * @param tenantId
     * @param currencyCode
     * @return
     * @throws Exception
     */
    @SuppressWarnings("unchecked")
    private Dto getCashBankCodeForCash(Long tenantId, String currencyCode) throws Exception {
        Dto inputDtoForGetCashAccountList = new Dto();
        inputDtoForGetCashAccountList.put("tenantId", tenantId);
        inputDtoForGetCashAccountList.put("code", GeneralConstants.EMPTY_VALUE);
        inputDtoForGetCashAccountList.put("name", GeneralConstants.EMPTY_VALUE);
        inputDtoForGetCashAccountList.put("flagCashBank", MasterConstants.FLAG_CASH);
        inputDtoForGetCashAccountList.put("bankCode", CommonConstants.ID_NOT_USED.toString());
        inputDtoForGetCashAccountList.put("currencyCode", currencyCode);
        inputDtoForGetCashAccountList.put("active", GeneralConstants.YES);

        // Processing
        Dto outputDtoForGetCashAccountList = getCashBankListAdvance.execute(inputDtoForGetCashAccountList);

        List<Dto> cashBankList = outputDtoForGetCashAccountList.getList("cashBankList");
        if (cashBankList.size() != 0) {
            return new Dto().put("id", cashBankList.get(0).getLong("id")).put("code", cashBankList.get(0).getString("code"));
        } else {
            throw new CoreException(PosBoExceptionConstants.POS_CASH_NOT_FOUND);
        }
    }

}