Subversion Repositories SmartDukaan

'''
Created on 27-Apr-2010

@author: ashish
'''
from shop2020.config.client.ConfigClient import ConfigClient
from shop2020.model.v1.inventory.impl import DataService
from shop2020.model.v1.inventory.impl.Convertors import to_t_item_inventory, \
    to_t_warehouse, to_t_vendor_item_pricing, to_t_vendor, to_t_vendor_item_mapping, \
    to_t_item_stock_purchase_params, to_t_oos_status
from shop2020.model.v1.inventory.impl.DataAcessors import add_warehouse, \
    update_inventory, retire_warehouse, get_item_availability_for_warehouse, \
    get_item_availability_for_location, get_all_warehouses_by_status, get_Warehouse, \
    get_all_items_for_warehouse, close_session, add_vendor, \
    get_item_inventory_by_item_id, reserve_item_in_warehouse, \
    reduce_reservation_count, get_all_item_pricing, add_vendor_pricing, \
    get_item_pricing, get_all_vendors, get_item_mappings, add_vendor_item_mapping, \
    update_inventory_history, is_alive, add_inventory, add_bad_inventory, \
    mark_missed_inventory_updates_as_processed, update_vendor_string, \
    get_item_keys_to_be_processed, reset_availability, get_shipping_locations, \
    initialize, get_inventory_snapshot, clear_item_availability_cache, \
    reset_availability_for_warehouse, get_vendor, get_pending_orders_inventory, \
    is_order_billable, get_our_warehouse_id_for_vendor, \
    get_item_availability_for_our_warehouses, get_monitored_warehouses_for_vendors, \
    get_ignored_warehouseids_and_itemids,insert_item_to_ignore_inventory_update_list, \
    delete_item_from_ignore_inventory_update_list,get_all_ignored_inventoryupdate_items_count, \
    get_ignored_inventoryupdate_itemids, update_item_stock_purchase_params, \
    get_item_stock_purchase_params, add_oos_status_for_item, \
    get_oos_statuses_for_x_days_for_item, get_non_zero_item_stock_purchase_params, \
    get_billable_inventory_and_pending_orders
from shop2020.model.v1.inventory.impl.DataService import Warehouse, \
    MissedInventoryUpdate, VendorItemMapping
from shop2020.thriftpy.model.v1.inventory.ttypes import \
    InventoryServiceException, WarehouseType, InventoryType, \
    AvailableAndReservedStock
from shop2020.utils.Utils import log_entry, to_java_date

