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
from shop2020.model.v1.catalog.impl.Convertors import to_t_item,\
    to_t_item_inventory, to_t_warehouse
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 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()