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_all_warehouses_by_status,\
    get_Warehouse, get_all_warehouses_for_item, get_all_items_for_warehouse,\
    update_item, start_item_on,\
    retire_item_on, get_item_inventory_by_catalog_id, get_item_by_catalog_id,\
    get_item_by_vendor_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
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):
        '''
        Constructor
        '''
        DataService.initialize()
        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")
        return add_item(item)
        pass

    def addWarehouse(self, warehouse):
        """
        Parameters:
         - warehouse
        """
        log_entry(self, "addWarehouse called")
        return add_warehouse(warehouse)
        pass


    def updateInventory(self, warehouse_id, timestamp, availability):
        """
        Parameters:
         - warehouse_id
         - timestamp
         - availability
        """
        log_entry(self, "update Inventory called")
        return update_inventory(warehouse_id, timestamp, availability)
        
    def isActive(self, catalog_item_id):
        """
        Parameters:
         - catalog_item_id
        """
        return is_active(catalog_item_id)

    def retireWarehouse(self, warehouse_id):
        """
        Parameters:
         - warehouse_id
        """
        log_entry(self, "retire warehouse called")
        return retire_warehouse(warehouse_id)
        
    
    def retireItem(self, item_id):
        """
        Parameters:
        - item_id
        """
        log_entry(self, "retire item called")
        return retire_item(item_id)

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

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

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

    def getItem(self, item_id):
        """
        Parameters:
         - item_id
        """
        log_entry(self, "item requested")
        return to_t_item( get_Item(item_id))
    
    def getItemByCatalogId(self, catalog_item_id):
        """
        Parameters:
        - catalog_item_id
        """
        log_entry(self, "item requested")
        return to_t_item( get_item_by_catalog_id(catalog_item_id))

    def getItemByVendorId(self, vendor_item_id):
        """
        Parameters:
        - catalog_item_id
        """
        log_entry(self, "item requested")
        return to_t_item( get_item_by_vendor_id(vendor_item_id))
        pass


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

    def getAllItemsByStatus(self, itemStatus):
        """
        Parameters:
         - itemStatus
        """
        log_entry(self, "all items requested")
        
        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

    def getItemInventory(self, item_id):
        """
        Parameters:
        - item_id
        """
        log_entry(self, "item inventory requested")
        inventory = get_item_inventoy(item_id)
        return to_t_item_inventory(inventory, item_id)

    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 getItemAvailibilityAtWarehouse(self, warehouse_id, item_id):
        """
        Parameters:
         - warehouse_id
         - item_id
        """
        log_entry(self, "item availability at warehouse requested")
        return get_item_availability_for_warehouse(warehouse_id, item_id)

    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
        """
        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
    
    def getWarehouse(self, warehouse_id):
        """
        Parameters:
         - warehouse_id
        """
        log_entry(self, "get warehouse call")
        warehouse = get_Warehouse(warehouse_id)
        if warehouse:
            return to_t_warehouse(warehouse)
        else:
            raise InventoryServiceException(101, "no such warehouse")

    def getAllWarehousesForItem(self, item_id):
        """
        Parameters:
         - item_id
        """
        log_entry(self, "getting all warehouses for item")
        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

    def getAllItemsForWarehouse(self, warehouse_id):
        """
        Parameters:
         - warehouse_id
        """
        log_entry(self, "getting all items for warehouse")
        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
    
    def updateItem(self, item):
        """
        Parameters:
         - item
        """
        log_entry(self, "addItem called")
        return update_item(item)

    def getBestSellers(self, start_index=0, total_items=None, category=-1):
        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)
    
    def getBestSellersCatalogIds(self, start_index, total_items, category=-1):
        """
        Parameters:
         - beginIndex
         - totalItems
        """
        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)

    def getBestSellersCount(self, ):
        return get_best_sellers_count(None)

    def getBestDeals(self,):
        return get_best_deals()
    
    def getBestDealsCatalogIds(self, start_index, total_items, category=-1):
        """
        Parameters:
         - beginIndex
         - totalItems
        """
        stop_index = start_index + total_items
        return get_best_deals_catalog_ids(start_index, stop_index, category)

    def getBestDealsCount(self, ):
        return get_best_deals_count()

    def getLatestArrivals(self,):
        return get_latest_arrivals(self.latest_arrivals_limit)

    def getLatestArrivalsCatalogIds(self, start_index, total_items, category=-1):
        """
        Parameters:
         - beginIndex
         - totalItems
        """
        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)

    def getLatestArrivalsCount(self, ):
        return get_latest_arrivals_count(self.latest_arrivals_limit)