BT AddAuditReport

package org.jleaf.common.bo.audit;

import java.util.List;

import javax.persistence.Query;

import org.jleaf.common.ComboIdConstants;
import org.jleaf.common.CommonConstants;
import org.jleaf.common.CommonExceptionConstants;
import org.jleaf.common.dao.audit.AuditReportDao;
import org.jleaf.common.dao.audit.ReportFormCounterDao;
import org.jleaf.common.dao.audit.ReprintReportFormDao;
import org.jleaf.common.entity.audit.AuditReport;
import org.jleaf.common.entity.audit.ReportFormCounter;
import org.jleaf.common.entity.audit.ReprintReportForm;
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.Info;
import org.jleaf.core.annotation.InfoIn;
import org.jleaf.core.annotation.InfoOut;
import org.jleaf.util.DateUtil;
import org.jleaf.util.DtoUtil;
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;

/**
 * Add user audit <br/>
 *
 *
 * @author Fredi, 2 Juli 2015
 * @version 1.0
 */
@Service
@InfoIn(value = {
        @Info(name = "userId", description = "User Id", type = Long.class, required = true),
        @Info(name = "tenantLoginId", description = "User login id", type = Long.class, required = true),
        @Info(name = "roleId", description = "Role id", type = String.class, required = true),
        @Info(name = "activityDatetime", description = "activity Datetime", type = String.class, required = true),
        @Info(name = "reportConfigName", description = "Report config name", type = String.class, required = true),
        @Info(name = "reportParameter", description = "Report Parameter", type = String.class),
        @Info(name = "ipAddress", description = "IP Address", type = String.class),

        @Info(name = "userLoginId", description = "User login Id", type = Long.class, required = true),
        @Info(name = "datetime", description = "Datetime", type = String.class, required = true)
})
@InfoOut(value = {
        })
public class AddAuditReport extends DefaultBusinessTransaction implements BusinessTransaction {
    private static final Logger log = LoggerFactory.getLogger(AddAuditReport.class);

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

    @Autowired
    @Qualifier("findRoleById")
    BusinessFunction findRoleById;

    @Autowired
    @Qualifier("findReportFormByIndex")
    BusinessFunction findReportFormByIndex;

    @Autowired
    @Qualifier("isReportFormExistsByIndex")
    BusinessFunction isReportFormExistsByIndex;

    @Autowired
    @Qualifier("isComboValueExistsByCode")
    BusinessFunction isComboValueExistsByCode;

    @Autowired
    @Qualifier("isReportFormConfigExists")
    BusinessFunction isReportFormConfigExists;

    @Autowired
    @Qualifier("isReportFormCounterExistsByIndex")
    BusinessFunction isReportFormCounterExistsByIndex;

    @Autowired
    @Qualifier("isSystemConfigExistsByParameterCode")
    BusinessFunction isSystemConfigExistsByParameterCode;

    @Autowired
    @Qualifier("isReprintReportFormExistsByFormCounter")
    BusinessFunction isReprintReportFormExistsByFormCounter;

    @Autowired
    @Qualifier("findLastAuditReportByReportCodeAndDoc")
    BusinessFunction findLastAuditReportByReportCodeAndDoc;

    @Autowired
    AuditReportDao auditReportDao;

    @Autowired
    ReportFormCounterDao reportFormCounterDao;

    @Autowired
    ReprintReportFormDao reprintReportFormDao;

    @Override
    public String getDescription() {
        return "Add description";
    }

