ProcessTrxDataLog

package org.jleaf.pos.bo.data;

import javax.persistence.Column;

import org.apache.log4j.lf5.viewer.LogBrokerMonitor;
import org.jleaf.core.BusinessFunction;
import org.jleaf.core.BusinessTransaction;
import org.jleaf.core.DefaultBusinessTransaction;
import org.jleaf.core.Dto;
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.entity.BaseEntity;
import org.jleaf.erp.master.MasterConstants;
import org.jleaf.erp.master.bo.admin.CancelClosingAp;
import org.jleaf.pos.PosBoConstants;
import org.jleaf.pos.dao.LogNempilBarangBalanceStockDao;
import org.jleaf.pos.dao.LogProductBalanceStockDao;
import org.jleaf.pos.dao.NempilBarangBalanceStockDao;
import org.jleaf.pos.dao.ProductBalanceDao;
import org.jleaf.pos.dao.ProductBalanceStockDao;
import org.jleaf.pos.entity.LogNempilBarangBalanceStock;
import org.jleaf.pos.entity.LogProductBalanceStock;
import org.jleaf.pos.entity.NempilBarangBalanceStock;
import org.jleaf.pos.entity.ProductBalance;
import org.jleaf.pos.entity.ProductBalanceStock;
import org.jleaf.util.Calc;
import org.jleaf.util.GsonUtil;
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;

/**
 * Trx Data Log Process Helper
 *
 * @author WTC, Jun 2, 2013
 */
/**
 * Menambahkan process untuk in_log_nempil_barang_balance_stock
 * modified by Adrian
 * Jul 7, 2017
 */
//@formatter:off
@Service
@InfoIn(value= {@Info(name = "log", description = "log", type=String.class, required=true)})
@InfoOut(value={})
@ErrorList(errorKeys={})
//@formatter:on
public class ProcessTrxDataLog extends DefaultBusinessTransaction implements BusinessTransaction {

    private static final Logger logger = LoggerFactory.getLogger(ProcessTrxDataLog.class);

    @Autowired
    private LogProductBalanceStockDao logProductBalanceStockDao;

    @Autowired
    private LogNempilBarangBalanceStockDao logNempilBarangBalanceStockDao;

    @Autowired
    private ProductBalanceStockDao productBalanceStockDao;

    @Autowired
    private NempilBarangBalanceStockDao nempilBarangBalanceStockDao;

    @Autowired
    private ProductBalanceDao productBalanceDao;

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

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

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

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

