GenerateBatchReportConsumer

package org.jleaf.erp.jmsclient.consumer;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;

import org.jleaf.common.CommonConstants;
import org.jleaf.core.BusinessFunction;
import org.jleaf.core.BusinessTransaction;
import org.jleaf.core.Dto;
import org.jleaf.core.GeneralConstants;
import org.jleaf.erp.jmsclient.ErpJleafJmsConstants;
import org.jleaf.erp.jmsclient.ErpJleafProperties;
import org.jleaf.erp.jmsclient.ErpJleafQueueAppContext;
import org.jleaf.erp.jmsclient.util.ReportServerHttpUtilForJms;
import org.jleaf.jms.AbstractConsumerWithEmail;
import org.jleaf.jms.AbstractQueueAppContext;
import org.jleaf.jms.bo.JmsConstants;
import org.jleaf.util.DateUtil;
import org.jleaf.util.DtoUtil;
import org.jleaf.util.ZipUtils;
import org.jleaf.util.mail.MailSenderConfig;
import org.json.simple.JSONObject;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.PreparedStatementCallback;
import org.springframework.jdbc.core.PreparedStatementCreator;


public class GenerateBatchReportConsumer extends AbstractConsumerWithEmail {
    private static final Logger log = LoggerFactory.getLogger(GenerateBatchReportConsumer.class);

    @Override
    protected Properties getServerConfigProp() {
        return ErpJleafProperties.getServerConfigProperties();
    }

    @Override
    public MailSenderConfig getMailConfig() {
        return null;
    }

    @Override
    public AbstractQueueAppContext getQueueAppContext() {
        return ErpJleafQueueAppContext.getInstance();
    }

    String functionForSendEmail = GeneralConstants.EMPTY_VALUE;
    Long requestUserId = GeneralConstants.NULL_REF_VALUE_LONG;