    @SuppressWarnings("unchecked")
    @Override
    public Dto prepare(Dto inputDto, Dto originalDto) throws Exception {
        log.info("inputDto BF : "+inputDto);

        // val key
        ValidationUtil.valDtoContainsKey(inputDto, "tenantLoginId");
        ValidationUtil.valDtoContainsKey(inputDto, "userLoginId");

        ValidationUtil.valDtoContainsKey(inputDto, "userId");
        ValidationUtil.valDtoContainsKey(inputDto, "roleId");
        ValidationUtil.valDtoContainsKey(inputDto, "activityDatetime");
        ValidationUtil.valDtoContainsKey(inputDto, "reportConfigName");
        ValidationUtil.valDtoContainsKey(inputDto, "reportParameter");
        ValidationUtil.valDtoContainsKey(inputDto, "ipAddress");

        Long tenantLoginId = inputDto.getLong("tenantLoginId");
        Long userLoginId = inputDto.getLong("userLoginId");
        Long userId = inputDto.getLong("userId");
        Long roleId = inputDto.getLong("roleId");
        String activityDatetime = inputDto.getString("activityDatetime");
        String reportParameter = inputDto.getString("reportParameter");
        String reportConfigName = inputDto.getString("reportConfigName");
        String ipAddress = inputDto.getString("ipAddress");
        String datetime = inputDto.getString("datetime");

        // val format
        ValidationUtil.valDatetime(activityDatetime, "activityDatetime");

        // validation existensi data
        findUserById.execute(new Dto().put("id", userId));
        findRoleById.execute(new Dto().put("id", roleId));

        /**
         * Add report audit
         * # find reportCode from combo by findComboValueByCode
         * # Check if report reprintable by findReportFormConfig with key reprintable
         * # get last report form counter
         * # prepare insert into t_audit_report
         * # prepare insert / update report form counter --> update lastCounter + 1
         * # insert into t_audit_report
         * # insert / update report form counter
         */
        // chek report parameter
        Dto outputIsSystemConfigExistsByParameterCode = isSystemConfigExistsByParameterCode.execute(new Dto()
                .put("tenantId", tenantLoginId)
                .put("parameterCode", CommonConstants.PARAMETER_REPORT_AUDIT_ACTIVE));

        log.info("outputIsSystemConfigExistsByParameterCode : "+outputIsSystemConfigExistsByParameterCode);
        if(outputIsSystemConfigExistsByParameterCode.getBoolean("exists") ){
            Dto systemConfigDto = outputIsSystemConfigExistsByParameterCode.getDto("systemConfigDto");
            if(GeneralConstants.YES.equals(systemConfigDto.get("value"))){
                // continue process
            } else{
                inputDto.put("skip", true);
                return null;
            }
        } else{
            inputDto.put("skip", true);
            return null;
        }

        // find from combo
        Dto outputIsComboValueExistsByCode = isComboValueExistsByCode.execute(new Dto()
                .put("comboId", ComboIdConstants.COMBO_REPORT_FORM)
                .put("code", reportConfigName)
                .put("varName", "reportConfig"));

        log.info("outputIsComboValueExistsByCode : "+outputIsComboValueExistsByCode);
        if(!outputIsComboValueExistsByCode.getBoolean("exists")){
            inputDto.put("skip", true);
            return null;
        }

        Dto comboReportDto = outputIsComboValueExistsByCode.getDto("comboValueDto");

        String reportCode = comboReportDto.getString("codeGroup");

        // find report form
        Dto outputIsReportFormExistsByIndex = isReportFormExistsByIndex.execute(new Dto()
                .put("reportCode", reportCode));

        String reportDocStatement = GeneralConstants.EMPTY_VALUE; //reportFormDto.getString("reportDocStatement");
        String docNo = GeneralConstants.EMPTY_VALUE;
        String docDate = GeneralConstants.EMPTY_VALUE;
        String keyDocId = GeneralConstants.EMPTY_VALUE;
        Long docTypeId = GeneralConstants.NULL_REF_VALUE_LONG; //reportFormDto.getLong("docTypeId");
        Long ouId = GeneralConstants.NULL_REF_VALUE_LONG;
        Long printCounter = 1l;
        Long docId = GeneralConstants.NULL_REF_VALUE_LONG;
        String[] paramsKey = null;


        Dto reportParameterDto = new Dto(reportParameter);
        if(outputIsReportFormExistsByIndex.getBoolean("exists")){
            Dto reportFormDto = outputIsReportFormExistsByIndex.getDto("reportFormDto");

            // validate report parameter must contain key doc id
            keyDocId = reportFormDto.getString("keyDocId");
            if(!keyDocId.isEmpty()){
                paramsKey = keyDocId.split(CommonConstants.SEPARATOR_KEY_DOC);
            }

            // validation reportParameter must contain all parameter key
            for (String paramKey : paramsKey) {
                ValidationUtil.valDtoContainsKey(reportParameterDto, paramKey.trim());
            }

            //docId = Long.valueOf(reportParameterDto.getLong( keyDocId ).toString());
            reportDocStatement = reportFormDto.getString("reportDocStatement");
            docTypeId = reportFormDto.getLong("docTypeId");
        }

        // get document information
        Dto docInfoDto = new Dto();

        if(!reportDocStatement.trim().isEmpty()){
            Query queryDocInfo = auditReportDao.createNativeQuery(reportDocStatement);

            if(paramsKey!=null){
                for (String paramKey : paramsKey) {
                    queryDocInfo.setParameter(paramKey, reportParameterDto.get(paramKey));
                }
            }

            List<Object[]> result = queryDocInfo.getResultList();

            try{
                // query must result
                // 0 docId 1 docTypeId 2 docNo 3 docDate 4 ouId
                List<Dto> resultDtoList = DtoUtil.createDtoListFromArray(result, "docId", "docTypeId", "docNo", "docDate", "ouId");
                docInfoDto = resultDtoList.get(0);

                docId = Long.valueOf(docInfoDto.get("docId").toString());
                docNo = docInfoDto.getString("docNo");
                docDate = docInfoDto.getString("docDate");
                docTypeId = docInfoDto.getLong("docTypeId");
                ouId = docInfoDto.getLong("ouId");

            } catch(Exception ex){
                log.warn("Unsuccesfully execute query from reportDocStatement : "+reportDocStatement);
            }
        }

        // find config reprintable or not
        String reprintable = GeneralConstants.YES;

        Dto outputIsReportFormConfigExists = isReportFormConfigExists.execute(new Dto()
                .put("tenantId", tenantLoginId)
                .put("configKey", CommonConstants.CONFIG_KEY_REPRINTABLE)
                .put("reportCode", reportCode));

        log.info("outputIsReportFormConfigExists : "+outputIsReportFormConfigExists);
        if(outputIsReportFormConfigExists.getBoolean("exists")){
            Dto reportFormConfigDto = outputIsReportFormConfigExists.getDto("reportFormConfigDto");
            reprintable = reportFormConfigDto.getString("configValue");
        }

        // find last counter
        Dto resultIsReportFormCounterExistsByIndex = isReportFormCounterExistsByIndex.execute(new Dto()
                .put("tenantId", tenantLoginId)
                .put("reportCode", reportCode)
                .put("docId", docId)
                .put("docTypeId", docTypeId)
                );
        log.info("resultIsReportFormCounterExistsByIndex : "+resultIsReportFormCounterExistsByIndex);

        // chreck if can print
        Dto reportFormCounterDto = new Dto();
        Dto reprintReportFormDto = new Dto();
        boolean isUpdateReprintReportForm = false;
        if(resultIsReportFormCounterExistsByIndex.getBoolean("exists")){
            reportFormCounterDto = resultIsReportFormCounterExistsByIndex.getDto("reportFormCounterDto");
            printCounter = new Long(reportFormCounterDto.getLong("lastCounter") + 1);
            if(GeneralConstants.NO.equals(reprintable)){
                if(reportFormCounterDto.getLong("lastCounter") > 0){
                    // find request form
                    Dto outputIsReprintReportFormExistsByFormCounter = isReprintReportFormExistsByFormCounter.execute(new Dto()
                            .put("tenantId", tenantLoginId)
                            .put("reportFormCounterId", reportFormCounterDto.get("id"))
                            .put("lastCounter", reportFormCounterDto.get("lastCounter")) );

                    log.info("outputIsReprintReportFormExistsByFormCounter : "+outputIsReprintReportFormExistsByFormCounter);
                    if(outputIsReprintReportFormExistsByFormCounter.getBoolean("exists")){
                        reprintReportFormDto = outputIsReprintReportFormExistsByFormCounter.getDto("reprintReportFormDto");

                        if(CommonConstants.RELEASED_TRANSACTION.equals(reprintReportFormDto.get("statusDoc"))
                                && userId.equals(reprintReportFormDto.get("reqUserId")) ){
                            isUpdateReprintReportForm = true;

                            reprintReportFormDto.put("reprintDatetime", activityDatetime);
                            reprintReportFormDto.put("statusDoc", CommonConstants.FINAL_TRANSACTION);

                            this.prepareUpdateAudit(reprintReportFormDto, userLoginId, datetime);

                            // update lastCounter
                            reportFormCounterDto.put("lastCounter", printCounter);
                        }else{
                            Dto outputFindLastAuditReportByReportCodeAndDoc = findLastAuditReportByReportCodeAndDoc.execute(new Dto()
                                    .put("tenantId", tenantLoginId)
                                    .put("reportCode", reportCode)
                                    .put("docId", docId)
                                    .put("docTypeId", docTypeId)
                                    );
                            if(!userId.equals(reprintReportFormDto.get("reqUserId"))){
                                //
                                Dto userRequestReprintDto = findUserById.execute(new Dto().put("id", reprintReportFormDto.get("reqUserId")));

                                throw new CoreException(CommonExceptionConstants.REPRINT_REPORT_ALREADY_REQUESTED, docNo, userRequestReprintDto.get("name"), DateUtil.displayDateTime(reprintReportFormDto.getString("createDateTime")));
                            }

                            throw new CoreException(CommonExceptionConstants.REPORT_ALREADY_PRINTED, docNo, outputFindLastAuditReportByReportCodeAndDoc.get("name"), DateUtil.displayDateTime(outputFindLastAuditReportByReportCodeAndDoc.getString("activityDatetime")));
                        }
                    } else {
                        Dto outputFindLastAuditReportByReportCodeAndDoc = findLastAuditReportByReportCodeAndDoc.execute(new Dto()
                            .put("tenantId", tenantLoginId)
                            .put("reportCode", reportCode)
                            .put("docId", docId)
                            .put("docTypeId", docTypeId)
                        );

                        throw new CoreException(CommonExceptionConstants.REPORT_ALREADY_PRINTED, docNo, outputFindLastAuditReportByReportCodeAndDoc.get("name"), DateUtil.displayDateTime(outputFindLastAuditReportByReportCodeAndDoc.getString("activityDatetime")));
                    }
                }
            } else{
                reportFormCounterDto.put("lastCounter", printCounter);
            }
        } else{
            ReportFormCounter reportFormCounter = new ReportFormCounter();
            reportFormCounter.setTenantId(tenantLoginId);
            reportFormCounter.setReportCode(reportCode);
            reportFormCounter.setDocId(docId);
            reportFormCounter.setDocTypeId(docTypeId);
            reportFormCounter.setDocNo(docNo);
            reportFormCounter.setDocDate(docDate);
            reportFormCounter.setDocTypeId(docTypeId);
            reportFormCounter.setLastCounter(1l);
            reportFormCounter.setOuId(ouId);
            reportFormCounter.setVersion(0);

            reportFormCounterDto = new Dto(reportFormCounter);
            this.prepareInsertAudit(reportFormCounterDto, userLoginId, datetime);
        }
        this.prepareUpdateAudit(reportFormCounterDto, userLoginId, datetime);

        // prepare insert audit
        AuditReport auditReport = new AuditReport();
        auditReport.setTenantId(tenantLoginId);
        auditReport.setReportCode(reportCode);
        auditReport.setReportConfigName(reportConfigName);
        auditReport.setDocId(docId);
        auditReport.setDocTypeId(docTypeId);
        auditReport.setOuId(ouId);
        auditReport.setDocNo(docNo);
        auditReport.setDocDate(docDate);
        auditReport.setUserId(userId);
        auditReport.setRoleId(roleId);
        auditReport.setActivityDatetime(activityDatetime);
        auditReport.setReportParameter(reportParameter);
        auditReport.setPrintCounter(printCounter);
        auditReport.setIpAddress(ipAddress);
        auditReport.setVersion(0);

        Dto auditReportDto = new Dto(auditReport);
        this.prepareInsertAudit(auditReportDto, userLoginId, datetime);
        this.prepareUpdateAudit(auditReportDto, userLoginId, datetime);

        inputDto.put("skip", false);
        inputDto.put("isUpdateReprintReportForm", isUpdateReprintReportForm);
        inputDto.put("auditReportDto", auditReportDto);
        inputDto.put("reportFormCounterDto", reportFormCounterDto);
        inputDto.put("reprintReportFormDto", reprintReportFormDto);

        return null;
    }

