backup_VoidPosShopForSasaObsolete

package org.jleaf.erp.pos_intgr.bo.pos;

import org.jleaf.common.CommonConstants;
import org.jleaf.common.CommonExceptionConstants;
import org.jleaf.core.*;
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.cb.dao.BalanceSettlementDao;
import org.jleaf.erp.cb.dao.CashBankBalanceDao;
import org.jleaf.erp.cb.entity.BalanceSettlement;
import org.jleaf.erp.cb.entity.CashBankBalance;
import org.jleaf.erp.inv.dao.LogProductBalanceStockDao;
import org.jleaf.erp.inv.dao.ProductBalanceStockDao;
import org.jleaf.erp.inv.entity.LogProductBalanceStock;
import org.jleaf.erp.inv.entity.ProductBalanceStock;
import org.jleaf.erp.master.MasterConstants;
import org.jleaf.erp.pos_intgr.PosIntegrationConstants;
import org.jleaf.erp.pos_intgr.PosIntegrationExceptionConstants;
import org.jleaf.erp.pos_intgr.PosIntegrationExceptionConstantsForSasa;
import org.jleaf.erp.pos_intgr.dao.*;
import org.jleaf.erp.pos_intgr.entity.*;
import org.jleaf.util.Calc;
import org.jleaf.util.GsonUtil;
import org.jleaf.util.ValidationUtil;
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;

import javax.persistence.Query;
import java.util.*;

/**
 * Void POS Shop
 *
 * @author WTC, May 10, 2013
 * @version 1.0.0
 */

/**
 * Menambahkan insert ke in_log_nempil_barang_balance_stock
 * modified by Adrian
 * Jul 7, 2017
 */
