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);

	}

}