    @Override
    public Dto process(Dto inputDto, Dto originalDto) throws Exception {
        // insert audit report
        if(!inputDto.getBoolean("skip")){
            Dto auditReportDto = inputDto.getDto("auditReportDto");
            AuditReport auditReport = GsonUtil.fromDto(auditReportDto, AuditReport.class);
            auditReportDao.persist(auditReport);

            Dto reportFormCounterDto = inputDto.getDto("reportFormCounterDto");
            ReportFormCounter reportFormCounter = GsonUtil.fromDto(reportFormCounterDto, ReportFormCounter.class);
            if(reportFormCounterDto.get("id")==null){
                reportFormCounterDao.persist(reportFormCounter);
            } else{
                reportFormCounter = reportFormCounterDao.merge(reportFormCounter.getId(), reportFormCounter);
            }

            boolean isUpdateReprintReportForm = inputDto.getBoolean("isUpdateReprintReportForm");
            if(isUpdateReprintReportForm){
                Dto reprintReportFormDto = inputDto.getDto("reprintReportFormDto");
                ReprintReportForm reprintReportForm = GsonUtil.fromDto(reprintReportFormDto, ReprintReportForm.class);
                reprintReportForm = reprintReportFormDao.merge(reprintReportForm.getId(), reprintReportForm);

                log.debug("Updated reprint report form : "+new Dto(reprintReportForm));
            }

            return new Dto(auditReport)
                .put("reportFormCounterId", reportFormCounter.getId());
        }

        return new Dto();
    }
}