Subversion Repositories SmartDukaan

Rev

Rev 5098 | Rev 5189 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
4600 varun.gupt 1 
package in.shop2020.support.controllers;
2 
 
4734 varun.gupt 3 
import in.shop2020.logistics.LogisticsServiceException;
4 
import in.shop2020.logistics.Provider;
4600 varun.gupt 5 
import in.shop2020.model.v1.catalog.InventoryService.Client;
6 
import in.shop2020.model.v1.catalog.Vendor;
7 
import in.shop2020.model.v1.order.LineItem;
8 
import in.shop2020.model.v1.order.Order;
4734 varun.gupt 9 
import in.shop2020.model.v1.order.OrderStatus;
5020 varun.gupt 10 
import in.shop2020.model.v1.order.OrderStatusGroups;
4600 varun.gupt 11 
import in.shop2020.model.v1.order.PaymentSettlement;
12 
import in.shop2020.model.v1.order.Transaction;
13 
import in.shop2020.model.v1.order.TransactionServiceException;
14 
import in.shop2020.payments.Payment;
15 
import in.shop2020.payments.PaymentException;
16 
import in.shop2020.payments.PaymentGateway;
17 
import in.shop2020.thrift.clients.CatalogClient;
4734 varun.gupt 18 
import in.shop2020.thrift.clients.LogisticsClient;
4600 varun.gupt 19 
import in.shop2020.thrift.clients.PaymentClient;
20 
import in.shop2020.thrift.clients.TransactionClient;
21 
 
5020 varun.gupt 22 
import java.io.ByteArrayOutputStream;
23 
import java.io.File;
24 
import java.io.FileInputStream;
25 
import java.io.FileNotFoundException;
26 
import java.io.IOException;
27 
import java.text.DateFormat;
28 
import java.text.ParseException;
29 
import java.text.SimpleDateFormat;
30 
import java.util.ArrayList;
31 
import java.util.Date;
32 
import java.util.HashMap;
33 
import java.util.List;
34 
import java.util.Map;
35 
 
4600 varun.gupt 36 
import javax.servlet.ServletContext;
37 
import javax.servlet.ServletOutputStream;
38 
import javax.servlet.http.HttpServletRequest;
39 
import javax.servlet.http.HttpServletResponse;
40 
import javax.servlet.http.HttpSession;
41 
 
42 
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
43 
import org.apache.poi.ss.usermodel.Cell;
44 
import org.apache.poi.ss.usermodel.CellStyle;
45 
import org.apache.poi.ss.usermodel.Font;
46 
import org.apache.poi.ss.usermodel.Row;
47 
import org.apache.poi.ss.usermodel.Sheet;
48 
import org.apache.poi.ss.usermodel.Workbook;
49 
import org.apache.poi.ss.util.CellRangeAddress;
5020 varun.gupt 50 
import org.apache.poi.xssf.usermodel.XSSFWorkbook;
4600 varun.gupt 51 
import org.apache.struts2.interceptor.ServletRequestAware;
52 
import org.apache.struts2.interceptor.ServletResponseAware;
53 
import org.apache.struts2.rest.DefaultHttpHeaders;
54 
import org.apache.struts2.rest.HttpHeaders;
55 
import org.apache.struts2.util.ServletContextAware;
4715 varun.gupt 56 
import org.apache.thrift.TApplicationException;
4600 varun.gupt 57 
import org.apache.thrift.TException;
58 
import org.apache.thrift.transport.TTransportException;
59 
import org.slf4j.Logger;
60 
import org.slf4j.LoggerFactory;
61 
 
4715 varun.gupt 62 
import com.opensymphony.xwork2.ValidationAwareSupport;
63 
 
4600 varun.gupt 64 
/**
65 
 * @author Varun Gupta
66 
 * @description: This class handles web requests to generate vendor specific reconciliation reports
67 
 *               for given vendor for a given date range
68 
 */
