Subversion Repositories SmartDukaan

package in.shop2020.support.controllers;

import in.shop2020.model.v1.catalog.CatalogService;
import in.shop2020.model.v1.catalog.EbayItem;
import in.shop2020.model.v1.catalog.Item;
import in.shop2020.model.v1.inventory.HoldInventoryDetail;
import in.shop2020.model.v1.inventory.InventoryService;
import in.shop2020.model.v1.inventory.InventoryType;
import in.shop2020.model.v1.inventory.ItemInventory;
import in.shop2020.model.v1.inventory.Warehouse;
import in.shop2020.model.v1.order.OrderSource;
import in.shop2020.support.utils.ReportsUtils;
import in.shop2020.thrift.clients.CatalogClient;
import in.shop2020.thrift.clients.InventoryClient;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

import org.apache.commons.io.FileUtils;
import org.apache.poi.hssf.usermodel.HSSFWorkbook;
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.struts2.convention.annotation.InterceptorRef;
import org.apache.struts2.convention.annotation.InterceptorRefs;
import org.apache.struts2.convention.annotation.Result;
import org.apache.struts2.convention.annotation.Results;
import org.apache.struts2.interceptor.ServletRequestAware;
import org.apache.thrift.transport.TTransportException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.opensymphony.xwork2.ActionSupport;

@SuppressWarnings("serial")
@InterceptorRefs({
    @InterceptorRef("defaultStack"),
    @InterceptorRef("login")
})
@Results({
    @Result(name="authfail", type="redirectAction", params = {"actionName" , "reports"})
})
public class HoldInventoryController extends ActionSupport implements ServletRequestAware {
        
        public class ItemStockDetail {
                private long itemId;
                private long available;
                private long reserved;
                private long held;

                public ItemStockDetail(long itemId, long available, long reserved,
                                long held) {
                        this.itemId = itemId;
                        this.available = available;
                        this.reserved = reserved;
                        this.held = held;
                }
                public long getItemId() {
                        return itemId;
                }
                public void setItemId(long itemId) {
                        this.itemId = itemId;
                }
                public long getAvailable() {
                        return available;
                }
                public void setAvailable(long available) {
                        this.available = available;
                }
                public long getReserved() {
                        return reserved;
                }
                public void setReserved(long reserved) {
                        this.reserved = reserved;
                }
                public long getHeld() {
                        return held;
                }
                public void setHeld(long held) {
                        this.held = held;
                }
                
        }
        
        private static Logger logger = LoggerFactory.getLogger(HoldInventoryController.class);
        
        private static Map<Long, Warehouse> warehouseMap;
        private static List<Warehouse> warehouses;
        private List<HoldInventoryDetail> holdInventoryDetails;
        private Map<Long, Item> itemMap;
        private Map<Long, ItemStockDetail> itemAvailabilityMap;
        
        private long source;
        private long itemId;
        private long warehouseId;
        private long heldQuantity;
        
        private HttpServletRequest request;
    private HttpSession session;
    
    private String errorMsg = "";
    
    static {
        try {
                InventoryService.Client inventoryClient = new InventoryClient().getClient();
                warehouseMap = new HashMap<Long, Warehouse>(100);
                warehouses = inventoryClient.getWarehouses(null, InventoryType.GOOD, 0, 0, 0);
                for (Warehouse warehouse : warehouses) {
                        warehouseMap.put(warehouse.getId(), warehouse);
                }
        } catch (Exception e) {
                try {
                        InventoryService.Client inventoryClient = new InventoryClient().getClient();
                        warehouses = inventoryClient.getWarehouses(null, InventoryType.GOOD, 0, 0, 0);
                        for (Warehouse warehouse : warehouses) {
                                warehouseMap.put(warehouse.getId(), warehouse);
                        }
                } catch (Exception e1) {
                        e1.printStackTrace();
                        //TODO log statement
                }
        }
        
    }
    
