Subversion Repositories SmartDukaan

'''
Created on 27-Apr-2010

@author: ashish
'''
from elixir import *
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, to_t_amazon_inventory_snapshot, \
    to_t_amazon_fba_inventory_snapshot, to_t_snapdeal_inventory_snapshot, \
    to_t_hold_inventory_detail, to_t_flipkart_inventory_snapshot
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, get_warehouse_name, \
    get_amazon_inventory_for_item, get_all_amazon_inventory, \
    add_or_update_amazon_inventory_for_item, update_reservation_for_order, \
    get_last_n_day_sale_for_item, add_or_update_amazon_fba_inventory, \
    add_update_hold_inventory, get_amazon_fba_inventory, \
    get_all_amazon_fba_inventory, get_oursgood_warehouseids_for_location, \
    get_holdinventorydetail_forItem_forWarehouseId_exceptsource, \
    get_snapdeal_inventory_for_item, add_or_update_snapdeal_inventor_for_item, \
    get_nlc_for_warehouse, get_snapdeal_inventory_snapshot, \
    get_held_inventory_map_for_item, get_hold_inventory_details, \
    add_or_update_flipkart_inventory_snapshot, get_flipkart_inventory_snapshot, \
    get_flipkart_inventory_for_Item, get_oos_statuses_for_x_days, \
    get_all_vendor_item_pricing, get_state_master, update_snapdeal_stock_at_eod, \
    update_flipkart_stock_at_eod, get_wanlc_for_source, \
    get_all_available_amazon_inventory, _task_update_item_availability_cache, \
    add_vendor_item_pricing_in_bulk, add_inventory_in_bulk, \
    get_item_pincode_availability, get_fofo_availability, \
    get_fofo_fulfilment_warehouse_map, get_item_availability_for_state
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
        '''
        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, stateId):
        """
        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
         As of now stateId is used for partner purpose only and data have been bypassed.
        """
        try:
            if stateId == -1:
                return get_item_availability_for_location(itemId, sourceId)
            else:
                return get_item_availability_for_state(itemId, sourceId, stateId)
        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 updateReservationForOrder(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 update_reservation_for_order(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 getAllVendorItemPricing(self, itemId, vendorId):
        """
        Returns list of all stored pricing information for given itemId and vendorId.
        
        Parameters:
         - itemId
         - vendorId
        """
        try:
            return [to_t_vendor_item_pricing(vid) for vid in get_all_vendor_item_pricing(itemId, vendorId)]
        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:
            f = open('/catalog-dumps/catalog.items')
            itemids = f.readline()
            f.close()
            if len(itemids) == 0 or "NULL" in itemids:
                pass
            else:
                itemids = [int(itemid) for itemid in itemids.split(",")]
                clear_item_availability_cache(itemids)
        except:
            print "Could not read file"
        finally:
            close_session()
        return

    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, billingWarehouseId):
        """
        Returns warehouseId for our warehouse for a vendor
        """    
        try:
            return get_our_warehouse_id_for_vendor(vendorId, billingWarehouseId)
        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, sourceId, days):
        """
        Get OOSStatus Objects for "days" number of days and sourceId for source. If sourceId is zero return for all sources.
        """
        try:
            return [to_t_oos_status(oos) for oos in get_oos_statuses_for_x_days_for_item(itemId, sourceId, days)]
        finally:
            close_session()
            
    def getOosStatusesForXDays(self, sourceId, days):
        """
        Get OOSStatus Objects for "days" number of days and sourceId for source. If sourceId is zero return for all sources.
        """
        try:
            return [to_t_oos_status(oos) for oos in get_oos_statuses_for_x_days(sourceId, 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 getLastNdaySaleForItem(self, itemId, numberOfDays):
        """
        Get Sale for Last N day for an Item
        """
        try:
            return get_last_n_day_sale_for_item(itemId, numberOfDays)
        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()
            
    def getWarehouseName(self,warehouseId):
        try:
            name = get_warehouse_name(warehouseId)
            return name
        finally:
            close_session()
            
    def getAmazonInventoryForItem(self, amazonItemId):
        result = []
        try:
            result = get_amazon_inventory_for_item(amazonItemId)
            if result is not None:
                result = to_t_amazon_inventory_snapshot(result)
        except:
            return result
        finally:
            close_session()
            return result
        
    def getAllAmazonInventory(self):
        try:
            amazoninventory = []
            all_inventory = get_all_amazon_inventory()
            for inventory in all_inventory:
                amazoninventory.append(to_t_amazon_inventory_snapshot((inventory)))
            return amazoninventory                                           
        finally:
            close_session() 
            
    def addOrUpdateAmazonInventoryForItem(self, amazoninventorysnapshot,time):
        try:
            add_or_update_amazon_inventory_for_item(amazoninventorysnapshot,time)
        finally:
            close_session()
            
    def addOrUpdateAmazonFbaInventory(self,amazonfbainventorysnapshot):
        try:
            add_or_update_amazon_fba_inventory(amazonfbainventorysnapshot)
            session.commit()
            return True 
        finally:
            close_session()
            
    def addUpdateHoldInventory(self, itemId, warehouseId, holdQuantity, source):
        try:
            add_update_hold_inventory(itemId, warehouseId, holdQuantity, source)
        finally:
            close_session()
            
    def getAmazonFbaItemInventory(self,itemId):
        fba_inventory = []
        try:
            for inventory in get_amazon_fba_inventory(itemId):
                fba_inventory.append(to_t_amazon_fba_inventory_snapshot(inventory))
            return fba_inventory     
        finally:
            close_session()            
            
    def getAllAmazonFbaItemInventory(self):
        all_fba_inventory = []
        try:
            for inventory in get_all_amazon_fba_inventory():
                all_fba_inventory.append(to_t_amazon_fba_inventory_snapshot(inventory))
            return all_fba_inventory     
        except:
            return None 
        finally:
            close_session()
            
    def getOursGoodWarehouseIdsForLocation(self,state_id):
        ids=[]
        try:
            for id in get_oursgood_warehouseids_for_location(state_id):
                ids.append(id[0])
            return ids
        except:
            return None
        finally:
            close_session()
    
    def getHoldInventoryDetailForItemForWarehouseIdExceptSource(self,item_id,warehouse_id,source):
        try:
            return get_holdinventorydetail_forItem_forWarehouseId_exceptsource(item_id,warehouse_id,source)
        finally:
            close_session()
    
    def getSnapdealInventoryForItem(self,item_id):
        try:
            return to_t_snapdeal_inventory_snapshot(get_snapdeal_inventory_for_item(item_id)) 
        finally:
            close_session()            
    def addOrUpdateSnapdealInventoryForItem(self,snapdealinventoryitem):
        try:
            add_or_update_snapdeal_inventor_for_item(snapdealinventoryitem)
        finally:
            close_session()
            
    def getNlcForWarehouse(self,warehouse_id,item_id):
        try:
            return get_nlc_for_warehouse(warehouse_id,item_id)
        finally:
            close_session()
            
    def addOrUpdateAllAmazonFbaInventory(self,allamazonfbainventorysnapshot):
        print 'inside handler'
        try:
            for amazonfbainventorysnapshot in allamazonfbainventorysnapshot:
                print amazonfbainventorysnapshot 
                add_or_update_amazon_fba_inventory(amazonfbainventorysnapshot)
            session.commit()    
        finally:
            close_session()
    
    def addOrUpdateAllSnapdealInventory(self,allsnapdealinventorysnapshot):
        try:
            for snapdealinventorysnapshot in allsnapdealinventorysnapshot:
                add_or_update_snapdeal_inventor_for_item(snapdealinventorysnapshot)
        finally:
            close_session()
            
    def getSnapdealInventorySnapshot(self):
        allsnapdealinventorysnapshot = []
        try:     
            for inventorysnapshot in get_snapdeal_inventory_snapshot():
                allsnapdealinventorysnapshot.append(to_t_snapdeal_inventory_snapshot(inventorysnapshot))  
            return allsnapdealinventorysnapshot
        finally:            
            close_session()
            
    def getHeldInventoryMapForItem(self, itemId, warehouseId):
        try:
            return get_held_inventory_map_for_item(itemId, warehouseId)
        finally:
            close_session()
            
    def getHoldInventoryDetails(self, itemId, warehouseId, source):
        try:
            return [to_t_hold_inventory_detail(holdInventoryDetail) for holdInventoryDetail in get_hold_inventory_details(itemId, warehouseId, source)]
        finally:
            close_session()
            
    def addOrUpdateFlipkartInventorySnapshot(self,flipkartInventorySnapshot,time):
        try:
            add_or_update_flipkart_inventory_snapshot(flipkartInventorySnapshot,time)
        finally:
            close_session()    
    
    
    def getFlipkartInventorySnapshot(self):
        try:
            return [to_t_flipkart_inventory_snapshot(snapshot) for snapshot in get_flipkart_inventory_snapshot()]
        finally:
            close_session()
    
    def getFlipkartlInventoryForItem(self,item_id):
        try:
            return to_t_flipkart_inventory_snapshot(get_flipkart_inventory_for_Item(item_id))
        finally:
            close_session()
            
    def getStateMaster(self):
        try:
            return get_state_master()
        finally:
            close_session()
    
    def updateSnapdealStockAtEOD(self,allsnapdealstock):
        try:
            update_snapdeal_stock_at_eod(allsnapdealstock)
        finally:
            close_session()
            
    def updateFlipkartStockAtEOD(self,allflipkartstock):
        try:
            update_flipkart_stock_at_eod(allflipkartstock)
        finally:
            close_session()
    
    def getWanNlcForSource(self,item_id,source):
        try:
            return get_wanlc_for_source(item_id,source)
        finally:
            close_session()
    
    def getAllAvailableAmazonFbaItemInventory(self):
        try:
            amazoninventory = []
            all_inventory = get_all_available_amazon_inventory()
            for inventory in all_inventory:
                amazoninventory.append(to_t_amazon_fba_inventory_snapshot((inventory)))
            return amazoninventory                                           
        finally:
            close_session() 
    
    def updateItemAvailabilityForItemIds(self,itemIds):
        try:
            return _task_update_item_availability_cache(itemIds)
        except:
            return False
        finally:
            close_session()
            
    def addVendorItemPricingInBulk(self,vendorItemPricingList):
        try:
            return add_vendor_item_pricing_in_bulk(vendorItemPricingList)
        finally:
            close_session()
            
    def addInventoryInBulk(self, bulkInventoryList):
        try:
            add_inventory_in_bulk(bulkInventoryList)
        finally:
            close_session()            
                    
    def getItemPincodeAvailability(self, itemPricingMap, pin):
        try:
            return get_item_pincode_availability(itemPricingMap, pin)
        finally:
            close_session()
            
    def getFofoAvailability(self, itemIds):
        try:
            return get_fofo_availability(itemIds)
        finally:
            close_session()
            
    def getFofoFulFillmentWarehouseMap(self, itemIds):
        try:
            return get_fofo_fulfilment_warehouse_map(itemIds)
        finally:
            close_session()