Subversion Repositories SmartDukaan

package in.shop2020.inventory.controllers;

import in.shop2020.inventory.controllers.PurchaseController.ScanRecordType;
import in.shop2020.model.v1.catalog.CatalogService;
import in.shop2020.model.v1.catalog.CatalogServiceException;
import in.shop2020.model.v1.catalog.Item;
import in.shop2020.model.v1.catalog.ItemType;
import in.shop2020.model.v1.inventory.InventoryServiceException;
import in.shop2020.model.v1.inventory.Vendor;
import in.shop2020.model.v1.inventory.InventoryService.Client;
import in.shop2020.model.v1.inventory.Warehouse;
import in.shop2020.model.v1.inventory.WarehouseType;
import in.shop2020.model.v1.order.LineItem;
import in.shop2020.purchase.PurchaseReturn;
import in.shop2020.purchase.PurchaseServiceException;
import in.shop2020.thrift.clients.CatalogClient;
import in.shop2020.thrift.clients.InventoryClient;
import in.shop2020.thrift.clients.PurchaseClient;
import in.shop2020.thrift.clients.WarehouseClient;
import in.shop2020.warehouse.InventoryItem;
import in.shop2020.warehouse.Scan;
import in.shop2020.warehouse.ScanType;
import in.shop2020.warehouse.TransferLot;
import in.shop2020.warehouse.WarehouseService;
import in.shop2020.warehouse.WarehouseServiceException;

import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.ArrayList;

