Subversion Repositories SmartDukaan

'''
Created on 27-Apr-2010

@author: ashish
'''
from shop2020.model.v1.catalog.impl import DataService
from shop2020.utils.Utils import log_entry
from shop2020.model.v1.catalog.impl.DataAcessors import add_item, add_warehouse,\
    update_inventory, retire_warehouse, retire_item, change_item_status,\
    get_item, get_all_items, get_all_items_by_status, get_item_inventoy,\
    get_item_availability_for_warehouse, get_item_availability_for_location, get_all_warehouses_by_status,\
    get_Warehouse, get_all_warehouses_for_item, get_all_items_for_warehouse,\
    update_item, start_item_on, close_session, \
    retire_item_on, get_item_inventory_by_item_id, get_items_by_catalog_id,\
    get_best_deals, get_best_deals_catalog_ids, get_best_deals_count, get_best_sellers, get_latest_arrivals, get_latest_arrivals_catalog_ids, get_latest_arrivals_count,\
    is_active, get_best_sellers_catalog_ids, get_best_sellers_count, put_category_object,\
    get_category_object, mark_item_as_content_complete,\
    reserve_item_in_warehouse, reduce_reservation_count, generate_new_entity_id,\
    get_item_pricing
from shop2020.model.v1.catalog.impl.Convertors import to_t_item,\
    to_t_item_inventory, to_t_warehouse, to_t_vendor_item_pricing
from shop2020.thriftpy.model.v1.catalog.ttypes import status,\
    InventoryServiceException
from shop2020.config.client.ConfigClient import ConfigClient


