Subversion Repositories SmartDukaan

from datetime import datetime

from dtr.storage.MemCache import MemCache

from dtr.utils.utils import get_mongo_connection, SOURCE_MAP

from elixir import *

from shop2020.clients.InventoryClient import InventoryClient

from shop2020.model.v1.catalog.impl import DataService as CatalogDataService

from shop2020.model.v1.catalog.impl.DataService import Item, PrivateDeals, \

    BulkItemPricing, Tag_Listing

from shop2020.model.v1.inventory.impl import DataService as InventoryDataService

from shop2020.model.v1.inventory.impl.DataService import ItemAvailabilityCache

import optparse

import traceback

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

flaggedItems = []

itemPricingMap = {}

#listingPricing map is {<itemId>:[{tag_id:<tagId>, selling_price:<sellingPrice>, mop:<mop>}]}

listingPricingMap = {}

bulkItemsMap = {}

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'),'category_id':{"$in":[3,5,6]}})

    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)

        item_id_tags = session.query(Tag_Listing).filter(Tag_Listing.active==True).all()

        item_id_tags_map = {}

        for item_id_tag in item_id_tags:

            if not item_id_tags_map.has_key(item_id_tag.item_id):

                item_id_tags_map[item_id_tag.item_id] = []

            item_id_tags_map.get(item_id_tag.item_id).append(item_id_tag.tag_id)

        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]

            #No more normal deals only privatedeals are to be considered here

            items = session.query(Item,PrivateDeals).join((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"

                    temp = {'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}

                    if item_id_tags_map.has_key(d_item.id):

                        temp['tag_ids'] = item_id_tags_map.get(d_item.id)

                    tempList.append(temp)

                    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():

        itemList = []

        for item in v:

            availability = inventoryMap.get(item.get('item_id'))

            if availability is None or availability == 0:

                continue

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

            if item['minBuyQuantity'] > availability:

                item['minBuyQuantity'] = availability

            checkBulkPrices(item)

            item['bulkPricing'] = sorted(item['bulkPricing'], key=lambda k: k['quantity'],reverse=False)

            itemList.append(item)

        if len(itemList) > 0:    

            temp = sorted(itemList, key = lambda x: (x['availability']),reverse=True)

            mc = get_memcache_connection(host=options.mongoHost)

            mc.set(str("item_availability_"+str(k)), temp, 60*60)

        else:

            mc = get_memcache_connection(host=options.mongoHost)

            mc.delete(str("item_availability_"+str(k)))

def checkBulkPrices(item):

    adjusted = False

    """Lets check minBuyQty exist in bulkPricing"""

    minBuyQty = item['minBuyQuantity']

    for bulkPricingDict in item['bulkPricing']:

        if bulkPricingDict.get('quantity') == minBuyQty:

            adjusted = True

    if minBuyQty > 1 and not adjusted:

        allBulkPricing = bulkItemsMap.get(item.get('item_id'))

        if allBulkPricing is None or len(allBulkPricing) == 0:

            item['bulkPricing'] = [{'quantity':minBuyQty,'price':item.get('sellingPrice')}]

        else:

            allBulkPricing = sorted(allBulkPricing, key=lambda k: k['quantity'],reverse=False)

            effectiveBulkPrice = None

            for bulkPricing in allBulkPricing:

                if bulkPricing.get('quantity') < minBuyQty:

                    effectiveBulkPrice = bulkPricing

            if effectiveBulkPrice is None:

                item['bulkPricing'].append({'quantity':minBuyQty,'price':item.get('sellingPrice')})

            else:

                item['bulkPricing'].append({'quantity':minBuyQty,'price':effectiveBulkPrice['price']})

    toremove = []

    for bulkPricing in item['bulkPricing']:

        if bulkPricing['quantity'] < item['minBuyQuantity'] or bulkPricing['quantity'] > item['maxQuantity']:

            toremove.append(bulkPricing)

    for removePricing in toremove:

        item['bulkPricing'].remove(removePricing)

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():

    global 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()

def flagFofoMissingItems():

    try:

        CatalogDataService.initialize(db_hostname=options.hostname,setup=False)

        item_id_tags = session.query(Tag_Listing).filter(Tag_Listing.active==True).all()

        for item_id_tag in item_id_tags:

            if item_id_tag.item_id not in flaggedItems:

                flaggedItems.append(item_id_tag.item_id)

    finally:

        session.close()

if __name__ == '__main__':

    populateSaholicBundles()

    addItemIdInfo()

    addBulkPricingInfo()

    #Gets tagListing

    fetchItemAvailablity()

    flagNoAvailableItems()

    flagFofoMissingItems()

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