INI

/**
 *
 */
package org.jleaf.erp.sls.bo.tasksales;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.persistence.Query;

import org.jleaf.common.CommonExceptionConstants;
import org.jleaf.common.entity.User;
import org.jleaf.core.BusinessFunction;
import org.jleaf.core.BusinessTransaction;
import org.jleaf.core.CoreException;
import org.jleaf.core.DefaultBusinessTransaction;
import org.jleaf.core.Dto;
import org.jleaf.core.GeneralConstants;
import org.jleaf.core.annotation.ErrorList;
import org.jleaf.core.annotation.Info;
import org.jleaf.core.annotation.InfoIn;
import org.jleaf.core.annotation.InfoOut;
import org.jleaf.core.dao.QueryBuilder;
import org.jleaf.erp.master.MasterExceptionConstants;
import org.jleaf.erp.master.bo.partner.FindPartnerByIndex;
import org.jleaf.erp.sls.SalesConstants;
import org.jleaf.erp.sls.SalesExceptionConstants;
import org.jleaf.erp.sls.bo.tasksales.utils.DecodedImageFile;
import org.jleaf.erp.sls.dao.InvoiceBalanceVisitPlanDetailDao;
import org.jleaf.erp.sls.dao.InvoiceExchangeDao;
import org.jleaf.erp.sls.dao.InvoiceVisitPlanDao;
import org.jleaf.erp.sls.dao.SalesmanVisitPlanDao;
import org.jleaf.erp.sls.dao.SalesmanVisitRealizationDao;
import org.jleaf.erp.sls.dao.UserPartnerDao;
import org.jleaf.erp.sls.entity.InvoiceBalanceVisitPlanDetail;
import org.jleaf.erp.sls.entity.InvoiceExchange;
import org.jleaf.erp.sls.entity.InvoiceVisitPlan;
import org.jleaf.erp.sls.entity.SalesmanVisitPlan;
import org.jleaf.erp.sls.entity.SalesmanVisitRealization;
import org.jleaf.erp.sls.entity.UserPartner;
import org.jleaf.util.DateUtil;
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.core.env.Environment;
import org.springframework.stereotype.Service;


/**
 *
 * @author WTC, Jul 4, 2013
 *
 */
//@formatter:off
@Service
@InfoIn(value = {
        @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),
        @Info(name = "apiKey", description = "apiKey", type = String.class),
        @Info(name = "visitDate", description = "visit Date", type = String.class),
        @Info(name = "userId", description = "user Id", type = Long.class),
        @Info(name = "salesmanVisitPlanId", description = "salesman Visit Plan Id", type = Long.class),
        @Info(name = "salesmanVisitRealizationId", description = "salesman Visit Realization Id", type = Long.class),
        @Info(name = "dueDate", description = "due Date", type = String.class),
        @Info(name = "extDocNo", description = "ext Doc No", type = String.class),
        @Info(name = "extDocName", description = "ext Doc Name", type = String.class),
        @Info(name = "remark", description = "remark", type = String.class),
        @Info(name = "invoiceItem", description = "strategy", type = List.class),
})
@InfoOut(value = {
        @Info(name = "invoiceExchange", description = "invoiceExchange", type = Object.class),

})
@ErrorList(errorKeys = {
        CommonExceptionConstants.TENANT_LOGIN_CANT_USED,
        CommonExceptionConstants.OU_ID_NOT_FOUND,
        CommonExceptionConstants.OU_NOT_LEGAL_ENTITY,
        CommonExceptionConstants.OULEGAL_ID_NOT_FOUND,
        MasterExceptionConstants.PARTNER_ID_NOT_FOUND,
        MasterExceptionConstants.POLICY_PARTNER_AUTHORIZATION_FAILED,
})
//@formatter:on
public class UpdateInvoiceVisitPlanForExchange extends DefaultBusinessTransaction implements BusinessTransaction {

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


    @Autowired
    private UserPartnerDao userPartnerDao;

