Subversion Repositories SmartDukaan

package in.shop2020.inventory.controllers;

import in.shop2020.model.v1.catalog.Item;

import in.shop2020.model.v1.inventory.InventoryService;

import in.shop2020.model.v1.inventory.InventoryType;

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.Invoice;

import in.shop2020.purchase.PurchaseOrder;

import in.shop2020.purchase.PurchaseServiceException;

import in.shop2020.thrift.clients.CatalogClient;

import in.shop2020.thrift.clients.HelperClient;

import in.shop2020.thrift.clients.InventoryClient;

import in.shop2020.thrift.clients.PurchaseClient;

import in.shop2020.thrift.clients.WarehouseClient;

import in.shop2020.utils.HelperService;

import in.shop2020.utils.ModelUtils;

import in.shop2020.warehouse.InventoryItem;

import in.shop2020.warehouse.ScanType;

import in.shop2020.warehouse.WarehouseService;

import in.shop2020.warehouse.WarehouseService.Client;

import in.shop2020.warehouse.WarehouseServiceException;

import java.util.ArrayList;

import java.util.Calendar;

import java.util.Date;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import javax.servlet.ServletContext;

import org.apache.commons.lang.StringUtils;

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

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

import org.apache.thrift.TException;

import org.apache.thrift.transport.TTransportException;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

@SuppressWarnings("serial")

@Results({ @Result(name = "redirect", type = "redirectAction", params = {

        "actionName", "warehouse" }) })

public class PurchaseController extends BaseController {

    /**

     * 

     */

    private static final int NUM_BULK__SCAN_ITEMS = 10;

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

    public static enum ScanRecordType { VALID, BLANK };

    private ServletContext context;

    private String id;

    private Long transferLotId;

    private String itemId;

    private String itemNo;

    private String errorMsg = "";

    private List<Item> items;

    private List<LineItem> lineItems;

    private List<Invoice> invoices;

    private String invoiceNumber;

    private Double freightCharges ;

    private Long poId;

    private String purchaseOrderId;

    private Long warehouseId;

    private Long transferWarehouseId;

    private Warehouse warehouse;

    public String editNew() {

        purchaseOrderId = request.getParameter("poId");

        try {

            in.shop2020.purchase.PurchaseService.Client purchaseClient = new PurchaseClient().getClient();

            //invoices = purchaseClient.getInvoices(getPreviousDay(getPreviousDay(new Date())).getTime());

            PurchaseOrder po = purchaseClient.getPurchaseOrder(Long.parseLong(purchaseOrderId));

            invoices = purchaseClient.getInvoicesForWarehouse(po.getWarehouseId(), po.getSupplierId(), getPreviousDay(getPreviousDay(new Date())).getTime());

        } catch (Exception e) {

            logger.error("Error loading invoices", e);

        }

        return "new";

    }

    private Date getPreviousDay(Date date) {

        Calendar calendar = Calendar.getInstance();

        calendar.setTime(date);

        calendar.add(Calendar.DAY_OF_MONTH, -1);

        return calendar.getTime();

    }

    public String create() {

    	this.purchaseOrderId = request.getParameter("poId");

        poId = Long.parseLong(purchaseOrderId);

        invoiceNumber = request.getParameter("invoiceNo");

        String fc = request.getParameter("freightCharges").trim();

        freightCharges = 0D;

        id = "0";

        if (fc != null && !fc.isEmpty())

            freightCharges = Double.parseDouble(fc);

        return show();

        //return "create";

    }

    public String show() {

        resetLineItems();

        setItemsFromPO();

        return SHOW;

    }