    public String index() {
        if(!ReportsUtils.canAccessReport((Long)session.getAttribute(ReportsUtils.ROLE), "/hold-inventory"))
            return "authfail";
        
        try {
                itemMap = new HashMap<Long, Item>(50);
                itemAvailabilityMap = new HashMap<Long, ItemStockDetail>(); 
                        InventoryService.Client inventoryClient = new InventoryClient().getClient();
                        holdInventoryDetails = inventoryClient.getHoldInventoryDetails(0,0,0);
                        List<HoldInventoryDetail> tobeRemovedHoldInventories = new ArrayList<HoldInventoryDetail>();
                        for(HoldInventoryDetail tmpHoldInventoryDetail : holdInventoryDetails) {
                                if (tmpHoldInventoryDetail.getHeld()<=0) {
                                        tobeRemovedHoldInventories.add(tmpHoldInventoryDetail);
                                }
                        }
                        holdInventoryDetails.removeAll(tobeRemovedHoldInventories);
                        
                        Map<Long, ItemInventory> itemInventoryMap = inventoryClient.getInventorySnapshot(0);
                        CatalogService.Client catalogClient = new CatalogClient().getClient();
                        for (HoldInventoryDetail holdInventoryDetail : holdInventoryDetails) {
                                if(itemMap.containsKey(holdInventoryDetail.getItem_id())) {
                                        continue;
                                }
                                long availability = 0;
                                long reserved = 0;
                                long held = 0;
                                Item item = catalogClient.getItem(holdInventoryDetail.getItem_id());
                                Map<Long, Long> itemAvailability = itemInventoryMap.get(holdInventoryDetail.getItem_id()).getAvailability();
                                Map<Long, Long> itemReserved = itemInventoryMap.get(holdInventoryDetail.getItem_id()).getReserved();
                                Map<Long, Long> itemHeld = itemInventoryMap.get(holdInventoryDetail.getItem_id()).getHeld();
                                
                                for (Long availabilityKey : itemAvailability.keySet()) {
                                        if (availabilityKey!=16) {
                                                availability += itemAvailability.get(availabilityKey);
                                        }
                                }
                                for (Long reservedKey : itemReserved.keySet()) {
                                        if (reservedKey!=16) {
                                                reserved += itemReserved.get(reservedKey);
                                        }
                                }
                                for (Long heldKey : itemHeld.keySet()) {
                                        if (heldKey!=16) {
                                                held += itemHeld.get(heldKey);
                                        }
                                }
                                ItemStockDetail itemStockDetail = new ItemStockDetail(holdInventoryDetail.getItem_id(), availability, reserved, held);
                                itemAvailabilityMap.put(holdInventoryDetail.getItem_id(), itemStockDetail);
                                itemMap.put(holdInventoryDetail.getItem_id(), item);
                        }
                        
                } catch (Exception e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace(); 
                }
        
        return "index";
    }
    
    public String create() throws Exception{
        InventoryService.Client inventoryClient = new InventoryClient().getClient();
        inventoryClient.addUpdateHoldInventory(itemId, warehouseId, heldQuantity, source);
        return index();
    }
    
        @Override
        public void setServletRequest(HttpServletRequest request) {
                this.request = request;
        this.session = request.getSession();
        }

        public String getErrorMsg() {
                return errorMsg;
        }

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

        public static Map<Long, Warehouse> getWarehouseMap() {
                return warehouseMap;
        }

        public static List<Warehouse> getWarehouses() {
                return warehouses;
        }

        public List<HoldInventoryDetail> getHoldInventoryDetails() {
                return holdInventoryDetails;
        }

        public long getSource() {
                return source;
        }

        public void setSource(long source) {
                this.source = source;
        }

        public long getItemId() {
                return itemId;
        }

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

        public long getWarehouseId() {
                return warehouseId;
        }

        public void setWarehouseId(long warehouseId) {
                this.warehouseId = warehouseId;
        }

        public long getHeldQuantity() {
                return heldQuantity;
        }

        public void setHeldQuantity(long heldQuantity) {
                this.heldQuantity = heldQuantity;
        }

        public Map<Long, Item> getItemMap() {
                return itemMap;
        }

        public void setItemMap(Map<Long, Item> itemMap) {
                this.itemMap = itemMap;
        }

        public Map<Long, ItemStockDetail> getItemAvailabilityMap() {
                return itemAvailabilityMap;
        }

        public void setItemAvailabilityMap(
                        Map<Long, ItemStockDetail> itemAvailabilityMap) {
                this.itemAvailabilityMap = itemAvailabilityMap;
        }
        
        public String getSource(long source) {
                if(source == 0) {
                        return "DONT-SELL";
                }
                return OrderSource.findByValue(new Long(source).intValue()).toString();
        }
}