    @Autowired
    private InvoiceBalanceVisitPlanDetailDao invoiceBalanceVisitPlanDetailDao;

    @Autowired
    private InvoiceExchangeDao invoiceExchangeDao;

    @Autowired
    private InvoiceVisitPlanDao invoiceVisitPlanDao;

    @Autowired
    Environment env;

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

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

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

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

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

    @Override
    public String getDescription() {
        return "Update Invoice Visit Plan For Exchange";
    }

    @SuppressWarnings("unchecked")
    @Override
    public Dto prepare(Dto inputDto, Dto originalDto) throws Exception {
//      log.info("INPUT DTO prepare {} --> {}", inputDto);

        ValidationUtil.valDtoContainsKey(inputDto, "userLoginId");
        ValidationUtil.valDtoContainsKey(inputDto, "tenantLoginId");
        ValidationUtil.valDtoContainsKey(inputDto, "roleLoginId");
        ValidationUtil.valDtoContainsKey(inputDto, "datetime");

        Long userLoginId = inputDto.getLong("userLoginId");
        Long tenantLoginId = inputDto.getLong("tenantLoginId");
        Long roleLoginId = inputDto.getLong("roleLoginId");
        String datetime = inputDto.getString("datetime");

        List<Dto> invoiceItemList = inputDto.getList("invoiceItem");
        Long salesmanVisitPlanId  = inputDto.getLong("salesmanVisitPlanId");
        Long userId  = inputDto.getLong("userId");
        Long salesmanVisitRealizationId  = inputDto.getLong("salesmanVisitRealizationId");
        String visitDate = inputDto.getString("visitDate");
        String extDocNo = inputDto.getString("extDocNo");
        String extDocDate = inputDto.getString("extDocDate");
        String dueDate = inputDto.getString("dueDate");
        String remark = inputDto.getString("remark");

        Dto inputFindSalesmanVistPlanById = new Dto();
        inputFindSalesmanVistPlanById.put("id", salesmanVisitPlanId);
        Dto salesmanVisitPlanDto = findSalesmanVisitPlanById.execute(inputFindSalesmanVistPlanById);
        Long customerId = salesmanVisitPlanDto.getLong("customerId");

        Dto inputFindCustomerByIdDto = new Dto();
        inputFindCustomerByIdDto.put("id", customerId);

        Dto customerDto = findPartnerById.execute(inputFindCustomerByIdDto);
        String customerCode = customerDto.getString("code");

        if (!GeneralConstants.YES.equals(customerDto.getString("active"))) {
            throw new CoreException(SalesExceptionConstants.DATA_NOT_ACTIVE,customerCode);
        }

        String docNo = SalesConstants.PREFIX_DOC_NO_INVOICE_EXCHANGE.concat(customerCode).concat("-").concat(DateUtil.dateTimeNow());

        Dto inputIsInvoiceExchangeExistsByIndex = new Dto();
        inputIsInvoiceExchangeExistsByIndex.put("tenantId", tenantLoginId);
        inputIsInvoiceExchangeExistsByIndex.put("docNo", docNo);
        inputIsInvoiceExchangeExistsByIndex.put("docDate", visitDate);

        Dto outputIsInvoiceExchangeExistsByIndex = isInvoiceExchangeExistsByIndex.execute(inputIsInvoiceExchangeExistsByIndex);
        log.info("OUTPUT DTO outputIsInvoiceExchangeExistsByIndex PREPARE {} --> {}", outputIsInvoiceExchangeExistsByIndex);
        if (outputIsInvoiceExchangeExistsByIndex.getBoolean("exists")) {
            throw new CoreException(SalesExceptionConstants.INVOICE_EXCHANGE_IS_EXISTS, DateUtil.convertToDate(DateUtil.dateTimeNow()));
        }

        QueryBuilder builderUserPartner = new QueryBuilder();
        builderUserPartner.add("SELECT A.partner_id ")
                    .add(" FROM ").add(UserPartner.TABLE_NAME).add(" A ")
                    .add(" INNER JOIN ").add(User.TABLE_NAME).add(" B ON A.user_id = B.user_id AND A.tenant_id =B.tenant_id")
                    .add(" WHERE B.user_id = :userId AND B.tenant_id = :tenantId");

                Query qUserPartner = userPartnerDao.createNativeQuery(builderUserPartner.toString());

                qUserPartner.setParameter("tenantId", tenantLoginId);
                qUserPartner.setParameter("userId", userId);

                Object userPartner = qUserPartner.getSingleResult();
                Long employeeId = Long.valueOf(userPartner.toString());

        Dto inputFindAdminProcessVisitPlanByIndex = new Dto();
        inputFindAdminProcessVisitPlanByIndex.put("tenantId", tenantLoginId);
        inputFindAdminProcessVisitPlanByIndex.put("employeeId", employeeId);
        inputFindAdminProcessVisitPlanByIndex.put("startDate", visitDate);

        Dto adminProcessVisitPlan = findAdminProcessVisitPlanByIndex.execute(inputFindAdminProcessVisitPlanByIndex);
        if(!adminProcessVisitPlan.getString("statusVisit").equals(SalesConstants.IN_PROGRESS_TRANSACTION)) {
            throw new CoreException(SalesExceptionConstants.INVOICE_EXCHANGE_IS_EXISTS);
        }
        Long adminProcessVisitPlanId = adminProcessVisitPlan.getLong("id");
        Long registerId = adminProcessVisitPlan.getLong("registerId");


        Dto invoiceExchangeDto = new Dto();
        invoiceExchangeDto.put("tenantId", tenantLoginId);
        invoiceExchangeDto.put("adminProcessVisitPlanId", adminProcessVisitPlanId);
        invoiceExchangeDto.put("registerId", registerId);
        invoiceExchangeDto.put("customerId", customerId);
        invoiceExchangeDto.put("employeeId", employeeId);
        invoiceExchangeDto.put("salesmanVisitPlanId", salesmanVisitPlanId);
        invoiceExchangeDto.put("salesmanVisitRealizationId", salesmanVisitRealizationId);
        invoiceExchangeDto.put("docNo", docNo);
        invoiceExchangeDto.put("docDate", visitDate);
        invoiceExchangeDto.put("currCode", SalesConstants.IDR);
        invoiceExchangeDto.put("extDocNo", extDocNo);
        invoiceExchangeDto.put("extDocDate", extDocDate);
        invoiceExchangeDto.put("dueDate", dueDate);
        invoiceExchangeDto.put("remark", remark);
        invoiceExchangeDto.put("statusDoc", SalesConstants.RELEASED_TRANSACTION);
        this.prepareInsertAudit(invoiceExchangeDto, userLoginId, datetime);
        this.prepareUpdateAudit(invoiceExchangeDto, userLoginId, datetime);

        inputDto.put("invoiceExchangeDto", invoiceExchangeDto);
        List<Dto> inputInvoiceVisitPlanList = new ArrayList<Dto>();
        List<Dto> inputBalanceVisitPlanDetailList = new ArrayList<Dto>();

        for(Dto item : invoiceItemList) {
            Dto inputInvoiceVisitPlan = new Dto();
            inputInvoiceVisitPlan.put("id", item.get("invoiceVisitPlanId"));
            Dto invoiceVisitPlan = findInvoiceVisitPlanById.execute(inputInvoiceVisitPlan);

            if(invoiceVisitPlan.getString("status").equals(SalesConstants.EXCHANGE_INVOICE)) {
                throw new CoreException(SalesExceptionConstants.INVOICE_EXCHANGE_IS_EXCHANGED,docNo);
            }

            invoiceVisitPlan.put("status", SalesConstants.EXCHANGE_INVOICE);
            this.prepareUpdateAudit(invoiceVisitPlan, userLoginId, datetime);
            inputInvoiceVisitPlanList.add(invoiceVisitPlan);

            Dto invoiceBalanceVisitPlanDetail = new Dto();
            invoiceBalanceVisitPlanDetail.put("tenantId", tenantLoginId);
            invoiceBalanceVisitPlanDetail.put("adminProcessVisitPlanId", adminProcessVisitPlanId);
            invoiceBalanceVisitPlanDetail.put("registerId", registerId);
            invoiceBalanceVisitPlanDetail.put("salesmanVisitPlanId", salesmanVisitPlanId);
            invoiceBalanceVisitPlanDetail.put("salesmanVisitRealizationId", salesmanVisitRealizationId);
            invoiceBalanceVisitPlanDetail.put("customerId", customerId);
            invoiceBalanceVisitPlanDetail.put("employeeId", employeeId);
            invoiceBalanceVisitPlanDetail.put("refId", GeneralConstants.NULL_REF_VALUE_LONG);
            invoiceBalanceVisitPlanDetail.put("refInvoiceId", invoiceVisitPlan.getLong("id"));
            invoiceBalanceVisitPlanDetail.put("invoiceExtId", invoiceVisitPlan.getLong("invoiceExtId"));
            invoiceBalanceVisitPlanDetail.put("docNo", invoiceExchangeDto.getString("docNo"));
            invoiceBalanceVisitPlanDetail.put("docDate", invoiceExchangeDto.getString("docDate"));
            invoiceBalanceVisitPlanDetail.put("invoiceDocNo", invoiceVisitPlan.getString("docNo"));
            invoiceBalanceVisitPlanDetail.put("invoiceDocDate", invoiceVisitPlan.getString("docDate"));
            invoiceBalanceVisitPlanDetail.put("flgInvoice", SalesConstants.EXCHANGE_INVOICE);
            this.prepareInsertAudit(invoiceBalanceVisitPlanDetail, userId, datetime);
            this.prepareUpdateAudit(invoiceBalanceVisitPlanDetail, userId, datetime);
            inputBalanceVisitPlanDetailList.add(invoiceBalanceVisitPlanDetail);

        }

        inputDto.put("inputInvoiceVisitPlanList", inputInvoiceVisitPlanList);
        inputDto.put("inputBalanceVisitPlanDetailList", inputBalanceVisitPlanDetailList);

        return null;
    }