4745 varun.gupt 69 
//
4715 varun.gupt 70 
//@InterceptorRefs({
71 
//    @InterceptorRef("defaultStack"),
72 
//    @InterceptorRef("login")
73 
//})
74 
//@Results({
75 
//    @Result(name="authfail", type="redirectAction", params = {"actionName" , "reports"})
76 
//})
77 
public class VendorReconciliationController extends ValidationAwareSupport implements ServletRequestAware, ServletResponseAware, ServletContextAware {
4600 varun.gupt 78 
 
79 
    private static Logger logger = LoggerFactory.getLogger(VendorReconciliationController.class);
80 
 
81 
	private enum OrderReportColumn {
82 
	    ORDER_ID(0),
83 
	    ORDER_DATE(1),
84 
		BILLING_NUMBER(2),
85 
		BILLING_DATE(3),
86 
		DELIVERY_DATE(4),
87 
		SETTLEMENT_DATE(5),
88 
		CURRENT_STATUS(6),
4745 varun.gupt 89 
		PAYMENT_STATUS(7),
4600 varun.gupt 90 
		BRAND(7),
91 
		MODEL_NAME(8),
92 
		MODEL_NUMBER(9),
93 
		COLOR(10),
94 
		QUANTITY(11),
95 
		UNIT_TRANSFER_PRICE(12),
96 
		UNIT_SELLING_PRICE(13),
97 
		TOTAL_TRANSFER_PRICE(14),
98 
		TOTAL_SELLING_PRICE(15),
5020 varun.gupt 99 
		PAYMENT_TYPE(16),
100 
		PAYMENT_ID(17),
101 
		COUPON_CODE(18),
102 
		SERVICE_TAX(19),
103 
		OTHER_CHARGES(20),
104 
		NET_COLLECTION(21),
105 
	    REFUND(22),
106 
	    FINAL_AMOUNT(23),
107 
	    IS_RESHIPED_ORDER(24);
4600 varun.gupt 108 
//		COUPON_CATEGORY(19),
109 
//		DISCOUNT(20),
110 
 
111 
		private int value;
112 
 
113 
		OrderReportColumn(int value) {
114 
			this.value = value;
115 
		}
116 
		public int getValue(){
117 
			return this.value;
118 
		}
119 
	}
120 
 
121 
	private enum OrderMismatchColumn	{
122 
		ORDER_ID(0),
123 
		EXPECTED_COLLECTION(1),
124 
		ACTUAL_COLLECTION(2);
125 
 
126 
		private int value;
127 
 
128 
		OrderMismatchColumn(int value) {
129 
			this.value = value;
130 
		}
131 
		public int getValue(){
132 
			return this.value;
133 
		}
134 
	}
135 
 
136 
	private HttpServletRequest request;
137 
	private HttpServletResponse response;
138 
	private ServletContext context;
139 
    private HttpSession session;
140 
	private List<Vendor> vendors;
5020 varun.gupt 141 
	private Map<Long, String> codProviders = new HashMap<Long, String>();
142 
	private Map<Long, String> paymentGateways = new HashMap<Long, String>();
143 
 
4600 varun.gupt 144 
	private String reportSource;
4715 varun.gupt 145 
	private List<Long> orderIdsWithoutSuccess;
4600 varun.gupt 146 
 
5098 varun.gupt 147 
	private File orderIdsToBeMarkedPaid;
4600 varun.gupt 148 
	private File hdfcSettlementReport;
149 
 
150 
	private File ebsSettlementReport;
151 
	private File ebsSettlementSummary;
152 
 
153 
	private String bluedartSettlementDate;
154 
	private File bluedartSettlementReport;
155 
 
4715 varun.gupt 156 
	private String aramexSettlementDate;
157 
	private File aramexSettlementReport;
158 
 
4600 varun.gupt 159 
	private Map<Long, Map<String, Double>> misMatches = new HashMap<Long, Map<String, Double>>();
160 
	private Map<Long, String> ebsSettlementSummaries;
161 
 
5020 varun.gupt 162 
	private List<OrderStatus> refundOrderStatuses;
4734 varun.gupt 163 
 
4745 varun.gupt 164 
	private List<Order> refundedOrdersBilledinDateRange = new ArrayList<Order>();
165 
	private List<Order> reshippedOrders = new ArrayList<Order>();
166 
 
5020 varun.gupt 167 
	private Map<Long, PaymentSettlement> paymentSettlementsMap;
168 
 
4600 varun.gupt 169 
	private final DateFormat DATE_FORMAT = new SimpleDateFormat("dd/MM/yyyy");
170 
 
5020 varun.gupt 171 
	private int rowCount = 0;
172 
 
4600 varun.gupt 173 
	public String index()	{
5098 varun.gupt 174 
		initiatializeDashboard();
4600 varun.gupt 175 
		return "report";
176 
	}
177 
 
178 
	public HttpHeaders create()	{
179 
 
180 
		String formType = request.getParameter("formtype");
4715 varun.gupt 181 
		logger.info("Form Type: " + formType);
4600 varun.gupt 182 
 
183 
		if (formType.equals("uploadEBSSettlementSummary")) {
184 
			uploadEBSSettlementSummary();
185 
 
186 
		} else if (formType.equals("uploadEBSSettlements")) {
187 
			uploadEBSSettlements();
188 
 
189 
		} else if (formType.equals("uploadHDFCSettlements")) {
190 
			uploadHDFCSettlements();
191 
 
192 
		} else if (formType.equals("uploadBluedartSettlements")) {
193 
			uploadBluedartSettlements();
4715 varun.gupt 194 
 
195 
		} else if (formType.equals("uploadAramexSettlements")) {
196 
			uploadAramexSettlements();
5098 varun.gupt 197 
 
198 
		} else if (formType.equals("markOrdersAsPaid"))	{
199 
//			uploadOrderIdsToBeMarkedPaid();
4600 varun.gupt 200 
		}
4715 varun.gupt 201 
	    logger.info("Order Ids where no successful payment was found", orderIdsWithoutSuccess);
5098 varun.gupt 202 
 
203 
		initiatializeDashboard();
4600 varun.gupt 204 
		return new DefaultHttpHeaders("report");
205 
	}
206 
 
207 
	public HttpHeaders generateReconciliationReport()	{
208 
		DateFormat dateFormat = new SimpleDateFormat("dd/MM/yyyy");
209 
 
210 
		try	{
211 
			//Formatting Form input parameters
212 
 
5020 varun.gupt 213 
//		    Date startDate = dateFormat.parse(request.getParameter("start"));
214 
//			Date endDate = dateFormat.parse(request.getParameter("end"));
4600 varun.gupt 215 
		    long vendorId = Long.parseLong(request.getParameter("vendor"));
216 
 
5020 varun.gupt 217 
		    logger.info("Vendor ID: " + vendorId);
4600 varun.gupt 218 
 
4745 varun.gupt 219 
		    String vendorName = getVendorName(vendorId);
4600 varun.gupt 220 
			DateFormat dateFormatForFile = new SimpleDateFormat("dd.MM.yyyy");
4715 varun.gupt 221 
 
4600 varun.gupt 222 
			response.setContentType("application/vnd.ms-excel");
5020 varun.gupt 223 
			response.setHeader("Content-disposition", "inline; filename=" + vendorName + "-reconciliation.xls");
4600 varun.gupt 224 
 
225 
			ServletOutputStream sos;
226 
			try {
5020 varun.gupt 227 
				ByteArrayOutputStream baos = getReconciliationReport(vendorId);
4600 varun.gupt 228 
				sos = response.getOutputStream();
229 
				baos.writeTo(sos);
230 
				sos.flush();
231 
			} catch (IOException e)	{
232 
				logger.error("Error while streaming the hotspot reconciliation report", e);
233 
			}
234 
		} catch (NullPointerException e)   {
235 
            logger.error("NullPointerException", e);
4745 varun.gupt 236 
		}
4600 varun.gupt 237 
		return new DefaultHttpHeaders("report");
238 
	}
239 
 
240 
	public void uploadEBSSettlementSummary()	{
241 
 
242 
		DateFormat settlementDateFormat = new SimpleDateFormat("dd MMM,yyyy hh:mm:ss a");
243 
		DateFormat transactionDateFormat = new SimpleDateFormat("yyyy-MM-dd");
244 
 
245 
		Workbook wb = null;
246 
        try {
247 
            wb = new HSSFWorkbook(new FileInputStream(ebsSettlementSummary));
248 
        } catch (FileNotFoundException e) {
249 
            logger.error("Unable to open the Settlement Summary report", e);
250 
        } catch (IOException e) {
251 
            logger.error("Unable to open the Settlement Summary report", e);
252 
        }
253 
        Sheet sheet = wb.getSheetAt(0);
254 
 
255 
        int indexSettlementId = 0;
256 
        int indexSettlementDate = 1;
257 
        int indexTransactionDateFrom = 2;
258 
        int indexTransactionDateTo = 3;
259 
        int indexAmount = 4;
260 
 
261 
        Row firstRow = sheet.getRow(0);
262 
        Row secondRow = sheet.getRow(1);
263 
        Row thirdRow = sheet.getRow(2);
264 
        Row fourthRow = sheet.getRow(3);
265 
        Row fifthRow = sheet.getRow(4);
5020 varun.gupt 266 
 
4600 varun.gupt 267 
		TransactionClient tsc;
268 
 
269 
		try {
270 
			tsc = new TransactionClient();
271 
			in.shop2020.model.v1.order.TransactionService.Client transactionClient = tsc.getClient();
272 
 
273 
			for(Row row: sheet)	{
274 
				if(row.equals(firstRow) || row.equals(secondRow) || row.equals(thirdRow) || row.equals(fourthRow) || row.equals(fifthRow))	{
275 
					continue;
276 
				}
277 
				long settlementId = (long) row.getCell(indexSettlementId).getNumericCellValue();
278 
				String settlementDateStr = row.getCell(indexSettlementDate).getStringCellValue();
279 
				String transactionDateFromStr = row.getCell(indexTransactionDateFrom).getStringCellValue();
280 
				String transactionDateToStr = row.getCell(indexTransactionDateTo).getStringCellValue();
281 
				Double amount = row.getCell(indexAmount).getNumericCellValue();
282 
 
283 
				Date settlementDate = settlementDateFormat.parse(settlementDateStr);
284 
				Date transactionDateFrom = transactionDateFormat.parse(transactionDateFromStr);
285 
				Date transactionDateTo = transactionDateFormat.parse(transactionDateToStr);
286 
 
287 
				try	{
288 
					transactionClient.saveEBSSettlementSummary(settlementId, settlementDate.getTime(), transactionDateFrom.getTime(), transactionDateTo.getTime(), amount);
289 
 
290 
				} catch (Exception e) {
291 
					e.printStackTrace();
292 
				}
293 
			}
294 
        } catch (Exception e) {
295 
        	e.printStackTrace();
296 
		}
297 
	}
298 
 
299 
	public void uploadHDFCSettlements()	{
300 
		logger.info("Uploading HDFC settlements");
301 
 
302 
		Workbook wb = null;
303 
		try {
304 
			wb = new HSSFWorkbook(new FileInputStream(this.hdfcSettlementReport));
305 
		} catch (FileNotFoundException e) {
4734 varun.gupt 306 
			String errMsg = "Unable to open the HDFC Payout report";
307 
			logger.error(errMsg, e);
308 
			addActionError(errMsg);
309 
			return;
4600 varun.gupt 310 
		} catch (IOException e) {
4734 varun.gupt 311 
			String errMsg = "Unable to open the HDFC Payout report";
312 
			logger.error(errMsg, e);
313 
			addActionError(errMsg);
314 
			return;
4600 varun.gupt 315 
		}
316 
		Sheet sheet = wb.getSheetAt(0);
317 
 
318 
		Row firstRow = sheet.getRow(0);
319 
 
320 
		int indexRECFMT = 2;
321 
		int indexSettlementDate = 7;
322 
		int indexPaymentId = 13;
323 
		int indexMSF = 14;
324 
		int indexServiceTax = 15;
325 
		int indexEduCess = 16;
326 
		int indexNetCollection = 17;
327 
 
328 
		TransactionClient tsc;
329 
		String paymentIdStr = "";
330 
		long paymentId = 0;
5020 varun.gupt 331 
 
4734 varun.gupt 332 
		int countSuccessfulInserts = 0;
333 
		int countRefunds = 0;
4600 varun.gupt 334 
 
335 
		try {
336 
			tsc = new TransactionClient();
337 
			in.shop2020.model.v1.order.TransactionService.Client transactionClient = tsc.getClient();
338 
 
339 
			for (Row row: sheet)	{
340 
                if(row.equals(firstRow))	continue;
341 
 
5020 varun.gupt 342 
                if(row.getCell(0).getStringCellValue().equals("Total"))	break;
343 
 
4600 varun.gupt 344 
                try	{
345 
                    String recfmt = row.getCell(indexRECFMT).getStringCellValue();
346 
                    Date settlementDate = row.getCell(indexSettlementDate).getDateCellValue();
347 
                	double netCollection = row.getCell(indexNetCollection).getNumericCellValue();
5020 varun.gupt 348 
                	paymentIdStr = row.getCell(indexPaymentId).getStringCellValue().replace("'", "").trim();
4600 varun.gupt 349 
                	paymentId = Long.parseLong(paymentIdStr);
350 
 
351 
                	logger.info("paymentId: " + paymentId + ", recfmt: " + recfmt + ", settlementDate: " + settlementDate + ", netCollection: " + netCollection);
352 
 
4715 varun.gupt 353 
                    if (recfmt.trim().equalsIgnoreCase("CVD"))	{
354 
                    	if (netCollection > 0.0)	netCollection *= -1.0;
355 
                    	transactionClient.savePaymentSettlements(settlementDate.getTime(), 1, paymentId, 0.0, 0.0, netCollection);
4734 varun.gupt 356 
                    	countRefunds += 1;
5020 varun.gupt 357 
 
4600 varun.gupt 358 
                    } else	{
359 
                    	double msf = row.getCell(indexMSF).getNumericCellValue();
360 
                    	double serviceTax = row.getCell(indexServiceTax).getNumericCellValue();
361 
                    	double eduCess = row.getCell(indexEduCess).getNumericCellValue();
362 
                    	logger.info("msf: " + msf + ", serviceTax: " + serviceTax + ", eduCess: " + eduCess);
363 
 
364 
                    	transactionClient.savePaymentSettlements(settlementDate.getTime(), 1, paymentId, serviceTax, (eduCess + msf), netCollection);
4734 varun.gupt 365 
                    	countSuccessfulInserts += 1;
4600 varun.gupt 366 
                 	}
367 
                } catch (NumberFormatException e) {
4734 varun.gupt 368 
                	String errMsg = "NumberFormatException recieved for payment Id, " + paymentIdStr;
369 
        			logger.error(errMsg + e);
370 
        			addActionError(errMsg);
4600 varun.gupt 371 
 
372 
        		} catch (TransactionServiceException e) {
4734 varun.gupt 373 
                	String errMsg = "TransactionServiceException recieved for payment Id, " + paymentId;
374 
        			logger.error(errMsg + e);
375 
        			addActionError(errMsg);
4600 varun.gupt 376 
        		}
377 
			}
378 
		} catch (TTransportException e) {
379 
			logger.error("TTransportException recieved for payment Id," + Long.toString(paymentId) + " " + e);
380 
 
381 
		} catch (TException e) {
382 
			logger.error("TException recieved for payment Id," + Long.toString(paymentId) + " " + e);
383 
		}
4734 varun.gupt 384 
		addActionMessage("Added settlements for " + countSuccessfulInserts + " payments");
385 
		addActionMessage("Added settlements for " + countRefunds + " refund payments");
4600 varun.gupt 386 
	}
387 
 
388 
	public void uploadEBSSettlements()	{
389 
		Workbook wb = null;
390 
        try {
391 
            wb = new HSSFWorkbook(new FileInputStream(this.ebsSettlementReport));
392 
        } catch (FileNotFoundException e) {
4734 varun.gupt 393 
            logger.error("Unable to open the EBS Settlement detail report", e);
4600 varun.gupt 394 
        } catch (IOException e) {
4734 varun.gupt 395 
            logger.error("Unable to open the EBS Settlement detail report", e);
4600 varun.gupt 396 
        }
397 
 
398 
        Sheet sheet = wb.getSheetAt(0);
399 
 
400 
		Row firstRow = sheet.getRow(0);
401 
		Row secondRow = sheet.getRow(1);
402 
 
403 
        int indexPaymentId = 2;
404 
        int indexTxnType = 5;
405 
        int indexAmount = 6;
406 
 
407 
        Map<Long, Map<String, Double>> map = new HashMap<Long, Map<String,Double>>();
408 
        Map <String, Double> record;
4734 varun.gupt 409 
        int countPaymentIds = 0;
4600 varun.gupt 410 
 
411 
        try	{
412 
        	for (Row row: sheet)	{
413 
                if(row.equals(firstRow) || row.equals(secondRow))	continue;
414 
 
415 
                long paymentId = Long.parseLong(row.getCell(indexPaymentId).getStringCellValue());
416 
                String transactionType = row.getCell(indexTxnType).getStringCellValue();
417 
                double amount = row.getCell(indexAmount).getNumericCellValue();
418 
 
419 
                if(map.containsKey(paymentId))	{
420 
                	map.get(paymentId).put(transactionType, amount);
421 
 
422 
                } else	{
423 
                	record = new HashMap<String, Double>();
424 
                	record.put(transactionType, amount);
425 
                	map.put(paymentId, record);
4734 varun.gupt 426 
                	countPaymentIds += 1;
4600 varun.gupt 427 
                }
428 
        	}
429 
        } catch	(NullPointerException e)	{
430 
        	logger.error("" + e);
431 
        }
4734 varun.gupt 432 
        addActionMessage("Total Payment Ids added: " + countPaymentIds);
4600 varun.gupt 433 
 
434 
		TransactionClient tsc;
435 
        long settlementId = Long.parseLong(request.getParameter("settlementId"));
436 
 
4734 varun.gupt 437 
        int countPaymentsRecieved = 0;
438 
        int countPaymentsRefunded = 0;
439 
 
4600 varun.gupt 440 
        try	{
441 
			tsc = new TransactionClient();
442 
			in.shop2020.model.v1.order.TransactionService.Client transactionClient = tsc.getClient();
4734 varun.gupt 443 
			long settlementDate;
4600 varun.gupt 444 
 
4734 varun.gupt 445 
			try	{
446 
				settlementDate = transactionClient.getEBSSettlementDate(settlementId);
447 
			} catch (TransactionServiceException e) {
448 
				String errMsg = "Could not retrieve EBS Settlement date for settlementId, " + settlementId;
449 
	        	logger.error(errMsg + e);
450 
	        	addActionError(errMsg);
451 
	        	return;
452 
			}
453 
 
4600 varun.gupt 454 
        	for (long paymentId: map.keySet())	{
455 
            	record = map.get(paymentId);
456 
 
457 
            	if(record.containsKey("Captured"))	{
458 
            		double capturedAmount = record.get("Captured");
459 
            		double tdr = record.get("TDR");
460 
            		double serviceTax = record.get("ServiceTax");
461 
 
462 
            		if(tdr < 0)	tdr *= -1;
463 
            		if(serviceTax < 0)	serviceTax *= -1;
464 
 
465 
            		double amount = capturedAmount - tdr - serviceTax;
4734 varun.gupt 466 
 
467 
            		try	{
468 
            			transactionClient.savePaymentSettlements(settlementDate, 2, paymentId, serviceTax, tdr, amount);
469 
        			} catch (TransactionServiceException e) {
470 
        				String errMsg = "Could not save settlement for paymentId, " + paymentId;
471 
        	        	logger.error(errMsg + e);
472 
        	        	addActionError(errMsg);
473 
        			}
474 
            		countPaymentsRecieved += 1;
475 
            	}
476 
 
477 
            	if(record.containsKey("Refunded"))	{
4600 varun.gupt 478 
            		double refundedAmount = record.get("Refunded");
479 
 
480 
            		if (refundedAmount > 0)	refundedAmount *= -1;
481 
 
4734 varun.gupt 482 
            		try	{
483 
            			transactionClient.savePaymentSettlements(settlementDate, 2, paymentId, 0.0, 0.0, refundedAmount);
484 
        			} catch (TransactionServiceException e) {
485 
        				String errMsg = "Could not save refund settlement for paymentId, " + paymentId;
486 
        	        	logger.error(errMsg + e);
487 
        	        	addActionError(errMsg);
488 
        			}
489 
            		countPaymentsRefunded += 1;
4600 varun.gupt 490 
            	}
491 
            }
4734 varun.gupt 492 
        	addActionMessage("Total count of payments recieved: " + countPaymentsRecieved);
493 
        	addActionMessage("Total count of payments refunded: " + countPaymentsRefunded);
4600 varun.gupt 494 
 
4734 varun.gupt 495 
        	try	{
496 
        		transactionClient.markEBSSettlementUploaded(settlementId);
497 
			} catch (TransactionServiceException e) {
498 
				String errMsg = "Could not mark settlement for details Uploaded. Settlement ID: " + settlementId;
499 
	        	logger.error(errMsg + e);
500 
	        	addActionError(errMsg);
501 
			}
4600 varun.gupt 502 
        } catch (TTransportException e) {
503 
        	logger.error("TTransportException " + e);
504 
		} catch (TException e) {
505 
        	logger.error("TException " + e);
506 
		}
507 
	}
508 
 
509 
	public void uploadBluedartSettlements()	{
510 
 
511 
		Workbook wb = null;
512 
        try {
513 
            wb = new HSSFWorkbook(new FileInputStream(this.bluedartSettlementReport));
514 
        } catch (FileNotFoundException e) {
515 
            logger.error("Unable to open the Settlement report", e);
516 
        } catch (IOException e) {
517 
            logger.error("Unable to open the Settlement report", e);
518 
        }
519 
 
520 
        Sheet sheet = wb.getSheetAt(0);
521 
 
522 
        Row firstRow = sheet.getRow(0);
523 
        logger.info("Cell count:" + firstRow.getPhysicalNumberOfCells());
524 
 
5098 varun.gupt 525 
        int indexOrderId = 15;
526 
        int indexAmount = 14;
4600 varun.gupt 527 
 
528 
        TransactionClient tsc;
4734 varun.gupt 529 
    	int countSuccessfulSaves = 0;
4600 varun.gupt 530 
 
531 
        try	{
532 
			long settlementDate = DATE_FORMAT.parse(bluedartSettlementDate).getTime();
533 
        	tsc = new TransactionClient();
534 
        	in.shop2020.model.v1.order.TransactionService.Client transactionClient = tsc.getClient();
535 
 
536 
        	for (Row row : sheet) {
4875 varun.gupt 537 
    			long orderId = 0;
5098 varun.gupt 538 
    			String orderIdString = "";
4600 varun.gupt 539 
        		try	{
5098 varun.gupt 540 
        			orderIdString = row.getCell(indexOrderId).getStringCellValue();
541 
        			orderId = Long.parseLong(orderIdString);
4715 varun.gupt 542 
 
4600 varun.gupt 543 
        			double amount = row.getCell(indexAmount).getNumericCellValue();
5020 varun.gupt 544 
        			logger.info("Bluedart SettlementDate: " + settlementDate + ", OrderId: " + orderId + ", Amount: " + amount);
4905 varun.gupt 545 
        			transactionClient.savePaymentSettlements(settlementDate, 4, orderId, 0.0, 0.0, amount);
4875 varun.gupt 546 
        			countSuccessfulSaves += 1;
4600 varun.gupt 547 
 
5098 varun.gupt 548 
        		} catch (IllegalStateException e) {
549 
        			logger.error("" + e);
550 
 
551 
        		} catch(NumberFormatException e)	{
552 
        			logger.error("Extracted String: " + orderIdString + " " + e);
553 
 
4600 varun.gupt 554 
        		} catch (NullPointerException e) {
4875 varun.gupt 555 
        			logger.error("For OrderId: " + orderId + " " + e);
4600 varun.gupt 556 
 
4875 varun.gupt 557 
        		} catch (TransactionServiceException e) {
558 
					logger.error("For OrderId: " + orderId + " " + e);
4600 varun.gupt 559 
				}
560 
        	}
561 
        } catch (ParseException e) {
562 
        	logger.error("Could not parse " + bluedartSettlementDate + " " + e);
4875 varun.gupt 563 
			addActionError(e.getMessage());
564 
 
4600 varun.gupt 565 
		} catch (TTransportException e) {
566 
			logger.error("" + e);
4875 varun.gupt 567 
			addActionError(e.getMessage());
568 
 
4600 varun.gupt 569 
        } catch (TException e) {
570 
        	logger.error("" + e);
4875 varun.gupt 571 
			addActionError(e.getMessage());
4600 varun.gupt 572 
        }
4734 varun.gupt 573 
        addActionMessage("Successfully added Bluedart settlement details for " + countSuccessfulSaves + " orders");
4600 varun.gupt 574 
	}
575 
 
4715 varun.gupt 576 
	public void uploadAramexSettlements()	{
577 
		logger.info("Uploading Aramex Settlements" + this.aramexSettlementDate);
578 
 
579 
		if(this.aramexSettlementDate.equals(""))	{
580 
			addActionError("Settlement date cannot be left blank");
581 
			return;
582 
		}
583 
 
584 
		Workbook wb = null;
585 
        try {
5020 varun.gupt 586 
        	wb = new XSSFWorkbook(new FileInputStream(this.aramexSettlementReport));
4715 varun.gupt 587 
        } catch (FileNotFoundException e) {
4875 varun.gupt 588 
        	addActionError(e.getMessage());
4715 varun.gupt 589 
            logger.error("Unable to open the Settlement report", e);
590 
        } catch (IOException e) {
4875 varun.gupt 591 
        	addActionError(e.getMessage());
4715 varun.gupt 592 
            logger.error("Unable to open the Settlement report", e);
593 
        } catch (NullPointerException e) {
594 
        	addActionError(e.getMessage());
595 
        	logger.error("Unable to open the Settlement report", e);
596 
        	return;
597 
		}
598 
 
599 
        Sheet sheet = wb.getSheetAt(0);
600 
 
4734 varun.gupt 601 
        int indexAmount = 1;
5108 varun.gupt 602 
        int indexAWB = 0;
4715 varun.gupt 603 
 
604 
        Row firstRow = sheet.getRow(0);
605 
        logger.info("Cell count:" + firstRow.getPhysicalNumberOfCells());
606 
 
607 
        TransactionClient tsc;
4734 varun.gupt 608 
        int countSuccessfulSaves = 0;
4715 varun.gupt 609 
        try	{
610 
			long settlementDate = DATE_FORMAT.parse(aramexSettlementDate).getTime();
611 
 
612 
        	tsc = new TransactionClient();
613 
        	in.shop2020.model.v1.order.TransactionService.Client transactionClient = tsc.getClient();
614 
 
615 
	    	for (Row row: sheet)	{
616 
	    		if(row.equals(firstRow))	continue;
617 
 
5108 varun.gupt 618 
	    		try {
619 
	    			if(row.getCell(indexAWB).getNumericCellValue() < 1)	break;
620 
				} catch (NullPointerException e) {
621 
					break;
622 
				}
5020 varun.gupt 623 
 
5108 varun.gupt 624 
	    		long awb = (long) row.getCell(indexAWB).getNumericCellValue();
625 
 
4715 varun.gupt 626 
	    		try {
5108 varun.gupt 627 
		    		long orderId = transactionClient.getOrderForAwb(Long.toString(awb)).getId();
628 
		    		double amount = row.getCell(indexAmount).getNumericCellValue();
629 
		    		logger.info("Aramex Settlement, Order Id: " + orderId + " Amount: " + amount);
630 
 
4907 varun.gupt 631 
					transactionClient.savePaymentSettlements(settlementDate, 4, orderId, 0.0, 0.0, amount);
4734 varun.gupt 632 
					countSuccessfulSaves += 1;
4715 varun.gupt 633 
 
634 
				} catch (TransactionServiceException e) {
5108 varun.gupt 635 
					logger.error("Transaction Service Exception while getting order for AWB, " + awb, e);
636 
					addActionError("Transaction Service Exception while getting order for AWB, " + awb);
4715 varun.gupt 637 
				}
638 
	    	}
639 
        } catch (ParseException e) {
640 
        	addActionError("Could not parse " + aramexSettlementDate);
641 
        	logger.error("Could not parse " + aramexSettlementDate + " " + e);
4875 varun.gupt 642 
 
4715 varun.gupt 643 
        } catch (TTransportException e) {
4875 varun.gupt 644 
        	addActionError(e.getMessage());
4715 varun.gupt 645 
        	logger.error("" + e);
4875 varun.gupt 646 
 
4715 varun.gupt 647 
        } catch (TException e) {
4875 varun.gupt 648 
        	addActionError(e.getMessage());
4715 varun.gupt 649 
        	logger.error("" + e);
650 
        }
4734 varun.gupt 651 
        addActionMessage("Successfully added Aramex settlement details for " + countSuccessfulSaves + " orders");
4715 varun.gupt 652 
	}
653 
 
5098 varun.gupt 654 
	public void uploadOrderIdsToBeMarkedPaid()	{
655 
		logger.info("Uploading Order Ids to be marked as paid");
656 
 
657 
		Workbook wb = null;
658 
        try {
659 
        	wb = new XSSFWorkbook(new FileInputStream(this.orderIdsToBeMarkedPaid));
660 
        } catch (FileNotFoundException e) {
661 
        	addActionError(e.getMessage());
662 
            logger.error("Unable to open the sheet containing orders for which vendor is paid", e);
663 
        	return;
664 
        } catch (IOException e) {
665 
        	addActionError(e.getMessage());
666 
            logger.error("Unable to open the sheet containing orders for which vendor is paid", e);
667 
        	return;
668 
        } catch (NullPointerException e) {
669 
        	addActionError(e.getMessage());
670 
        	logger.error("Unable to open the sheet containing orders for which vendor is paid", e);
671 
        	return;
672 
		}
673 
 
674 
        Sheet sheet = wb.getSheetAt(0);
675 
        int indexOrderId = 0;
676 
 
677 
        TransactionClient tsc;
678 
        int countSuccessfulSaves = 0;
679 
 
680 
//        try	{
681 
//        	tsc = new TransactionClient();
682 
//        	in.shop2020.model.v1.order.TransactionService.Client transactionClient = tsc.getClient();
683 
//
684 
//	    	for (Row row: sheet)	{
685 
//
686 
//	    		if(row.getCell(indexOrderId).getStringCellValue().equals(""))	break;
687 
//
688 
//	    		long orderId = Long.parseLong(row.getCell(indexOrderId).getStringCellValue());
689 
//	    		logger.info("Aramex Settlement, Order Id: " + orderId);
690 
//	    		try {
691 
//	    			transactionClient.updateOrderAsPaidToVendor(orderId);
692 
//					countSuccessfulSaves += 1;
693 
//
694 
//				} catch (TransactionServiceException e) {
695 
//					logger.error("Transaction Service Exception while getting order for id, " + orderId, e);
696 
//					addActionError("Transaction Service Exception while getting order for id, " + orderId);
697 
//				}
698 
//	    	}
699 
//        } catch (TTransportException e) {
700 
//        	addActionError(e.getMessage());
701 
//        	logger.error("" + e);
702 
//
703 
//        } catch (TException e) {
704 
//        	addActionError(e.getMessage());
705 
//        	logger.error("" + e);
706 
//        }
707 
        addActionMessage("Successfully marked " + countSuccessfulSaves + " orders as paid to vendor");
708 
	}
709 
 
4600 varun.gupt 710 
	// Prepares the XLS worksheet object and fills in the data with proper formatting
5020 varun.gupt 711 
	private ByteArrayOutputStream getReconciliationReport(long vendorId)	{
4875 varun.gupt 712 
 
5020 varun.gupt 713 
		List<PaymentSettlement> paymentSettlements = new ArrayList<PaymentSettlement>();
714 
		List<PaymentSettlement> refundPaymentSettlements = new ArrayList<PaymentSettlement>();
715 
 
4745 varun.gupt 716 
		try	{
717 
			TransactionClient tsc = new TransactionClient();
718 
			in.shop2020.model.v1.order.TransactionService.Client transactionClient = tsc.getClient();
5020 varun.gupt 719 
 
720 
			paymentSettlements = transactionClient.getSettlementsByDate(0, (new Date()).getTime(), false);
4745 varun.gupt 721 
			logger.info("Settlement Count: " + paymentSettlements.size());
4905 varun.gupt 722 
 
5020 varun.gupt 723 
			refundPaymentSettlements = transactionClient.getSettlementsByDate(0, (new Date()).getTime(), true);
724 
			logger.info("Refund Settlement Count: " + refundPaymentSettlements.size());
4745 varun.gupt 725 
 
726 
		} catch	(TransactionServiceException e)	{
727 
			String errMsg = "Transaction Service Exception occured";
728 
			logger.error(errMsg, e);
729 
			addActionError(errMsg);
730 
		} catch (TTransportException e) {
731 
			String errMsg = "Transaction Service Exception occured";
732 
			logger.error(errMsg, e);
733 
			addActionError(errMsg);
734 
		} catch (TException e) {
735 
			// TODO Auto-generated
736 
			String errMsg = "Transaction Service Exception occured";
737 
			logger.error(errMsg, e);
738 
			addActionError(errMsg);
739 
		}
740 
 
4600 varun.gupt 741 
		ByteArrayOutputStream baosXLS = new ByteArrayOutputStream();
4745 varun.gupt 742 
 
4600 varun.gupt 743 
	    Workbook wb = new HSSFWorkbook();
4875 varun.gupt 744 
 
4600 varun.gupt 745 
	    //Create the style for the title row
746 
	    Font font = wb.createFont();
747 
	    font.setBoldweight(Font.BOLDWEIGHT_BOLD);
748 
	    CellStyle boldStyle = wb.createCellStyle();
749 
	    boldStyle.setFont(font);
750 
 
751 
	    CellStyle rightAlignStyle = wb.createCellStyle();
752 
	    rightAlignStyle.setAlignment(CellStyle.ALIGN_RIGHT);
753 
 
754 
		Sheet orderSheet = wb.createSheet("Orders");
4875 varun.gupt 755 
		Sheet reshippedOrderSheet = wb.createSheet("Reshipped");
4600 varun.gupt 756 
		Sheet mismatchSheet = wb.createSheet("Mismatches");
757 
 
5020 varun.gupt 758 
	    populateOrderSheet(paymentSettlements, refundPaymentSettlements, vendorId, orderSheet, boldStyle, rightAlignStyle);
759 
//	    populateReshippedOrderSheet(reshippedOrders, reshippedOrderSheet);
760 
//	    populateMismatchSheet(mismatchSheet);
4600 varun.gupt 761 
 
762 
		// Write the workbook to the output stream
763 
		try {
764 
			wb.write(baosXLS);
765 
			baosXLS.close();
766 
		} catch (IOException e) {
767 
			logger.error("Unable to write the hotspot reconciliation report to the byte array", e);
768 
		}
769 
		return baosXLS;
770 
	}
771 
 
772 
	private void populateMismatchSheet(Sheet sheet)	{
773 
	    int serialNo = 0;
774 
		Row titleRow = sheet.createRow(serialNo ++);
775 
	    Cell titleCell = titleRow.createCell(0);
776 
	    titleCell.setCellValue("Order Reconciliation Report (Mis-matches)");
777 
 
778 
	    sheet.addMergedRegion(new CellRangeAddress(0, 0, 0, 4));
779 
	    sheet.createRow(serialNo ++);
780 
 
781 
	    Row headerRow = sheet.createRow(serialNo ++);
782 
	    headerRow.createCell(OrderMismatchColumn.ORDER_ID.getValue()).setCellValue("Order Id");
783 
	    headerRow.createCell(OrderMismatchColumn.EXPECTED_COLLECTION.getValue()).setCellValue("Expected Collection");
784 
	    headerRow.createCell(OrderMismatchColumn.ACTUAL_COLLECTION.getValue()).setCellValue("Actual Collection");
785 
 
786 
	    for (long orderId: misMatches.keySet())	{
787 
	    	Row contentRow = sheet.createRow(serialNo ++);
788 
	    	contentRow.createCell(OrderMismatchColumn.ORDER_ID.getValue()).setCellValue(orderId);
789 
	    	contentRow.createCell(OrderMismatchColumn.EXPECTED_COLLECTION.getValue()).setCellValue(misMatches.get(orderId).get("expected"));
790 
	    	contentRow.createCell(OrderMismatchColumn.ACTUAL_COLLECTION.getValue()).setCellValue(misMatches.get(orderId).get("actual"));
791 
	    }
792 
	}
793 
 
4875 varun.gupt 794 
	private void populateReshippedOrderSheet(List<Order> orders, Sheet sheet) {
795 
	    short serialNo = 0;
796 
 
797 
	    // Create the title row and put all the titles in it. Rows are 0 based.
798 
	    Row titleRow = sheet.createRow(serialNo ++);
799 
	    Cell titleCell = titleRow.createCell(0);
800 
	    titleCell.setCellValue("Reshipped Orders");
801 
 
802 
	    sheet.addMergedRegion(new CellRangeAddress(0, 0, 0, 6));
803 
 
804 
	    sheet.createRow(serialNo ++);
805 
 
806 
	    Row headerRow = sheet.createRow(serialNo ++);
807 
	    headerRow.createCell(OrderReportColumn.ORDER_ID.getValue()).setCellValue("Order Id");
808 
	    headerRow.createCell(OrderReportColumn.ORDER_DATE.getValue()).setCellValue("Order Date");
809 
	    headerRow.createCell(OrderReportColumn.BILLING_NUMBER.getValue()).setCellValue("Billing Number");
810 
	    headerRow.createCell(OrderReportColumn.BILLING_DATE.getValue()).setCellValue("Billing Date");
811 
	    headerRow.createCell(OrderReportColumn.DELIVERY_DATE.getValue()).setCellValue("Delivery Date");
812 
	    headerRow.createCell(OrderReportColumn.SETTLEMENT_DATE.getValue()).setCellValue("Settlement Date");
813 
	    headerRow.createCell(OrderReportColumn.BRAND.getValue()).setCellValue("Brand");
814 
	    headerRow.createCell(OrderReportColumn.MODEL_NAME.getValue()).setCellValue("Model Name");
815 
	    headerRow.createCell(OrderReportColumn.MODEL_NUMBER.getValue()).setCellValue("Model Number");
816 
	    headerRow.createCell(OrderReportColumn.COLOR.getValue()).setCellValue("Color");
817 
	    headerRow.createCell(OrderReportColumn.QUANTITY.getValue()).setCellValue("Quantity");
818 
	    headerRow.createCell(OrderReportColumn.UNIT_TRANSFER_PRICE.getValue()).setCellValue("Unit Transfer Price");
819 
	    headerRow.createCell(OrderReportColumn.UNIT_SELLING_PRICE.getValue()).setCellValue("Unit Selling Price");
820 
	    headerRow.createCell(OrderReportColumn.TOTAL_TRANSFER_PRICE.getValue()).setCellValue("Total Transfer Price");
821 
	    headerRow.createCell(OrderReportColumn.TOTAL_SELLING_PRICE.getValue()).setCellValue("Total Selling Price");
822 
	    headerRow.createCell(OrderReportColumn.CURRENT_STATUS.getValue()).setCellValue("Current Status");
823 
	    headerRow.createCell(OrderReportColumn.PAYMENT_TYPE.getValue()).setCellValue("Payment Type");
824 
	    headerRow.createCell(OrderReportColumn.PAYMENT_STATUS.getValue()).setCellValue("Payment Status");
825 
	    headerRow.createCell(OrderReportColumn.PAYMENT_ID.getValue()).setCellValue("Payment Id");
826 
	    headerRow.createCell(OrderReportColumn.COUPON_CODE.getValue()).setCellValue("Coupon Code");
827 
//	    headerRow.createCell(OrderReportColumn.COUPON_CATEGORY.getValue()).setCellValue("Coupon Category");
828 
//	    headerRow.createCell(OrderReportColumn.DISCOUNT.getValue()).setCellValue("Discount");
829 
	    headerRow.createCell(OrderReportColumn.SERVICE_TAX.getValue()).setCellValue("Service Tax");
830 
	    headerRow.createCell(OrderReportColumn.OTHER_CHARGES.getValue()).setCellValue("Other Charges");
831 
	    headerRow.createCell(OrderReportColumn.NET_COLLECTION.getValue()).setCellValue("Net Collection");
832 
 
833 
	    sheet.createRow(serialNo ++);
834 
 
835 
		TransactionClient tsc;
836 
    	PaymentClient psc;
837 
    	LogisticsClient lsc;
838 
 
839 
		try {
840 
			tsc = new TransactionClient();
841 
			in.shop2020.model.v1.order.TransactionService.Client transactionClient = tsc.getClient();
842 
 
843 
			psc = new PaymentClient();
844 
	    	in.shop2020.payments.PaymentService.Client paymentClient = psc.getClient();
845 
 
846 
	    	lsc = new LogisticsClient();
847 
	    	in.shop2020.logistics.LogisticsService.Client logisticsClient = lsc.getClient();
848 
 
849 
	    	Map<Long, String> codProviders = new HashMap<Long, String>();
850 
 
851 
	    	for (Provider provider: logisticsClient.getAllProviders())	{
852 
	    		codProviders.put(provider.getId(), provider.getName());
853 
	    	}
854 
 
855 
	    	List<PaymentGateway> tPaymentGateways = paymentClient.getActivePaymentGateways();
856 
	    	Map<Long, String> paymentGateways = new HashMap<Long, String>();
857 
 
858 
	    	for (PaymentGateway tPaymentGateway: tPaymentGateways)	{
859 
	    		paymentGateways.put(tPaymentGateway.getId(), tPaymentGateway.getName());
860 
	    	}
861 
 
862 
			int countMultipleOrderTxns = 0;
863 
 
864 
			for (Order order: orders)	{
865 
			    logger.info("For order: " + order.getId());
866 
 
867 
			    LineItem lineItem = order.getLineitems().get(0);
868 
			    double transferPrice = lineItem.getTransfer_price();
869 
			    Payment payment = null;
870 
 
871 
			    try	{
872 
			    	if(order.isCod())	{
873 
			    		payment = paymentClient.getPaymentForTxnId(order.getTransactionId()).get(0);
874 
			    	} else	{
875 
			    		payment = paymentClient.getSuccessfulPaymentForTxnId(order.getTransactionId());
876 
			    	}
877 
				    logger.info("getSuccessfulPaymentForTxnId, " + order.getTransactionId() + ": " + payment);
878 
 
879 
			    } catch (TApplicationException e)	{
880 
			    	orderIdsWithoutSuccess.add(order.getId());
881 
			    	String errMsg = "Exception while getting successfull payment for transaction Id, " + order.getTransactionId();
882 
					logger.error(errMsg, e);
883 
					addActionError(errMsg);
884 
				}
885 
 
886 
			    Transaction txn = transactionClient.getTransaction(order.getTransactionId());
887 
			    PaymentSettlement paymentSettlement = null;
888 
			    String paymentType = null;
889 
 
890 
			    if(payment != null)	{
891 
			    	paymentSettlement = transactionClient.getSettlementForPaymentId(payment.getPaymentId());
892 
			    	paymentType = paymentGateways.get(payment.getGatewayId());
893 
			    }
894 
 
895 
	            double totalSellingPrice = lineItem.getTotal_price();
896 
	            double serviceTax = 0.0;
897 
	            double otherCollectionCharges = 0.0;
898 
	            double netCollection = 0.0;
899 
 
900 
	            if(paymentSettlement != null)	{
901 
		            serviceTax = paymentSettlement.getServiceTax();
902 
		            otherCollectionCharges = paymentSettlement.getOtherCharges();
903 
		            netCollection = paymentSettlement.getNetCollection();
904 
	            }
905 
 
906 
	            if (netCollection < 0.0)	{
907 
	            	paymentType = paymentType + "-REFUND";
908 
	            }
909 
 
910 
		    	Row contentRow = sheet.createRow(serialNo++);
911 
	            contentRow.createCell(OrderReportColumn.ORDER_ID.getValue()).setCellValue(order.getId());
912 
	            contentRow.createCell(OrderReportColumn.ORDER_DATE.getValue()).setCellValue(DATE_FORMAT.format(new Date(order.getCreated_timestamp())));
913 
			    contentRow.createCell(OrderReportColumn.BILLING_NUMBER.getValue()).setCellValue(order.getInvoice_number());
914 
			    contentRow.createCell(OrderReportColumn.BILLING_DATE.getValue()).setCellValue(DATE_FORMAT.format(new Date(order.getBilling_timestamp())));
915 
			    contentRow.createCell(OrderReportColumn.DELIVERY_DATE.getValue()).setCellValue(DATE_FORMAT.format(new Date(order.getDelivery_timestamp())));
916 
			    contentRow.createCell(OrderReportColumn.BRAND.getValue()).setCellValue(getValueForEmptyString(lineItem.getBrand()));
917 
			    contentRow.createCell(OrderReportColumn.MODEL_NAME.getValue()).setCellValue(getValueForEmptyString(lineItem.getModel_name()));
918 
			    contentRow.createCell(OrderReportColumn.MODEL_NUMBER.getValue()).setCellValue(getValueForEmptyString(lineItem.getModel_number()));
919 
			    contentRow.createCell(OrderReportColumn.COLOR.getValue()).setCellValue(getValueForEmptyString(lineItem.getColor()));
920 
			    contentRow.createCell(OrderReportColumn.QUANTITY.getValue()).setCellValue(lineItem.getQuantity());
921 
			    contentRow.createCell(OrderReportColumn.UNIT_TRANSFER_PRICE.getValue()).setCellValue(transferPrice);
922 
			    contentRow.createCell(OrderReportColumn.UNIT_SELLING_PRICE.getValue()).setCellValue(lineItem.getUnit_price());
923 
			    contentRow.createCell(OrderReportColumn.TOTAL_TRANSFER_PRICE.getValue()).setCellValue(transferPrice * lineItem.getQuantity());
924 
			    contentRow.createCell(OrderReportColumn.TOTAL_SELLING_PRICE.getValue()).setCellValue(totalSellingPrice);
925 
			    contentRow.createCell(OrderReportColumn.CURRENT_STATUS.getValue()).setCellValue(order.getStatusDescription());
926 
 
927 
		    	double refund = 0.0;
928 
 
929 
		    	if(order.isCod())	{
930 
		    		contentRow.createCell(OrderReportColumn.PAYMENT_TYPE.getValue()).setCellValue("COD - " + codProviders.get(order.getLogistics_provider_id()));
931 
		    	} else	{
932 
			    	contentRow.createCell(OrderReportColumn.PAYMENT_TYPE.getValue()).setCellValue(paymentType);
933 
		    	}
934 
 
935 
			    if (payment != null)	{
936 
				    contentRow.createCell(OrderReportColumn.SETTLEMENT_DATE.getValue()).setCellValue(DATE_FORMAT.format(new Date(paymentSettlement.getSettlementDate())));
937 
			    	contentRow.createCell(OrderReportColumn.PAYMENT_STATUS.getValue()).setCellValue(payment.getStatus().name());
938 
			    	contentRow.createCell(OrderReportColumn.PAYMENT_ID.getValue()).setCellValue(payment.getPaymentId());
939 
			    }
940 
			    contentRow.createCell(OrderReportColumn.COUPON_CODE.getValue()).setCellValue(txn.getCoupon_code());
941 
			    contentRow.createCell(OrderReportColumn.SERVICE_TAX.getValue()).setCellValue(serviceTax);
942 
			    contentRow.createCell(OrderReportColumn.OTHER_CHARGES.getValue()).setCellValue(otherCollectionCharges);
943 
			    contentRow.createCell(OrderReportColumn.NET_COLLECTION.getValue()).setCellValue(netCollection);
944 
			}
945 
 
946 
		    logger.info("Order Ids where no successful payment was found: " + orderIdsWithoutSuccess.size());
947 
		    logger.info(orderIdsWithoutSuccess.toString());
948 
 
949 
	    	sheet.createRow(serialNo++);
950 
 
951 
		} catch (TTransportException e) {
952 
			logger.error("TTransportException " + e);
953 
		} catch (PaymentException e) {
954 
			logger.error("PaymentException " + e);
955 
		} catch (TException e) {
956 
			logger.error("TException " + e);
957 
		} catch (TransactionServiceException e) {
958 
			logger.error("Transaction Service Exception " + e);
959 
		} catch (LogisticsServiceException e) {
960 
			addActionError("Error loading list of COD providers");
961 
			logger.error("Logistics Service Exception " + e);
962 
		}
963 
	}
964 
 
5020 varun.gupt 965 
	private void populateOrderSheet(List<PaymentSettlement> paymentSettlements, List<PaymentSettlement> refundSettlements, long vendorId, Sheet sheet, CellStyle style, CellStyle rightAlignStyle) {
966 
 
967 
	    // Create the title row and put all the titles in it. Rows are 0 based
968 
	    Row titleRow = sheet.createRow(rowCount ++);
4600 varun.gupt 969 
	    Cell titleCell = titleRow.createCell(0);
5020 varun.gupt 970 
	    titleCell.setCellValue("Order Reconciliation Report");
4600 varun.gupt 971 
	    titleCell.setCellStyle(style);
972 
 
5020 varun.gupt 973 
	    sheet.addMergedRegion(new CellRangeAddress(0, 0, 0, 4));
4600 varun.gupt 974 
 
5020 varun.gupt 975 
	    sheet.createRow(rowCount ++);
4600 varun.gupt 976 
 
5020 varun.gupt 977 
	    Row headerRow = sheet.createRow(rowCount ++);
4600 varun.gupt 978 
	    headerRow.createCell(OrderReportColumn.ORDER_ID.getValue()).setCellValue("Order Id");
979 
	    headerRow.createCell(OrderReportColumn.ORDER_DATE.getValue()).setCellValue("Order Date");
980 
	    headerRow.createCell(OrderReportColumn.BILLING_NUMBER.getValue()).setCellValue("Billing Number");
981 
	    headerRow.createCell(OrderReportColumn.BILLING_DATE.getValue()).setCellValue("Billing Date");
982 
	    headerRow.createCell(OrderReportColumn.DELIVERY_DATE.getValue()).setCellValue("Delivery Date");
983 
	    headerRow.createCell(OrderReportColumn.SETTLEMENT_DATE.getValue()).setCellValue("Settlement Date");
984 
	    headerRow.createCell(OrderReportColumn.BRAND.getValue()).setCellValue("Brand");
985 
	    headerRow.createCell(OrderReportColumn.MODEL_NAME.getValue()).setCellValue("Model Name");
986 
	    headerRow.createCell(OrderReportColumn.MODEL_NUMBER.getValue()).setCellValue("Model Number");
987 
	    headerRow.createCell(OrderReportColumn.COLOR.getValue()).setCellValue("Color");
988 
	    headerRow.createCell(OrderReportColumn.QUANTITY.getValue()).setCellValue("Quantity");
989 
	    headerRow.createCell(OrderReportColumn.UNIT_TRANSFER_PRICE.getValue()).setCellValue("Unit Transfer Price");
990 
	    headerRow.createCell(OrderReportColumn.UNIT_SELLING_PRICE.getValue()).setCellValue("Unit Selling Price");
991 
	    headerRow.createCell(OrderReportColumn.TOTAL_TRANSFER_PRICE.getValue()).setCellValue("Total Transfer Price");
992 
	    headerRow.createCell(OrderReportColumn.TOTAL_SELLING_PRICE.getValue()).setCellValue("Total Selling Price");
993 
	    headerRow.createCell(OrderReportColumn.CURRENT_STATUS.getValue()).setCellValue("Current Status");
994 
	    headerRow.createCell(OrderReportColumn.PAYMENT_TYPE.getValue()).setCellValue("Payment Type");
4745 varun.gupt 995 
	    headerRow.createCell(OrderReportColumn.PAYMENT_STATUS.getValue()).setCellValue("Payment Status");
4600 varun.gupt 996 
	    headerRow.createCell(OrderReportColumn.PAYMENT_ID.getValue()).setCellValue("Payment Id");
997 
	    headerRow.createCell(OrderReportColumn.COUPON_CODE.getValue()).setCellValue("Coupon Code");
998 
	    headerRow.createCell(OrderReportColumn.SERVICE_TAX.getValue()).setCellValue("Service Tax");
999 
	    headerRow.createCell(OrderReportColumn.OTHER_CHARGES.getValue()).setCellValue("Other Charges");
1000 
	    headerRow.createCell(OrderReportColumn.NET_COLLECTION.getValue()).setCellValue("Net Collection");
1001 
 
5020 varun.gupt 1002 
	    sheet.createRow(rowCount ++);
4600 varun.gupt 1003 
 
1004 
		TransactionClient tsc;
1005 
    	PaymentClient psc;
4734 varun.gupt 1006 
    	LogisticsClient lsc;
4745 varun.gupt 1007 
 
4600 varun.gupt 1008 
		try {
1009 
			tsc = new TransactionClient();
1010 
			in.shop2020.model.v1.order.TransactionService.Client transactionClient = tsc.getClient();
5020 varun.gupt 1011 
 
1012 
	    	lsc = new LogisticsClient();
1013 
	    	in.shop2020.logistics.LogisticsService.Client logisticsClient = lsc.getClient();
1014 
 
4600 varun.gupt 1015 
			psc = new PaymentClient();
1016 
	    	in.shop2020.payments.PaymentService.Client paymentClient = psc.getClient();
1017 
 
5020 varun.gupt 1018 
	    	List<PaymentGateway> tPaymentGateways = paymentClient.getActivePaymentGateways();
4734 varun.gupt 1019 
 
5020 varun.gupt 1020 
	    	for (PaymentGateway tPaymentGateway: tPaymentGateways)	{
1021 
	    		paymentGateways.put(tPaymentGateway.getId(), tPaymentGateway.getName());
1022 
	    	}
4734 varun.gupt 1023 
 
1024 
	    	for (Provider provider: logisticsClient.getAllProviders())	{
1025 
	    		codProviders.put(provider.getId(), provider.getName());
1026 
	    	}
1027 
 
5098 varun.gupt 1028 
	    	class PaymentSettlementMap	{
1029 
	    		public PaymentSettlement settlement;
1030 
	    		public Payment payment;
1031 
	    		public Transaction transaction;
1032 
	    		public Order order;
1033 
 
1034 
	    		public PaymentSettlementMap(PaymentSettlement settlement, Payment pmt, Transaction txn, Order order)	{
1035 
	    			this.settlement = settlement;
1036 
	    			this.payment = pmt;
1037 
	    			this.transaction = txn;
1038 
	    			this.order = order;
1039 
	    		}
1040 
 
1041 
	    		public PaymentSettlementMap(PaymentSettlement settlement, Payment pmt, Transaction txn)	{
1042 
	    			this.settlement = settlement;
1043 
	    			this.payment = pmt;
1044 
	    			this.transaction = txn;
1045 
	    		}
1046 
	    	}
1047 
 
1048 
	    	List<Long> allOrderIds = new ArrayList<Long>();
1049 
	    	Map<Long, PaymentSettlementMap> referenceMap = new HashMap<Long, PaymentSettlementMap>();
1050 
 
5020 varun.gupt 1051 
	    	for (PaymentSettlement paymentSettlement: paymentSettlements)	{
5098 varun.gupt 1052 
	    		try {
1053 
    				if(paymentSettlement.getPaymentGatewayId() == 4)	{	// If COD
1054 
	    				Order order = transactionClient.getOrder(paymentSettlement.getReferenceId());
1055 
	    				Transaction txn = transactionClient.getTransaction(order.getTransactionId());
1056 
	    				Payment payment = paymentClient.getPaymentForTxnId(txn.getId()).get(0);
1057 
 
1058 
		    			if (order.getVendorId() == vendorId)	{
1059 
		    				allOrderIds.add(order.getId());
1060 
		    			}
1061 
 
1062 
    				} else	{	// If prepaid
1063 
    					Payment payment = paymentClient.getPayment(paymentSettlement.getReferenceId());
1064 
    					Transaction txn = transactionClient.getTransaction(payment.getMerchantTxnId());
1065 
 
1066 
    					for (Order order: txn.getOrders())	{
1067 
    						allOrderIds.add(order.getId());
1068 
    					}
1069 
    				}
1070 
    			} catch (TransactionServiceException e) {
1071 
					logger.error("TransactionServiceException " + e);
1072 
				} catch (TException e) {
1073 
					logger.error("TException " + e);
1074 
				} catch (PaymentException e) {
1075 
					logger.error("PaymentException " + e);
1076 
				}
1077 
	    	}
1078 
 
1079 
	    	for (PaymentSettlement paymentSettlement: paymentSettlements)	{
5020 varun.gupt 1080 
 
1081 
    			try {
1082 
    				if(paymentSettlement.getPaymentGatewayId() == 4)	{	// If COD
1083 
	    				Order order = transactionClient.getOrder(paymentSettlement.getReferenceId());
1084 
	    				Transaction txn = transactionClient.getTransaction(order.getTransactionId());
1085 
	    				Payment payment = paymentClient.getPaymentForTxnId(txn.getId()).get(0);
1086 
 
1087 
		    			if (order.getVendorId() == vendorId)	{
1088 
					    	Row contentRow = sheet.createRow(rowCount ++);
1089 
					    	outputCODRow(contentRow, paymentSettlement, order, txn, payment);
1090 
		    			}
1091 
 
1092 
    				} else	{	// If prepaid
1093 
    					Payment payment = paymentClient.getPayment(paymentSettlement.getReferenceId());
1094 
    					Transaction txn = transactionClient.getTransaction(payment.getMerchantTxnId());
1095 
 
1096 
    					outputPrepaidTransactionRows(sheet, vendorId, paymentSettlement, txn, payment);
1097 
    				}
1098 
    			} catch (TransactionServiceException e) {
1099 
					logger.error("TransactionServiceException " + e);
1100 
				} catch (TException e) {
1101 
					logger.error("TException " + e);
1102 
				} catch (PaymentException e) {
1103 
					logger.error("PaymentException " + e);
1104 
				}
4600 varun.gupt 1105 
	    	}
1106 
 
5020 varun.gupt 1107 
	    	rowCount ++;
1108 
 
1109 
	    	for (PaymentSettlement paymentSettlement: refundSettlements)	{
1110 
	    		try {
1111 
	    			Payment payment = paymentClient.getPayment(paymentSettlement.getReferenceId());
1112 
					Transaction txn = transactionClient.getTransaction(payment.getMerchantTxnId());
1113 
 
1114 
					outputRefundRows(sheet, vendorId, paymentSettlement, txn, payment);
1115 
    			} catch (TransactionServiceException e) {
1116 
					logger.error("TransactionServiceException " + e);
1117 
				} catch (TException e) {
1118 
					logger.error("TException " + e);
1119 
				} catch (PaymentException e) {
1120 
					logger.error("PaymentException " + e);
4875 varun.gupt 1121 
				}
5020 varun.gupt 1122 
	    	}
1123 
		} catch (TTransportException e) {
1124 
			logger.error("TTransportException", e);
1125 
		} catch (LogisticsServiceException e) {
1126 
			logger.error("LogisticsServiceException" + e);
1127 
		} catch (TException e) {
1128 
			logger.error("TException" + e);
1129 
		} catch (PaymentException e) {
1130 
			logger.error("PaymentException" + e);
1131 
		}
1132 
	}
1133 
 
1134 
	private void outputRefundRows(Sheet sheet, long vendorId, PaymentSettlement paymentSettlement, Transaction txn, Payment payment)	{
1135 
		logger.info("Printing orders for pmt Id, " + payment.getPaymentId());
1136 
 
1137 
		boolean isFirstOrderForTransaction = true;
1138 
 
1139 
		for (Order order: txn.getOrders())	{
1140 
			if(order.getVendorId() == vendorId && refundOrderStatuses.contains(order.getStatus()))	{
1141 
		    	Row contentRow = sheet.createRow(rowCount ++);
1142 
		    	LineItem lineItem = order.getLineitems().get(0);
4734 varun.gupt 1143 
 
5020 varun.gupt 1144 
		        contentRow.createCell(OrderReportColumn.ORDER_ID.getValue()).setCellValue(order.getId());
1145 
		        contentRow.createCell(OrderReportColumn.ORDER_DATE.getValue()).setCellValue(DATE_FORMAT.format(new Date(order.getCreated_timestamp())));
1146 
			    contentRow.createCell(OrderReportColumn.BILLING_NUMBER.getValue()).setCellValue(order.getInvoice_number());
1147 
			    contentRow.createCell(OrderReportColumn.BILLING_DATE.getValue()).setCellValue(DATE_FORMAT.format(new Date(order.getBilling_timestamp())));
1148 
			    contentRow.createCell(OrderReportColumn.DELIVERY_DATE.getValue()).setCellValue(DATE_FORMAT.format(new Date(order.getDelivery_timestamp())));
1149 
			    contentRow.createCell(OrderReportColumn.BRAND.getValue()).setCellValue(getValueForEmptyString(lineItem.getBrand()));
1150 
			    contentRow.createCell(OrderReportColumn.MODEL_NAME.getValue()).setCellValue(getValueForEmptyString(lineItem.getModel_name()));
1151 
			    contentRow.createCell(OrderReportColumn.MODEL_NUMBER.getValue()).setCellValue(getValueForEmptyString(lineItem.getModel_number()));
1152 
			    contentRow.createCell(OrderReportColumn.COLOR.getValue()).setCellValue(getValueForEmptyString(lineItem.getColor()));
1153 
			    contentRow.createCell(OrderReportColumn.QUANTITY.getValue()).setCellValue(lineItem.getQuantity());
1154 
			    contentRow.createCell(OrderReportColumn.UNIT_TRANSFER_PRICE.getValue()).setCellValue(lineItem.getTransfer_price());
1155 
			    contentRow.createCell(OrderReportColumn.UNIT_SELLING_PRICE.getValue()).setCellValue(lineItem.getUnit_price());
1156 
			    contentRow.createCell(OrderReportColumn.TOTAL_TRANSFER_PRICE.getValue()).setCellValue(lineItem.getTransfer_price() * lineItem.getQuantity());
1157 
			    contentRow.createCell(OrderReportColumn.TOTAL_SELLING_PRICE.getValue()).setCellValue(lineItem.getTotal_price());
1158 
			    contentRow.createCell(OrderReportColumn.CURRENT_STATUS.getValue()).setCellValue(order.getStatusDescription());
1159 
		    	contentRow.createCell(OrderReportColumn.PAYMENT_TYPE.getValue()).setCellValue(paymentGateways.get(payment.getGatewayId()));
1160 
			    contentRow.createCell(OrderReportColumn.SETTLEMENT_DATE.getValue()).setCellValue(DATE_FORMAT.format(new Date(paymentSettlement.getSettlementDate())));
1161 
			    contentRow.createCell(OrderReportColumn.COUPON_CODE.getValue()).setCellValue(txn.getCoupon_code());
1162 
		    	contentRow.createCell(OrderReportColumn.PAYMENT_STATUS.getValue()).setCellValue(payment.getStatus().name());
1163 
		    	contentRow.createCell(OrderReportColumn.PAYMENT_ID.getValue()).setCellValue(payment.getPaymentId());
1164 
 
1165 
		    	if(isFirstOrderForTransaction)	{
1166 
			    	contentRow.createCell(OrderReportColumn.SERVICE_TAX.getValue()).setCellValue(paymentSettlement.getServiceTax());
1167 
				    contentRow.createCell(OrderReportColumn.OTHER_CHARGES.getValue()).setCellValue(paymentSettlement.getOtherCharges());
1168 
				    contentRow.createCell(OrderReportColumn.NET_COLLECTION.getValue()).setCellValue(paymentSettlement.getNetCollection());
1169 
				    isFirstOrderForTransaction = false;
1170 
		    	}
4715 varun.gupt 1171 
			}
5020 varun.gupt 1172 
		}
1173 
	}
5098 varun.gupt 1174 
 
5020 varun.gupt 1175 
	private void outputPrepaidTransactionRows(Sheet sheet, long vendorId, PaymentSettlement paymentSettlement, Transaction txn, Payment payment)	{
1176 
		logger.info("Printing orders for pmt Id, " + payment.getPaymentId());
1177 
 
1178 
		boolean isFirstOrderForTransaction = true;
1179 
 
1180 
		for (Order order: txn.getOrders())	{
1181 
			if(order.getVendorId() == vendorId)	{
1182 
		    	Row contentRow = sheet.createRow(rowCount ++);
1183 
		    	LineItem lineItem = order.getLineitems().get(0);
4734 varun.gupt 1184 
 
5020 varun.gupt 1185 
		        contentRow.createCell(OrderReportColumn.ORDER_ID.getValue()).setCellValue(order.getId());
1186 
		        contentRow.createCell(OrderReportColumn.ORDER_DATE.getValue()).setCellValue(DATE_FORMAT.format(new Date(order.getCreated_timestamp())));
1187 
			    contentRow.createCell(OrderReportColumn.BILLING_NUMBER.getValue()).setCellValue(order.getInvoice_number());
1188 
			    contentRow.createCell(OrderReportColumn.BILLING_DATE.getValue()).setCellValue(DATE_FORMAT.format(new Date(order.getBilling_timestamp())));
1189 
			    contentRow.createCell(OrderReportColumn.DELIVERY_DATE.getValue()).setCellValue(DATE_FORMAT.format(new Date(order.getDelivery_timestamp())));
1190 
			    contentRow.createCell(OrderReportColumn.BRAND.getValue()).setCellValue(getValueForEmptyString(lineItem.getBrand()));
1191 
			    contentRow.createCell(OrderReportColumn.MODEL_NAME.getValue()).setCellValue(getValueForEmptyString(lineItem.getModel_name()));
1192 
			    contentRow.createCell(OrderReportColumn.MODEL_NUMBER.getValue()).setCellValue(getValueForEmptyString(lineItem.getModel_number()));
1193 
			    contentRow.createCell(OrderReportColumn.COLOR.getValue()).setCellValue(getValueForEmptyString(lineItem.getColor()));
1194 
			    contentRow.createCell(OrderReportColumn.QUANTITY.getValue()).setCellValue(lineItem.getQuantity());
1195 
			    contentRow.createCell(OrderReportColumn.UNIT_TRANSFER_PRICE.getValue()).setCellValue(lineItem.getTransfer_price());
1196 
			    contentRow.createCell(OrderReportColumn.UNIT_SELLING_PRICE.getValue()).setCellValue(lineItem.getUnit_price());
1197 
			    contentRow.createCell(OrderReportColumn.TOTAL_TRANSFER_PRICE.getValue()).setCellValue(lineItem.getTransfer_price() * lineItem.getQuantity());
1198 
			    contentRow.createCell(OrderReportColumn.TOTAL_SELLING_PRICE.getValue()).setCellValue(lineItem.getTotal_price());
1199 
			    contentRow.createCell(OrderReportColumn.CURRENT_STATUS.getValue()).setCellValue(order.getStatusDescription());
1200 
		    	contentRow.createCell(OrderReportColumn.PAYMENT_TYPE.getValue()).setCellValue(paymentGateways.get(payment.getGatewayId()));
1201 
			    contentRow.createCell(OrderReportColumn.SETTLEMENT_DATE.getValue()).setCellValue(DATE_FORMAT.format(new Date(paymentSettlement.getSettlementDate())));
1202 
			    contentRow.createCell(OrderReportColumn.COUPON_CODE.getValue()).setCellValue(txn.getCoupon_code());
1203 
		    	contentRow.createCell(OrderReportColumn.PAYMENT_STATUS.getValue()).setCellValue(payment.getStatus().name());
1204 
		    	contentRow.createCell(OrderReportColumn.PAYMENT_ID.getValue()).setCellValue(payment.getPaymentId());
4715 varun.gupt 1205 
 
5020 varun.gupt 1206 
		    	if(isFirstOrderForTransaction)	{
1207 
			    	contentRow.createCell(OrderReportColumn.SERVICE_TAX.getValue()).setCellValue(paymentSettlement.getServiceTax());
1208 
				    contentRow.createCell(OrderReportColumn.OTHER_CHARGES.getValue()).setCellValue(paymentSettlement.getOtherCharges());
4715 varun.gupt 1209 
				    contentRow.createCell(OrderReportColumn.NET_COLLECTION.getValue()).setCellValue(paymentSettlement.getNetCollection());
5020 varun.gupt 1210 
				    isFirstOrderForTransaction = false;
4715 varun.gupt 1211 
		    	}
5020 varun.gupt 1212 
			}
4600 varun.gupt 1213 
		}
1214 
	}
1215 
 
5020 varun.gupt 1216 
	private void outputCODRow(Row contentRow, PaymentSettlement paymentSettlement, Order order, Transaction txn, Payment payment)	{
1217 
 
1218 
		LineItem lineItem = order.getLineitems().get(0);
1219 
 
1220 
        contentRow.createCell(OrderReportColumn.ORDER_ID.getValue()).setCellValue(order.getId());
1221 
        contentRow.createCell(OrderReportColumn.ORDER_DATE.getValue()).setCellValue(DATE_FORMAT.format(new Date(order.getCreated_timestamp())));
1222 
	    contentRow.createCell(OrderReportColumn.BILLING_NUMBER.getValue()).setCellValue(order.getInvoice_number());
1223 
	    contentRow.createCell(OrderReportColumn.BILLING_DATE.getValue()).setCellValue(DATE_FORMAT.format(new Date(order.getBilling_timestamp())));
1224 
	    contentRow.createCell(OrderReportColumn.DELIVERY_DATE.getValue()).setCellValue(DATE_FORMAT.format(new Date(order.getDelivery_timestamp())));
1225 
	    contentRow.createCell(OrderReportColumn.BRAND.getValue()).setCellValue(getValueForEmptyString(lineItem.getBrand()));
1226 
	    contentRow.createCell(OrderReportColumn.MODEL_NAME.getValue()).setCellValue(getValueForEmptyString(lineItem.getModel_name()));
1227 
	    contentRow.createCell(OrderReportColumn.MODEL_NUMBER.getValue()).setCellValue(getValueForEmptyString(lineItem.getModel_number()));
1228 
	    contentRow.createCell(OrderReportColumn.COLOR.getValue()).setCellValue(getValueForEmptyString(lineItem.getColor()));
1229 
	    contentRow.createCell(OrderReportColumn.QUANTITY.getValue()).setCellValue(lineItem.getQuantity());
1230 
	    contentRow.createCell(OrderReportColumn.UNIT_TRANSFER_PRICE.getValue()).setCellValue(lineItem.getTransfer_price());
1231 
	    contentRow.createCell(OrderReportColumn.UNIT_SELLING_PRICE.getValue()).setCellValue(lineItem.getUnit_price());
1232 
	    contentRow.createCell(OrderReportColumn.TOTAL_TRANSFER_PRICE.getValue()).setCellValue(lineItem.getTransfer_price() * lineItem.getQuantity());
1233 
	    contentRow.createCell(OrderReportColumn.TOTAL_SELLING_PRICE.getValue()).setCellValue(lineItem.getTotal_price());
1234 
	    contentRow.createCell(OrderReportColumn.CURRENT_STATUS.getValue()).setCellValue(order.getStatusDescription());
1235 
    	contentRow.createCell(OrderReportColumn.PAYMENT_TYPE.getValue()).setCellValue("COD - " + codProviders.get(order.getLogistics_provider_id()));
1236 
    	contentRow.createCell(OrderReportColumn.SERVICE_TAX.getValue()).setCellValue(paymentSettlement.getServiceTax());
1237 
	    contentRow.createCell(OrderReportColumn.OTHER_CHARGES.getValue()).setCellValue(paymentSettlement.getOtherCharges());
1238 
	    contentRow.createCell(OrderReportColumn.NET_COLLECTION.getValue()).setCellValue(paymentSettlement.getNetCollection());
1239 
	    contentRow.createCell(OrderReportColumn.SETTLEMENT_DATE.getValue()).setCellValue(DATE_FORMAT.format(new Date(paymentSettlement.getSettlementDate())));
1240 
	    contentRow.createCell(OrderReportColumn.COUPON_CODE.getValue()).setCellValue(txn.getCoupon_code());
1241 
    	contentRow.createCell(OrderReportColumn.PAYMENT_STATUS.getValue()).setCellValue(payment.getStatus().name());
1242 
    	contentRow.createCell(OrderReportColumn.PAYMENT_ID.getValue()).setCellValue(payment.getPaymentId());
1243 
	}
1244 
 
5098 varun.gupt 1245 
	private void initiatializeDashboard()	{
1246 
		try	{
1247 
			CatalogClient csc = new CatalogClient();
1248 
			Client catalogClient = csc.getClient();
1249 
			OrderStatusGroups orderStatusGroups = new OrderStatusGroups();
1250 
			refundOrderStatuses = orderStatusGroups.getRefundedOrders();
1251 
 
1252 
			vendors = catalogClient.getAllVendors();
1253 
			orderIdsWithoutSuccess = new ArrayList<Long>();
1254 
 
1255 
			TransactionClient tsc = new TransactionClient();
1256 
			in.shop2020.model.v1.order.TransactionService.Client transactionClient = tsc.getClient();
1257 
 
1258 
			ebsSettlementSummaries = transactionClient.getEBSSettlementSummaries();
1259 
			logger.info("", ebsSettlementSummaries);
1260 
 
1261 
		} catch (TException e) {
1262 
			logger.error("TException", e);
1263 
 
1264 
		} catch (TransactionServiceException e) {
1265 
			logger.error("TransactionServiceException", e);
1266 
		}
1267 
	}
1268 
 
4600 varun.gupt 1269 
	public List<Vendor> getAllVendors()	{
1270 
		return this.vendors;
1271 
	}
1272 
 
1273 
	private String getValueForEmptyString(String s){
1274 
		if(s==null || s.equals(""))
1275 
			return "-";
1276 
		else
1277 
			return s;
1278 
	}
1279 
 
1280 
	private String getVendorName(long vendorId)	{
1281 
		for (Vendor vendor: vendors)	{
1282 
			if (vendor.getId() == vendorId)	return vendor.getName();
1283 
		}
1284 
		return null;
1285 
	}
1286 
 
1287 
	public String getReportSource()	{
1288 
		return reportSource;
1289 
	}
1290 
 
1291 
	public void setReportSource(String reportSource)	{
1292 
		this.reportSource = reportSource;
1293 
	}
1294 
 
1295 
    public File getHdfcSettlementReport() {
1296 
        return hdfcSettlementReport;
1297 
    }
1298 
 
1299 
    public void setHdfcSettlementReport(File hdfcSettlementReport) {
1300 
        this.hdfcSettlementReport = hdfcSettlementReport;
1301 
    }
1302 
 
1303 
    public File getEbsSettlementSummary()	{
1304 
    	return ebsSettlementSummary;
1305 
    }
1306 
 
1307 
    public void setEbsSettlementSummary(File ebsSettlementSummary)	{
1308 
    	this.ebsSettlementSummary = ebsSettlementSummary;
1309 
    }
1310 
 
1311 
    public File getEbsSettlementReport()	{
1312 
    	return ebsSettlementReport;
1313 
    }
1314 
 
1315 
    public void setEbsSettlementReport(File ebsSettlementReport)	{
1316 
    	this.ebsSettlementReport = ebsSettlementReport;
1317 
    }
1318 
 
1319 
    public String getBluedartSettlementDate()	{
1320 
    	return bluedartSettlementDate;
1321 
    }
1322 
 
1323 
    public void setBluedartSettlementDate(String bluedartSettlementDate)	{
1324 
    	this.bluedartSettlementDate = bluedartSettlementDate;
1325 
    }
1326 
 
1327 
    public File getBluedartSettlementReport()	{
1328 
    	return bluedartSettlementReport;
1329 
    }
1330 
 
1331 
    public void setBluedartSettlementReport(File bluedartSettlementReport)	{
1332 
    	this.bluedartSettlementReport = bluedartSettlementReport;
1333 
    }
1334 
 
4715 varun.gupt 1335 
    public String getAramexSettlementDate()	{
1336 
    	return this.aramexSettlementDate;
1337 
    }
1338 
 
1339 
    public void setAramexSettlementDate(String aramexSettlementDate)	{
1340 
    	this.aramexSettlementDate = aramexSettlementDate;
1341 
    }
1342 
 
1343 
    public void setAramexSettlementReport(File aramexSettlementReport) {
1344 
		this.aramexSettlementReport = aramexSettlementReport;
1345 
	}
1346 
 
1347 
	public File getAramexSettlementReport() {
1348 
		return aramexSettlementReport;
1349 
	}
1350 
 
4600 varun.gupt 1351 
	@Override
4715 varun.gupt 1352 
     public void setServletContext(ServletContext context) {
4600 varun.gupt 1353 
        this.context = context;
1354 
    }
1355 
 
1356 
    public String getServletContextPath() {
1357 
        return context.getContextPath();
1358 
    }
1359 
 
1360 
	@Override
1361 
	public void setServletResponse(HttpServletResponse response) {
1362 
		this.response = response;
1363 
	}
1364 
 
1365 
	@Override
1366 
	public void setServletRequest(HttpServletRequest request) {
1367 
		this.request = request;
1368 
		this.session = request.getSession();
1369 
	}
1370 
 
1371 
	public Map<Long, String> getEBSSettlementSummaries()	{
1372 
		return ebsSettlementSummaries;
1373 
	}
5098 varun.gupt 1374 
 
1375 
	public void setOrderIdsToBeMarkedPaid(File orderIdsToBeMarkedPaid) {
1376 
		this.orderIdsToBeMarkedPaid = orderIdsToBeMarkedPaid;
1377 
	}
1378 
 
1379 
	public File getOrderIdsToBeMarkedPaid() {
1380 
		return orderIdsToBeMarkedPaid;
1381 
	}
4600 varun.gupt 1382 
}