Subversion Repositories SmartDukaan

from elixir import *
from dtr.storage.MemCache import MemCache
from shop2020.model.v1.catalog.impl import DataService as CatalogDataService
from shop2020.model.v1.inventory.impl import DataService as InventoryDataService
from shop2020.model.v1.catalog.impl.DataService import Item, PrivateDeals, BulkItemPricing
from shop2020.model.v1.inventory.impl.DataService import ItemAvailabilityCache
from dtr.utils.utils import get_mongo_connection, SOURCE_MAP
import optparse
import traceback
from datetime import datetime
from shop2020.clients.InventoryClient import InventoryClient

parser = optparse.OptionParser()
parser.add_option("-H", "--host", dest="hostname",
                      default="localhost",
                      type="string", help="The HOST where the DB server is running",
                      metavar="host")
parser.add_option("-m", "--m", dest="mongoHost",
                      default="localhost",
                      type="string", help="The HOST where the mongo server is running",
                      metavar="mongo_host")

(options, args) = parser.parse_args()

bundleMap = {}
inventoryMap = {}
memCon = None
maxQuantity = 20
flaggedItems = []

def get_inventory_client():
    ic = InventoryClient("inventory_service_server_host2","inventory_service_server_port2").get_client()
    return ic

def get_memcache_connection(host='127.0.0.1'):
    global memCon
    if memCon is None:
        print "Establishing connection %s host" %(host)
        try:
            memCon = MemCache(host)
        except Exception, e:
            print e
            return None
    return memCon

def populateSaholicBundles():
    global bundleMap
    allSaholicBundles = get_mongo_connection(host=options.mongoHost).Catalog.MasterData.find({'source_id':SOURCE_MAP.get('SAHOLIC')})
    for item in allSaholicBundles:
        try:
            if item.get('identifier') is not None or item.get('identifier').strip()!="":
                #validItems.append({'_id':item.get('_id'),'catalog_item_id':long(item.get('identifier'))})
                bundleMap[long(item.get('identifier'))] = []
                
            else:
                print "Identifier not valid for %d"%(item.get('_id'))
                print item.get('identifier')
        except Exception as e:
            print e
            print "Exception Identifier not valid for %d"%(item.get('_id'))

def addItemIdInfo():
    global bundleMap
    try:
        CatalogDataService.initialize(db_hostname=options.hostname,setup=False)
        totalLength = len(bundleMap.keys())
        fetch =100
        start = 0
        toBreak = False
        while(True):
            print start
            print fetch
            if fetch > totalLength:
                fetch = totalLength
                toBreak = True
                
            item_list = bundleMap.keys()[start:fetch]
            items = session.query(Item,PrivateDeals).outerjoin((PrivateDeals,Item.id==PrivateDeals.item_id)).filter(Item.catalog_item_id.in_(item_list)).all()
            for i in items:
                d_item = i[0]
                d_privatedeal = i[1]
                tempList = bundleMap.get(d_item.catalog_item_id)
                sellingPrice = d_item.sellingPrice
                sellingPriceType = "Normal"
                if d_privatedeal is not None and d_privatedeal.isActive==1 and d_privatedeal.startDate < datetime.now() and d_privatedeal.endDate > datetime.now() and d_privatedeal.dealPrice >0:
                    sellingPrice = d_privatedeal.dealPrice
                    sellingPriceType = "Private deal price"
                tempList.append({'item_id':d_item.id,'color':d_item.color,'sellingPrice':sellingPrice,'sellingPriceType':sellingPriceType,'minBuyQuantity':d_item.minimumBuyQuantity,'quantityStep':d_item.quantityStep})
            if toBreak:
                print "Breaking"
                break
            start = fetch
            fetch = start + fetch
    finally:
        session.close()

def addInfoToMemCache():
    for k, v in bundleMap.iteritems():
        for item in v:
            availability = inventoryMap.get(item.get('item_id'))
            if availability is None:
                availability = 0
            item['availability'] = availability
            if availability < maxQuantity:
                item['maxQuantity'] = availability
            else:
                item['maxQuantity'] = maxQuantity
        temp = sorted(v, key = lambda x: (x['availability']),reverse=True)
        mc = get_memcache_connection(host=options.mongoHost)
        mc.set(str("item_availability_"+str(k)), temp, 60*60)

def flagNoAvailableItems():
    global flaggedItems
    for k, v in bundleMap.iteritems():
        for item in v:
            availability = inventoryMap.get(item.get('item_id'))
            if availability is None:
                flaggedItems.append(item.get('item_id'))

def addBulkPricingInfo():
    bulkItemsMap = {}
    bulkItems = session.query(BulkItemPricing).all()
    for item in bulkItems:
        if bulkItemsMap.has_key(item.item_id):
            temp_list = bulkItemsMap.get(item.item_id)
            temp_list.append({'quantity':item.quantity,'price':item.price}) 
        else:
            bulkItemsMap[item.item_id] = [{'quantity':item.quantity,'price':item.price}]
    for k, v in bundleMap.iteritems():
        for item in v:
            bulkPricing = bulkItemsMap.get(item.get('item_id'))
            if bulkPricing is None:
                item['bulkPricing'] = []
            else:
                item['bulkPricing'] = bulkPricing 

    
def fetchItemAvailablity():
    global inventoryMap
    try: 
        InventoryDataService.initialize(db_hostname=options.hostname,setup=False)
        allInventory = session.query(ItemAvailabilityCache).filter(ItemAvailabilityCache.sourceId==1).all()
        for itemInventory in allInventory:
            inventoryMap[itemInventory.itemId] = itemInventory.totalAvailability
    finally:
        session.close()

if __name__ == '__main__':
    populateSaholicBundles()
    addItemIdInfo()
    addBulkPricingInfo()
    fetchItemAvailablity()
    flagNoAvailableItems()
    if len(flaggedItems) > 0:
        print "Flagged items ",flaggedItems
        get_inventory_client().updateItemAvailabilityForItemIds(flaggedItems)
        fetchItemAvailablity()
    addInfoToMemCache()
    mc = get_memcache_connection(host=options.mongoHost)
    print mc.get("item_availability_1005556")