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
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 

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

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 type(item.get('identifier'))
        except Exception as e:
            print e
            print "Exception Identifier not valid for %d"%(item.get('_id'))
    print bundleMap 
                

def addItemIdInfo():
    global bundleMap
    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()
        print items
        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})
        if toBreak:
            print "Breaking"
            break
        start = fetch
        fetch = start + fetch
    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, 24*60*60)

    
def fetchItemAvailablity():
    global inventoryMap
    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
    session.close()

if __name__ == '__main__':
    populateSaholicBundles()
    addItemIdInfo()
    fetchItemAvailablity()
    addInfoToMemCache()
    mc = get_memcache_connection(host=options.mongoHost)
    print mc.get("item_availability_1005556")