//@Service("voidPosShop")
@Service
//@formatter:off
@InfoIn(value = {
        @Info(name = "id", description = "Point of Sales Id", type = Long.class),
        @Info(name = "refProcessNo", description = "POS process no", type = String.class),
        @Info(name = "version", description = "version", type = Long.class),
        @Info(name = "voidDate", description = "void Date", type = String.class),
        @Info(name = "reason", description = "void reason", type = String.class),
        @Info(name = "remark", description = "void remark", type = String.class),
        @Info(name = "securityCode", description = "security code for voiding POS transaction", type = String.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 = "processNo", description = "process no", type = String.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,
        CommonExceptionConstants.USER_ID_NOT_FOUND,
        PosIntegrationExceptionConstants.POS_ID_NOT_FOUND,
        PosIntegrationExceptionConstants.POS_ALREADY_VOIDED,
        PosIntegrationExceptionConstants.POS_NOT_SUBMITTED,
        PosIntegrationExceptionConstants.POS_TRANSFERRED_TO_SERVER,
        PosIntegrationExceptionConstants.PRODUCT_BALANCE_STOCK_NOT_FOUND,
        PosIntegrationExceptionConstants.OUTLET_SECURITY_CODE_NOT_FOUND,
        PosIntegrationExceptionConstants.INVALID_SECURITY_CODE,
        PosIntegrationExceptionConstants.OUTLET_NOT_FOUND,
        PosIntegrationExceptionConstants.OUTLET_NOT_ACTIVATED
})
//@formatter:on
public class VoidPosShopForSasaObsolete extends DefaultBusinessTransaction implements BusinessTransaction {
    private static final Logger log = LoggerFactory.getLogger(VoidPosShopForSasaObsolete.class);
    @Autowired
    private PointOfSalesDao posDao;

    @Autowired
    private PointOfSalesItemDao posItemDao;

    @Autowired
    private PointOfSalesExtSasaDao pointOfSalesExtSasaDao;

    @Autowired
    private ProductBalanceStockDao productBalanceStockDao;

    @Autowired
    private NempilBarangBalanceStockDao nempilBarangBalanceStockDao;

    @Autowired
    private LogProductBalanceStockDao logProductBalanceStockDao;

    @Autowired
    private LogNempilBarangBalanceStockDao logNempilBarangBalanceStockDao;

    @Autowired
    private CashBankBalanceDao cashBankBalanceDao;

    @Autowired
    private BalanceSettlementDao balanceSettlementDao;

    @Autowired
    private TrxLogVoidedPosCustomDao trxLogVoidedPosCustomDao;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    @SuppressWarnings("unchecked")
    @Override
    public Dto prepare(Dto inputDto, Dto originalDto) throws Exception {
        // Standard Validation
        ValidationUtil.valDtoContainsKey(inputDto, "id");
        ValidationUtil.valBlankOrNull(inputDto, "refProcessNo");
        ValidationUtil.valBlankOrNull(inputDto, "reason");
        ValidationUtil.valBlankOrNull(inputDto, "securityCode");
        ValidationUtil.valLong(inputDto, "version");
        ValidationUtil.valDtoContainsKey(inputDto, "userLoginId");
        ValidationUtil.valDtoContainsKey(inputDto, "roleLoginId");
        ValidationUtil.valDtoContainsKey(inputDto, "tenantLoginId");
        ValidationUtil.valBlankOrNull(inputDto, "datetime");

        // Preparing input parameters
        Long id = inputDto.getLong("id");
        Long userLoginId = inputDto.getLong("userLoginId");
        Long roleLoginId = inputDto.getLong("roleLoginId");
        Long tenantLoginId = inputDto.getLong("tenantLoginId");
        String datetime = inputDto.getString("datetime");
        String voidDate = inputDto.getString("voidDate");
        String refProcessNo = inputDto.getString("refProcessNo");

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

        // Find POS by id
        Dto posDto = new Dto();
        posDto.put("id", id);
        posDto.put("processNo", refProcessNo);
        posDto.put("tenantId", tenantLoginId);
        posDto = findPosById.execute(posDto);

        Dto posForVoidDto = new Dto();
        posForVoidDto.put("id", id);
        posForVoidDto.put("processNo", refProcessNo);
        posForVoidDto.put("tenantId", tenantLoginId);
        posForVoidDto = findPosById.execute(posForVoidDto);

        Long docTypeId = posDto.getLong("docTypeId");
        String docNo = posDto.getString("docNo");
        String docDate = posDto.getString("docDate");
        Long ouId = posDto.getLong("ouId");
        String currCode = posDto.getString("currCode");
        Double totalRefund = posDto.getDouble("totalRefund");
        String status = posDto.getString("status");
        String processNo = docNo; // TODO: harusnya autonum

        log.info("Value of void Date: "+voidDate);
        log.info("Value of doc Date: "+docDate);

        // validasi pos bisa divoid atau tidak
        valVoid(docNo, docDate, ouId, tenantLoginId, posDto.getDouble("totalPayment"));

        // Validate the pos status must be S (submitted)
        if (!PosIntegrationConstants.SUBMITTED_TRANSACTION.equals(status)) {
            if (PosIntegrationConstants.VOIDED_TRANSACTION.equals(status))
                throw new CoreException(PosIntegrationExceptionConstants.POS_ALREADY_VOIDED);
            else
                throw new CoreException(PosIntegrationExceptionConstants.POS_NOT_SUBMITTED);
        }

        // Validate the outlet has been activated, by index.
        Dto outletDto = valOutletActivatedByIndex.execute(new Dto().put("tenantId", tenantLoginId).put("ouId", ouId));
        Long outletId = outletDto.getLong("id");
        Long warehouseId = outletDto.getLong("warehouseId");

        Dto valDocDateDto = new Dto();
        valDocDateDto.put("tenantId", tenantLoginId);
        valDocDateDto.put("docDate", voidDate);
        valDocDateDto.put("ouId", ouId);
        valDocCanInputByDate.execute(valDocDateDto);

        // Validate the security code is valid
        Dto valVoidPosDto = new Dto();
        valVoidPosDto.put("tenantId", tenantLoginId);
        valVoidPosDto.put("securityCode", inputDto.getString("securityCode"));
        valVoidPosDto.put("ouId", ouId);
        valVoidPos.execute(valVoidPosDto);

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

        // Preparing Input Header
        Dto mergePosDto = (Dto) posDto.clone();
        mergePosDto.put("status", PosIntegrationConstants.VOIDED_TRANSACTION);
        mergePosDto.put("version", inputDto.getLong("version"));
        mergePosDto.put("updateUsername", username);
        prepareUpdateAudit(mergePosDto, userLoginId, datetime);

        // Preparing log voided POS dto
        Dto persistLogVoidedPosDto = new Dto();
        persistLogVoidedPosDto.putLong("trxLogVoidedPosCustomPk.id", GeneralConstants.NULL_REF_VALUE_LONG);
        persistLogVoidedPosDto.putString("trxLogVoidedPosCustomPk.processNo", processNo);
        persistLogVoidedPosDto.putLong("trxLogVoidedPosCustomPk.tenantId", tenantLoginId);
        persistLogVoidedPosDto.putLong("docTypeId", PosIntegrationConstants.DOCUMENT_VOID_SALES_RETAIL_SHOP);
        persistLogVoidedPosDto.putString("docNo", docNo);
        persistLogVoidedPosDto.putString("docDate", voidDate);
        persistLogVoidedPosDto.putLong("ouId", ouId);
        persistLogVoidedPosDto.putLong("refDocTypeId", docTypeId);
        persistLogVoidedPosDto.putLong("refId", id);
        persistLogVoidedPosDto.putString("reason", inputDto.getString("reason"));
        persistLogVoidedPosDto.putString("remark", inputDto.getString("remark"));
        persistLogVoidedPosDto.putString("securityCode", inputDto.getString("securityCode"));
        prepareInsertAudit(persistLogVoidedPosDto, userLoginId, datetime);
        prepareUpdateAudit(persistLogVoidedPosDto, userLoginId, datetime);

        // Looping detail item
        // Update product balance stock
        Dto paramPosItemListDto = new Dto();
        paramPosItemListDto.putLong("posId", id);
        paramPosItemListDto.putString("processNo", refProcessNo);
        paramPosItemListDto.putLong("tenantId", tenantLoginId);
        List<Dto> posItemList = getPosItemListByPosId.execute(paramPosItemListDto).getList("posItemList");
        Map<Long, Dto> mergeProductBalanceStockList = new HashMap<Long, Dto>();
        if (posItemList != null) {
            for (Dto posItemDto : posItemList) {

                // Preparing Variable
                Long productId = posItemDto.getLong("productId");
                Long productBalanceId = posItemDto.getLong("productBalanceId");
                String productStatus = PosIntegrationConstants.DEFAULT_PRODUCT_STATUS;
                Double qty = posItemDto.getDouble("qty");

                Dto mergeProductBalanceStockDto = null;
                if (GeneralConstants.NULL_REF_VALUE_LONG.equals(productBalanceId)) {
                    List<Dto> posAssemblyProductList = getPosAssemblyProductListByPosItemId.execute(
                            new Dto().putLong("posItemId", posItemDto.getLong("id"))).getList("posAssemblyProductList");
                    for (Dto posAssemblyProductDto : posAssemblyProductList) {
                        productId = posAssemblyProductDto.getLong("productId");
                        productBalanceId = posAssemblyProductDto.getLong("productBalanceId");
                        productStatus = posAssemblyProductDto.getString("productStatus");
                        qty = posAssemblyProductDto.getDouble("qty");

                        mergeProductBalanceStockDto = getMergeProductBalanceStock(tenantLoginId, warehouseId, productId, productBalanceId,
                                                        productStatus, mergeProductBalanceStockList, userLoginId, datetime);

                        updateProductBalanceStock(docNo, voidDate, ouId, userLoginId,
                                tenantLoginId, datetime, qty, mergeProductBalanceStockDto);
                    }
                } else {
                    mergeProductBalanceStockDto = getMergeProductBalanceStock(tenantLoginId, warehouseId, productId, productBalanceId,
                                                    productStatus, mergeProductBalanceStockList, userLoginId, datetime);

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

        // TODO: 27/02/20 Prepare input POS for Refund
        Dto persistPosDto = (Dto) posForVoidDto.clone();
        persistPosDto.put("docNo", persistPosDto.getString("docNo").concat("_").concat(CommonConstants.STATE_VOID));
        persistPosDto.put("pointOfSalesPk.id", GeneralConstants.NULL_REF_VALUE_LONG);
        persistPosDto.put("pointOfSalesPk.processNo", persistPosDto.getString("docNo"));
        persistPosDto.put("pointOfSalesPk.tenantId", tenantLoginId);
        persistPosDto.put("status", PosIntegrationConstants.SUBMITTED_TRANSACTION);
        persistPosDto.put("createUsername", username);
        persistPosDto.put("updateUsername", username);
        persistPosDto.put("docDate", voidDate);
        persistPosDto.put("remark", inputDto.getString("remark"));
        persistPosDto.put("grossAmount", persistPosDto.getDouble("grossAmount")*(-1));
        persistPosDto.put("nettAmount", persistPosDto.getDouble("nettAmount")*(-1));
        persistPosDto.put("addAmount", persistPosDto.getDouble("addAmount")*(-1));
        persistPosDto.put("totalAmount", persistPosDto.getDouble("totalAmount")*(-1));
        persistPosDto.put("roundingAmount", persistPosDto.getDouble("roundingAmount")*(-1));
        persistPosDto.put("totalPayment", persistPosDto.getDouble("totalPayment")*(-1));
        persistPosDto.put("totalRefund", persistPosDto.getDouble("totalRefund")*(-1));
        prepareInsertAudit(persistPosDto, userLoginId, datetime);
        prepareUpdateAudit(persistPosDto, userLoginId, datetime);

        String processNoForVoid = persistPosDto.getString("pointOfSalesPk.processNo");

        log.info("Value of Void POS Persist: "+persistPosDto);

        // TODO: 27/02/20 Prepare input POS item for refund
        Map<Long, Dto> persistPosItemList = new HashMap<Long, Dto>();
        if (posItemList != null) {
            for (Dto posItemDto : posItemList) {

                Dto findPosItem = new Dto();
                findPosItem.put("id", posItemDto.getLong("id"));
                findPosItem = findPosItemById.execute(findPosItem);

                Double qty = findPosItem.getDouble("qty");
                Double nettAmountItem = findPosItem.getDouble("nettAmountItem");

                findPosItem.put("processNo", processNoForVoid);
                findPosItem.put("qty", qty*(-1));
                findPosItem.put("nettAmountItem", nettAmountItem*(-1));
                prepareInsertAudit(findPosItem, userLoginId, datetime);
                prepareUpdateAudit(findPosItem, userLoginId, datetime);

                persistPosItemList.put(findPosItem.getLong("id"), new Dto().put("posItemDto", findPosItem));
            }
        }
        log.info("Value of Void POS Item Persist: "+persistPosItemList);

        // Looping detail item nempil
        // Update product nempil balance stock
        Dto paramPosItemNempilListDto = new Dto();
        paramPosItemNempilListDto.putLong("posId", id);
        paramPosItemNempilListDto.putString("processNo", refProcessNo);
        paramPosItemNempilListDto.putLong("tenantId", tenantLoginId);
        List<Dto> posItemNempilList = getPosItemNempilListByPosId.execute(paramPosItemNempilListDto).getList("posItemNempilList");
        Map<Long, Dto> mergeProductNempilBalanceStockList = new HashMap<Long, Dto>();
        if (posItemNempilList != null) {
            for (Dto posItemNempilDto : posItemNempilList) {

                // Preparing Variable
                Long productId = posItemNempilDto.getLong("id");
                String productCode = posItemNempilDto.getString("productCode");
                Double qty = posItemNempilDto.getDouble("qty");
                Double sellPrice = posItemNempilDto.getDouble("sellPrice");
                Double grossSellPrice = posItemNempilDto.getDouble("grossSellPrice");

                Dto mergeNempilBarangBalanceStockDto = null;
                mergeNempilBarangBalanceStockDto = getMergeNempilBarangBalanceStock(tenantLoginId, ouId, productCode, productId,
                        mergeProductNempilBalanceStockList);

                updateNempilBarangBalanceStock(docNo, voidDate, ouId, userLoginId, tenantLoginId, datetime, qty, mergeNempilBarangBalanceStockDto);
            }
        }

        // Looping Cash
        // Update cash balance
        Dto paramPosCashPaymentListDto = new Dto();
        paramPosCashPaymentListDto.putLong("posId", id);
        paramPosCashPaymentListDto.putString("processNo", refProcessNo);
        paramPosCashPaymentListDto.putLong("tenantId", tenantLoginId);
        List<Dto> cashList = getPosCashPaymentListByPosId.execute(paramPosCashPaymentListDto).getList("posCashPaymentList");
        List<Dto> persistCashBalanceList = new ArrayList<Dto>();
        List<Dto> mergeCashBalanceList = new ArrayList<Dto>();
        if (cashList != null) {
            for (Dto cashDto : cashList) {

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

                Dto findCashBankOuByIdDto = findCashBankOuById.execute(new Dto().put("cashBankId", getCashBankDataOutletList(outletId, currPaymentCode).getLong("id")));

                // Check is Cash Balance exists
                Dto cashBalanceDto = new Dto();
                cashBalanceDto.put("tenantId", tenantLoginId);
                cashBalanceDto.put("ouId", findCashBankOuByIdDto.getLong("ouId"));
                cashBalanceDto.put("cashBankId", getCashBankDataOutletList(outletId, currPaymentCode).getLong("id"));
                cashBalanceDto.put("cashBankDate", voidDate);
                cashBalanceDto.put("recType", PosIntegrationConstants.RECORD_TYPE_CASH_BALANCE_CREDIT);
                cashBalanceDto = isCashBankBalanceExistsByIndex.execute(cashBalanceDto);

                // Preparing for Cash Balance
                if (cashBalanceDto.getBoolean("exists")) {
                    // merge cash balance
                    Dto mergeCashBalanceDto = cashBalanceDto.getDto("cashBankBalanceDto");
                    mergeCashBalanceDto.put("amount", new Calc(mergeCashBalanceDto.getDouble("amount")).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", findCashBankOuByIdDto.getLong("ouId"));
                    persistCashBalanceDto.put("cashBankId", getCashBankDataOutletList(outletId, currPaymentCode).getLong("id"));
                    persistCashBalanceDto.put("cashBankDate", voidDate);
                    persistCashBalanceDto.put("recType", PosIntegrationConstants.RECORD_TYPE_CASH_BALANCE_CREDIT);
                    persistCashBalanceDto.put("currCode", currPaymentCode);
                    persistCashBalanceDto.put("amount", paymentAmount);
                    prepareInsertAudit(persistCashBalanceDto, userLoginId, datetime);

                    persistCashBalanceList.add(persistCashBalanceDto);
                }
            }
        }

        // Looping Non Cash
        // Update Non Cash Balance
        Dto paramPosNonCashPaymentListDto = new Dto();
        paramPosNonCashPaymentListDto.putLong("posId", id);
        paramPosNonCashPaymentListDto.putString("processNo", refProcessNo);
        paramPosNonCashPaymentListDto.putLong("tenantId", tenantLoginId);
        List<Dto> nonCashList = getPosNonCashPaymentListByPosId.execute(paramPosNonCashPaymentListDto).getList("posNonCashPaymentList");
        List<Dto> mergeNonCashBalanceList = new ArrayList<Dto>();
        if (nonCashList != null) {
            for (Dto nonCashDto : nonCashList) {
                Long deviceMerchantId = nonCashDto.getLong("deviceMerchantId");
                String cardType = nonCashDto.getString("cardType");
                String bankCardCode = nonCashDto.getString("bankCardCode");
                String cardNo = nonCashDto.getString("cardNo");

                // The non cash balance could be already merged. Try to look it in the list first.
                boolean merged = false;
                for (Dto tempDto : mergeNonCashBalanceList) {
                    if (deviceMerchantId.equals(tempDto.getLong("deviceMerchantId")) &&
                            cardType.equals(tempDto.getString("cardType")) &&
                            bankCardCode.equals(tempDto.getString("bankCardCode")) &&
                            cardNo.equals(tempDto.getString("cardNo"))) {
                        merged = true;
                        tempDto.put("amountPayment",
                                new Calc(tempDto.getDouble("amountPayment")).subtract(nonCashDto.getDouble("paymentAmount")).doubleValue());
                        break;
                    }
                }

                // The non cash balance hasn't been merged yet. Find and merge it
                if (!merged) {
                    Dto nonCashBalanceDto = new Dto();
                    nonCashBalanceDto.put("tenantId", tenantLoginId);
                    nonCashBalanceDto.put("ouId", ouId);
                    nonCashBalanceDto.put("docTypeId", docTypeId);
                    nonCashBalanceDto.put("docNo", docNo);
                    nonCashBalanceDto.put("docDate", voidDate);
                    nonCashBalanceDto.put("deviceMerchantId", deviceMerchantId);
                    nonCashBalanceDto.put("cardType", cardType);
                    nonCashBalanceDto.put("bankCardCode", bankCardCode);
                    nonCashBalanceDto.put("cardNo", cardNo);
                    nonCashBalanceDto = findBalanceSettlementByIndex.execute(nonCashBalanceDto);

                    // merge non cash balance
                    nonCashBalanceDto.put("amountPayment",
                            new Calc(nonCashBalanceDto.getDouble("amountPayment")).subtract(nonCashDto.getDouble("paymentAmount")).doubleValue());
                    prepareUpdateAudit(nonCashBalanceDto, userLoginId, datetime);

                    mergeNonCashBalanceList.add(nonCashBalanceDto);
                }
            }
        }

        // Update Cash Balance for Refund
        if(totalRefund.doubleValue() > 0D){
            // Check is Cash Balance exists
            Dto cashBalanceDto = new Dto();
            cashBalanceDto.put("tenantId", tenantLoginId);
            cashBalanceDto.put("ouId", ouId);
            cashBalanceDto.put("cashBankId", getCashBankDataOutletList(outletId, currCode).getLong("id"));
            cashBalanceDto.put("cashBankDate", voidDate);
            cashBalanceDto.put("recType", PosIntegrationConstants.RECORD_TYPE_CASH_BALANCE_DEBT);
            cashBalanceDto = isCashBankBalanceExistsByIndex.execute(cashBalanceDto);

            // Preparing for Cash Balance

            if (cashBalanceDto.getBoolean("exists")) {
                // merge cash balance
                Dto mergeCashBalanceDto = cashBalanceDto.getDto("cashBankBalanceDto");
                mergeCashBalanceDto.put("amount", new Calc(mergeCashBalanceDto.getDouble("amount")).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", getCashBankDataOutletList(outletId, currCode).getLong("id"));
                persistCashBalanceDto.put("cashBankDate", voidDate);
                persistCashBalanceDto.put("recType", PosIntegrationConstants.RECORD_TYPE_CASH_BALANCE_DEBT);
                persistCashBalanceDto.put("currCode", currCode);
                persistCashBalanceDto.put("amount", totalRefund);
                prepareInsertAudit(persistCashBalanceDto, userLoginId, datetime);

                persistCashBalanceList.add(persistCashBalanceDto);
            }
        }

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

        // Set persist Dto to inputDto
        inputDto.putDto("mergePosDto", mergePosDto);
        inputDto.putDto("persistPosDto", persistPosDto);
        inputDto.putList("mergeProductBalanceStockList", new ArrayList<Dto>(mergeProductBalanceStockList.values()));
        inputDto.putList("mergeProductNempilBalanceStockList", new ArrayList<Dto>(mergeProductNempilBalanceStockList.values()));
        inputDto.putList("persistPosItemList", new ArrayList<Dto>(persistPosItemList.values()));
        inputDto.putList("persistCashBalanceList", persistCashBalanceList);
        inputDto.putList("mergeCashBalanceList", mergeCashBalanceList);
        inputDto.putList("mergeNonCashBalanceList", mergeNonCashBalanceList);
        inputDto.putDto("persistLogVoidedPosDto", persistLogVoidedPosDto);
        inputDto.putString("dbVersion", dbVersionString);

        return null;
    }

    private void valVoid(String docNo, String docDate, Long ouId, Long tenantId, Double totalPayment) {
        QueryBuilder builderValVoid = new QueryBuilder();
        builderValVoid.add(" SELECT COUNT(1) ")
                     .add(" FROM fi_invoice_ar_balance A ")
                     .add(" INNER JOIN fi_invoice_ar B ON A.invoice_ar_id = B.invoice_ar_id ")
                     .add(" INNER JOIN m_ou_structure C ON B.ou_id = C.ou_bu_id AND C.ou_id = :ouId ")
                     .add(" WHERE B.tenant_id = :tenantId ")
                     .add(" AND B.doc_type_id = :docTypeIdDebtNoteAr ")
                     .add(" AND B.doc_no = :docNo ")
                     .add(" AND B.doc_date = :docDate ")
                     .add(" AND A.doc_type_id = :docTypeIdDebtNoteAr ")
                     .add(" AND ((A.flg_payment = :NO AND A.payment_amount <> :totalPayment) OR (A.flg_payment = :inProgress AND A.payment_amount <> 0) OR (A.flg_payment = :YES AND A.payment_amount <> 0)) ");

        Query queryValVoid = posDao.createNativeQuery(builderValVoid.toString());
        queryValVoid.setParameter("ouId", ouId);
        queryValVoid.setParameter("tenantId", tenantId);
        queryValVoid.setParameter("docTypeIdDebtNoteAr", 241);
        queryValVoid.setParameter("docNo", docNo);
        queryValVoid.setParameter("docDate", docDate);
        queryValVoid.setParameter("inProgress", PosIntegrationConstants.IN_PROGRESS_TRANSACTION);
        queryValVoid.setParameter("YES", GeneralConstants.YES);
        queryValVoid.setParameter("NO", GeneralConstants.NO);
        queryValVoid.setParameter("totalPayment", totalPayment);

        Double countValVoid = Double.valueOf(queryValVoid.getSingleResult().toString());

        /*
         * mod by Didit, 5 Des 2016
         * tidak perlu cek lagi saldo tax, karena dpp dan ppn digabung dalam satu saldo
         *
        builderValVoid = new QueryBuilder();
        builderValVoid.add(" SELECT COUNT(1) ")
                     .add(" FROM fi_invoice_tax_ar_balance A ")
                     .add(" INNER JOIN fi_invoice_ar_balance D ON A.invoice_ar_balance_id = D.invoice_ar_balance_id ")
                     .add(" INNER JOIN fi_invoice_ar B ON D.invoice_ar_id = B.invoice_ar_id ")
                     .add(" INNER JOIN m_ou_structure C ON B.ou_id = C.ou_bu_id AND C.ou_id = :ouId ")
                     .add(" WHERE B.tenant_id = :tenantId ")
                     .add(" AND B.doc_type_id = :docTypeIdDebtNoteAr ")
                     .add(" AND B.doc_no = :docNo ")
                     .add(" AND B.doc_date = :docDate ")
                     .add(" AND A.doc_type_id = :docTypeIdFakturPajakKeluaran ")
                     .add(" AND A.payment_amount <> 0 ")
                     .add(" OR (A.flg_payment = :inProgress AND A.payment_amount = 0) ");

        queryValVoid = posDao.createNativeQuery(builderValVoid.toString());
        queryValVoid.setParameter("ouId", ouId);
        queryValVoid.setParameter("tenantId", tenantId);
        queryValVoid.setParameter("docTypeIdDebtNoteAr", 241);
        queryValVoid.setParameter("docNo", docNo);
        queryValVoid.setParameter("docDate", docDate);
        queryValVoid.setParameter("docTypeIdFakturPajakKeluaran", 281);
        queryValVoid.setParameter("inProgress", PosIntegrationConstants.IN_PROGRESS_TRANSACTION);

        Calc countValVoidCalc = new Calc(countValVoid).add(Double.valueOf(queryValVoid.getSingleResult().toString()));
        */
        if (countValVoid.doubleValue() != 0) {
            throw new CoreException(PosIntegrationExceptionConstantsForSasa.POS_CAN_NOT_VOID);
        }
    }

    private void updateProductBalanceStock(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")).add(qty).doubleValue();

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

        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(PosIntegrationConstants.PARTNER_RETAIL);
            logProductBalanceStock.setDocTypeId(PosIntegrationConstants.DOCUMENT_VOID_SALES_RETAIL_SHOP);
            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(qty);

            logProductBalanceStockDto = new Dto(logProductBalanceStock);
            prepareInsertAudit(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")).add(qty).doubleValue());
        }
    }

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

        // 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) {
            mergeProductBalanceStockDto = new Dto().put("productBalanceStock", productBalanceStockDto);
            mergeProductBalanceStockList.put(productBalanceStockDto.getLong("id"), mergeProductBalanceStockDto);
            prepareUpdateAudit(productBalanceStockDto, userLoginId, datetime);
        }

        return mergeProductBalanceStockDto;
    }

    private void updateNempilBarangBalanceStock(String docNo, String docDate,
                                                Long ouId, Long userLoginId, Long tenantLoginId, String datetime,
                                                Double qty,
                                                Dto mergeNempilBarangBalanceStockDto) {

        Dto nempilBarangBalanceStockDto = mergeNempilBarangBalanceStockDto.getDto("nempilBarangBalanceStock");
        // Nempil Barang Balance
        // Count qty opname = qty Opname + qty Item
        Double qtyOpname = new Calc(nempilBarangBalanceStockDto.getDouble("qty")).add(qty).doubleValue();

        // Update qty at nempil barang balance stock
        nempilBarangBalanceStockDto.put("qty", qtyOpname);
        prepareUpdateAudit(nempilBarangBalanceStockDto, userLoginId, datetime);

        Dto logNempilBarangBalanceStockDto;
        if ((logNempilBarangBalanceStockDto = mergeNempilBarangBalanceStockDto.getDto("logNempilBarangBalanceStock")) == null) {
            // Create Log for nempil barang balance stock
            LogNempilBarangBalanceStock logNempilBarangBalanceStock = new LogNempilBarangBalanceStock();
            logNempilBarangBalanceStock.setTenantId(tenantLoginId);
            logNempilBarangBalanceStock.setOuId(ouId);
            logNempilBarangBalanceStock.setDocTypeId(PosIntegrationConstants.DOCUMENT_VOID_SALES_RETAIL_SHOP);
            logNempilBarangBalanceStock.setDocNo(docNo);
            logNempilBarangBalanceStock.setDocDate(docDate);
            logNempilBarangBalanceStock.setProductCode(nempilBarangBalanceStockDto.getString("productCode"));
            logNempilBarangBalanceStock.setQty(qty);

            logNempilBarangBalanceStockDto = new Dto(logNempilBarangBalanceStock);
            prepareInsertAudit(logNempilBarangBalanceStockDto, userLoginId, datetime);

            prepareUpdateAudit(logNempilBarangBalanceStockDto, userLoginId, datetime);
            mergeNempilBarangBalanceStockDto.putDto("logNempilBarangBalanceStock", logNempilBarangBalanceStockDto);
        } else {
            // Update the qty of log for product balance stock
            logNempilBarangBalanceStockDto.put("qty", new Calc(logNempilBarangBalanceStockDto.getDouble("qty")).add(qty).doubleValue());
        }
    }

    private Dto getMergeNempilBarangBalanceStock(Long tenantLoginId, Long ouId, String productCode, Long productId,
                                                 Map<Long, Dto> mergeNempilBarangBalanceStockList) throws Exception {

        // Validation product balance stock must exists
        Dto nempilBarangBalanceStockDto = new Dto();
        nempilBarangBalanceStockDto.put("tenantId", tenantLoginId);
        nempilBarangBalanceStockDto.put("ouId", ouId);
        nempilBarangBalanceStockDto.put("productCode", productCode);
        nempilBarangBalanceStockDto = findProductNempilByIndex.execute(nempilBarangBalanceStockDto);

        Dto mergeNempilBarangBalanceStockDto = mergeNempilBarangBalanceStockList.get(nempilBarangBalanceStockDto.getLong("id"));
        if (mergeNempilBarangBalanceStockDto == null) {
            mergeNempilBarangBalanceStockDto = new Dto().put("nempilBarangBalanceStock", nempilBarangBalanceStockDto);
            mergeNempilBarangBalanceStockList.put(nempilBarangBalanceStockDto.getLong("id"), mergeNempilBarangBalanceStockDto);
        }

        return mergeNempilBarangBalanceStockDto;
    }

    @SuppressWarnings("unchecked")
    @Override
    public Dto process(Dto inputDto, Dto originalDto) throws Exception {
        Dto mergePosDto = inputDto.getDto("mergePosDto");
        Dto persistPosDto = inputDto.getDto("persistPosDto");
        List<Dto> mergeProductBalanceStockList = inputDto.getList("mergeProductBalanceStockList");
        List<Dto> mergeProductNempilBalanceStockList = inputDto.getList("mergeProductNempilBalanceStockList");
        List<Dto> persistPosItemList = inputDto.getList("persistPosItemList");
        List<Dto> persistCashBalanceList = inputDto.getList("persistCashBalanceList");
        List<Dto> mergeCashBalanceList = inputDto.getList("mergeCashBalanceList");
        List<Dto> mergeNonCashBalanceList = inputDto.getList("mergeNonCashBalanceList");
        Dto persistLogVoidedPosDto = inputDto.getDto("persistLogVoidedPosDto");
        Long tenantLoginId = inputDto.getLong("tenantLoginId");
        Long userLoginId = inputDto.getLong("userLoginId");
        String datetime = inputDto.getString("datetime");
        String dbVersion = inputDto.getString("dbVersion");

        // Insert header data
        PointOfSales pos = GsonUtil.fromDto(mergePosDto, PointOfSales.class);
        PointOfSalesPk posPk = pos.getPointOfSalesPk();
        posDao.merge(posPk, pos);

        PointOfSales posVoid = GsonUtil.fromDto(persistPosDto, PointOfSales.class);
        posDao.persist(posVoid);

        Long posId = posPk.getId();
        String sessionId = UUID.randomUUID().toString();
        Long tenantId = posPk.getTenantId();
        String processNo = posPk.getProcessNo();
        Long ouId = pos.getOuId();
        String docDate = pos.getDocDate();

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

            Dto logProductBalanceStockDto = productBalanceStockDto.getDto("logProductBalanceStock");
            logProductBalanceStockDto.put("refId", posId);

            // Persist Log Product Balance Stock
            LogProductBalanceStock logProductBalanceStock = GsonUtil.fromDto(logProductBalanceStockDto, LogProductBalanceStock.class);
            logProductBalanceStockDao.persist(logProductBalanceStock);
        }

        // Merge Nempil Barang Balance Stock
        for (Dto nempilBarangBalanceStockDto : mergeProductNempilBalanceStockList) {
            NempilBarangBalanceStock nempilBarangBalanceStock = GsonUtil.fromDto(nempilBarangBalanceStockDto.getDto("nempilBarangBalanceStock"), NempilBarangBalanceStock.class);
            nempilBarangBalanceStock = nempilBarangBalanceStockDao.merge(nempilBarangBalanceStock.getId(), nempilBarangBalanceStock);

            // Persist Log Nempil Barang Balance Stock
            LogNempilBarangBalanceStock logNempilBarangBalanceStock = GsonUtil.fromDto(nempilBarangBalanceStockDto.getDto("logNempilBarangBalanceStock"),
                    LogNempilBarangBalanceStock.class);
            logNempilBarangBalanceStockDao.persist(logNempilBarangBalanceStock);
        }

        // Persist new pos item void
        for (Dto posItemDto : persistPosItemList) {
            Dto preparePosItemDto = posItemDto.getDto("posItemDto");
            preparePosItemDto.remove("id");

            PointOfSalesItem pointOfSalesItem = GsonUtil.fromDto(preparePosItemDto, PointOfSalesItem.class);
            posItemDao.persist(pointOfSalesItem);
        }

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

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

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


        TrxLogVoidedPosCustom logVoidedPos = GsonUtil.fromDto(persistLogVoidedPosDto, TrxLogVoidedPosCustom.class);
        trxLogVoidedPosCustomDao.persist(logVoidedPos);

        // panggil proses void pos untuk cabut data jurnal
        QueryBuilder builder = new QueryBuilder();
        builder.add("SELECT COUNT( i_process_void_pos_delete_journal( :sessionId, :tenantId, :trxPosId, :processNo, :userId, :datetime ) )");

        Query query = posDao.createNativeQuery(builder.toString());
        query.setParameter("tenantId", tenantId);
        query.setParameter("sessionId", sessionId);
        query.setParameter("trxPosId", posId);
        query.setParameter("processNo", processNo);
        query.setParameter("userId", userLoginId);
        query.setParameter("datetime", datetime);

        query.getSingleResult();

        return new Dto(pos);
    }

    @SuppressWarnings("unchecked")
    private Dto getCashBankDataOutletList(Long outletId, String currencyCode) throws Exception {
        Dto inputDtoForGetCashAccountList = new Dto();
        inputDtoForGetCashAccountList.put("outletId", outletId);
        inputDtoForGetCashAccountList.put("flagCashBank", MasterConstants.FLAG_CASH);

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

        List<Dto> cashBankList = outputDtoForGetCashAccountList.getList("cashBankDataOutletList");

        if (cashBankList != null) {
            for (Dto cashBankOutlet : cashBankList) {
                if (currencyCode.equals(cashBankOutlet.getString("currencyCode"))) {
                    return new Dto().put("id", Long.valueOf(cashBankOutlet.get("cashBankId").toString())).put("code", cashBankOutlet.getString("cashBankCode"));
                }
            }
        } else {
            throw new CoreException(PosIntegrationExceptionConstants.POS_CASH_NOT_FOUND);
        }

        return new Dto();
    }

}