Subversion Repositories SmartDukaan

package in.shop2020.support.controllers;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.IOException;

import java.text.DateFormat;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.util.Collection;

import java.util.Date;

import java.util.HashMap;

import java.util.Map;

import java.util.Map.Entry;

import in.shop2020.model.v1.order.TransactionService.Client;

import in.shop2020.model.v1.order.TransactionServiceException;

import in.shop2020.support.utils.ReportsUtils;

import in.shop2020.thrift.clients.TransactionClient;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpSession;

import org.apache.commons.io.FileUtils;

import org.apache.poi.hssf.usermodel.HSSFWorkbook;

import org.apache.poi.ss.usermodel.Row;

import org.apache.poi.ss.usermodel.Sheet;

import org.apache.poi.ss.usermodel.Workbook;

import org.apache.struts2.convention.annotation.InterceptorRef;

import org.apache.struts2.convention.annotation.InterceptorRefs;

import org.apache.struts2.convention.annotation.Result;

import org.apache.struts2.convention.annotation.Results;

import org.apache.struts2.interceptor.ServletRequestAware;

import org.apache.thrift.TException;

import org.apache.thrift.transport.TTransportException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import com.opensymphony.xwork2.ActionSupport;

@SuppressWarnings("serial")

@InterceptorRefs({

    @InterceptorRef("defaultStack"),

    @InterceptorRef("login")

})

@Results({

    @Result(name="authfail", type="redirectAction", params = {"actionName" , "reports"})

})

public class CodReconciliationController extends ActionSupport implements ServletRequestAware {

    private static Logger logger = LoggerFactory.getLogger(CodReconciliationController.class);

    private HttpServletRequest request;

    private HttpSession session;

    private File codReport;

    private String codReportContentType;

    private String codReportFileName;

    private String errorMsg = "";

    public String index() {

        if(!ReportsUtils.canAccessReport((Long)session.getAttribute(ReportsUtils.ROLE), request.getServletPath()))

            return "authfail";

        checkForErrors();

        return "authsuccess";

    }

    public String create() {

        File fileToCreate = null;

        try {

            fileToCreate = new File("/tmp/", this.codReportFileName);

            FileUtils.copyFile(this.codReport, fileToCreate);

        } catch (Exception e) {

           logger.error("Error while writing COD report to the local file system", e);

           addActionError("Error while writing COD report to the local file system");

        }

        String xferBy = this.request.getParameter("xferBy");

        String xferTxnId = this.request.getParameter("xferTxnId");

        String xferDateStr = this.request.getParameter("xferTxnDate"); 

        DateFormat df = new SimpleDateFormat("dd/MM/yyyy");

        Date xferDate = null;

        try {

            xferDate = df.parse(xferDateStr);

        } catch (ParseException e1) {

            logger.error("Invalid date: " + xferDateStr);

            addActionError("Invalid date supplied");

        }

        if(checkForErrors())

            return "authsuccess";

        //Parse the file and submit the data for update to the transaction service

        Workbook wb = null;

        try {

            wb = new HSSFWorkbook(new FileInputStream(fileToCreate));

        } catch (FileNotFoundException e) {

            logger.error("Unable to open the COD report", e);

            addActionError("Unable to open the COD report. Please check the report format.");

        } catch (IOException e) {

            logger.error("Unable to open the COD report", e);

            addActionError("Unable to open the COD report. Please check the report format.");

        }

        if(checkForErrors())

            return "authsuccess";

        HashMap<String, Double> collectedAmountMap = new HashMap<String, Double>(); 

        Sheet sheet = wb.getSheetAt(0);

        Row firstRow = sheet.getRow(0);

        logger.info("Last row number is:" + sheet.getLastRowNum());

        for (Row row : sheet) {

            if(row.equals(firstRow))

                continue;

            logger.info("Row no. " + row.getRowNum());

            String awb = row.getCell(0).getStringCellValue();

            double collectedAmount = row.getCell(1).getNumericCellValue();

            collectedAmountMap.put(awb, collectedAmount);

        }

        TransactionClient tsc = null;

        try {

            tsc = new TransactionClient();

        } catch (TTransportException e) {

            logger.error("Unable to establish connection to the transaction service", e);

            addActionError("Unable to establish connection to the transaction service");

        }

        if(checkForErrors())

            return "authsuccess";

        Client txnClient = tsc.getClient();

        try {

            Map<String, String> unprocessedAwbs = txnClient.reconcileCodCollection(collectedAmountMap, xferBy, xferTxnId, xferDate.getTime());

            if(!unprocessedAwbs.isEmpty()){

                for(Entry<String, String> entry: unprocessedAwbs.entrySet())

                    addActionError("Unable to process AWB no. " + entry.getKey() + " bcoz of " + entry.getValue());

            }

        } catch (TransactionServiceException e) {

            logger.error("Unable to reconcile COD collection", e);

            addActionError(e.getMessage());

        } catch (TException e) {

            logger.error("Unable to reconcile COD collection", e);

            addActionError(e.getMessage());

        }

        checkForErrors();

        return "authsuccess";

    }

    @Override

    public void setServletRequest(HttpServletRequest request) {

        this.request = request;

        this.session = request.getSession();

    }

    public File getCodReport() {

        return codReport;

    }

    public void setCodReport(File codReport) {

        this.codReport = codReport;

    }

    public String getCodReportContentType() {

        return codReportContentType;

    }

    public void setCodReportContentType(String codReportContentType) {

        this.codReportContentType = codReportContentType;

    }

    public String getCodReportFileName() {

        return codReportFileName;

    }

    public void setCodReportFileName(String codReportFileName) {

        this.codReportFileName = codReportFileName;

    }

    public String getErrorMsg(){

        return this.errorMsg;

    }

    private boolean checkForErrors(){

        Collection<String> actionErrors = getActionErrors();

        if(actionErrors != null && !actionErrors.isEmpty()){

            for (String str : actionErrors) {

                errorMsg += "<BR/>" + str;

            }

            return true;

        }

        return false;

    }

}