import org.apache.thrift.TException;
import org.apache.thrift.transport.TTransportException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class TransferLotController extends BaseController{

        /**
         * 
         */
        private static final long serialVersionUID = 3052114881399915348L;
        
        private Long id;
        private TransferLot transferLot;
        private List<TransferLot>transferLots;
        private String remoteTransferRefNumber;
        private String fromDate;
        private String toDate;
        private String errorMessage = "";
        private Calendar transferLotFromDate;
        private Calendar transferLotToDate;
        private Long originWarehouseId;
        private List<LineItem> lineItems;
        private Long destinationWarehouseId;
        
        private String output;
        private static Map<Long, Warehouse> warehouseMap;
        
        private static SimpleDateFormat formatter = new SimpleDateFormat("yyyy-MM-dd");
        
    private static Logger logger = LoggerFactory.getLogger(TransferLotController.class);
        
    static {
                warehouseMap = new HashMap<Long, Warehouse>();
                InventoryClient inventoryServiceClient;
                try {
                        inventoryServiceClient = new InventoryClient();
                Client inventoryClient = inventoryServiceClient.getClient();
                List<Warehouse> warehouses;
                        warehouses = inventoryClient.getAllWarehouses(true);
                for(Warehouse warehouse : warehouses){
                        warehouseMap.put(warehouse.getId(), warehouse);
                }
                } catch (TTransportException e) {
                        logger.error("Error in populating warehouse map", e);
                } catch (TException e) {
                        logger.error("Error in populating warehouse map", e);
                } catch (InventoryServiceException isex) {
                        logger.error("Error in populating warehouse map", isex);
                }
        }
    
        public String index(){
                if(warehouseMap==null||warehouseMap.size()<1){
        //TODO          fetchWarehouseMap();
                }
                try{
                        WarehouseService.Client warehouseClient = new WarehouseClient().getClient();
                        transferLotFromDate = Calendar.getInstance();
                        transferLotToDate = Calendar.getInstance();
                        if(fromDate==null) {
                                transferLotFromDate.add(Calendar.MONTH, -1);
                        } else {
                                transferLotFromDate.setTime(formatter.parse(fromDate));
                                if(toDate!=null) {
                                        transferLotToDate.setTime(formatter.parse(toDate));
                                }
                        }
                        transferLots = warehouseClient.getTransferLotsByDate(transferLotFromDate.getTimeInMillis(), transferLotToDate.getTimeInMillis());
                } catch(TException e){
                        logger.error("Error in getting transfer lots", e);
                } catch(ParseException pex) {
                        logger.error("Error in parsing time", pex);
                } catch(WarehouseServiceException wsex) {
                        logger.error("Error in getting transfer lots", wsex);
                }
                return INDEX;
        }
        
    public String create() {
        originWarehouseId = Long.parseLong(request.getParameter("originWarehouseId"));
        destinationWarehouseId = Long.parseLong(request.getParameter("destinationWarehouseId"));
        try {
                WarehouseService.Client warehouseClient = new WarehouseClient().getClient();
                id = warehouseClient.createTransferLot(originWarehouseId, destinationWarehouseId);
        } catch (TException tex) {
                logger.error("Error in creating transferlot between warehouseId " + originWarehouseId + " and " + destinationWarehouseId, tex);
                errorMessage = "Error in creating transferlot between warehouseId " + originWarehouseId + " and " + destinationWarehouseId;
        } catch (WarehouseServiceException wex) {
                logger.error("Error in creating transferlot between warehouseId " + originWarehouseId + " and " + destinationWarehouseId, wex);
                errorMessage = "Error in creating transferlot between warehouseId " + originWarehouseId + " and " + destinationWarehouseId;
        }
        return show();
    }

        public String show(){
                resetLineItems();
                return SHOW;
        }
        public String update() {
                try {
                        if(!areValidScans()){
                                errorMessage = "Invalid Scans";
                                return show();
                        }
                        if(id == null || id==0) {
                    //if(!createPurchase()) {
                        errorMessage = "No transferLot-Id selected for Transfer";
                                return "new";
                        //}
                }
                        List<InventoryItem> inventoryItems = new ArrayList<InventoryItem>();
                        CatalogService.Client catalogClient = new CatalogClient().getClient();
                        for (LineItem lineItem : lineItems) {
                if (lineItem.getItem_id() == 0) {
                    continue;
                }
                InventoryItem inventoryItem = new InventoryItem();
                inventoryItem.setItemId(lineItem.getItem_id());
                inventoryItem.setCurrentQuantity(new Double(lineItem.getQuantity()).longValue());
                inventoryItem.setItemNumber(lineItem.getItem_number());
                if(catalogClient.getItem(lineItem.getItem_id()).getType()==ItemType.SERIALIZED) {
                        inventoryItem.setSerialNumber(lineItem.getSerial_number());
                }
                inventoryItems.add(inventoryItem);
            }
                        WarehouseService.Client warehouseClient = new WarehouseClient().getClient();
                        warehouseClient.scanForTransfer(inventoryItems, ScanType.WAREHOUSE_TRANSFER_OUT, id);
                } catch (TTransportException e) {
            errorMessage = "Error while establishing connection to the warehouse server";
            logger.error(errorMessage, e);
        } catch (WarehouseServiceException e) {
                errorMessage = e.getMessage();
            logger.error(errorMessage, e);
        } catch (TException e) {
                errorMessage = "Error while scanning in the item";
            logger.error(errorMessage, e);
        } catch (CatalogServiceException csex) {
                errorMessage = "Error while getting the serialized details of item";
            logger.error(errorMessage, csex);
        }
        return show();
        }
        
        public String editNew(){
                return "new";
        }
        
        private boolean areValidScans() throws NumberFormatException, TException {
        boolean areValidScans = true;
        return areValidScans;
        }
        
        private void resetLineItems() {
        lineItems = new ArrayList<LineItem>();

        for (int i = 0; i < 11; i++) {
            LineItem lineItem = new LineItem();
            lineItem.setId(i);
            lineItem.setExtra_info("");
            lineItem.setSerial_number("");
            lineItem.setItem_number("");
            lineItem.setQuantity(1);
            lineItem.setItem_id(-1);
            lineItems.add(lineItem);
        }
    }
        
        public String getTransferLotItems() {
                try {
                        WarehouseService.Client warehouseClient = new WarehouseClient().getClient();
                        Map<Long, Long> transferLotItems = warehouseClient.getItemsInTransferLot(id);
                        CatalogService.Client catalogClient = new CatalogClient().getClient();
                        String transferLotItemDiv = "<div id = 'transfer-lot-item-list-div' align='center'><table id = 'transfer-lot-item-list-table'><tr><th>Item</th><th>Quantity</th></tr>";
                        for(Long itemId : transferLotItems.keySet()){
                                Item item = catalogClient.getItem(itemId);
                                transferLotItemDiv = transferLotItemDiv + "<tr><td>" + item.getBrand() + " " + item.getModelName() + " " + item.getModelNumber() + " " + item.getColor();
                                transferLotItemDiv = transferLotItemDiv  + "</td><td>" + transferLotItems.get(itemId) +"</td></tr>";
                        }
                        transferLotItemDiv = transferLotItemDiv + "</table></div>";
                        setOutput(transferLotItemDiv);
                } catch (TException tex) {
                        logger.error("Error in marking transfer lot as received",tex);
                } catch (CatalogServiceException csex) {
                        logger.error("Error in marking transfer lot as received",csex);
                }
                return OUTPUT;
        }

        public String markTransferLotAsReceived() throws Exception {
                try{
                        WarehouseService.Client warehouseClient = new WarehouseClient().getClient();
                        warehouseClient.markItemsAsReceivedForTransferLot(id);
                        warehouseClient.markTransferLotAsReceived(id, remoteTransferRefNumber);
                } catch(TException e){
                        logger.error("Error in marking transfer lot as received",e);
                        throw new Exception("Error in marking transfer lot as received");
                } catch(WarehouseServiceException wsex) {
                        logger.error("Error in marking transfer lot as received",wsex);
                        throw new Exception("Error in marking transfer lot as received");
                }
                return INDEX;
        }
        
        public String getWarehouseName(Long warehouseId){
                return warehouseMap.get(warehouseId).getDisplayName();
        }
        
        public boolean isTransferReceivable(TransferLot transferLot) {
                if(warehouseMap.get(transferLot.getDestinationWarehouseId()).getWarehouseType()==WarehouseType.OURS_THIRDPARTY||
                                warehouseMap.get(transferLot.getDestinationWarehouseId()).getWarehouseType()==WarehouseType.THIRD_PARTY) {
                        return false;
                } else {
                        return true;
                }
        }
        
        
        
        
        public String getDateTime(long milliseconds) {
        Calendar cal = Calendar.getInstance();
        cal.setTimeInMillis(milliseconds);
        return formatter.format(cal.getTime());
    }
        
        public static void setWarehouseMap(Map<Long, Warehouse> warehouseMap) {
                TransferLotController.warehouseMap = warehouseMap;
        }

        public TransferLot getTransferLot() {
                return transferLot;
        }

        public void setTransferLot(TransferLot transferLot) {
                this.transferLot = transferLot;
        }

        public List<TransferLot> getTransferLots() {
                return transferLots;
        }

        public void setTransferLots(List<TransferLot> transferLots) {
                this.transferLots = transferLots;
        }

        public String getRemoteTransferRefNumber() {
                return remoteTransferRefNumber;
        }

        public void setRemoteTransferRefNumber(String remoteTransferRefNumber) {
                this.remoteTransferRefNumber = remoteTransferRefNumber;
        }

        public Long getId() {
                return id;
        }

        public void setId(Long id) {
                this.id = id;
        }

        public String getOutput() {
                return output;
        }

        public void setOutput(String output) {
                this.output = output;
        }

        public Long getOriginWarehouseId() {
                return originWarehouseId;
        }

        public void setOriginWarehouseId(Long originWarehouseId) {
                this.originWarehouseId = originWarehouseId;
        }

        public Long getDestinationWarehouseId() {
                return destinationWarehouseId;
        }

        public void setDestinationWarehouseId(Long destinationWarehouseId) {
                this.destinationWarehouseId = destinationWarehouseId;
        }

        public String getErrorMessage() {
                return errorMessage;
        }

        public void setErrorMsg(String errorMessage) {
                this.errorMessage = errorMessage;
        }

        public List<LineItem> getLineItems() {
                return lineItems;
        }

        public void setLineItems(List<LineItem> lineItems) {
                this.lineItems = lineItems;
        }
        
        
        
}