    private void add(BaseEntity entity, Long userId, String datetime) throws Exception {
        if (entity instanceof LogProductBalanceStock) {
            LogProductBalanceStock logProductBalanceStock = (LogProductBalanceStock)entity;
            logProductBalanceStockDao.persist(logProductBalanceStock);

            // Check whether product balance stock exists by index
            Dto checkExistsProductBalanceStockDto = new Dto();
            checkExistsProductBalanceStockDto.put("tenantId", logProductBalanceStock.getTenantId());
            checkExistsProductBalanceStockDto.put("warehouseId", logProductBalanceStock.getWarehouseId());
            checkExistsProductBalanceStockDto.put("productId", logProductBalanceStock.getProductId());
            checkExistsProductBalanceStockDto.put("productBalanceId", logProductBalanceStock.getProductBalanceId());
            checkExistsProductBalanceStockDto.put("productStatus", logProductBalanceStock.getProductStatus());
            Dto resultProductBalanceStockDto = isProductBalanceStockExistsByIndex.execute(checkExistsProductBalanceStockDto);

            if (resultProductBalanceStockDto.getBoolean("exists")) {
                // Set new qty if exists
                Dto mergeProductBalanceStockDto = resultProductBalanceStockDto.getDto("productBalanceStockDto");

                mergeProductBalanceStockDto.putDouble("qty",
                        new Calc(mergeProductBalanceStockDto.getDouble("qty")).add(logProductBalanceStock.getQty()).doubleValue());
                prepareUpdateAudit(mergeProductBalanceStockDto, userId, datetime);

                ProductBalanceStock productBalanceStock = GsonUtil.fromDto(mergeProductBalanceStockDto, ProductBalanceStock.class);
                productBalanceStockDao.merge(productBalanceStock.getId(), productBalanceStock);
            } else {
                // insert new record if not exists
                Dto productBalanceStockDto = new Dto();
                productBalanceStockDto.put("tenantId", logProductBalanceStock.getTenantId());
                productBalanceStockDto.put("warehouseId", logProductBalanceStock.getWarehouseId());
                productBalanceStockDto.put("productId", logProductBalanceStock.getProductId());
                productBalanceStockDto.put("productBalanceId", logProductBalanceStock.getProductBalanceId());
                productBalanceStockDto.put("baseUomId", logProductBalanceStock.getBaseUomId());
                productBalanceStockDto.put("qty", logProductBalanceStock.getQty());
                productBalanceStockDto.put("productStatus", logProductBalanceStock.getProductStatus());
                prepareInsertAudit(productBalanceStockDto, userId, datetime);
                prepareUpdateAudit(productBalanceStockDto, userId, datetime);

                ProductBalanceStock productBalanceStock = GsonUtil.fromDto(productBalanceStockDto, ProductBalanceStock.class);
                productBalanceStockDao.persist(productBalanceStock);
            }

        } else if (entity instanceof ProductBalance){
            ProductBalance productBalance = (ProductBalance) entity;

            Dto productBalanceDto = new Dto();
            productBalanceDto.put("id", productBalance.getId());

            Dto resultProductBalanceDto = new Dto();
            resultProductBalanceDto = isProductBalanceExistsById.execute(productBalanceDto);

            if (!resultProductBalanceDto.getBoolean("exists")) {
                productBalanceDao.persist(productBalance);
            }
        } else if (entity instanceof LogNempilBarangBalanceStock) {
            //Adrian, Jul 7, 2017
            //Process in_log_nempil_barang_balance_stock

            LogNempilBarangBalanceStock logNempilBarangBalanceStock = (LogNempilBarangBalanceStock)entity;
            logNempilBarangBalanceStockDao.persist(logNempilBarangBalanceStock);

            //Check whether nempil barang balance stock exists by index
            Dto checkExistsNempilBarangBalanceStockDto = new Dto();
            checkExistsNempilBarangBalanceStockDto.put("tenantId", logNempilBarangBalanceStock.getTenantId());
            checkExistsNempilBarangBalanceStockDto.put("ouId", logNempilBarangBalanceStock.getOuId());
            checkExistsNempilBarangBalanceStockDto.put("productCode", logNempilBarangBalanceStock.getProductCode());
            Dto resultNempilBarangBalanceStockDto = isNempilBarangBalanceStockExistByIndex.execute(checkExistsNempilBarangBalanceStockDto);

            if (resultNempilBarangBalanceStockDto.getBoolean("isTrue")) {
                // Set new qty if exists
                Dto mergeNempilBarangBalanceStockDto = resultNempilBarangBalanceStockDto.getDto("nempilBarangBalanceStockDto");

                mergeNempilBarangBalanceStockDto.putDouble("qty",
                        new Calc(mergeNempilBarangBalanceStockDto.getDouble("qty")).add(logNempilBarangBalanceStock.getQty()).doubleValue());
                prepareUpdateAudit(mergeNempilBarangBalanceStockDto, userId, datetime);

                NempilBarangBalanceStock nempilBarangBalanceStock = GsonUtil.fromDto(mergeNempilBarangBalanceStockDto, NempilBarangBalanceStock.class);
                nempilBarangBalanceStockDao.merge(nempilBarangBalanceStock.getId(), nempilBarangBalanceStock);
            } else {
                // insert new record if not exists
                Dto nempilBarangBalanceStockDto = new Dto();
                nempilBarangBalanceStockDto.put("tenantId", logNempilBarangBalanceStock.getTenantId());
                nempilBarangBalanceStockDto.put("ouId", logNempilBarangBalanceStock.getOuId());
                nempilBarangBalanceStockDto.put("productCode", logNempilBarangBalanceStock.getProductCode());
                nempilBarangBalanceStockDto.put("productName", logNempilBarangBalanceStock.getProductName());
                nempilBarangBalanceStockDto.put("qty", logNempilBarangBalanceStock.getQty());
                prepareInsertAudit(nempilBarangBalanceStockDto, userId, datetime);
                prepareUpdateAudit(nempilBarangBalanceStockDto, userId, datetime);

                NempilBarangBalanceStock nempilBarangBalanceStock = GsonUtil.fromDto(nempilBarangBalanceStockDto, NempilBarangBalanceStock.class);
                nempilBarangBalanceStockDao.persist(nempilBarangBalanceStock);
            }

        }
    }

