Subversion Repositories SmartDukaan

package in.shop2020.inventory.controllers;

import in.shop2020.model.v1.order.Order;
import in.shop2020.thrift.clients.InventoryClient;
import in.shop2020.thrift.clients.TransactionClient;
import in.shop2020.thrift.clients.WarehouseClient;
import in.shop2020.warehouse.InventoryItem;
import in.shop2020.warehouse.WarehouseService.Client;

import java.io.BufferedInputStream;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileWriter;
import java.io.InputStream;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;

import javax.servlet.ServletOutputStream;

import org.apache.commons.lang.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
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;

public class PriceDropController extends BaseController {

        private static final DateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");

        private TransactionClient tsc;
        private in.shop2020.model.v1.order.TransactionService.Client tClient;

        private InventoryClient ic;
        private in.shop2020.model.v1.inventory.InventoryService.Client iClient;

        private WarehouseClient wc;
        private Client wClient;

        private static Log logger = LogFactory.getLog(PurchaseReportController.class);
        private String closingDate;
        private int itemId;

        private File imeiFile;
        private String imeiFileContentType;
        private String imeiFileFileName;
        private String affectedDate;

        private double priceDrop;

        public File getImeiFile() {
                return imeiFile;
        }

        public String getAffectedDate() {
                return affectedDate;
        }

        public void setAffectedDate(String affectedDate) {
                this.affectedDate = affectedDate;
        }

        public void setImeiFile(File imeiFile) {
                this.imeiFile = imeiFile;
        }

        public String getImeiFileContentType() {
                return imeiFileContentType;
        }

        public void setImeiFileContentType(String imeiFileContentType) {
                this.imeiFileContentType = imeiFileContentType;
        }

        public String getImeiFileFileName() {
                return imeiFileFileName;
        }

        public void setImeiFileFileName(String imeiFileFileName) {
                this.imeiFileFileName = imeiFileFileName;
        }

        public int getItemId() {
                return itemId;
        }

        public void setItemId(int itemId) {
                this.itemId = itemId;
        }


        public String index() {
                return INDEX;
        }

        public String downloadImeis() throws Exception {
                long closingDateLong;
                try {
                        closingDateLong = sdf.parse(this.closingDate).getTime();
                } catch (Exception e) {
                        this.addActionError("Invalid closing date");
                        return INDEX;
                }
                tsc = new TransactionClient();
                tClient = tsc.getClient();

                List<Order> inTransitOrders;

                inTransitOrders = tClient.getInTransitOrdersOnDateByItemId(closingDateLong, this.itemId);

                Set<Long> warehouseSet = new HashSet<Long>();
                for (Order o : inTransitOrders) {
                        warehouseSet.add(o.getFulfilmentWarehouseId());
                }

                ic = new InventoryClient();
                iClient = ic.getClient();

                Map<Long, String> warehouseNameMap = new HashMap<Long, String>();
                for (Long warehouseId : warehouseSet) {
                        warehouseNameMap.put(warehouseId, iClient.getWarehouseName(warehouseId));
                }

                byte[] buffer = null;
                File file = createFile(inTransitOrders, warehouseNameMap);
                buffer = new byte[(int) file.length()];
                InputStream input = null;
                try {
                        int totalBytesRead = 0;
                        input = new BufferedInputStream(new FileInputStream(file));
                        while (totalBytesRead < buffer.length) {
                                int bytesRemaining = buffer.length - totalBytesRead;
                                // input.read() returns -1, 0, or more :
                                int bytesRead = input.read(buffer, totalBytesRead, bytesRemaining);
                                if (bytesRead > 0) {
                                        totalBytesRead = totalBytesRead + bytesRead;
                                }
                        }
                        /*
                         * the above style is a bit tricky: it places bytes into the
                         * 'buffer' array; 'buffer' is an output parameter; the while loop
                         * usually has a single iteration only.
                         */
                } finally {
                        input.close();
                }

                response.setContentType("application/vnd.ms-excel");
                response.setHeader("Content-disposition", "inline; filename=" + file.getName());

                ServletOutputStream sos = response.getOutputStream();
                sos.write(buffer);
                sos.flush();

                return null;
        }