class InventoryServiceHandler:
    '''
    classdocs
    '''
    
    def __init__(self, dbname='catalog', db_hostname='localhost'):
        '''
        Constructor
u        '''
        initialize(dbname, db_hostname)
        try:
            config_client = ConfigClient()
            self.latest_arrivals_limit = int(config_client.get_property("LATEST_ARRIVALS_LIMIT"));
            self.best_sellers_limit = int(config_client.get_property("BEST_SELLERS_LIMIT"))
        except:
            self.latest_arrivals_limit = 50
            self.best_sellers_limit = 50
       
    def addWarehouse(self, warehouse):
        """
        Parameters:
         - warehouse
        """
        log_entry(self, "addWarehouse called")
        try:
            return add_warehouse(warehouse)
        finally:
            close_session()

    def updateInventoryHistory(self, warehouse_id, timestamp, availability):
        """
        Stores the incremental warehouse updates of items.
        
        Parameters:
         - warehouse_id
         - timestamp
         - availability
        """
        try:
            return update_inventory_history(warehouse_id, timestamp, availability)
        finally:
            close_session()

    def updateInventory(self, warehouse_id, timestamp, availability):
        """
        Parameters:
         - warehouse_id
         - timestamp
         - availability
        """
        log_entry(self, "update Inventory called")
        try:
            return update_inventory(warehouse_id, timestamp, availability)
        finally:
            close_session()

    def addInventory(self, itemId, warehouseId, quantity):
        """
        Add the inventory to existing stock.
    
        Parameters:
         - itemId
         - warehouseId
         - quantity
        """
        log_entry(self, "add Inventory called")
        try:
            return add_inventory(itemId, warehouseId, quantity)
        finally:
            close_session()

    def retireWarehouse(self, warehouse_id):
        """
        Parameters:
         - warehouse_id
        """
        log_entry(self, "retire warehouse called")
        try:
            return retire_warehouse(warehouse_id)
        finally:
            close_session()

    
    def getItemInventoryByItemId(self, item_id):
        """
        Parameters:
         - item_id
        """
        log_entry(self, "item inventory requested")
        try:
            inventory = get_item_inventory_by_item_id(item_id)
            return to_t_item_inventory(inventory, item_id)
        finally:
            close_session()

    def getItemAvailabilityAtLocation(self, itemId, sourceId):
        """
        Determines the warehouse that should be used to fulfil an order for the given item.
        It first checks all the warehouses which are in the logistics location given by the
        warehouse_loc parameter. If none of the warehouses there have any inventory, then the
        preferred warehouse for the item is used.
        
        Returns an ordered list of size 4 with following elements in the given order:
        1. Logistics location of the warehouse which was finally picked up to ship the order.
        2. Id of the warehouse which was finally picked up.
        3. Inventory size in the selected warehouse.
        4. Expected delay added by the category manager.
        
        Parameters:
         - itemId
         - sourceId
        """
        try:
            return get_item_availability_for_location(itemId, sourceId)
        finally:
            close_session()
            
    def getItemAvailibilityAtWarehouse(self, warehouse_id, item_id):
        """
        Parameters:
         - warehouse_id
         - item_id
        """
        log_entry(self, "item availability at warehouse requested")
        try:
            return get_item_availability_for_warehouse(warehouse_id, item_id)
        finally:
            close_session()
        
    def getItemAvailabilitiesAtOurWarehouses(self, item_ids):
        try:   
            return get_item_availability_for_our_warehouses(item_ids)
        finally:
            close_session()
            
    def getItemInventoryHistory(self, id, item_id, warehouse_id, from_date, to_date):
        """
        Parameters:
         - id
         - item_id
         - warehouse_id
         - from_date
         - to_date
        """
        pass

    def getAllWarehouses(self, isActive):
        """
        Parameters:
        - isActive
        """
        try:
            if isActive:
                warehouses = get_all_warehouses_by_status(3)
            else:
                warehouses = get_all_warehouses_by_status(None)
            
            ret_warehouses = []
            
            for warehouse in warehouses:
                ret_warehouses.append(to_t_warehouse(warehouse))
            return ret_warehouses
        finally:
            close_session()
            
    def getWarehouse(self, warehouse_id):
        """
        Parameters:
         - warehouse_id
        """
        log_entry(self, "get warehouse call")
        try:
            warehouse = get_Warehouse(warehouse_id)
            if warehouse:
                return to_t_warehouse(warehouse)
            else:
                raise InventoryServiceException(101, "no such warehouse: " + str(warehouse_id))
        finally:
            close_session()
            
    def getAllItemsForWarehouse(self, warehouse_id):
        """
        Parameters:
         - warehouse_id
        """
        log_entry(self, "getting all items for warehouse")
        try:
            all_items = get_all_items_for_warehouse(warehouse_id)
            t_items = []
            for item in all_items:
                t_items.append(item.id)
            return t_items
        finally:
            close_session()

    def isOrderBillable(self, itemId, warehouseId, sourceId, orderId):
        """
        Depending on reservation in the table, verify if we can bill this order or not.
    
        Parameters:
         - itemId
         - warehouseId
         - sourceId
         - orderId
        """
        try:
            return is_order_billable(itemId, warehouseId, sourceId, orderId)
        finally:
            close_session()
            
    def reserveItemInWarehouse(self, itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity):
        """
        Increases the reservation count for an item in a warehouse. Should always succeed normally.
        
        Parameters:
         - itemId
         - warehouseId
        """
        log_entry(self, "reserveItemInWarehouse called")
        try:
            return reserve_item_in_warehouse(itemId, warehouseId, sourceId, orderId, createdTimestamp, promisedShippingTimestamp, quantity)
        finally:
            close_session()
    
    def reduceReservationCount(self, itemId, warehouseId, sourceId, orderId, quantity):
        """
        Decreases the reservation count for an item in a warehouse. Should always succeed normally.
        
        Parameters:
         - itemId
         - warehouseId
        """
        log_entry(self, "reduceReservationCount called")
        try:
            return reduce_reservation_count(itemId, warehouseId, sourceId, orderId, quantity)
        finally:
            close_session()
            
    def getItemPricing(self, itemId, vendorId):
        """
        Returns the pricing information of an item associated with the vendor of the given warehouse.
        Raises an exception if either the item, vendor or the associated pricing information can't be found.
        
        Parameters:
         - itemId
         - warehouseId
        """
        try:
            return to_t_vendor_item_pricing(get_item_pricing(itemId, vendorId))
        finally:
            close_session()
            
            
    def getAllItemPricing(self, itemId):
        """
        Returns list of the pricing information of an item associated an item.
        Raises an exception if the item can't be found.
        
        Parameters:
         - itemId
        """
        try:
            return [to_t_vendor_item_pricing(vid) for vid in get_all_item_pricing(itemId)]
        finally:
            close_session()

    def addVendorItemPricing(self, vendorItemPricing):
        """
        Adds vendor prices corresponding to the item. If pricing already exists then updates the prices. 
        Raises an exception if either the item or vendor can't be found corresponding to their ids.
        
        Parameters:
         - vendorItemPricing
        """
        log_entry(self, "updateVendorItemPricing called")
        try:
            return add_vendor_pricing(vendorItemPricing)
        finally:
            close_session()
            
    def getVendor(self, vendorId):
        """
        Return a vendor for id
        """
        try:
            return to_t_vendor(get_vendor(vendorId))
        finally:
            close_session()


    def getAllVendors(self, ):
        """
        Return list of all vendors
        """
        try:
            return [to_t_vendor(v) for v in get_all_vendors()]
        finally:
            close_session()

    def addVendorItemMapping(self, key, vendorItemMapping):
        """
        Adds VendorItemMapping. Updates VendorItemMapping if exists corresponding to the item key.
        
        Parameters:
         - key
         - vendorItemMapping
        """
        log_entry(self, "addVendorItemMapping called")
        try:
            return add_vendor_item_mapping(key, vendorItemMapping)
        finally:
            close_session()

    def getVendorItemMappings(self, itemId):
        """
        Returns the list of vendor item mapping corresponding to itemId passed as parameter.
        Raises an exception if item not found corresponding to itemId
        
        Parameters:
         - itemId
        """
        try:
            item_mappings = get_item_mappings(itemId)
            return [to_t_vendor_item_mapping(vim) for vim in item_mappings]
        finally:
            close_session()
    
    def isAlive(self, ):
        """
        For checking weather service is active alive or not. It also checks connectivity with database
        """
        try:
            return is_alive()
        finally:
            close_session()

    def closeSession(self, ):
        """
        For closing the open session in sqlalchemy
        """
        close_session()
        
    def addVendor(self, vendor):
        """
        add a new vendor
        """
        try:
            return add_vendor(vendor)
        finally:
            close_session()
    
    def getWarehouses(self, warehouseType, inventoryType, vendorId, billingWarehouseId, shippingWarehouseId):
        """
        This method returns all warehouses for a given warehosueType, inventoryType, vendor, billingWarehouse and shippingWarehouse.
        getWarehouses(WarehouseType.OURS, InventoryType.GOOD, 3, 7, 7) would return ours warehouse with GOOD type inventory for vendor 1 for billing warehouse 7 and shipping warehouse 7
        getWarehouses(WarehouseType.OURS, InventoryType.GOOD, 3, 7, 7) would return ours warehouse with GOOD type inventory for vendor 3 for billing warehouse 7 and shipping warehouse 7
        getWarehouses(null, null, 3, 7, 7) would return all type warehouses with all type inventory for vendor 3 for billing warehouse 7 and shipping warehouse 7
        getWarehouses(null, null, 0, 0, 7) would return all type warehouses with all type inventory for all vendors for all billing warehouses at shipping warehouse 7

        Parameters:
         - warehouseType
         - inventoryType
         - vendorId
         - billingWarehouseId
         - shippingWarehouseId
        """
        try:
            query = Warehouse.query
            if warehouseType is not None:
                query = query.filter_by(warehouseType = WarehouseType._VALUES_TO_NAMES[warehouseType])
            if inventoryType is not None:
                query = query.filter_by(inventoryType = InventoryType._VALUES_TO_NAMES[inventoryType])
            if vendorId:
                query = query.filter_by(vendor_id = vendorId)
            if billingWarehouseId:
                query = query.filter_by(billingWarehouseId = billingWarehouseId)
            if shippingWarehouseId:
                query = query.filter_by(shippingWarehouseId = shippingWarehouseId)

            return [to_t_warehouse(w) for w in query.all()]
        finally:
            close_session()

    def getItemKeysToBeProcessed(self, warehouseId):
        """
        Returns the list of item keys which need to be processed for a given warehouse.
        This is currently used by Support application to send item keys whose inventory needs
        to be updated from PLB

        Parameters:
         - warehouseId
        """
        try:
            return get_item_keys_to_be_processed(warehouseId)
        finally:
            close_session()

    def markMissedInventoryUpdatesAsProcessed(self, itemKey, warehouseId):
        """
        Marks/Deletes missed inventory updates for a given key and warehouse.
        This generally happens when updates from PLB are applied on the currentinventorysnapshot for an item

        Parameters:
         - itemKey
         - warehouseId
        """
        try:
            mark_missed_inventory_updates_as_processed(itemKey, warehouseId)
        finally:
            close_session()

    def resetAvailability(self, itemKey, vendorId, quantity, warehouseId):
        """
        Resets availability of an item to the quantity mentioned in a warehouse.

        Parameters:
         - itemKey
         - vendorId
         - quantity
         - warehouseId
        """
        try:
            reset_availability(itemKey, vendorId, quantity, warehouseId)
        finally:
            close_session()

    def resetAvailabilityForWarehouse(self, warehouseId):
        """
        Resets availability of a warehouse to zero.

        Parameters:
         - warehouseId
        """
        try:
            reset_availability_for_warehouse(warehouseId)
        finally:
            close_session()

    def getIgnoredItemKeys(self, ):
        """
        Returns all the item key mappings that have been ignored until date. Value of map has the warehouse id
        and the timestamp from where alert was raised.
        """
        try:
            itemKeysMap = {}
            for key in MissedInventoryUpdate.query.filter_by(isIgnored = 1).all():
                itemKeysMap[key.itemKey] = { key.warehouseId : to_java_date(key.timestamp) }
    
            return itemKeysMap
        finally:
            close_session()

    def addBadInventory(self, itemId, warehouseId, quantity):
        """
        Add the BAD type inventory to existing stock.

        Parameters:
         - itemId
         - warehouseId
         - quantity
        """
        try:
            add_bad_inventory(itemId, warehouseId, quantity)
        finally:
            close_session()
        
    def getShippingLocations(self, ):
        """
        Returns all shipping locations
        """
        try:
            return [to_t_warehouse(w) for w in get_shipping_locations()]
        finally:
            close_session()

    def getAllVendorItemMappings(self, ):
        """
        Fetches all the vendor item mappings present.
        """
        try:
            return [to_t_vendor_item_mapping(m) for m in VendorItemMapping.query.all()]
        finally:
            close_session()

    def getInventorySnapshot(self, warehouseId):
        """
        Gets items' inventory for a warehouse
        If warehouse is passed as zero, items' inventory across all warehouses is sent

        Parameters:
         - warehouseId
        """
        try:
            resultMap = {}
            itemInventoryMap = get_inventory_snapshot(warehouseId)
            for key, value in itemInventoryMap.items():
                resultMap[key] = to_t_item_inventory(value, key)

            return resultMap
        finally:
            close_session()

    def clearItemAvailabilityCache(self, ):
        """
        Clear item availability cache.
        """
        try:
            clear_item_availability_cache()
        finally:
            close_session()

    def clearItemAvailabilityCacheForItem(self, item_id):
        """
        Clear item availability cache.
        """
        try:
            clear_item_availability_cache(item_id)
        finally:
            close_session()

    def getPendingOrdersInventory(self, vendorId):
        """
        Returns a list of inventory stock for items for which there are pending orders for the given vendor.
        """
        try:
            pending_items_inventory = get_pending_orders_inventory(vendorId)
            return [AvailableAndReservedStock(itemId = i[0], available=i[1], reserved=i[2], minimumStock=0) for i in pending_items_inventory]
        finally:
            close_session()
               
    def updateVendorString(self, warehouseId, vendorString):
        """
        Parameters:
         - warehouseId
         - vendorString
        """
        try:
            update_vendor_string(warehouseId, vendorString)
        finally:
            close_session()
    def getOurWarehouseIdForVendor(self, vendorId):
        """
        Returns warehouseId for our warehouse for a vendor
        """    
        try:
            return get_our_warehouse_id_for_vendor(vendorId)
        finally:
            close_session()
    def getMonitoredWarehouseForVendors(self, vendorIds):
        """
        Returns monitored warehouse ids for vendors
        """    
        try:
            return get_monitored_warehouses_for_vendors(vendorIds)
        finally:
            close_session()
    def getIgnoredWarehouseidsAndItemids(self):
        """
        Returns list of itemid and warehouseId for ignored inventory update
        """    
        try:
            return get_ignored_warehouseids_and_itemids()
        finally:
            close_session()
            
    def insertItemtoIgnoreInventoryUpdatelist(self,item_id,warehouse_id):
        """
        Returns list of itemid and warehouseId for ignored inventory update
        """
        try:
            return insert_item_to_ignore_inventory_update_list(item_id,warehouse_id)
        finally:
            close_session()     
    def deleteItemFromIgnoredInventoryUpdateList(self,item_id,warehouse_id):
        """
        Deletes warehouse and item entry from inventory update ignore list
        """
        try:
            return delete_item_from_ignore_inventory_update_list(item_id,warehouse_id)
        finally:
            close_session()
    def getAllIgnoredInventoryupdateItemsCount(self):
        """
        Returns all ignored inventory update item count
        """
        try:
            return get_all_ignored_inventoryupdate_items_count()
        finally:
            close_session()
        
        
    def getIgnoredInventoryUpdateItemids(self,offset,limit):
        """
        Returns all ignored inventory update items
        """
        try:
            return get_ignored_inventoryupdate_itemids(offset,limit)
        finally:
            close_session()
    def updateItemStockPurchaseParams(self, item_id, numOfDaysStock, minStockLevel):
        """
        Update/Add parameters required for heuristic purchase of Items 
        """ 
        try:               
            update_item_stock_purchase_params(item_id, numOfDaysStock, minStockLevel)
        finally:
            close_session()
            
    def getItemStockPurchaseParams(self, item_id):
        """
        Get parameters required for heuristic purchase of Items 
        """ 
        try:               
            return to_t_item_stock_purchase_params(get_item_stock_purchase_params(item_id))
        finally:
            close_session()
            
    def addOosStatusForItem(self, oosStatusMap, date):
        """
        Add OOS status for Item 
        """
        try:
            add_oos_status_for_item(oosStatusMap, date)
        finally:
            close_session()
            
    def getOosStatusesForXDaysForItem(self, itemId, days):
        """
        Get OOSStatus Objects for "days" number of days 
        """
        try:
            return [to_t_oos_status(oos) for oos in get_oos_statuses_for_x_days_for_item(itemId, days)]
        finally:
            close_session()
            
    def getNonZeroItemStockPurchaseParams(self):
        """
        Get All ItemStockPurchaseParam objects where either minStockLevel or minNumOfDaysOfStock is zero 
        """
        try:
            return [to_t_item_stock_purchase_params(ispp) for ispp in get_non_zero_item_stock_purchase_params()]
        finally:
            close_session()
    def getBillableInventoryAndPendingOrders(self):
        """
        Returns a list of inventory stock for items for which there are pending orders or have 
        billable inventory.
        """
        try:
            items_inventory = get_billable_inventory_and_pending_orders()
            return [AvailableAndReservedStock(itemId = i[0], available=i[1], reserved=i[2], minimumStock=0) for i in items_inventory]
        finally:
            close_session()