API tools faq
paste
Advertisement
aadddrr

Panggil service di Servlet

aadddrr
Aug 3rd, 2018
110
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Java 45.76 KB | None | 0 0
raw download clone embed print report
  1. package org.jleaf.web.report.servlet;
  2.  
  3. import java.io.ByteArrayOutputStream;
  4. import java.io.IOException;
  5. import java.io.InputStream;
  6. import java.io.InputStreamReader;
  7. import java.io.ObjectOutputStream;
  8. import java.io.OutputStream;
  9. import java.io.Reader;
  10. import java.io.StringWriter;
  11. import java.net.HttpURLConnection;
  12. import java.net.URL;
  13. import java.nio.charset.Charset;
  14. import java.util.Arrays;
  15. import java.util.List;
  16. import java.util.Map;
  17. import java.util.Properties;
  18.  
  19. import javax.servlet.ServletException;
  20. import javax.servlet.http.HttpServlet;
  21. import javax.servlet.http.HttpServletRequest;
  22. import javax.servlet.http.HttpServletResponse;
  23. import javax.servlet.http.HttpSession;
  24.  
  25. import org.jleaf.core.CoreException;
  26. import org.jleaf.core.Dto;
  27. import org.jleaf.core.GeneralConstants;
  28. import org.jleaf.util.Base64;
  29. import org.jleaf.util.DateUtil;
  30. import org.jleaf.util.DtoUtil;
  31. import org.jleaf.web.ServiceProvider;
  32. import org.jleaf.web.WebUtil;
  33. import org.jleaf.web.audit.AuditReportApi;
  34. import org.jleaf.web.helper.ServiceResult;
  35. import org.jleaf.web.jsf.WebAppContext;
  36. import org.jleaf.web.jsf.WebJsfConstants;
  37. import org.jleaf.web.jsf.util.MessageUtil;
  38. import org.jleaf.web.report.ReportConfig;
  39. import org.jleaf.web.report.ReportConfigRepository;
  40. import org.jleaf.web.report.ReportConstants;
  41. import org.jleaf.web.report.ReportDataConnector;
  42. import org.jleaf.web.report.ReportDataConnectorFactory;
  43. import org.jleaf.web.report.excel.ExcelReportExporter;
  44. import org.jleaf.web.report.excel.NewExcelReportExporter;
  45. import org.jleaf.web.report.jasper.JasperReportExporter;
  46. import org.jleaf.web.report.jasper.ReportTypeFactory;
  47. import org.jleaf.web.util.DownloadReportUtil;
  48. import org.json.simple.JSONArray;
  49. import org.json.simple.JSONObject;
  50. import org.json.simple.JSONValue;
  51. import org.json.simple.parser.JSONParser;
  52. import org.slf4j.Logger;
  53. import org.slf4j.LoggerFactory;
  54. import org.springframework.beans.factory.annotation.Autowired;
  55. import org.springframework.beans.factory.config.AutowireCapableBeanFactory;
  56. import org.springframework.context.ApplicationContext;
  57. import org.springframework.core.io.Resource;
  58. import org.springframework.web.context.WebApplicationContext;
  59. import org.springframework.web.context.support.WebApplicationContextUtils;
  60.  
  61. import simple.escp.data.DataSource;
  62. import simple.escp.data.EmptyDataSource;
  63. import simple.escp.data.JsonDataSource;
  64. import simple.escp.fill.FillJob;
  65. import simple.escp.json.JsonTemplate;
  66.  
  67. /**
  68.  * @author fredi, 22 feb 2016
  69.  */
  70. public class DownloadReportFromProviderServlet extends HttpServlet {
  71.     private static final long serialVersionUID = -3271390873558511409L;
  72.     private static final Logger log = LoggerFactory.getLogger(DownloadReportFromProviderServlet.class);
  73.  
  74.     @Autowired
  75.     private ApplicationContext applicationContext;
  76.  
  77.     @Autowired
  78.     private ServiceProvider serviceProvider;
  79.    
  80.     public DownloadReportFromProviderServlet() {
  81.  
  82.     }
  83.  
  84.     public void init() {
  85.         WebApplicationContext ctx = WebApplicationContextUtils.getRequiredWebApplicationContext(getServletContext());
  86.  
  87.         AutowireCapableBeanFactory bf = ctx.getAutowireCapableBeanFactory();
  88.  
  89.         bf.autowireBean(this);
  90.     }
  91.  
  92.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  93.         filterDoRequest(request, response);
  94.  
  95.     }
  96.  
  97.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  98.         filterDoRequest(request, response);
  99.     }
  100.  
  101.     protected void filterDoRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  102.         log.info("Incoming report request.");
  103.        
  104.         // check CONFIG
  105.         Properties prop =  WebUtil.getGlobalProperties(this);
  106.         if( prop.getProperty(WebJsfConstants.PROP_REPORT_REDIRECT_ACTIVE) != null
  107.             && new Boolean(true).toString().equals( prop.getProperty(WebJsfConstants.PROP_REPORT_REDIRECT_ACTIVE).trim())
  108.                
  109.             && prop.getProperty(WebJsfConstants.PROP_REPORT_REDIRECT_HOST) != null
  110.             && !prop.getProperty(WebJsfConstants.PROP_REPORT_REDIRECT_HOST).trim().isEmpty()
  111.            
  112.             && prop.getProperty(WebJsfConstants.PROP_REPORT_REDIRECT_PORT) != null
  113.             && !prop.getProperty(WebJsfConstants.PROP_REPORT_REDIRECT_PORT).trim().isEmpty()
  114.  
  115.             && prop.getProperty(WebJsfConstants.PROP_REPORT_REDIRECT_DOWNLOAD_SERVLET) != null
  116.             && !prop.getProperty(WebJsfConstants.PROP_REPORT_REDIRECT_DOWNLOAD_SERVLET).trim().isEmpty()
  117.  
  118.             && prop.getProperty(WebJsfConstants.PROP_REPORT_REDIRECT_DOWNLOAD_SERVLET) != null
  119.             && !prop.getProperty(WebJsfConstants.PROP_REPORT_REDIRECT_DOWNLOAD_SERVLET).trim().isEmpty()
  120.  
  121.             ){
  122.            
  123.             String redirectHost = prop.getProperty(WebJsfConstants.PROP_REPORT_REDIRECT_HOST).trim();
  124.             String redirectPort = prop.getProperty(WebJsfConstants.PROP_REPORT_REDIRECT_PORT).trim();
  125.             String redirectDownloadServlet = prop.getProperty(WebJsfConstants.PROP_REPORT_REDIRECT_DOWNLOAD_SERVLET).trim();
  126.            
  127.             String reportName = request.getParameter("reportName");
  128.             String type = request.getParameter("type");
  129.             String inputEncoded = request.getParameter("input");
  130.             String fileName = request.getParameter("fileName");
  131.  
  132.             log.debug("report name : " + reportName);
  133.             log.debug("report type : " + type);
  134.             log.debug("input encoded : " + inputEncoded);
  135.            
  136.             log.debug("redirectHost : "+redirectHost);
  137.            
  138.             String protocol = "http://";
  139.            
  140.             String baseUrl = protocol.concat( redirectHost )
  141.                     .concat(":").concat(redirectPort)
  142.                     .concat(redirectDownloadServlet);
  143.            
  144.            
  145.             try{
  146.                 log.debug("base URL : "+baseUrl);
  147.                 DownloadReportUtil.dowloadReport(request, response,
  148.                         baseUrl,
  149.                         reportName,
  150.                         type,
  151.                         fileName,
  152.                         inputEncoded);
  153.                
  154.             } catch(Exception e){
  155.                 throw new ServletException(e.getMessage());
  156.             }
  157.         } else{
  158.            
  159.             doRequest(request, response);
  160.         }
  161.        
  162.     }
  163.    
  164.     @SuppressWarnings({ "rawtypes" })
  165.     protected void doRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
  166.         ReportConfigRepository reportConfigRepository = (ReportConfigRepository) WebAppContext.getInstance().getObject(WebJsfConstants.REPORT_CONFIG_REPOSITORY);
  167.  
  168.         String reportName = request.getParameter("reportName");
  169.         String type = request.getParameter("type");
  170.         String inputEncoded = request.getParameter("input");
  171.         String fileName = request.getParameter("fileName");
  172.  
  173.         log.debug("report name : " + reportName);
  174.         log.debug("report type : " + type);
  175.         log.debug("input encoded : " + inputEncoded);
  176.  
  177.         String inputDecoded = new String(Base64.decode(inputEncoded));
  178.         JSONParser parser = new JSONParser();
  179.         JSONObject inputJson = new JSONObject();
  180.        
  181.         try{
  182.             inputJson = (JSONObject)parser.parse(inputDecoded);
  183.         } catch(Exception e){
  184.             throw new ServletException("Error parsing report input");
  185.         }
  186.  
  187.         //default case if null
  188.         if (type == null) {
  189.             log.warn("Type report file not set, setted to default " + ReportConstants.REPORT_TYPE_DEFAULT);
  190.             type = ReportConstants.REPORT_TYPE_DEFAULT;
  191.         }
  192.  
  193.         if (fileName == null) {
  194.             log.warn("File name not set, setted to default " + ReportConstants.REPORT_FILE_NAME_DEFAULT);
  195.             fileName = ReportConstants.REPORT_FILE_NAME_DEFAULT + "." + type;
  196.         }else{
  197.             fileName = fileName+"."+type;
  198.         }
  199.  
  200.         //get report config
  201.         log.debug("get report config");
  202.         if(reportConfigRepository.getReportConfig(reportName)==null){
  203.             throw new ServletException("Report config not found with name "+reportName);
  204.         }
  205.        
  206.         ReportConfig reportConfig = reportConfigRepository.getReportConfig(reportName);
  207.         List<Map> outputList = (List<Map>)reportConfig.getOutputList();    
  208.        
  209.         //write byte report config
  210.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
  211.         ObjectOutputStream os = new ObjectOutputStream(baos);
  212.         os.writeObject(reportConfig);
  213.         os.close();
  214.         String reportConfigObjectEncoded = Base64.encodeToString(baos.toByteArray(), false);
  215.        
  216.         //get data from provider
  217.         Dto resultDto = null;
  218.         log.debug("get data from provider");
  219.         try {
  220.             //create payload
  221.             Dto headerRequestDto = populateRequestHeaderFromSession(request);
  222.             Dto payloadRequestDto = new Dto();
  223.             payloadRequestDto.put("input", inputEncoded);
  224.             payloadRequestDto.put("config", reportConfigObjectEncoded);
  225.            
  226.             Dto paramConnector = new Dto();
  227.             paramConnector.put("url", getDataProviderUrl());           
  228.            
  229.             ReportDataConnector connector = ReportDataConnectorFactory.getConnector(reportConfig.getType(), paramConnector);
  230.            
  231.            
  232.             log.debug("Execute request : ");
  233.             log.debug("Header : "+headerRequestDto);
  234.             log.debug("Payload : "+payloadRequestDto);
  235.             Dto outputDto = connector.execute(payloadRequestDto, headerRequestDto);
  236.            
  237.             log.debug("outputDto : "+outputDto);
  238.             String status = outputDto.getString("output.status");
  239.             if (status != null) {
  240.                 if (status.equals(GeneralConstants.OK)) {
  241.                     resultDto = outputDto;
  242. //                  reportDataList = (List<Dto>)DtoUtil.convertToArray(resultDto.get(keyDataList));
  243.                 } else if (status.equals(GeneralConstants.FAIL)) {
  244.                     log.error("Error in service");
  245.                     log.error(outputDto.get("output.message")+"");
  246.                    
  247.                     throw new ServletException(outputDto.get("output.message")+"");
  248.                 }
  249.             }
  250.         } catch (Exception e) {
  251.             log.error("Error in requesting services", e);
  252.            
  253.             throw new ServletException("Error in requesting data : "+ (e!=null?e.getMessage():e) );
  254.         }
  255.        
  256.         if(resultDto!=null){
  257.             Long userLoginId = Long.valueOf(request.getSession().getAttribute(WebJsfConstants.SESS_LOGGED_USER_ID).toString());
  258.             Long roleLoginId = Long.valueOf(request.getSession().getAttribute(WebJsfConstants.SESS_LOGGED_CURRENT_ROLE).toString());
  259.             Long tenantLoginId = Long.valueOf(request.getSession().getAttribute(WebJsfConstants.SESS_LOGGED_TENANT_ID).toString());
  260.            
  261.             log.info("Template type: " + reportConfig.getTemplateType());
  262.             // Dec 16, adding support for excel template
  263.             try{
  264.                 if(ReportConfig.TEMPLATE_TYPE_JASPER.equals(reportConfig.getTemplateType())){
  265.                     this.responseUsingTemplateJasper(response, request, reportConfig, outputList, resultDto, type, fileName, inputJson, tenantLoginId, roleLoginId, userLoginId);
  266.                 } else if(ReportConfig.TEMPLATE_TYPE_JXLS.equals(reportConfig.getTemplateType())){
  267.                     this.responseUsingTemplateJxls(response, request, reportConfig, outputList, resultDto, type, fileName, inputJson, tenantLoginId, roleLoginId, userLoginId );
  268.                 } else if(ReportConfig.TEMPLATE_TYPE_EXCEL.equals(reportConfig.getTemplateType())){
  269.                     this.responseUsingTemplateJxls(response, request, reportConfig, outputList, resultDto, type, fileName, inputJson, tenantLoginId, roleLoginId, userLoginId );
  270.                 } else if(ReportConfig.TEMPLATE_TYPE_JETT.equals(reportConfig.getTemplateType())){
  271.                     this.responseUsingTemplateJett(response, request, reportConfig, outputList, resultDto, type, fileName, inputJson, tenantLoginId, roleLoginId, userLoginId );
  272.                 } else if(ReportConfig.TEMPLATE_TYPE_ESCP.equals(reportConfig.getTemplateType())){
  273.                     this.responseUsingTemplateEscp(response, request, reportConfig, outputList, resultDto, type, fileName, inputJson, tenantLoginId, roleLoginId, userLoginId );
  274.                 }
  275.             } catch(CoreException se){
  276.                 log.error("Error report", se);
  277.                
  278.                 String errorKey = se.getErrorKey();
  279.                 Object[] args = se.getParamValues();
  280.                
  281.                 if(args!=null){
  282.                     log.debug(Arrays.toString(args));                  
  283.                 }
  284.                
  285. //              response.addHeader("errorKey", MessageUtil.getInstance().getLabel(errorKey , args));
  286. //              response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, errorKey);
  287.                
  288.                 String message = MessageUtil.getInstance().getLabel(errorKey , args);
  289.                 log.debug("Servlet message from core exception : "+message);
  290.                
  291.                 throw new ServletException(message);
  292.             } catch (Exception e) {
  293.                 log.error("Error report", e);
  294.                
  295. //              response.addHeader("errorKey", e.getMessage());
  296. //              response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, e.getMessage());
  297.                 throw new ServletException("Error generate report : "+e.getMessage());
  298.             }
  299.         }
  300.     }
  301.    
  302.     /**
  303.      * Diganti dengan yang ada parameter json input
  304.      * @param response
  305.      * @param reportConfig
  306.      * @param outputList
  307.      * @param resultDto
  308.      * @param type
  309.      * @param fileName
  310.      * @throws IOException
  311.      */
  312.     @Deprecated
  313.     private void responseUsingTemplateJasper(HttpServletResponse response, ReportConfig reportConfig, List<Map> outputList, Dto resultDto, String type, String fileName) throws IOException{
  314.         String keyOutput = outputList.get(0).get(ReportConstants.KEY_CONFIG_OUTPUT_ITEM_NAME).toString();
  315.         List<Dto> reportDataList = (List<Dto>)DtoUtil.convertToArray(resultDto.get("output.payload.detail."+keyOutput));
  316.         Dto parametersDto = resultDto.getDto("output.payload.parameter");
  317.        
  318.         //generate report
  319.         log.info("Generating report");
  320.    
  321.         log.debug("Loading layout : "+reportConfig.getLayout());
  322.         Resource res = applicationContext.getResource( reportConfig.getLayout() );
  323.         InputStream layoutStream = res.getInputStream();
  324.        
  325.         log.debug("Writing report");
  326.        
  327.         try {
  328.             ByteArrayOutputStream bos = null;
  329.             OutputStream osResponse = response.getOutputStream();
  330.            
  331.             //generate report file based on type
  332.             log.debug("start ReportExporter");
  333.             bos = JasperReportExporter.export(parametersDto, reportDataList, ReportTypeFactory.getReportType(type), layoutStream);
  334.             log.debug("end ReportExporter");
  335.             log.debug("start ContentDispositionFactory");
  336.             ContentDispositionFactory.setContentDisposition(type, response, fileName);
  337.             log.debug("end ContentDispositionFactory");
  338.             bos.writeTo(osResponse);
  339.             osResponse.close();
  340.         }catch (Exception e) {
  341.             log.error("Error in create report ", e);
  342.         }
  343.     }
  344.    
  345.     @SuppressWarnings({ "unchecked", "rawtypes" })
  346.     private void responseUsingTemplateJasper(HttpServletResponse response, ReportConfig reportConfig, List<Map> outputList, Dto resultDto, String type, String fileName, JSONObject jsonInput) throws IOException{
  347.         String keyOutput = outputList.get(0).get(ReportConstants.KEY_CONFIG_OUTPUT_ITEM_NAME).toString();
  348.         List<Dto> reportDataList = (List<Dto>)DtoUtil.convertToArray(resultDto.get("output.payload.detail."+keyOutput));
  349.         Dto parametersDto = resultDto.getDto("output.payload.parameter");
  350.        
  351.         //generate report
  352.         log.info("Generating report");
  353.  
  354.         String layout = reportConfig.getLayout(jsonInput);
  355.         log.debug("Loading layout : "+layout);
  356.         Resource res = applicationContext.getResource( layout );
  357.        
  358.         InputStream layoutStream = res.getInputStream();
  359.        
  360.         log.debug("Writing report");
  361.        
  362.         try {
  363.             ByteArrayOutputStream bos = null;
  364.             OutputStream osResponse = response.getOutputStream();
  365.            
  366.             //generate report file based on type
  367.             log.debug("start ReportExporter");
  368.             bos = JasperReportExporter.export(parametersDto, reportDataList, ReportTypeFactory.getReportType(type), layoutStream);
  369.             log.debug("end ReportExporter");
  370.             log.debug("start ContentDispositionFactory");
  371.             ContentDispositionFactory.setContentDisposition(type, response, fileName);
  372.             log.debug("end ContentDispositionFactory");
  373.             bos.writeTo(osResponse);
  374.             osResponse.close();
  375.         }catch (Exception e) {
  376.             log.error("Error in create report", e);
  377.         }
  378.     }
  379.  
  380.     /**
  381.      * added audit report
  382.      */
  383.     @SuppressWarnings({ "unchecked", "rawtypes" })
  384.     private void responseUsingTemplateJasper(HttpServletResponse response, HttpServletRequest request, ReportConfig reportConfig, List<Map> outputList, Dto resultDto, String type, String fileName, JSONObject jsonInput, Long tenantLoginId, Long roleLoginId, Long userLoginId) throws Exception{
  385.         String keyOutput = outputList.get(0).get(ReportConstants.KEY_CONFIG_OUTPUT_ITEM_NAME).toString();
  386.         List<Dto> reportDataList = (List<Dto>)DtoUtil.convertToArray(resultDto.get("output.payload.detail."+keyOutput));
  387.         Dto parametersDto = resultDto.getDto("output.payload.parameter");
  388.        
  389.         //generate report
  390.         log.info("Generating report");
  391.    
  392.         String layout = reportConfig.getLayout(jsonInput);
  393.         log.debug("Loading layout : "+layout);
  394.         Resource res = applicationContext.getResource( layout );
  395.        
  396.         InputStream layoutStream = res.getInputStream();
  397.        
  398.         log.debug("Writing report");
  399.        
  400.         ByteArrayOutputStream bos = null;
  401.         try {
  402.             OutputStream osResponse = response.getOutputStream();
  403.            
  404.             //generate report file based on type
  405.             log.debug("start ReportExporter");
  406.             bos = JasperReportExporter.export(parametersDto, reportDataList, ReportTypeFactory.getReportType(type), layoutStream);
  407.             log.debug("end ReportExporter");
  408.             log.debug("start ContentDispositionFactory");
  409.            
  410.            
  411.             // caling report audit
  412.             doAuditReport(reportConfig.getName(), jsonInput, tenantLoginId, roleLoginId, userLoginId, request);
  413.            
  414.             ContentDispositionFactory.setContentDisposition(type, response, fileName);
  415.             log.debug("end ContentDispositionFactory");
  416.             bos.writeTo(osResponse);
  417.             osResponse.close();
  418.            
  419.             layoutStream.close();
  420.         }catch (Exception e) {
  421.             log.error("Error in create report", e);
  422.             throw e;
  423.         }finally{
  424.             if(bos!=null){
  425.                 bos.flush();
  426.                 bos.close();               
  427.             }
  428.         }
  429.     }
  430.    
  431.     @Deprecated
  432.     private void responseUsingTemplateJxls(HttpServletResponse response, ReportConfig reportConfig, List<Map> outputList, Dto resultDto, String type, String fileName) throws IOException{
  433.        
  434.         // Need to support multiple outputList
  435.        
  436.         Dto dataForReportDto = new Dto();
  437.        
  438.         for(int i=0; i<outputList.size(); i++){
  439.             String keyOutput = outputList.get(i).get(ReportConstants.KEY_CONFIG_OUTPUT_ITEM_NAME).toString();
  440.             List<Dto> reportDataList = (List<Dto>)DtoUtil.convertToArray(resultDto.get("output.payload.detail."+keyOutput));
  441.             dataForReportDto.put("detail." + keyOutput, reportDataList);
  442.         }
  443.        
  444.         Dto parametersDto = resultDto.getDto("output.payload.parameter");
  445.         dataForReportDto.put("parameter", parametersDto);
  446.        
  447.         //generate report
  448.         log.info("Generating report");
  449.    
  450.         log.debug("Loading layout : "+reportConfig.getLayout());
  451.         Resource res = applicationContext.getResource(reportConfig.getLayout());
  452.         InputStream layoutStream = res.getInputStream();
  453.        
  454.         log.debug("Writing report");
  455.        
  456.         try {
  457.             ByteArrayOutputStream bos = null;
  458.             OutputStream osResponse = response.getOutputStream();
  459.            
  460.             //generate report file based on type
  461.             log.debug("start ReportExporter");
  462.             bos = ExcelReportExporter.export(dataForReportDto, type, layoutStream);
  463.            
  464.             log.debug("end ReportExporter");
  465.             log.debug("start ContentDispositionFactory");
  466.            
  467.             // For excel only few supported format
  468.             // ReportConstants.REPORT_TYPE_PDF
  469.             // ReportConstants.REPORT_TYPE_XLS
  470.             ContentDispositionFactory.setContentDisposition(ReportConstants.REPORT_TYPE_XLSX, response, fileName);
  471.             log.debug("end ContentDispositionFactory");
  472.             bos.writeTo(osResponse);
  473.             osResponse.close();
  474.         }catch (Exception e) {
  475.             log.error("Error in create report ", e);
  476.         }
  477.     }
  478.    
  479.     @SuppressWarnings({ "unchecked", "rawtypes" })
  480.     private void responseUsingTemplateJxls(HttpServletResponse response, ReportConfig reportConfig, List<Map> outputList, Dto resultDto, String type, String fileName, JSONObject jsonInput) throws IOException{
  481.        
  482.         // Need to support multiple outputList
  483.        
  484.         Dto dataForReportDto = new Dto();
  485.        
  486.         for(int i=0; i<outputList.size(); i++){
  487.             String keyOutput = outputList.get(i).get(ReportConstants.KEY_CONFIG_OUTPUT_ITEM_NAME).toString();
  488.             List<Dto> reportDataList = (List<Dto>)DtoUtil.convertToArray(resultDto.get("output.payload.detail."+keyOutput));
  489.             dataForReportDto.put("detail." + keyOutput, reportDataList);
  490.         }
  491.        
  492.         Dto parametersDto = resultDto.getDto("output.payload.parameter");
  493.         dataForReportDto.put("parameter", parametersDto);
  494.        
  495.         //generate report
  496.         log.info("Generating report");
  497.  
  498.         String layout = reportConfig.getLayout(jsonInput);
  499.         log.debug("Loading layout : "+layout);
  500.         Resource res = applicationContext.getResource(layout);
  501.         InputStream layoutStream = res.getInputStream();
  502.        
  503.         log.debug("Writing report");
  504.        
  505.         try {
  506.             ByteArrayOutputStream bos = null;
  507.             OutputStream osResponse = response.getOutputStream();
  508.            
  509.             //generate report file based on type
  510.             log.debug("start ReportExporter");
  511.             bos = ExcelReportExporter.export(dataForReportDto, type, layoutStream);
  512.            
  513.             log.debug("end ReportExporter");
  514.             log.debug("start ContentDispositionFactory");
  515.            
  516.             // For excel only few supported format
  517.             // ReportConstants.REPORT_TYPE_PDF
  518.             // ReportConstants.REPORT_TYPE_XLS
  519.             ContentDispositionFactory.setContentDisposition(ReportConstants.REPORT_TYPE_XLSX, response, fileName);
  520.             log.debug("end ContentDispositionFactory");
  521.             bos.writeTo(osResponse);
  522.             osResponse.close();
  523.         }catch (Exception e) {
  524.             log.error("Error in create report", e);
  525.         }
  526.     }
  527.    
  528.     /**
  529.      * added report audit
  530.      */
  531.     @SuppressWarnings({ "unchecked", "rawtypes" })
  532.     private void responseUsingTemplateJxls(HttpServletResponse response, HttpServletRequest request, ReportConfig reportConfig, List<Map> outputList, Dto resultDto, String type, String fileName, JSONObject jsonInput, Long tenantLoginId, Long roleLoginId, Long userLoginId) throws Exception{
  533.        
  534.         // Need to support multiple outputList
  535.        
  536.         Dto dataForReportDto = new Dto();
  537.        
  538.         for(int i=0; i<outputList.size(); i++){
  539.             String keyOutput = outputList.get(i).get(ReportConstants.KEY_CONFIG_OUTPUT_ITEM_NAME).toString();
  540.             List<Dto> reportDataList = (List<Dto>)DtoUtil.convertToArray(resultDto.get("output.payload.detail."+keyOutput));
  541.             dataForReportDto.put("detail." + keyOutput, reportDataList);
  542.         }
  543.        
  544.         Dto parametersDto = resultDto.getDto("output.payload.parameter");
  545.         dataForReportDto.put("parameter", parametersDto);
  546.        
  547.         //generate report
  548.         log.info("Generating report");
  549.  
  550.         String layout = reportConfig.getLayout(jsonInput);
  551.         log.debug("Loading layout : "+layout);
  552.         Resource res = applicationContext.getResource(layout);
  553.         InputStream layoutStream = res.getInputStream();
  554.        
  555.         log.debug("Writing report");
  556.        
  557.         ByteArrayOutputStream bos = null;
  558.         try {
  559.             OutputStream osResponse = response.getOutputStream();
  560.            
  561.             //generate report file based on type
  562.             log.debug("start ReportExporter");
  563.             bos = ExcelReportExporter.export(dataForReportDto, type, layoutStream);
  564.            
  565.             log.debug("end ReportExporter");
  566.             log.debug("start ContentDispositionFactory");
  567.            
  568.             // caling report audit
  569.             doAuditReport(reportConfig.getName(), jsonInput, tenantLoginId, roleLoginId, userLoginId, request);
  570.  
  571.             // For excel only few supported format
  572.             // ReportConstants.REPORT_TYPE_PDF
  573.             // ReportConstants.REPORT_TYPE_XLS
  574.             ContentDispositionFactory.setContentDisposition(ReportConstants.REPORT_TYPE_XLSX, response, fileName);
  575.             log.debug("end ContentDispositionFactory");
  576.             bos.writeTo(osResponse);
  577.             osResponse.close();
  578.            
  579.             layoutStream.close();
  580.         }catch (Exception e) {
  581.             log.error("Error in create report", e);
  582.             throw e;
  583.         }finally{
  584.             if(bos!=null){
  585.                 bos.flush();
  586.                 bos.close();
  587.             }
  588.         }
  589.     }
  590.    
  591.     /**
  592.      * Diganti dengan yang tambah paramater JSONInput
  593.      *
  594.      * @param response
  595.      * @param reportConfig
  596.      * @param outputList
  597.      * @param resultDto
  598.      * @param type
  599.      * @param fileName
  600.      * @throws IOException
  601.      */
  602.     @Deprecated
  603.     private void responseUsingTemplateJett(HttpServletResponse response, ReportConfig reportConfig, List<Map> outputList, Dto resultDto, String type, String fileName) throws IOException{
  604.        
  605.         // Need to support multiple outputList
  606.        
  607.         Dto dataForReportDto = new Dto();
  608.        
  609.         for(int i=0; i<outputList.size(); i++){
  610.             String keyOutput = outputList.get(i).get(ReportConstants.KEY_CONFIG_OUTPUT_ITEM_NAME).toString();
  611.             List<Dto> reportDataList = (List<Dto>)DtoUtil.convertToArray(resultDto.get("output.payload.detail."+keyOutput));
  612.             dataForReportDto.put("detail." + keyOutput, reportDataList);
  613.         }
  614.        
  615.         Dto parametersDto = resultDto.getDto("output.payload.parameter");
  616.         dataForReportDto.put("parameter", parametersDto);
  617.        
  618.         //generate report
  619.         log.info("Generating report");
  620.    
  621.         log.debug("Loading layout : "+reportConfig.getLayout());
  622.         Resource res = applicationContext.getResource(reportConfig.getLayout());
  623.         InputStream layoutStream = res.getInputStream();
  624.        
  625.         log.debug("Writing report");
  626.        
  627.         try {
  628.             ByteArrayOutputStream bos = null;
  629.             OutputStream osResponse = response.getOutputStream();
  630.            
  631.             //generate report file based on type
  632.             log.debug("start ReportExporter");
  633.             bos = NewExcelReportExporter.export(dataForReportDto, type, layoutStream);
  634.            
  635.             log.debug("end ReportExporter");
  636.             log.debug("start ContentDispositionFactory");
  637.            
  638.             // For excel only few supported format
  639.             // ReportConstants.REPORT_TYPE_PDF
  640.             // ReportConstants.REPORT_TYPE_XLS
  641.             ContentDispositionFactory.setContentDisposition(ReportConstants.REPORT_TYPE_XLSX, response, fileName);
  642.             log.debug("end ContentDispositionFactory");
  643.             bos.writeTo(osResponse);
  644.             osResponse.close();
  645.         }catch (Exception e) {
  646.             log.error("Error in create report ", e);
  647.         }
  648.     }
  649.    
  650.     @SuppressWarnings({ "unchecked", "rawtypes" })
  651.     private void responseUsingTemplateJett(HttpServletResponse response, ReportConfig reportConfig, List<Map> outputList, Dto resultDto, String type, String fileName, JSONObject jsonInput) throws IOException{
  652.        
  653.         // Need to support multiple outputList
  654.        
  655.         Dto dataForReportDto = new Dto();
  656.        
  657.         for(int i=0; i<outputList.size(); i++){
  658.             String keyOutput = outputList.get(i).get(ReportConstants.KEY_CONFIG_OUTPUT_ITEM_NAME).toString();
  659.             List<Dto> reportDataList = (List<Dto>)DtoUtil.convertToArray(resultDto.get("output.payload.detail."+keyOutput));
  660.             dataForReportDto.put("detail." + keyOutput, reportDataList);
  661.         }
  662.        
  663.         Dto parametersDto = resultDto.getDto("output.payload.parameter");
  664.         dataForReportDto.put("parameter", parametersDto);
  665.        
  666.         //generate report
  667.         log.info("Generating report");
  668.  
  669.         String layout = reportConfig.getLayout(jsonInput);
  670.         log.debug("Loading layout : "+layout);
  671.         Resource res = applicationContext.getResource(layout);
  672.         InputStream layoutStream = res.getInputStream();
  673.        
  674.         log.debug("Writing report");
  675.        
  676.         try {
  677.             ByteArrayOutputStream bos = null;
  678.             OutputStream osResponse = response.getOutputStream();
  679.            
  680.             //generate report file based on type
  681.             log.debug("start ReportExporter");
  682.             bos = NewExcelReportExporter.export(dataForReportDto, type, layoutStream);
  683.            
  684.             log.debug("end ReportExporter");
  685.             log.debug("start ContentDispositionFactory");
  686.            
  687.             // For excel only few supported format
  688.             // ReportConstants.REPORT_TYPE_PDF
  689.             // ReportConstants.REPORT_TYPE_XLS
  690.             ContentDispositionFactory.setContentDisposition(ReportConstants.REPORT_TYPE_XLSX, response, fileName);
  691.             log.debug("end ContentDispositionFactory");
  692.             bos.writeTo(osResponse);
  693.             osResponse.close();
  694.         }catch (Exception e) {
  695.             log.error("Error in create report", e);
  696.         }
  697.     }
  698.    
  699.     /**
  700.      * Added report audit
  701.      */
  702.     @SuppressWarnings({ "unchecked", "rawtypes" })
  703.     private void responseUsingTemplateJett(HttpServletResponse response, HttpServletRequest request, ReportConfig reportConfig, List<Map> outputList, Dto resultDto, String type, String fileName, JSONObject jsonInput, Long tenantLoginId, Long roleLoginId, Long userLoginId) throws Exception{
  704.        
  705.         // Need to support multiple outputList
  706.        
  707.         Dto dataForReportDto = new Dto();
  708.        
  709.         for(int i=0; i<outputList.size(); i++){
  710.             String keyOutput = outputList.get(i).get(ReportConstants.KEY_CONFIG_OUTPUT_ITEM_NAME).toString();
  711.             List<Dto> reportDataList = (List<Dto>)DtoUtil.convertToArray(resultDto.get("output.payload.detail."+keyOutput));
  712.             dataForReportDto.put("detail." + keyOutput, reportDataList);
  713.         }
  714.        
  715.         Dto parametersDto = resultDto.getDto("output.payload.parameter");
  716.         dataForReportDto.put("parameter", parametersDto);
  717.        
  718.         //generate report
  719.         log.info("Generating report");
  720.  
  721.         String layout = reportConfig.getLayout(jsonInput);
  722.         log.debug("Loading layout : "+layout);
  723.         Resource res = applicationContext.getResource(layout);
  724.         InputStream layoutStream = res.getInputStream();
  725.        
  726.         log.debug("Writing report");
  727.        
  728.         ByteArrayOutputStream bos = null;
  729.         try {
  730.             OutputStream osResponse = response.getOutputStream();
  731.            
  732.             //generate report file based on type
  733.             log.debug("start ReportExporter");
  734.             bos = NewExcelReportExporter.export(dataForReportDto, type, layoutStream);
  735.            
  736.             log.debug("end ReportExporter");
  737.             log.debug("start ContentDispositionFactory");
  738.  
  739.             // caling report audit
  740.             doAuditReport(reportConfig.getName(), jsonInput, tenantLoginId, roleLoginId, userLoginId, request);
  741.  
  742.             // For excel only few supported format
  743.             // ReportConstants.REPORT_TYPE_PDF
  744.             // ReportConstants.REPORT_TYPE_XLS
  745.             ContentDispositionFactory.setContentDisposition(ReportConstants.REPORT_TYPE_XLSX, response, fileName);
  746.             log.debug("end ContentDispositionFactory");
  747.             bos.writeTo(osResponse);
  748.             osResponse.close();
  749.            
  750.             layoutStream.close();
  751.         }catch (Exception e) {
  752.             log.error("Error in create report", e);
  753.             throw e;
  754.         }finally{
  755.             if(bos!=null){
  756.                 bos.flush();
  757.                 bos.close();
  758.             }
  759.         }
  760.     }
  761.    
  762.     /**
  763.      * Diganti dengan yang ditambah parameter JsonInput
  764.      *
  765.      * @param response
  766.      * @param reportConfig
  767.      * @param outputList
  768.      * @param resultDto
  769.      * @param type
  770.      * @param fileName
  771.      * @throws IOException
  772.      */
  773.     @Deprecated
  774.     private void responseUsingTemplateEscp(HttpServletResponse response, ReportConfig reportConfig, List<Map> outputList, Dto resultDto, String type, String fileName) throws IOException{
  775.        
  776.         // Need to support multiple outputList
  777.        
  778.         Dto dataForReportDto = new Dto();
  779.        
  780.         for(int i=0; i<outputList.size(); i++){
  781.             String keyOutput = outputList.get(i).get(ReportConstants.KEY_CONFIG_OUTPUT_ITEM_NAME).toString();
  782.             List<Dto> reportDataList = (List<Dto>)DtoUtil.convertToArray(resultDto.get("output.payload.detail."+keyOutput));
  783.             dataForReportDto.put(keyOutput, reportDataList);
  784.         }
  785.        
  786.         Dto parametersDto = resultDto.getDto("output.payload.parameter");
  787.         dataForReportDto.put("parameter", parametersDto);
  788.        
  789.         //generate report
  790.         log.info("Generating report");
  791.    
  792.         log.debug("Loading layout : "+reportConfig.getLayout());
  793.         Resource res = applicationContext.getResource(reportConfig.getLayout());
  794.         InputStream layoutStream = res.getInputStream();
  795.        
  796.         log.debug("Writing report");
  797.        
  798.         try {
  799.             ByteArrayOutputStream bos = null;
  800.             OutputStream osResponse = response.getOutputStream();
  801.            
  802.             //generate report file based on type
  803.             log.debug("start ReportExporter escp");
  804.            
  805.             JsonTemplate template = new JsonTemplate( layoutStream );
  806.             String jsonSource = dataForReportDto.toString();
  807.             DataSource ds = "".equals(jsonSource) ? new EmptyDataSource() : new JsonDataSource(jsonSource);
  808.  
  809.             Charset charset = Charset.isSupported("ISO-8859-1") ? Charset.forName("ISO-8859-1") :
  810.                 Charset.forName("US-ASCII");
  811.  
  812.             FillJob fillJob = new FillJob(template.parse(), ds);
  813.             byte[] datas = fillJob.fill().getBytes(charset);
  814.            
  815.             bos = new ByteArrayOutputStream(datas.length);
  816.             bos.write(datas, 0, datas.length);
  817.                        
  818.             log.debug("end ReportExporter");
  819.             log.debug("start ContentDispositionFactory");
  820.            
  821.             ContentDispositionFactory.setContentDisposition(ReportConstants.REPORT_TYPE_ESCP, response, fileName);
  822.             log.debug("end ContentDispositionFactory");
  823.             bos.writeTo(osResponse);
  824.             osResponse.close();
  825.         }catch (Exception e) {
  826.             log.error("Error in create report");
  827.             log.error(e+"");
  828.             e.printStackTrace();
  829.         }
  830.     }
  831.    
  832.    
  833.     @SuppressWarnings({ "unchecked", "rawtypes" })
  834.     private void responseUsingTemplateEscp(HttpServletResponse response, ReportConfig reportConfig, List<Map> outputList, Dto resultDto, String type, String fileName, JSONObject jsonInput) throws IOException{
  835.        
  836.         // Need to support multiple outputList
  837.        
  838.         Dto dataForReportDto = new Dto();
  839.        
  840.         for(int i=0; i<outputList.size(); i++){
  841.             String keyOutput = outputList.get(i).get(ReportConstants.KEY_CONFIG_OUTPUT_ITEM_NAME).toString();
  842.             List<Dto> reportDataList = (List<Dto>)DtoUtil.convertToArray(resultDto.get("output.payload.detail."+keyOutput));
  843.             dataForReportDto.put(keyOutput, reportDataList);
  844.         }
  845.        
  846.         Dto parametersDto = resultDto.getDto("output.payload.parameter");
  847.         dataForReportDto.put("parameter", parametersDto);
  848.        
  849.         //generate report
  850.         log.info("Generating report");
  851.    
  852.         String layout = reportConfig.getLayout(jsonInput);
  853.         log.debug("Loading layout : "+layout);
  854.         Resource res = applicationContext.getResource(layout);
  855.         InputStream layoutStream = res.getInputStream();
  856.        
  857.         log.debug("Writing report");
  858.        
  859.         try {
  860.             ByteArrayOutputStream bos = null;
  861.             OutputStream osResponse = response.getOutputStream();
  862.            
  863.             //generate report file based on type
  864.             log.debug("start ReportExporter escp");
  865.            
  866.             JsonTemplate template = new JsonTemplate( layoutStream );
  867.             String jsonSource = dataForReportDto.toString();
  868.             DataSource ds = "".equals(jsonSource) ? new EmptyDataSource() : new JsonDataSource(jsonSource);
  869.  
  870.             Charset charset = Charset.isSupported("ISO-8859-1") ? Charset.forName("ISO-8859-1") :
  871.                 Charset.forName("US-ASCII");
  872.  
  873.             FillJob fillJob = new FillJob(template.parse(), ds);
  874.             byte[] datas = fillJob.fill().getBytes(charset);
  875.            
  876.             bos = new ByteArrayOutputStream(datas.length);
  877.             bos.write(datas, 0, datas.length);
  878.                        
  879.             log.debug("end ReportExporter");
  880.             log.debug("start ContentDispositionFactory");
  881.            
  882.             ContentDispositionFactory.setContentDisposition(ReportConstants.REPORT_TYPE_ESCP, response, fileName);
  883.             log.debug("end ContentDispositionFactory");
  884.             bos.writeTo(osResponse);
  885.             osResponse.close();
  886.         }catch (Exception e) {
  887.             log.error("Error in create report", e);
  888.         }
  889.     }
  890.  
  891.     /**
  892.      * Added report audit
  893.      */
  894.     @SuppressWarnings({ "unchecked", "rawtypes" })
  895.     private void responseUsingTemplateEscp(HttpServletResponse response, HttpServletRequest request, ReportConfig reportConfig, List<Map> outputList, Dto resultDto, String type, String fileName, JSONObject jsonInput, Long tenantLoginId, Long roleLoginId, Long userLoginId) throws Exception{
  896.        
  897.         // Need to support multiple outputList
  898.        
  899.         Dto dataForReportDto = new Dto();
  900.        
  901.         for(int i=0; i<outputList.size(); i++){
  902.             String keyOutput = outputList.get(i).get(ReportConstants.KEY_CONFIG_OUTPUT_ITEM_NAME).toString();
  903.             List<Dto> reportDataList = (List<Dto>)DtoUtil.convertToArray(resultDto.get("output.payload.detail."+keyOutput));
  904.             dataForReportDto.put(keyOutput, reportDataList);
  905.         }
  906.        
  907.         Dto parametersDto = resultDto.getDto("output.payload.parameter");
  908.         dataForReportDto.put("parameter", parametersDto);
  909.        
  910.         //generate report
  911.         log.info("Generating report");
  912.    
  913.         String layout = reportConfig.getLayout(jsonInput);
  914.         log.debug("Loading layout : "+layout);
  915.         Resource res = applicationContext.getResource(layout);
  916.         InputStream layoutStream = res.getInputStream();
  917.        
  918.         log.debug("Writing report");
  919.  
  920.         ByteArrayOutputStream bos = null;
  921.         try {
  922.             OutputStream osResponse = response.getOutputStream();
  923.            
  924.             //generate report file based on type
  925.             log.debug("start ReportExporter escp");
  926.            
  927.             JsonTemplate template = new JsonTemplate( layoutStream );
  928.             String jsonSource = dataForReportDto.toString();
  929.             DataSource ds = "".equals(jsonSource) ? new EmptyDataSource() : new JsonDataSource(jsonSource);
  930.  
  931.             Charset charset = Charset.isSupported("ISO-8859-1") ? Charset.forName("ISO-8859-1") :
  932.                 Charset.forName("US-ASCII");
  933.  
  934.             FillJob fillJob = new FillJob(template.parse(), ds);
  935.             byte[] datas = fillJob.fill().getBytes(charset);
  936.            
  937.             bos = new ByteArrayOutputStream(datas.length);
  938.             bos.write(datas, 0, datas.length);
  939.                        
  940.             log.debug("end ReportExporter");
  941.             log.debug("start ContentDispositionFactory");
  942.            
  943.             // caling report audit
  944.             doAuditReport(reportConfig.getName(), jsonInput, tenantLoginId, roleLoginId, userLoginId, request);
  945.  
  946.             ContentDispositionFactory.setContentDisposition(ReportConstants.REPORT_TYPE_ESCP, response, fileName);
  947.             log.debug("end ContentDispositionFactory");
  948.             bos.writeTo(osResponse);
  949.             osResponse.close();
  950.            
  951.            
  952.             layoutStream.close();
  953.         }catch (Exception e) {
  954.             log.error("Error in create report", e);
  955.             throw e;
  956.         }finally{
  957.             if(bos!=null){
  958.                 bos.flush();
  959.                 bos.close();
  960.             }
  961.         }
  962.     }
  963.    
  964.     private Dto populateRequestHeaderFromSession(HttpServletRequest request){
  965.         Dto header = new Dto();
  966.         header.put(WebJsfConstants.SERVICE_HEADER_SESSION_ID, request.getSession().getId());
  967.         header.put(WebJsfConstants.SERVICE_HEADER_USER_LOGIN_ID, request.getSession().getAttribute(WebJsfConstants.SESS_LOGGED_USER_ID));
  968.         header.put(WebJsfConstants.SERVICE_HEADER_ROLE_LOGIN_ID, request.getSession().getAttribute(WebJsfConstants.SESS_LOGGED_CURRENT_ROLE));
  969.         header.put(WebJsfConstants.SERVICE_HEADER_TENANT_LOGIN_ID, request.getSession().getAttribute(WebJsfConstants.SESS_LOGGED_TENANT_ID));
  970.         header.put(WebJsfConstants.SERVICE_HEADER_TENANT_KEY, request.getSession().getAttribute(WebJsfConstants.SESS_LOGGED_TENANT_KEY));
  971.         header.put(WebJsfConstants.SERVICE_HEADER_SECURE_KEY, request.getSession().getAttribute(WebJsfConstants.SESS_LOGGED_SECURE_KEY));
  972.        
  973.         return header;
  974.     }
  975.    
  976.    
  977.     private String getDataProviderUrl() throws IOException{
  978.         Properties prop =  WebUtil.getGlobalProperties(this);
  979.        
  980.        
  981.         String host = prop.getProperty(ReportConstants.KEY_JASPER_PROXY_HOST);
  982.         String port = prop.getProperty(ReportConstants.KEY_JASPER_PROXY_PORT);
  983.         String servletName = prop.getProperty(ReportConstants.KEY_JASPER_PROXY_SERVLET);
  984.         String protocol = "http://";
  985.        
  986.         return protocol+host+":"+port+servletName;
  987.     }
  988.    
  989. //  private String parseLayout(ReportConfig reportConfig, String inputEncoded){
  990. //      String layout = reportConfig.getLayout();
  991. //     
  992. //      try{
  993. //          String inputDecoded = new String(Base64.decode(inputEncoded));
  994. //          JSONParser parser = new JSONParser();
  995. //          JSONObject inputJson = (JSONObject)parser.parse(inputDecoded);
  996. //         
  997. //          layout = VarUtil.sourceReplacer(layout, inputJson).toString();
  998. //         
  999. //      } catch(Exception e){
  1000. //          log.warn("Warning decode input report, ignore, use layput default");
  1001. //      }
  1002. //     
  1003. //      return layout;
  1004. //  }
  1005.    
  1006.     @SuppressWarnings("unchecked")
  1007.     public JSONObject executeService(HttpServletRequest request, String serviceName, JSONObject json) throws Exception {
  1008.        
  1009.         HttpSession session = request.getSession();
  1010.        
  1011.         String humanTask = "";
  1012.        
  1013.         log.debug("Production service context: " + serviceName);
  1014.         if (json == null) {
  1015.             json = new JSONObject();
  1016.         }
  1017.  
  1018.         String url = "";
  1019.         String moduleName = "jleaf";
  1020.  
  1021.         int idx = serviceName.indexOf('#');
  1022.         if (idx != -1) {
  1023.             moduleName = serviceName.substring(0, idx);
  1024.             serviceName = serviceName.substring(idx + 1);
  1025.         }
  1026.        
  1027.         // In new version using human task serviceName is contains of humanTask#serviceName
  1028.         idx = serviceName.indexOf('#');
  1029.         if(idx!=-1){
  1030.             humanTask = serviceName.substring(0,idx);
  1031.             serviceName = serviceName.substring(idx+1);
  1032.         }
  1033.  
  1034.         if (serviceName.equals("authenticate")) {
  1035.             // Perform authenticate
  1036.             url = getAuthenticateUrl();
  1037.         } else if (serviceName.equals("reauthenticate")) {
  1038.             url = getReauthenticateUrl();
  1039.         } else if (serviceName.equals("logout")) {
  1040.             return null;
  1041.         } else if (serviceName.equals("addUserAudit")) {
  1042.             url = getUserAuditUrl();
  1043.         } else {
  1044.             // Other task
  1045.             url = getTaskUrl();
  1046.         }
  1047.  
  1048.         JSONObject header = new JSONObject();
  1049.         JSONObject input = new JSONObject();
  1050.  
  1051.         // header.put(WebJsfConstants.SERVICE_HEADER_SESSION_ID,
  1052.         // session.getId());
  1053.         header.put(WebJsfConstants.SERVICE_HEADER_SESSION_ID, session.getId());
  1054.  
  1055.         if (session.getAttribute(WebJsfConstants.SESS_LOGGED_USER_ID) == null) {
  1056.             header.put(WebJsfConstants.SERVICE_HEADER_USER_LOGIN_ID, -1L);
  1057.         } else {
  1058.             header.put(WebJsfConstants.SERVICE_HEADER_USER_LOGIN_ID, session.getAttribute(WebJsfConstants.SESS_LOGGED_USER_ID));
  1059.         }
  1060.  
  1061.         if (session.getAttribute(WebJsfConstants.SESS_LOGGED_CURRENT_ROLE) == null) {
  1062.             header.put(WebJsfConstants.SERVICE_HEADER_ROLE_LOGIN_ID, -1L);
  1063.  
  1064.         } else {
  1065.             header.put(WebJsfConstants.SERVICE_HEADER_ROLE_LOGIN_ID, session.getAttribute(WebJsfConstants.SESS_LOGGED_CURRENT_ROLE));
  1066.         }
  1067.  
  1068.         if (session.getAttribute(WebJsfConstants.SESS_LOGGED_TENANT_ID) == null) {
  1069.             header.put(WebJsfConstants.SERVICE_HEADER_TENANT_LOGIN_ID, -1L);
  1070.  
  1071.         } else {
  1072.             header.put(WebJsfConstants.SERVICE_HEADER_TENANT_LOGIN_ID, session.getAttribute(WebJsfConstants.SESS_LOGGED_TENANT_ID));
  1073.         }
  1074.  
  1075.         if (session.getAttribute(WebJsfConstants.SESS_LOGGED_TENANT_KEY) == null) {
  1076.             header.put(WebJsfConstants.SERVICE_HEADER_TENANT_KEY, GeneralConstants.EMPTY_VALUE);
  1077.         } else {
  1078.             header.put(WebJsfConstants.SERVICE_HEADER_TENANT_KEY, session.getAttribute(WebJsfConstants.SESS_LOGGED_TENANT_KEY));
  1079.         }
  1080.         if (session.getAttribute(WebJsfConstants.SESS_LOGGED_SECURE_KEY) == null) {
  1081.             header.put(WebJsfConstants.SERVICE_HEADER_SECURE_KEY, GeneralConstants.EMPTY_VALUE);
  1082.         } else {
  1083.             header.put(WebJsfConstants.SERVICE_HEADER_SECURE_KEY, session.getAttribute(WebJsfConstants.SESS_LOGGED_SECURE_KEY));
  1084.         }
  1085.         header.put(WebJsfConstants.SERVICE_HEADER_MODULE, moduleName);
  1086.         header.put(WebJsfConstants.SERVICE_HEADER_DATETIME, DateUtil.dateTimeNow());
  1087.  
  1088.         if(humanTask.equals("")){
  1089.             // Need to support older version
  1090.             input.put("version", WebJsfConstants.VERSION_1_0);
  1091.             header.put(WebJsfConstants.SERVICE_HEADER_TASK_NAME, serviceName);
  1092.         } else {
  1093.             // New version use human task to authorize
  1094.             input.put("version", WebJsfConstants.VERSION_1_1);
  1095.             header.put(WebJsfConstants.SERVICE_HEADER_TASK_NAME, humanTask);
  1096.             header.put(WebJsfConstants.SERVICE_HEADER_SERVICE_NAME, serviceName);
  1097.         }
  1098.         // Since 1.1.8 adding some HTTP Information
  1099.         header.put(WebJsfConstants.SERVICE_HEADER_HTTP_REMOTE_ADDR, request.getRemoteAddr());
  1100.         header.put(WebJsfConstants.SERVICE_HEADER_HTTP_REMOTE_HOST, request.getRemoteHost());
  1101.         header.put(WebJsfConstants.SERVICE_HEADER_HTTP_REMOTE_PORT, request.getRemotePort());
  1102.         header.put(WebJsfConstants.SERVICE_HEADER_HTTP_REMOTE_USER, request.getRemoteUser());
  1103.         header.put(WebJsfConstants.SERVICE_HEADER_HTTP_USER_AGENT, request.getHeader("User-Agent"));
  1104.  
  1105.        
  1106.         input.put("header", header);
  1107.         input.put("payload", json);
  1108.  
  1109.         JSONObject send = new JSONObject();
  1110.         send.put("input", input);
  1111.  
  1112.         log.debug("Json Input: " + input);
  1113.  
  1114.         final String data = send.toJSONString();
  1115.  
  1116.         log.debug("Goto URL: " + url);
  1117.         URL anUrl = new URL(url);
  1118.         HttpURLConnection conn = (HttpURLConnection) anUrl.openConnection();
  1119.  
  1120.         conn.setRequestMethod("POST");
  1121.         conn.setDoOutput(true);
  1122.         conn.setDoInput(true);
  1123.         conn.setUseCaches(false);
  1124.         conn.setAllowUserInteraction(false);
  1125.         conn.setRequestProperty("Content-type", "application/json");
  1126.  
  1127.         OutputStream out = conn.getOutputStream();
  1128.         out.write(data.getBytes());
  1129.         out.close();
  1130.  
  1131.         if (conn.getResponseCode() == HttpURLConnection.HTTP_OK) {
  1132.             InputStream in = conn.getInputStream();
  1133.  
  1134.             StringWriter w = new StringWriter();
  1135.             Reader reader = new InputStreamReader(in);
  1136.             char[] buf = new char[1024];
  1137.  
  1138.             int read = 0;
  1139.             while ((read = reader.read(buf)) >= 0) {
  1140.                 w.append(new String(buf).substring(0, read));
  1141.             }
  1142.             in.close();
  1143.             conn.disconnect();
  1144.  
  1145.             String output = w.toString();
  1146.             log.debug("Json output: " + output);
  1147.  
  1148.             JSONObject jsonOutput = (JSONObject) JSONValue.parse(output);
  1149.  
  1150.             return jsonOutput;
  1151.         } else {
  1152.             throw new Exception("HTTP Error: " + conn.getResponseCode());
  1153.         }
  1154.     }
  1155.    
  1156.     private String getAuthenticateUrl() {
  1157.         return ServiceProvider.BASIC_PROTOCOL + getServiceProvider().getConfig(ServiceProvider.AUTH_PROXY);
  1158.     }
  1159.  
  1160.     private String getReauthenticateUrl() {
  1161.         return ServiceProvider.BASIC_PROTOCOL + getServiceProvider().getConfig(ServiceProvider.REAUTHENTICATE_PROXY);
  1162.     }
  1163.  
  1164.     private String getUserAuditUrl() {
  1165.         return ServiceProvider.BASIC_PROTOCOL + getServiceProvider().getConfig(ServiceProvider.USER_AUDIT_PROXY);
  1166.     }
  1167.  
  1168.     private String getTaskUrl() {
  1169.         return ServiceProvider.BASIC_PROTOCOL + getServiceProvider().getConfig(ServiceProvider.TASK_PROXY);
  1170.     }
  1171.  
  1172.     private ServiceProvider getServiceProvider() {
  1173.         return this.serviceProvider;
  1174.     }
  1175.    
  1176.     @SuppressWarnings("unchecked")
  1177.     private void doAuditReport(String reportName, JSONObject inputDto, Long tenantLoginId, Long roleLoginId, Long userLoginId, HttpServletRequest request) throws Exception{
  1178.             log.debug("Do audit report");
  1179.            
  1180.             // check setting, if not active skip
  1181.             HttpSession session = request.getSession();
  1182.             if(! GeneralConstants.YES.equals(session.getAttribute(WebJsfConstants.SESS_LOGGED_AUDIT_REPORT_ACTIVE)) ){
  1183.                 return;
  1184.             }
  1185.            
  1186.             Long userId = userLoginId;
  1187.             Long roleId = roleLoginId;
  1188.             String ipAddress = request.getRemoteAddr();
  1189.            
  1190.             JSONObject inputAddAudit = new JSONObject();
  1191.             inputAddAudit.put("userLoginId", userLoginId);
  1192.             inputAddAudit.put("tenantLoginId", tenantLoginId);
  1193.             inputAddAudit.put("roleLoginId", roleLoginId);
  1194.             inputAddAudit.put("datetime", DateUtil.dateTimeNow());
  1195.            
  1196.             inputAddAudit.put("userId", userId);
  1197.             inputAddAudit.put("roleId", roleId);
  1198.             inputAddAudit.put("activityDatetime", DateUtil.dateTimeNow());         
  1199.             inputAddAudit.put("reportConfigName", reportName);
  1200.             inputAddAudit.put("ipAddress", ipAddress);
  1201.             inputAddAudit.put("reportParameter", inputDto.toString());
  1202.  
  1203.            
  1204.             log.debug("Start calling report audit with input : "+inputAddAudit);
  1205.  
  1206.             JSONObject outputAudit = executeService(request, AuditReportApi.ADD_AUDIT_REPORT, inputAddAudit);
  1207.            
  1208.             if(ServiceResult.isFail(outputAudit)){
  1209.                 JSONObject result = (JSONObject)outputAudit.get("result");
  1210.                 String errorKey = (String) result.get("errorKey");
  1211.                 JSONArray arr = (JSONArray) JSONValue.parse(result.get("args").toString());
  1212.                
  1213.                 log.debug("Json ARR : "+arr);
  1214. //              log.debug("ARR : "+Arrays.toString(arr.toArray()));
  1215.                
  1216.                 throw new CoreException(errorKey, arr!=null?arr.toArray():null);
  1217.             }
  1218.            
  1219.             log.debug("Finish report audit with result : "+outputAudit);       
  1220.     }
  1221.    
  1222. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!