    @SuppressWarnings("rawtypes")
    private Class findClassObject(String typeData) {
        if (PosBoConstants.TYPE_DATA_IN_LOG_PRODUCT_BALANCE_STOCK.equals(typeData)) {
            return LogProductBalanceStock.class;
        } else if (PosBoConstants.TYPE_DATA_IN_PRODUCT_BALANCE.equals(typeData)) {
            return ProductBalance.class;
        } else if (PosBoConstants.TYPE_DATA_IN_LOG_NEMPIL_BARANG_BALANCE_STOCK.equals(typeData)) {
            return LogNempilBarangBalanceStock.class;
        }

        return null;
    }

    @SuppressWarnings("unchecked")
    private void executeAction(String mode, String dataLog, String typeData, Long userId, String datetime) throws Exception {
        logger.debug(">>>>>>>>>>>>>> executeAction typeData: " + typeData);
        logger.debug(">>>>>>>>>>>>>> findClassObject: " + findClassObject(typeData));
        BaseEntity entity = (BaseEntity)GsonUtil.fromDto(new Dto(dataLog), findClassObject(typeData));
        if (PosBoConstants.LOG_MODE_ADD.equals(mode)) {
            add(entity, userId, datetime);
        }
    }

    @Override
    public String getDescription() {
        return "process trx data log from server";
    }

    @Override
    public Dto prepare(Dto inputDto, Dto originalDto) throws Exception {
        String log = inputDto.getString("log");

        logger.debug(">>>>>>>>>>>>> log: " + log);

        int dbVersionSeparatorIndex = log.indexOf(MasterConstants.LOG_DATA_SEPARATOR);
        int typeDataSeparatorIndex = log.indexOf(MasterConstants.LOG_DATA_SEPARATOR, dbVersionSeparatorIndex + 1);
        int modeLogSeparatorIndex = log.indexOf(MasterConstants.LOG_DATA_SEPARATOR, typeDataSeparatorIndex + 1);

        logger.debug(">>>>>>>>>>>>> typeDataSeparatorIndex: " + typeDataSeparatorIndex);

        String dbVersion = log.substring(0, dbVersionSeparatorIndex);
        String typeData = log.substring(dbVersionSeparatorIndex + 1, typeDataSeparatorIndex);
        String mode = log.substring(typeDataSeparatorIndex + 1, modeLogSeparatorIndex);
        String dataLog = log.substring(modeLogSeparatorIndex + 1);

        logger.debug(">>>>>>>>>>>>> typeData: " + typeData);

        inputDto.put("dbVersion", dbVersion);
        inputDto.put("typeData", typeData);
        inputDto.put("dataLog", dataLog);
        inputDto.put("mode", mode);

        return null;
    }

    @Override
    public Dto process(Dto inputDto, Dto originalDto) throws Exception {
        String mode = inputDto.getString("mode");
        String dataLog = inputDto.getString("dataLog");
        String typeData = inputDto.getString("typeData");

        executeAction(mode, dataLog, typeData, inputDto.getLong("userLoginId"), inputDto.getString("datetime"));

        return new Dto();
    }
}