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 = []

itemPricingMap = []

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

    global itemPricingMap

    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,'maxQuantity':d_item.maximumBuyQuantity})

                itemPricingMap[d_item.id] =sellingPrice

            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:

                temp_maxQuantity = availability

            else:

                temp_maxQuantity = maxQuantity

        if item.get('maxQuantity') is None or item.get('maxQuantity')==0:

            item['maxQuantity'] = temp_maxQuantity

        else:

            item['maxQuantity'] = min(availability,item.get('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:

                singleUnitPricing = False

                for temp in bulkPricing:

                    if temp.get('quantity') ==1:

                        singleUnitPricing = True

                if not singleUnitPricing:

                    bulkPricing.append({'quantity':1,'price':itemPricingMap.get(item.get('item_id'))})

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