    private void resetLineItems() {

        lineItems = new ArrayList<LineItem>();

        for (int i = 0; i < NUM_BULK__SCAN_ITEMS; 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 boolean createPurchase(){

        try {

        	logger.info("poId="+poId+" invoiceNumber="+invoiceNumber+" freightCharges="+freightCharges);

            PurchaseClient purchaseClient = new PurchaseClient();

            in.shop2020.purchase.PurchaseService.Client client = purchaseClient

                    .getClient();

            id = "" + client.startPurchase(poId, invoiceNumber, freightCharges);

            logger.info("id = "+id);

        } catch (TTransportException e) {

            errorMsg = "Error while establishing connection to the warehouse server";

            logger.error(errorMsg, e);

        } catch (TException e) {

            errorMsg = "Error while scanning in the item";

            logger.error(errorMsg, e);

        } catch (PurchaseServiceException e) {

            errorMsg = e.getMessage();

            logger.error(errorMsg, e);

        }

        if (errorMsg.isEmpty())

            return true;

        else {

            addActionError(errorMsg);

            return false;

        }

    }

    public String update() {

        setItemsFromPO();

        try {

            if (!areValidScans()) {

                return SHOW;

            }

            if(id == null || Long.parseLong(id)==0) {

	            if(!createPurchase()) {

	        		return "new";

	        	}

            }

            WarehouseClient warehouseClient = new WarehouseClient();

            Client client = warehouseClient.getClient();

            in.shop2020.purchase.PurchaseService.Client purchaseClient = new PurchaseClient().getClient();

            PurchaseOrder po = purchaseClient.getPurchaseOrder(poId);

            if(transferLotId==null || transferLotId==0) {

	            if(transferWarehouseId!=null && transferWarehouseId!=0) {

	            	InventoryService.Client inventoryClient = new InventoryClient().getClient();

	                Warehouse fulfilmentWarehouse = inventoryClient.getWarehouses(WarehouseType.OURS, InventoryType.GOOD, po.getSupplierId(), po.getWarehouseId(), 0L).get(0);

	            	transferLotId = client.createTransferLot(po.getWarehouseId(), transferWarehouseId);

	            }

            }

            for (LineItem lineItem : lineItems) {

                if (ScanRecordType.BLANK.name().equals(lineItem.getExtra_info())) {

                    continue;

                }

                InventoryItem inventoryItem = new InventoryItem();

                inventoryItem.setItemId(lineItem.getItem_id());

                inventoryItem.setPurchaseId(Long.parseLong(id));

                inventoryItem.setCurrentQuantity(new Double(lineItem.getQuantity()).longValue());

                inventoryItem.setItemNumber(lineItem.getItem_number());

                inventoryItem.setSerialNumber(lineItem.getSerial_number());

                inventoryItem.setInitialQuantity(new Double(lineItem.getQuantity()).longValue());

                inventoryItem.setPhysicalWarehouseId(po.getWarehouseId());

            	client.scan(inventoryItem, ScanType.PURCHASE, new Double(lineItem.getQuantity()).longValue(), warehouseId, (transferLotId!=null)?transferLotId:0L);

            }

            resetLineItems();

        } catch (TTransportException e) {

            errorMsg = "Error while establishing connection to the warehouse server";

            logger.error(errorMsg, e);

        } catch (WarehouseServiceException e) {

            errorMsg = e.getMessage();

            logger.error(errorMsg, e);

        } catch (TException e) {

            errorMsg = "Error while scanning in the item";

            logger.error(errorMsg, e);

        } catch (PurchaseServiceException e) {

            errorMsg = "Error while creating the purchase";

            logger.error(errorMsg, e);

        }

        if (!errorMsg.isEmpty()) {

            addActionError(errorMsg);

        }

        return SHOW;

    }

    /**

     * @return

     * @throws TException 

     * @throws NumberFormatException 

     * @throws PurchaseServiceException 

     */

    private boolean areValidScans() throws NumberFormatException, TException, PurchaseServiceException {

        boolean areValidScans = true;

        in.shop2020.purchase.PurchaseService.Client purchaseClient = new PurchaseClient().getClient();

        //PurchaseOrder purchaseOrder = purchaseClient.getPurchaseOrderForPurchase(Long.parseLong(id));

        PurchaseOrder purchaseOrder = purchaseClient.getPurchaseOrder(poId);

        Map<Long, Long> itemsQuantityMapFromPO = new HashMap<Long, Long>();

        for (in.shop2020.purchase.LineItem lineItem : purchaseOrder.getLineitems()) {

            itemsQuantityMapFromPO.put(lineItem.getItemId(), (long) lineItem.getUnfulfilledQuantity());

        }

        Client warehouseClient = new WarehouseClient().getClient();

        for (LineItem lineItem : lineItems) {

            if (lineItem.getItem_id() == -1 && lineItem.getItem_number().isEmpty() && lineItem.getSerial_number().isEmpty()) {

                lineItem.setExtra_info(ScanRecordType.BLANK.name());

            }

            else {

                lineItem.setExtra_info(ScanRecordType.VALID.name());

                if (StringUtils.isNotBlank(lineItem.getSerial_number())) {

                    try {

                    	InventoryItem inventoryItem = warehouseClient.getInventoryItem(lineItem.getSerial_number());

                        if(inventoryItem.getLastScanType()!=ScanType.PURCHASE_RETURN) {

	                       lineItem.setExtra_info("Item scanned already.");

	                       areValidScans = false;

	                       continue;

                        }

                    } catch (Exception e) {

                    }

                }

                if (lineItem.getItem_id() == -1 && 

                        (StringUtils.isBlank(lineItem.getItem_number()) || 

                         StringUtils.isBlank(lineItem.getSerial_number())))

                {

                    lineItem.setExtra_info("Item not selected/Item or serial number not present");

                    areValidScans = false;

                    continue;

                }

                if (StringUtils.isBlank(lineItem.getItem_number())) {

                	lineItem.setExtra_info("Item number not entered");

                	areValidScans = false;

                	continue;

                }

                if (lineItem.getItem_id() == -1) {

                    List<Long> itemIds = warehouseClient.getItemIds(lineItem.getItem_number());

                    if (itemIds.isEmpty()) {

                        lineItem.setExtra_info("Unknown item number");

                        areValidScans = false;

                        continue;

                    }

                    if (itemIds.size() > 0) {

                        int numItemsInPO = 0;

                        for (long itemId : itemIds) {

                            if (itemsQuantityMapFromPO.containsKey(itemId)) {

                                numItemsInPO++;

                                lineItem.setItem_id(itemId);

                            }

                        }

                        if (numItemsInPO > 1) {

                            lineItem.setExtra_info("Multiple items found for given item Number. Choose item explicitly.");

                            areValidScans = false;

                            continue;

                        }

                    }

                }

                if (!itemsQuantityMapFromPO.containsKey(lineItem.getItem_id())) {

                    lineItem.setExtra_info("Item not present in PO.");

                    areValidScans = false;

                    continue;

                }

                itemsQuantityMapFromPO.put(lineItem.getItem_id(),

                        itemsQuantityMapFromPO.get(lineItem.getItem_id()) - new Double(lineItem.getQuantity()).longValue());

                if (itemsQuantityMapFromPO.get(lineItem.getItem_id()) < 0) {

                    lineItem.setExtra_info("Item already fulfilled in PO.");

                    areValidScans = false;

                    continue;

                }

            }

        }

        return areValidScans;

    }

    private void setItemsFromPO() {

        try {

            items = new ArrayList<Item>();

            in.shop2020.purchase.PurchaseService.Client purchaseClient = new PurchaseClient().getClient();

            //PurchaseOrder purchaseOrder = purchaseClient.getPurchaseOrderForPurchase(id);

            PurchaseOrder purchaseOrder = purchaseClient.getPurchaseOrder(poId);

            warehouseId = purchaseOrder.getWarehouseId();

            in.shop2020.model.v1.catalog.CatalogService.Client catalogClient = new CatalogClient().getClient();

            for (in.shop2020.purchase.LineItem lineItem : purchaseOrder.getLineitems()) {

                items.add(catalogClient.getItem(lineItem.getItemId()));

            }

            in.shop2020.model.v1.inventory.InventoryService.Client inventoryClient = new InventoryClient().getClient();

            warehouse = inventoryClient.getWarehouses(WarehouseType.OURS, InventoryType.GOOD, purchaseOrder.getSupplierId(), warehouseId, warehouseId).get(0);

        } catch (Exception e) {

            logger.error("Could not find items in PO with purchase: " + id, e);

        }

    }

    public String destroy() {

        long id = Long.parseLong(this.id);

        try {

            PurchaseClient warehouseClient = new PurchaseClient();

            in.shop2020.purchase.PurchaseService.Client client = warehouseClient

                    .getClient();

            client.closePurchase(id);

        } catch (TTransportException e) {

            errorMsg = "Error while establishing connection to the warehouse server";

            logger.error(errorMsg, e);

        } catch (TException e) {

            errorMsg = "Error while scanning in the item";

            logger.error(errorMsg, e);

        } catch (PurchaseServiceException e) {

            errorMsg = e.getMessage();

            logger.error(errorMsg, e);

        }

        return "redirect";

    }

    public String createItemNumberMapping() {

        long itemIdLong = Long.parseLong(itemId);

        try {

            Client warehouseClient = new WarehouseClient().getClient();

            warehouseClient.createItemNumberMapping(itemNo, itemIdLong);

        } catch (TTransportException e) {

            logger.error("Could not create thrift client", e);

        } catch (TException e) {

            logger.error("Could not create item number mapping", e);

        }

        return show();

    }

    /*public String setTransferItemsOption() {

    	boolean isTransferAllowed = false;

    	try {

			Client warehouseClient = new WarehouseClient().getClient();

	        isTransferAllowed = warehouseClient.isItemTransferAllowed(warehouseId, transferWarehouseId);

    	} catch (TTransportException e) {

            logger.error("Could not create thrift client", e);

        } catch (TException e) {

            logger.error("Could not check if item transfer allowed between warehouses", e);

        }//TODO

    	return "";

    }*/

    public List<Warehouse> getAllowedDestinationWarehousesForTransfer(long originWarehouseId){

    	try {

    		WarehouseService.Client warehouseClient = new WarehouseClient().getClient();

    		List<Long> allowedWarehouseIds = warehouseClient.getAllowedDestinationWarehousesForTransfer(originWarehouseId);

    		List<Warehouse> allowedWarehouses = new ArrayList<Warehouse>();

    		InventoryService.Client inventoryClient = new InventoryClient().getClient();

    		for(Long allowedWarehouseId : allowedWarehouseIds) {

    			allowedWarehouses.add(inventoryClient.getWarehouse(allowedWarehouseId));

    		}

    		return allowedWarehouses;

    	} catch(Exception e) {

    		logger.error("Error while getting all destination warehouses for warehouseId " + warehouseId, e);

    		return new ArrayList<Warehouse>();

    	}

    }

    public String itemNumberMappingEditNew() {

        return "item-number-mapping";

    }

    public String getName(Item item){

        return ModelUtils.extractProductNameFromItem(item);

    }

    public void setId(String id) {

        this.id = id;

    }

    public String getId() {

        return id;

    }

    public String getErrorMessage() {

        return errorMsg;

    }

    public String getPurchaseOrderId() {

        return purchaseOrderId;

    }

    public String getServletContextPath() {

        return context.getContextPath();

    }

    public String getItemId() {

        return itemId;

    }

    public void setItemId(String itemId) {

        this.itemId = itemId;

    }

    public String getItemNo() {

        return itemNo;

    }

    public void setItemNo(String itemNo) {

        this.itemNo = itemNo;

    }

    public List<Item> getItems() {

        return items;

    }

    public void setItems(List<Item> items) {

        this.items = items;

    }

    public List<LineItem> getLineItems() {

        return lineItems;

    }

    public void setLineItems(List<LineItem> lineItems) {

        this.lineItems = lineItems;

    }

    public Warehouse getWarehouse() {

        return warehouse;

    }

    public List<Invoice> getInvoices() {

        return invoices;

    }

    public void setInvoices(List<Invoice> invoices) {

        this.invoices = invoices;

    }

	public String getInvoiceNumber() {

		return invoiceNumber;

	}

	public void setInvoiceNumber(String invoiceNumber) {

		this.invoiceNumber = invoiceNumber;

	}

	public Double getFreightCharges() {

		return freightCharges;

	}

	public void setFreightCharges(Double freightCharges) {

		this.freightCharges = freightCharges;

	}

	public Long getPoId() {

		return poId;

	}

	public void setPoId(Long poId) {

		this.poId = poId;

	}

	public Long getWarehouseId() {

		return warehouseId;

	}

	public void setWarehouseId(Long warehouseId) {

		this.warehouseId = warehouseId;

	}

	public Long getTransferWarehouseId() {

		return transferWarehouseId;

	}

	public void setTransferWarehouseId(Long transferWarehouseId) {

		this.transferWarehouseId = transferWarehouseId;

	}

}