    @SuppressWarnings("unchecked")
    @Override
    protected void processExecuteQueue(String processName, String processNo, Long tenantId, Dto paramDto) throws Exception {

        String reportServerBaseUrl = getServerConfigProp().getProperty(ErpJleafJmsConstants.PROP_REPORT_SERVER_BASE_URL);
        String reportServerRequestDownloadSyncUrl = reportServerBaseUrl.concat("/").concat(ErpJleafJmsConstants.REPORT_SERVER_API_REQUEST_DOWNLOAD_SYNC);

        log.info("BEGIN processing queue processName ::: "+processName);
        log.info("BEGIN processing queue processNo ::: "+processNo);
        log.info("BEGIN processing queue tenantId ::: "+tenantId);
        log.info("BEGIN processing queue paramDto ::: "+paramDto);

        final Long reportMessageId = Long.valueOf(paramDto.get(JmsConstants.KEY_REPORT_MESSAGE_ID)+GeneralConstants.EMPTY_VALUE);

        ReportServerHttpUtilForJms reportServerHttpUtilForJms = new ReportServerHttpUtilForJms();
        Connection conn = null;
        FileOutputStream fos = null;
        try{
            // find reprot message
            BusinessFunction findReportMessageById = getQueueAppContext().getContext().getBean("findReportMessageById", BusinessFunction.class);
            Dto reportMessageDto = findReportMessageById.execute(new Dto().put("id", reportMessageId));

            // get common info from reportMessage
            BusinessFunction getReportParameterListByReportMessageId = getQueueAppContext().getContext().getBean("getReportParameterListByReportMessageId", BusinessFunction.class);
            Dto outputGetReportParameterListByReportMessageId = getReportParameterListByReportMessageId.execute(new Dto()
                    .put("reportMessageId", reportMessageDto.get("id")));
            Dto reportParameterDto = new Dto();
            java.util.List<Dto> reportParameterList = outputGetReportParameterListByReportMessageId.getList("reportParameterList");
            if(reportParameterList!=null && reportParameterList.size()>0){
                for (Dto dto : reportParameterList) {
                    reportParameterDto.put(dto.get("reportParameterKey"), dto.get("reportParameterValue"));
                }
            }

            // update progress report
            final String datetime = org.jleaf.util.DateUtil.dateTimeNow();
            BusinessTransaction updateReportMessage = getQueueAppContext().getContext()
                    .getBean("updateReportMessageStatus", BusinessTransaction.class);
            updateReportMessage.execute(new Dto()
                    .put("userLoginId", CommonConstants.USER_SUPER_ADMIN)
                    .put("tenantLoginId", tenantId)
                    .put("roleLoginId", CommonConstants.ROLE_SUPER_ADMIN)
                    .put("datetime", datetime)

                    .put("id", reportMessageId)
                    .put("version", reportMessageDto.get("version"))
                    .put("processQueueDatetime", datetime)
                    .put("processFinishDatetime", GeneralConstants.EMPTY_VALUE)
                    .put("processStatus", JmsConstants.QUEUED));

            // get connection from jdbc template
            JdbcTemplate jdbcTemplate = getQueueAppContext().getContext().getBean("jdbcTemplate", JdbcTemplate.class);

            conn = jdbcTemplate.getDataSource().getConnection();
            conn.setAutoCommit(false);

            List<Dto> resultList = getDataListForGenerateReport(conn, reportParameterDto);

            conn.commit();

            // prepare temp dir untuk menampung kumpulan file hasil generate
            File tempDir = createTempDir(reportParameterDto.getString("yearMonth"));

            for (Dto result : resultList) {

                functionForSendEmail = reportParameterDto.getString("functionForSendEmail");
                requestUserId = Long.valueOf(reportParameterDto.get("userLoginId").toString());

                log.info("invoice Dto ::: " + result.toString());

                JSONObject requestBody = new JSONObject();
                JSONObject header = new JSONObject();
                JSONObject body = new JSONObject();

                String fileName = new StringBuilder().append(result.getString("doc_no"))
                            .append("_").append(result.getString("ds_name"))
                            .append("_").append(result.getString("ds_code"))
                            .append(ErpJleafJmsConstants.EXT_PDF).toString();

                JSONObject params = new JSONObject();
                params.put("sessionId", reportParameterDto.get("sessionId"));
                params.put("tenantId", Long.valueOf(reportParameterDto.get("tenantLoginId").toString()));
                params.put("invoiceId", Long.valueOf(result.get("invoice_id").toString()));
                params.put("userId", Long.valueOf(reportParameterDto.get("userLoginId").toString()));
                params.put("approvalName", reportParameterDto.get("userLoginName"));

                header.put("userLoginId", Long.valueOf(reportParameterDto.get("userLoginId").toString()));
                header.put("roleLoginId", Long.valueOf(reportParameterDto.get("roleLoginId").toString()));
                header.put("tenantLoginId", Long.valueOf(reportParameterDto.get("tenantLoginId").toString()));
                header.put("userLoginName", reportParameterDto.get("userLoginName"));
                header.put("roleLoginName", reportParameterDto.get("roleLoginName"));
                header.put("datetime", reportParameterDto.get("datetime"));
                header.put("taskName", reportParameterDto.get("taskName"));
                header.put("sessionId", reportParameterDto.get("sessionId"));

                body.put("reportName", reportParameterDto.get("reportName"));
                body.put("fileName", fileName);
                body.put("remark", reportParameterDto.get("remark"));
                body.put("params", params);
                body.put("requestUserId", Long.valueOf(reportParameterDto.get("userLoginId").toString()));
                body.put("requestRoleId", Long.valueOf(reportParameterDto.get("roleLoginId").toString()));
                body.put("requestUserName", reportParameterDto.get("userLoginName"));
                body.put("requestRoleName", reportParameterDto.get("roleLoginName"));

                requestBody.put("header", header);
                requestBody.put("body", body);

                log.info("header ::: " + header.toString());
                log.info("body ::: " + body.toString());
                log.info("requestBody ::: " + requestBody.toString());

                File generatedFile = new File(tempDir, fileName);
                fos = new FileOutputStream(generatedFile, false);

                reportServerHttpUtilForJms.post(reportServerRequestDownloadSyncUrl, requestBody.toString(), fos );
                fos.close();

                // mark generated file to be deleted on exit
                generatedFile.deleteOnExit();
            }

            // Create zip file of parent temp dir
            File zipFile = getZipFile(reportParameterDto);
            ZipUtils.zipFolder(tempDir.getParentFile().getAbsolutePath(), zipFile.getAbsolutePath());

            Dto fileDto = new Dto();
            fileDto.put("fileName", zipFile.getAbsolutePath());
            fileDto.put("fileType", ErpJleafJmsConstants.FILE_TYPE_ZIP);
            fileDto.put("fileSize", zipFile.length());
            List<Dto> fileList = new ArrayList<Dto>(1);
            fileList.add(fileDto);

            // call BT complete
            BusinessTransaction completeGenerateReport = getQueueAppContext().getContext()
                    .getBean("completeGenerateReport", BusinessTransaction.class);

            Dto inputDtoForCompleteGenerateReport = new Dto();
            inputDtoForCompleteGenerateReport.put("tenantId", tenantId);
            inputDtoForCompleteGenerateReport.put("userId", CommonConstants.USER_SUPER_ADMIN);
            inputDtoForCompleteGenerateReport.put("roleId", CommonConstants.ROLE_SUPER_ADMIN);
            inputDtoForCompleteGenerateReport.put("datetime", org.jleaf.util.DateUtil.dateTimeNow());
            inputDtoForCompleteGenerateReport.put("reportMessageId", reportMessageId);
            inputDtoForCompleteGenerateReport.put("reportStatus", JmsConstants.PROCESS_RESULT_SUCCESS);
            inputDtoForCompleteGenerateReport.put("message", "Report Success Generated");
            inputDtoForCompleteGenerateReport.put("fileList", fileList);

            completeGenerateReport.execute(inputDtoForCompleteGenerateReport);

            reportMessageDto = findReportMessageById.execute(new Dto().put("id", reportMessageId));
            updateReportMessage.execute(new Dto()
                .put("userLoginId", CommonConstants.USER_SUPER_ADMIN)
                .put("tenantLoginId", tenantId)
                .put("roleLoginId", CommonConstants.ROLE_SUPER_ADMIN)
                .put("datetime", datetime)

                .put("id", reportMessageId)
                .put("version", reportMessageDto.get("version"))
                .put("processQueueDatetime", reportMessageDto.get("processQueueDatetime"))
                .put("processFinishDatetime", DateUtil.dateTimeNow())
                .put("processStatus", JmsConstants.PROCESS_RESULT_SUCCESS));


            jdbcTemplate = (JdbcTemplate) getAutowiredBean("jdbcTemplate");

            // Send Email

            PreparedStatementCreator psc = new PreparedStatementCreator() {
                @Override
                public PreparedStatement createPreparedStatement(Connection con) throws SQLException {
                    String sqlStatement = "SELECT " + functionForSendEmail + "(?, ?, ?)";
                    PreparedStatement ps = con.prepareStatement(sqlStatement);

                    ps.setString(1, datetime.toString());
                    ps.setLong(2, requestUserId);
                    ps.setLong(3, reportMessageId);
                    return ps;
                }
            };

            PreparedStatementCallback<Boolean> action = new PreparedStatementCallback<Boolean>() {
                @Override
                public Boolean doInPreparedStatement(PreparedStatement ps) throws SQLException, DataAccessException {
                    return ps.execute();
                }
            };

            log.info("BEGIN processing... " + processName);
            jdbcTemplate.execute(psc, action);

//          StringBuilder sendEmail = new StringBuilder();
//          sendEmail.append(" SELECT COUNT(1) FROM ")
//              .append(functionForSendEmail).append("('").append(datetime).append("', ")
//              .append(requestUserId).append(", ").append(reportMessageId).append(" )");
//
//          log.info("query untuk send email ::: "+sendEmail.toString());
//
//          PreparedStatement prepStatement = conn.prepareStatement(sendEmail.toString());
//          prepStatement.executeUpdate();
//
//          conn.commit();

            log.info("DONE process report successfully");
        } catch(Exception e){
            if (fos != null) fos.close();

            // call BT complete
            BusinessTransaction completeGenerateReport = getQueueAppContext().getContext()
                    .getBean("completeGenerateReport", BusinessTransaction.class);

            Dto inputDtoForCompleteGenerateReport = new Dto();
            inputDtoForCompleteGenerateReport.put("tenantId", tenantId);
            inputDtoForCompleteGenerateReport.put("userId", CommonConstants.USER_SUPER_ADMIN);
            inputDtoForCompleteGenerateReport.put("roleId", CommonConstants.ROLE_SUPER_ADMIN);
            inputDtoForCompleteGenerateReport.put("datetime", org.jleaf.util.DateUtil.dateTimeNow());
            inputDtoForCompleteGenerateReport.put("reportMessageId", reportMessageId);
            inputDtoForCompleteGenerateReport.put("reportStatus", JmsConstants.PROCESS_RESULT_ERROR);
            inputDtoForCompleteGenerateReport.put("message", e.getMessage());
            inputDtoForCompleteGenerateReport.put("fileList", null);

            completeGenerateReport.execute(inputDtoForCompleteGenerateReport);


            BusinessFunction findReportMessageById = getQueueAppContext().getContext().getBean("findReportMessageById", BusinessFunction.class);
            Dto reportMessageDto = findReportMessageById.execute(new Dto().put("id", reportMessageId));

            String datetime = org.jleaf.util.DateUtil.dateTimeNow();
            BusinessTransaction updateReportMessage = getQueueAppContext().getContext()
                    .getBean("updateReportMessageStatus", BusinessTransaction.class);
            updateReportMessage.execute(new Dto()
                .put("userLoginId", CommonConstants.USER_SUPER_ADMIN)
                .put("tenantLoginId", tenantId)
                .put("roleLoginId", CommonConstants.ROLE_SUPER_ADMIN)
                .put("datetime", datetime)

                .put("id", reportMessageId)
                .put("version", reportMessageDto.get("version"))
                .put("processQueueDatetime", datetime)
                .put("processFinishDatetime", DateUtil.dateTimeNow())
                .put("processStatus", JmsConstants.PROCESS_STATUS_ERROR));

            if(conn!=null){
                conn.rollback();
            }
            log.error("Error processing report", e);

            throw e;
        } finally{
            if(conn!=null){
                conn.close();
            }
        }

        log.debug("END processing... " + processName);
    }

