Subversion Repositories SmartDukaan

/**
 * 
 */
package in.shop2020.warehouse.handler;

import in.shop2020.model.v1.inventory.InventoryService;
import in.shop2020.model.v1.inventory.InventoryServiceException;
import in.shop2020.model.v1.inventory.Warehouse;
import in.shop2020.thrift.clients.InventoryClient;
import in.shop2020.warehouse.DoaOutInventoryItem;
import in.shop2020.warehouse.InTransitInventory;
import in.shop2020.warehouse.ScanType;
import in.shop2020.warehouse.domain.InventoryItem;
import in.shop2020.warehouse.persistence.InventoryItemMapper;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.collections.ListUtils;
import org.apache.thrift.TException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.mysql.jdbc.StringUtils;

/**
 * @author mandeep
 *
 */
@Service
public class InventoryItemHandler {
    @Autowired
    private InventoryItemMapper inventoryItemMapper;

    /**
     * @param inventoryItem
     */
    public InventoryItem insertInventoryItem(InventoryItem inventoryItem) {
        inventoryItemMapper.insertInventoryItem(inventoryItem);
        return inventoryItem;
    }

    /**
     * @param inventoryItemId
     * @return
     */
    public InventoryItem getInventoryItem(long inventoryItemId) {
        return inventoryItemMapper.getInventoryItem(inventoryItemId);
    }

    /**
     * @param serialNumber
     * @return
     */
    public InventoryItem getInventoryItem(String serialNumber) {
        return inventoryItemMapper.getInventoryItemFromSerialNumber(serialNumber);
    }

    public List<InventoryItem> getInventoryItemFromLastScanType(ScanType scanType) {
        return inventoryItemMapper.getInventoryItemsFromLastScanType(scanType);
    }

    /**
     * @param inventoryItemId
     * @return
     */
    public InventoryItem getInventoryItemFromId(long inventoryItemId) {
        return inventoryItemMapper.getInventoryItemsFromId(inventoryItemId);
    }

    /**
     * @param inventoryItem
     */
    public void update(InventoryItem inventoryItem) {
        inventoryItemMapper.update(inventoryItem);
    }

    /**
     * @param itemId
     * @param warehouseId
     * @return
     */
    public InventoryItem getInventoryItem(String itemNumber, long itemId, long warehouseId, long billingWarehouseId) {
        if (StringUtils.isNullOrEmpty(itemNumber)) {
            itemNumber = null;
        }

        return inventoryItemMapper.getNonSerializedInventoryItem(itemNumber, itemId, warehouseId, billingWarehouseId);
    }

        public Long getCurrentQuantityForNonSerializedItem(long itemId, long warehouseId, long physicalWarehouseId) {
                return inventoryItemMapper.getCurrentQuantityForNonSerializedItem(itemId, warehouseId, physicalWarehouseId, 0);
        }
        
        public Long getCurrentQuantityForNonSerializedItemWithGrnId(long itemId, long warehouseId, long physicalWarehouseId, long purchaseId) {
                return inventoryItemMapper.getCurrentQuantityForNonSerializedItem(itemId, warehouseId, physicalWarehouseId, purchaseId);
        }

        public void markPurchaseReturnIdForItem(long id, long currentQuantity, long purchaseReturnId) {
                inventoryItemMapper.markPurchaseReturnIdForItem(id, currentQuantity, purchaseReturnId);
                
        }
        
        public void markPurchaseReturnIdForBadItem(long id, long currentQuantity, long purchaseReturnId) {
                inventoryItemMapper.markPurchaseReturnIdForBadItem(id, currentQuantity, purchaseReturnId);
        }

        public List<InventoryItem> getCurrentNonSerializedItemsByItemId(long itemId, long warehouseId) throws InventoryServiceException, TException {
                InventoryService.Client inventoryClient = new InventoryClient().getClient();
                Warehouse warehouse = inventoryClient.getWarehouse(warehouseId);
                return inventoryItemMapper.getCurrentNonSerializedItemsByItemId(itemId, warehouseId, warehouse.getBillingWarehouseId(),0);
        }
        
        public List<InventoryItem> getCurrentNonSerializedItemsByItemIdWithGrnId(long itemId, long warehouseId, long purchaseId) throws InventoryServiceException, TException {
                InventoryService.Client inventoryClient = new InventoryClient().getClient();
                Warehouse warehouse = inventoryClient.getWarehouse(warehouseId);
                return inventoryItemMapper.getCurrentNonSerializedItemsByItemId(itemId, warehouseId, warehouse.getBillingWarehouseId(),purchaseId);
        }
        
        public List<InventoryItem> getNonSerializedItemsForBadInventory(long itemId, long currentWarehouseId, long physicalWarehouseId){
                return inventoryItemMapper.getNonSerializedItemsForBadInventory(itemId, currentWarehouseId, physicalWarehouseId);
        }
        
        public List<Map<String, Integer>> getCurrentSerializedInventory() {
                return inventoryItemMapper.getCurrentSerializedInventory();
        }
        
        public List<Map<String, Integer>> getCurrentNonSerializedInventory() {
                return inventoryItemMapper.getCurrentNonSerializedInventory();
        }

        public void markItemAsLost(long id, long currentQuantity) {
                inventoryItemMapper.markItemAsLost(id, currentQuantity);
                
        }

        /*public void markTransferLotAsRecieved(long id) {
                inventoryItemMapper.markTransferLotAsRecieved(id);
        }*/