    @SuppressWarnings("unchecked")
    @Override
    public Dto process(Dto inputDto, Dto originalDto) throws Exception {
//      log.info("INPUT DTO proses {} --> {}", inputDto);

        Dto outputDto = new Dto();

        Dto invoiceExchangeDto = inputDto.getDto("invoiceExchangeDto");
        InvoiceExchange invoiceExchange = GsonUtil.fromDto(invoiceExchangeDto, InvoiceExchange.class);
        invoiceExchangeDao.persist(invoiceExchange);
        Long refId = invoiceExchange.getId();

        List<Dto> inputInvoiceVisitPlanList = inputDto.getList("inputInvoiceVisitPlanList");
        for(Dto itemDto : inputInvoiceVisitPlanList) {
            InvoiceVisitPlan invoiceVisitPlan = GsonUtil.fromDto(itemDto, InvoiceVisitPlan.class);
            invoiceVisitPlanDao.merge(invoiceVisitPlan.getId(), invoiceVisitPlan);
        }

        List<Dto> inputBalanceVisitPlanDetailList = inputDto.getList("inputBalanceVisitPlanDetailList");
        for(Dto itemDto : inputBalanceVisitPlanDetailList) {
            itemDto.put("refId", refId);
            InvoiceBalanceVisitPlanDetail invoiceBalanceVisitPlanDetail = GsonUtil.fromDto(itemDto, InvoiceBalanceVisitPlanDetail.class);
            invoiceBalanceVisitPlanDetailDao.persist(invoiceBalanceVisitPlanDetail);
        }


        outputDto = new Dto(invoiceExchange);
        return outputDto;
    }
}