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_all_item_pricing, add_vendor_pricing, \
    get_item_pricing, get_category, get_all_categories, add_category,\
    get_item_status_description, get_all_vendors, check_vendor_item_mapping,\
    get_item_mappings, add_vendor_item_mapping, check_similar_item,\
    change_risky_flag, get_items_by_vendor_category, get_risky_items,\
    get_similar_items_catalog_ids, add_product_notification,\
    send_product_notifications
from shop2020.model.v1.catalog.impl.Convertors import to_t_item,\
    to_t_item_inventory, to_t_warehouse, to_t_vendor_item_pricing, to_t_category,\
    to_t_vendor, to_t_vendor_item_mapping
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', db_hostname='localhost'):
        '''
        Constructor
        '''
        DataService.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
       
    #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 getItemStatusDescription(self, itemId):
        """
        Parameters:
         - itemId
        """
        try:
            return get_item_status_description(itemId)
        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:
            item = to_t_item( get_item(item_id))
            return item
        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, category, brand, modelName, modelNumber):
        """
        Parameters:
         - entityId
         - category
         - brand
         - modelName
         - modelNumber
        """
        try:
            return mark_item_as_content_complete(entityId, category, brand, modelName, modelNumber)
        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, brand, 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, brand, category)
        finally:
            close_session()
            
    def getBestSellersCount(self, ):
        try:
            return get_best_sellers_count()
        finally:
            close_session()
            
    def getBestDeals(self,):
        try:
            return get_best_deals()
        finally:
            close_session()
            
    def getBestDealsCatalogIds(self, start_index, total_items, brand,category=-1):
        """
        Parameters:
         - beginIndex
         - totalItems
        """
        try:
            stop_index = start_index + total_items
            return get_best_deals_catalog_ids(start_index, stop_index, brand, 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, beginIndex, totalItems, brand, categories):
        """
        Returns the list of catalog ids of latest arrivals in the given categories of the given brand.
        To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
        
        Parameters:
         - beginIndex
         - totalItems
         - brand
         - categories
        """
        try:
            if beginIndex > self.latest_arrivals_limit:
                return []
            stopIndex = beginIndex + totalItems
            if stopIndex > self.latest_arrivals_limit:
                stopIndex = self.latest_arrivals_limit
            return get_latest_arrivals_catalog_ids(beginIndex, stopIndex, brand, categories)
        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 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 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 addCategory(self, category):
        """
        Parameters:
         - category
        """
        try:
            return add_category(category)
        finally:
            close_session()

    def getCategory(self, id):
        """
        Parameters:
         - id
        """
        try:
            return to_t_category(get_category(id))
        finally:
            close_session()

    def getAllCategories(self, ):
        try:
            categories = get_all_categories()
            return [to_t_category(category) for category in categories]
        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 getAllVendors(self, ):
        """
        Return list of all vendors
        """
        return [to_t_vendor(v) for v in get_all_vendors()]
    
    def itemExists(self, productGroup, brand, modelNumber, color, vendorId, category):
        try:
            return check_vendor_item_mapping(productGroup, brand, modelNumber, color, vendorId, category)
        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 checkSimilarItem(self, productGroup, brand, modelNumber, color):
        """
        Checks if similar item exists (with same ProductGroup, Brand, ModelNumber, Color)
        If yes, returns the itemId else returns 0
        
        Parameters:
         - productGroup
         - brand
         - modelNumber
         - color
        """
        try:
            return check_similar_item(productGroup, brand, modelNumber, color)
        finally:
            close_session()

    def changeItemRiskyFlag(self, itemId, risky):
        """
        Marks/Unmarks an item as risky. This flag is used for automatic marking of an item as INACTIVE in case of zero inventory.
        
        Parameters:
         - itemId
         - risky
        """
        try:
            change_risky_flag(itemId, risky)
        finally:
            close_session()
            
    def getItemsByVendorCategory(self, vendorCategory):
        """
        Return list of items filtered by vendor category.
        Raises exception if vendorCategory is null.
        
        Parameters:
         - vendorCategory
        """
        try:
            return [to_t_item(item) for item in get_items_by_vendor_category(vendorCategory)]
        finally:
            close_session()

    def getItemsByRiskyFlag(self, ):
        """
        Returns list of items marked as risky.
        """
        try:
            return [to_t_item(item) for item in get_risky_items()]
        finally:
            close_session()

    def getSimilarItemsCatalogIds(self, beginIndex, totalItems, itemId):
        """
        Returns list of catalog ids of items with same similarity index as of the given itemId
        
        Parameters:
         - beginIndex
         - totalItems
         - itemId
        """
        try:
            return get_similar_items_catalog_ids(beginIndex, beginIndex+totalItems, itemId)
        finally:
            close_session()

    def addProductNotification(self, itemId, email):
        """
        Add user requests for out of stock items. Once user will ask for notify me an entry will
        
        Parameters:
        - itemId
        - email
        """
        try:
            return add_product_notification(itemId, email)
        finally:
            close_session()
            
    def sendProductNotifications(self, ):
        """
        Send the product notifications to the users for items which has stock.
        """
        try:
            return send_product_notifications()
        finally:
            close_session()
    def closeSession(self, ):
        close_session()