        public List<InventoryItem> getInventoryItemsForTransferLot(long id) {
                return inventoryItemMapper.getInventoryItemsForTransferLot(id);
        }

        /*public InventoryItem getNonSeralizedInventoryItemForPhysicalWarehouse(
                        String itemNumber, long itemId, long physicalWarehouseId) {
                return  inventoryItemMapper.getNonSeralizedInventoryItemForPhysicalWarehouse(itemNumber, itemId, physicalWarehouseId);
        }*/

        public long getCurrentQuantityForNonSerializedItemInPhysicalWarehouse(
                        long itemId, long physicalWarehouseId) {
                return inventoryItemMapper.getCurrentQuantityForNonSerializedItemInPhysicalWarehouse(itemId, physicalWarehouseId);
        }

        public List<InventoryItem> getCurrentNonSerializedItemsByItemIdInPhysicalWarehouse(
                        long itemId, long physicalWarehouseId) {
                return inventoryItemMapper.getCurrentNonSerializedItemsByItemIdInPhysicalWarehouse(itemId, physicalWarehouseId);
        }

        public long getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse(
                        long itemId, long physicalWarehouseId) {
                return inventoryItemMapper.getCurrentQuantityForNonSerializedInTransitItemInPhysicalWarehouse(
                                itemId, physicalWarehouseId);
        }

        public List<InTransitInventory> getInTransitInventory(long originWarehouseId) {
                List<InTransitInventory> t_InTransitInventories = new ArrayList<InTransitInventory>();
                for(in.shop2020.warehouse.domain.InTransitInventory intransitInventory :inventoryItemMapper.getInTransitInventory(originWarehouseId)) {
                        t_InTransitInventories.add(intransitInventory.toThriftObject());
                }
                return t_InTransitInventories;
        }

        public List<InventoryItem> getCurrentInTransitInventoryInPhysicalWarehouse(
                        long itemId, long originWarehouseId) {
                return inventoryItemMapper.getCurrentInTransitInventoryInPhysicalWarehouse(itemId, originWarehouseId);
        }
        
        public List<InventoryItem> getTransferLotItemsForMarkReceive(
                        long transferLotId, ScanType scanType) {
                return inventoryItemMapper.getTransferLotItemsForMarkReceive(transferLotId,scanType);
        }

        public List<Long> getEmptyGrnsByDate(Date startDate, Date endDate) {
                List<Long> allGrns = inventoryItemMapper.getAllGrnsByDate(startDate, endDate);
                List<Long> nonEmptyGrns = inventoryItemMapper.getNonEmptyGrnsByDate(startDate, endDate);
                
                List<Long> emptyGrnsList = new ArrayList<Long>(10);
                
                Set<Long> emptyGrns = new HashSet<Long>();
                emptyGrns.addAll(allGrns);
                emptyGrns.removeAll(nonEmptyGrns);
                
                emptyGrnsList.addAll(emptyGrns);
                return emptyGrnsList;
        }

        public InventoryItem getSellableBadNonSerializedItem(long itemId, String itemNumber, long physicalWarehouseId) {
                return inventoryItemMapper.getSellableBadNonSerializedItem(itemId, itemNumber, physicalWarehouseId);
                
        }
        
        public List<InventoryItem> getInventoryItemScannedInForPO(long itemId, List<Long> purchaseIds) {
                return inventoryItemMapper.getInventoryItemScannedInForPO(itemId, purchaseIds);
        }
        
        public List<InventoryItem> getInventoryItemsBySerailNumbers(List<String> serialNumbers) {
                List<InventoryItem> inventoryItems = inventoryItemMapper.getInventoryItemsBySerailNumbers(serialNumbers);
                Map<String, InventoryItem> map = new HashMap<String, InventoryItem>();
                for(InventoryItem inventoryItem : inventoryItems){
                        String serialNumber = inventoryItem.getSerialNumber();
                        if(map.containsKey(serialNumber)){
                                InventoryItem savedInventoryItem = map.get(serialNumber);
                                if(savedInventoryItem.getId() < inventoryItem.getId()) {
                                        map.put(serialNumber, inventoryItem);
                                }
                        } else {
                                map.put(serialNumber, inventoryItem);
                        }
                }
                return new ArrayList<InventoryItem>(map.values());
        }
        
        public Long getCurrentBadQuantityForItem( long itemId, long currentWarehouseId, long physicalWarehouseId){
                return inventoryItemMapper.getCurrentBadQuantityForItem(itemId, currentWarehouseId, physicalWarehouseId);
        }
        
        public Map<Long, Long> getItemsInPurchaseReturn(long purchaseReturnId, ScanType type, String returnTime){               
                Map<Integer, Integer> result  = inventoryItemMapper.getItemsInPurchaseReturn(purchaseReturnId, type, returnTime);
                Map<Long, Long> purchaseReturnItems = new HashMap<Long, Long>();
                
                for(Integer itemId : result.keySet()){
                        Long count = Long.parseLong(((Object)((Map<String,Long>)(Object)result.get(itemId)).get("count")).toString());
                        purchaseReturnItems.put(new Long(itemId), count);
                }
                return purchaseReturnItems;
        }
        
        public List<DoaOutInventoryItem> getAllDoaOutInventoryItems(){
                return inventoryItemMapper.getAllDoaOutInventoryItems();
        }

        public InventoryItem getInventoryItem(String serialNumber, long billingWarehouseId) {
                return inventoryItemMapper.getInventoryItemFromSerialNumberWarehouse(serialNumber, billingWarehouseId);
        }
}