        private File createFile(List<Order> inTransitOrders, Map<Long, String> warehouseNameMap) {
                try {
                        String tmpDir = System.getProperty("java.io.tmpdir");
                        File file = new File(tmpDir + "/IntransitIMEIS-" + this.closingDate + this.itemId + ".xls");
                        BufferedWriter bufferedWriter = new BufferedWriter(new FileWriter(file));
                        bufferedWriter.write(StringUtils.join(new String[] { "Order Id", "Vendor Name", "Brand", "ModelName", "ModelNumber", "Color",
                                        "UnitPrice", "IMEI" }, '\t'));

                        for (Order order : inTransitOrders) {
                                bufferedWriter.newLine();
                                in.shop2020.model.v1.order.LineItem lineitem = order.getLineitems().get(0);
                                for (String serialNumber : lineitem.getSerial_number().split(",")) {
                                        bufferedWriter.write(StringUtils.join(
                                                        new String[] { String.valueOf(order.getId()), warehouseNameMap.get(order.getFulfilmentWarehouseId()),
                                                                        lineitem.getBrand(), lineitem.getModel_name(), lineitem.getModel_number(), lineitem.getColor(),
                                                                        String.valueOf(lineitem.getUnit_price()), serialNumber, order.getStatusDescription() }, '\t'));
                                }
                        }

                        bufferedWriter.close();
                        return file;
                } catch (Exception e) {
                        return null;
                }
        }

        public String uploadImeis() throws Exception {
                long affectedDateLong;
                try {
                        affectedDateLong = sdf.parse(this.affectedDate).getTime();
                } catch (Exception e) {
                        e.printStackTrace();
                        this.addActionError("Invalid Affected Date");
                        return INDEX;
                }
                FileInputStream inputStream = new FileInputStream(this.imeiFile);

                Workbook workbook = new HSSFWorkbook(inputStream);
                Sheet firstSheet = workbook.getSheetAt(0);
                
                Iterator<Row> iterator = firstSheet.iterator();
                Set<String> imeisSet = new HashSet<String>();
                // Ignore first row as it is header
                if (iterator.hasNext()) {
                        iterator.next();
                }
                while (iterator.hasNext()) {
                        Row nextRow = iterator.next();
                        // logger.info("IMEIs " + nextRow.getCell(0).getStringCellValue());
                        String imei = String.valueOf((long)(nextRow.getCell(0).getNumericCellValue()));
                        if (imei.length() < 15) {
                                addActionError("IMEI size should be of 15 digit - " + imei);
                                return INDEX;
                        }
                        imeisSet.add(imei);
                }
                // Check if all imeis belong to specified item
                wc = new WarehouseClient();
                wClient = wc.getClient();
                List<String> imeisList= new ArrayList<String>(imeisSet);
                if (imeisSet.size() > 0) {
                        List<InventoryItem> inventoryItems = wClient.getInventoryItemsBySerailNumbers(imeisList);
                        Map<String, InventoryItem> inventoryItemMap = new HashMap<String, InventoryItem>();
                        
                        for(InventoryItem inventoryItem : inventoryItems) {
                                inventoryItemMap.put(inventoryItem.getSerialNumber(), inventoryItem);
                        }
                        if(inventoryItems.size() != imeisSet.size()) {
                                addActionError("Few IMEIs are missing");
                                for (String imei : imeisSet) {
                                        if(!inventoryItemMap.containsKey(imei)) {
                                                addActionError(imei);
                                        }
                                        return INDEX;
                                }
                        }
                        for (InventoryItem inventoryItem : inventoryItems) {
                                if (inventoryItem.getItemId() != this.getItemId()) {
                                        addActionError("IMEI " + inventoryItem.getSerialNumber() + " belongs to other item - " + inventoryItem.getItemId());
                                        return INDEX;
                                }
                        }
                        
                        tsc = new TransactionClient();
                        tClient = tsc.getClient();
                        tClient.addPriceDrop(itemId, imeisList, this.priceDrop, affectedDateLong);
                        addActionMessage("Items Added Successfully");
                        
                } else {
                        addActionError("Serial numbers should not be empty");
                }
                
                
                
                return INDEX;
        }

        public void setClosingDate(String closingDate) {
                this.closingDate = closingDate;
        }

        public String getClosingDate() {
                return closingDate;
        }


        public void setPriceDrop(double priceDrop) {
                this.priceDrop = priceDrop;
        }

        public double getPriceDrop() {
                return priceDrop;
        }
        
        
}