    /**
     * Get list data untuk generate report
     */
    private List<Dto> getDataListForGenerateReport(Connection conn, Dto reportParameterDto) throws SQLException {
        List<Dto> resultList = new ArrayList<Dto>();

        // Get Batch
        // call function untuk mendapatkan data pendukung report yang akan digenerate
        String sqlStatement = "SELECT " + reportParameterDto.getString("functionForGetBatch") + "(?)";

        log.info("query untuk get batch ::: " + sqlStatement);

        PreparedStatement ps = conn.prepareStatement(sqlStatement);
        ps.setString(1, reportParameterDto.getString("yearMonth"));

        ResultSet resultSet = ps.executeQuery();

        while(resultSet.next()){

            Object rsDataObj = resultSet.getObject(1);

            if(rsDataObj instanceof ResultSet){
                ResultSet rsData = (ResultSet)rsDataObj;
                resultList = DtoUtil.createDtoListFromResultSet(rsData);
            }

            log.info("resultList::: " + resultList);
        }



        return resultList;
    }

    /**
     * Membuat folder temporer sebagai penampung file hasil generate report.
     * Contoh folder temporer: /tmp/yiuasd/invoice_2018_06
     *
     * @return folder temporer sebagai penampung file hasil generate report
     * @throws IOException
     */
    private File createTempDir(String yearMonth) throws IOException {
        String tmpFolderName = getServerConfigProp().getProperty(ErpJleafJmsConstants.PROP_TASKHUB_HOME) + ErpJleafJmsConstants.TMP_FOLDER_NAME;
        File mainTmpFolder = new File(tmpFolderName);
        if(!mainTmpFolder.exists()){
            mainTmpFolder.mkdirs();
        }
        log.debug("tmpParentFolder : "+tmpFolderName);

        // Create temp file, lalu hapus temp file tsb, karena akan di-recreate menjadi directory
        File tempFile = File.createTempFile("invoice_tmp", "", mainTmpFolder);
        String absolutePath = tempFile.getAbsolutePath();
        boolean delete = tempFile.delete();
        log.info(String.format("Temp file (%s) deleted: %s", absolutePath, delete));

        File tempDir = new File(absolutePath);
        String childDirName = new StringBuilder().append("invoice_").append(yearMonth.substring(0, 4)).append("_").append(yearMonth.substring(4)).toString();
        File tempChildDir = new File(tempDir, childDirName);
        boolean mkdir = tempChildDir.mkdirs();
        log.info(String.format("Temp dir (%s) created: %s", tempChildDir.getAbsolutePath(), mkdir));

        // mark directories to be deleted on exit. The sequence must be from parent folder, because the deletion sequence will be reversed
        tempDir.deleteOnExit();
        tempChildDir.deleteOnExit();

        return tempChildDir;
    }

    /**
     * Membuat object file zip yang akan berisi file-file hasil generate report
     *
     * @param reportParameterDto
     * @return object File zip
     */
    private File getZipFile(Dto reportParameterDto) {
        String zipFileName = new StringBuilder()
                .append("Invoice_")
                .append(reportParameterDto.getString("yearMonth").substring(0, 4))
                .append("_")
                .append(reportParameterDto.getString("yearMonth").substring(4))
                .append("_")
                .append(reportParameterDto.get("datetime"))
                .append("_")
                .append(reportParameterDto.get("userLoginName"))
                .append(ErpJleafJmsConstants.EXT_ZIP).toString();

        // Prepare folder untuk menampung zip file hasil generate
        String reportFolder = getServerConfigProp().getProperty(ErpJleafJmsConstants.PROP_TASKHUB_HOME) + ErpJleafJmsConstants.OUTPUT_REPORT_FOLDER_NAME;
        File reportFolderFile = new File(reportFolder);
        if(!reportFolderFile.exists()){
            reportFolderFile.mkdirs();
        }
        log.debug("reportFolder : "+reportFolder);

        return new File(reportFolder, zipFileName);

    }

}