class InventoryServiceHandler:
    '''
    classdocs
    '''
    
    def __init__(self, dbname='catalog'):
        '''
        Constructor
        '''
        DataService.initialize(dbname)
        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
       
    #DONE
    def addItem(self, item):
        """
        Availability and inventory attributes
        
        Parameters:
         - item
        """
        log_entry(self, "addItem called")
        try:
            return add_item(item)
        finally:
            close_session()

    def addWarehouse(self, warehouse):
        """
        Parameters:
         - warehouse
        """
        log_entry(self, "addWarehouse called")
        try:
            return add_warehouse(warehouse)
        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 isActive(self, item_id):
        """
        Parameters:
         - item_id
        """
        try:
            return is_active(item_id)
        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 retireItem(self, item_id):
        """
        Parameters:
        - item_id
        """
        log_entry(self, "retire item called")
        try:
            return retire_item(item_id)
        finally:
            close_session()

    def startItemOn(self, item_id, timestamp):
        """
        Parameters:
         - item_id
         - timestamp
        """
        try:
            start_item_on(item_id, timestamp)
        finally:
            close_session()

    def retireItemOn(self, item_id, timestamp):
        """
        Parameters:
         - item_id
         - timestamp
        """
        try:
            retire_item_on(item_id, timestamp)
        finally:
            close_session()

    def changeItemStatus(self, item_id, timestamp, newstatus):
        """
        Parameters:
         - item_id
         - timestamp
         - newstatus
        """
        log_entry(self, "change item status called")
        try:
            return change_item_status(item_id, newstatus)
        finally:
            close_session()


    def getItem(self, item_id):
        """
        Parameters:
         - item_id
        """
        log_entry(self, "item requested")
        try:
            return to_t_item( get_item(item_id))
        finally:
            close_session()
    
    def getItemsByCatalogId(self, catalog_item_id):
        """
        Parameters:
        - catalog_item_id
        """
        log_entry(self, "item requested")
        try:
            return get_items_by_catalog_id(catalog_item_id)
        finally:
            close_session()


    def getAllItems(self, isActive):
        """
        Parameters:
         - isActive
        """
        log_entry(self, "all items requested")
        try:
            items = get_all_items(isActive)
            ret_items = []
            for item in items:
                if item:
                    ret_items.append(to_t_item(item))
            return ret_items
        finally:
            close_session()
            
    def getAllItemsByStatus(self, itemStatus):
        """
        Parameters:
         - itemStatus
        """
        log_entry(self, "all items requested")
        try:
            items = get_all_items_by_status(itemStatus)
            ret_items = []
            for item in items:
                if item:
                    ret_items.append(to_t_item(item))
            return ret_items
        finally:
            close_session()

    def getItemInventory(self, item_id):
        """
        Parameters:
        - item_id
        """
        log_entry(self, "item inventory requested")
        try:
            inventory = get_item_inventoy(item_id)
            return to_t_item_inventory(inventory, item_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 getItemInventoryByCatalogId(self, item_id):
        """
        Parameters:
         - item_id
        """
        log_entry(self, "item inventory requested")
        inventory = get_item_inventory_by_catalog_id(item_id)
        return to_t_item_inventory(inventory, item_id)
    '''
    

    def getItemAvailabilityAtLocation(self, warehouse_loc, item_id):
        """
        Returns the id of the warehouse with the largest inventory of the item and the inventory size. The size of list will always be 2.
        
        Parameters:
         - warehouse_loc
         - item_id
        """
        try:
            return get_item_availability_for_location(warehouse_loc, item_id)
        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 markItemAsContentComplete(self, entityId):
        """
        Parameters:
         - entityId
        """
        try:
            return mark_item_as_content_complete(entityId)
        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(status.ACTIVE)
            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")
        finally:
            close_session()
            
    def getAllWarehousesForItem(self, item_id):
        """
        Parameters:
         - item_id
        """
        log_entry(self, "getting all warehouses for item")
        try:
            all_warehouses = get_all_warehouses_for_item(item_id)
            t_warehouses = []
            for warehouse in all_warehouses:
                t_warehouses.append(to_t_warehouse(warehouse))
            return t_warehouses
        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(to_t_item(item))
            return t_items
        finally:
            close_session()

    def reserveItemInWarehouse(self, itemId, warehouseId, 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, quantity)
        finally:
            close_session()
    
    def reduceReservationCount(self, itemId, warehouseId, 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, quantity)
        finally:
            close_session()
            
    def updateItem(self, item):
        """
        Parameters:
         - item
        """
        log_entry(self, "addItem called")
        try:
            return update_item(item)
        finally:
            close_session()
            
    def getBestSellers(self, start_index=0, total_items=None, category=-1):
        try:
            if total_items is None:
                total_items = self.best_sellers_limit
            stop_index = start_index + total_items
            return get_best_sellers(start_index, stop_index, category)
        finally:
            close_session()
            
    def getBestSellersCatalogIds(self, start_index, total_items, category=-1):
        """
        Parameters:
         - beginIndex
         - totalItems
        """
        try:
            if total_items is None:
                total_items = self.best_sellers_limit
            stop_index = start_index + total_items
            return get_best_sellers_catalog_ids(start_index, stop_index,category)
        finally:
            close_session()
            
    def getBestSellersCount(self, ):
        try:
            return get_best_sellers_count(None)
        finally:
            close_session()
            
    def getBestDeals(self,):
        try:
            return get_best_deals()
        finally:
            close_session()
            
    def getBestDealsCatalogIds(self, start_index, total_items, category=-1):
        """
        Parameters:
         - beginIndex
         - totalItems
        """
        try:
            stop_index = start_index + total_items
            return get_best_deals_catalog_ids(start_index, stop_index, category)
        finally:
            close_session()
            
    def getBestDealsCount(self, ):
        try:
            return get_best_deals_count()
        finally:
            close_session()
            
    def getLatestArrivals(self,):
        try:
            return get_latest_arrivals(self.latest_arrivals_limit)
        finally:
            close_session()
            
    def getLatestArrivalsCatalogIds(self, start_index, total_items, category=-1):
        """
        Parameters:
         - beginIndex
         - totalItems
        """
        try:
            if start_index > self.latest_arrivals_limit:
                return []
            stop_index = start_index + total_items
            if stop_index > self.latest_arrivals_limit:
                stop_index = self.latest_arrivals_limit
            return get_latest_arrivals_catalog_ids(start_index, stop_index, category)
        finally:
            close_session()
            
    def getLatestArrivalsCount(self, ):
        try:
            return get_latest_arrivals_count(self.latest_arrivals_limit)
        finally:
            close_session()

    def getItemPricing(self, itemId, warehouseId):
        """
        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, warehouseId))
        finally:
            close_session()

    def generateNewEntityID(self, ):
        try:
            return generate_new_entity_id()
        finally:
            close_session()
                    
    def putCategoryObject(self, object):
        """
        Parameters:
         - object
        """
        try:
            return put_category_object(object)
        finally:
            close_session()
            
    def getCategoryObject(self, ):
        try:
            return get_category_object()
        finally:
            close_session()
            
    def closeSession(self, ):
        close_session()