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.host,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.host,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")