[BACKUP] [3.5.0.0] pos-jleaf-bo-pos-spooring

package org.jleaf.pos.bo.data;

import javax.persistence.Column;

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.pos.PosBoConstants;
import org.jleaf.pos.dao.LogProductBalanceStockDao;
import org.jleaf.pos.dao.ProductBalanceDao;
import org.jleaf.pos.dao.ProductBalanceStockDao;
import org.jleaf.pos.entity.LogProductBalanceStock;
import org.jleaf.pos.entity.ProductBalance;
import org.jleaf.pos.entity.ProductBalanceStock;
import org.jleaf.util.Calc;
import org.jleaf.util.GsonUtil;
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
 */
//@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 {

    @Autowired
    private LogProductBalanceStockDao logProductBalanceStockDao;

    @Autowired
    private ProductBalanceStockDao productBalanceStockDao;

    @Autowired
    private ProductBalanceDao productBalanceDao;

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

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

    @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);
            }
        }
    }

    @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;
        }

        return null;
    }

    @SuppressWarnings("unchecked")
    private void executeAction(String mode, String dataLog, String typeData, Long userId, String datetime) throws Exception {
        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");

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

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

        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();
    }
}