WebSVN – SmartDukaan – Diff – /trunk/PyDTR/src/dtr/storage/Mongo.py

 import traceback
 from itertools import groupby
 import urllib
 import urllib2
 import json
+import collections
+try:
+    import ordereddict
+except:
+    pass
 con = None
 DataService.initialize(db_hostname="localhost")
 mc = MemCache("127.0.0.1")
 COLLECTION_MAP = {
                   'ExceptionalNlc':'skuBundleId',
                   'SkuDealerPrices':'skuBundleId',
                   'SkuDiscountInfo':'skuBundleId',
                   'SkuSchemeDetails':'skuBundleId',
-                  'DealPoints':'skuBundleId'
+                  'DealPoints':'skuBundleId',
+                  'FeaturedDeals': 'skuBundleId'
+                  }
 def get_mongo_connection(host='localhost', port=27017):
     global con
     if con is None:
             temp.append(temp_map)
             brandPrefMap[(x.brand).strip().upper()] = temp
     for x in session.query(user_actions).filter_by(user_id=userId).all():
         actionsMap[x.store_product_id] = 1 if x.action == 'like' else 0
-    all_deals = list(get_mongo_connection().Catalog.Deals.find({"$and":outer_query},{'_id':1,'category_id':1,'brand':1,'totalPoints':1,'bestSellerPoints':1,'nlcPoints':1,'rank':1,'available_price':1,'dealType':1,'source_id':1,'brand_id':1,'skuBundleId':1,'dp':1, 'showDp':1}).sort([('totalPoints',pymongo.DESCENDING),('bestSellerPoints',pymongo.DESCENDING),('nlcPoints',pymongo.DESCENDING),('rank',pymongo.DESCENDING)]))
+    all_deals = list(get_mongo_connection().Catalog.Deals.find({"$and":outer_query},{'_id':1,'category_id':1,'brand':1,'totalPoints':1,'bestSellerPoints':1,'nlcPoints':1,'rank':1,'available_price':1,'dealType':1,'source_id':1,'brand_id':1,'skuBundleId':1,'dp':1, 'showDp':1, 'gross_price':1}).sort([('totalPoints',pymongo.DESCENDING),('bestSellerPoints',pymongo.DESCENDING),('nlcPoints',pymongo.DESCENDING),('rank',pymongo.DESCENDING)]))
-    all_category_deals = []
     mobile_deals = []
     tablet_deals = []
     for deal in all_deals:
         if actionsMap.get(deal['_id']) == 0:
             fav_weight =.25
             mobile_deals.append(deal)
         elif deal['category_id'] ==5:
             tablet_deals.append(deal)
         else:
             continue
-        all_category_deals.append(deal)
     session.close()
+    mobile_deals = sorted(mobile_deals, key = lambda x: (x['persPoints'],x['totalPoints'],x['bestSellerPoints'], x['nlcPoints'], x['rank']),reverse=True)
+    tablet_deals = sorted(tablet_deals, key = lambda x: (x['persPoints'],x['totalPoints'],x['bestSellerPoints'], x['nlcPoints'], x['rank']),reverse=True)
+    try:
+        if mc.get("featured_deals") is None:
+            __populateFeaturedDeals()
+        featuredDeals = mc.get("featured_deals")
+    except Exception as e:
+        print traceback.print_exc()
+        featuredDeals = {3:{},5:{}}
+    print featuredDeals
+    sortedMapMobiles = {}
+    rankMapMobiles = {}
+    rankMobiles = 0
+    blockedRanksMobiles = []
+    blockedSkuBundlesMobiles = []
+    blockedInfoMobiles = {}
+    featuredDealsMobiles = featuredDeals.get(3)
+    for k, v in featuredDealsMobiles.iteritems():
+        if v.get('category_id') == 3:
+            blockedRanksMobiles.append(k-1)
+            blockedSkuBundlesMobiles.append(v.get('skuBundleId'))
+    print "Blocked ranks ", blockedRanksMobiles
+    print "Blocked bundles ", blockedSkuBundlesMobiles
+    for sorted_deal in mobile_deals:
+        while(True):
+            if rankMobiles in blockedRanksMobiles:
+                print "skipping rank ",rankMobiles
+                rankMobiles = rankMobiles +1
+            else:
+                break
+        if sorted_deal['skuBundleId'] in blockedSkuBundlesMobiles:
+            print "Yes sorted deal in blocked ",sorted_deal['skuBundleId']
+            if blockedInfoMobiles.has_key(sorted_deal['skuBundleId']):
+                blockedInfoMobiles.get(sorted_deal['skuBundleId']).append(sorted_deal)
+            else:
+                blockedInfoMobiles[sorted_deal['skuBundleId']] = [sorted_deal]
+            continue
+        if sortedMapMobiles.get(sorted_deal['skuBundleId']) is None:
+            sortedMapMobiles[sorted_deal['skuBundleId']] = {rankMobiles:[sorted_deal]}
+            rankMapMobiles[rankMobiles] = (sortedMapMobiles[sorted_deal['skuBundleId']].values())[0]
+            rankMobiles = rankMobiles +1
+        else:
+            for temp_list in sortedMapMobiles.get(sorted_deal['skuBundleId']).itervalues():
+                temp_list.append(sorted_deal)
+            rankMapMobiles[(sortedMapMobiles.get(sorted_deal['skuBundleId']).keys())[0]] = temp_list
+    print "Blocked info ", blockedInfoMobiles
+    for rank in blockedRanksMobiles:
+        print "Adding rank ",rank
+        rankMapMobiles[rank] = blockedInfoMobiles.get((featuredDealsMobiles.get(rank+1)).get('skuBundleId'))
+        print rankMapMobiles[rank]
+    sortedMapTablets = {}
+    rankMapTablets = {}
+    rankTablets = 0
+    blockedRanksTablets = []
+    blockedSkuBundlesTablets = []
+    blockedInfoTablets = {}
+    featuredDealsTablets = featuredDeals.get(5)
+    for k, v in featuredDealsTablets.iteritems():
+        if v.get('category_id') == 5:
+            blockedRanksTablets.append(k-1)
+            blockedSkuBundlesTablets.append(v.get('skuBundleId'))
+    print "Blocked ranks ", blockedRanksTablets
+    print "Blocked bundles ", blockedSkuBundlesTablets
+    for sorted_deal in tablet_deals:
+        while(True):
+            if rankTablets in blockedRanksTablets:
+                print "skipping rank ",rankTablets
+                rankTablets = rankTablets +1
+            else:
+                break
+        if sorted_deal['skuBundleId'] in blockedSkuBundlesTablets:
+            if blockedInfoTablets.has_key(sorted_deal['skuBundleId']):
+                blockedInfoTablets.get(sorted_deal['skuBundleId']).append(sorted_deal)
+            else:
+                blockedInfoTablets[sorted_deal['skuBundleId']] = [sorted_deal]
+            continue
+        if sortedMapTablets.get(sorted_deal['skuBundleId']) is None:
+            sortedMapTablets[sorted_deal['skuBundleId']] = {rankTablets:[sorted_deal]}
+            rankMapTablets[rankTablets] = (sortedMapTablets[sorted_deal['skuBundleId']].values())[0]
+            rankTablets = rankTablets +1
+        else:
+            for temp_list in sortedMapTablets.get(sorted_deal['skuBundleId']).itervalues():
+                temp_list.append(sorted_deal)
+            rankMapTablets[(sortedMapTablets.get(sorted_deal['skuBundleId']).keys())[0]] = temp_list
+    for rank in blockedRanksTablets:
+        print "Adding rank ",rank
+        rankMapTablets[rank] = blockedInfoTablets.get((featuredDealsTablets.get(rank+1)).get('skuBundleId'))
+        print rankMapTablets[rank]
-    mem_cache_val = {3:mobile_deals, 5:tablet_deals, 0:all_deals}
+    mem_cache_val = {3:mobile_deals, 5:tablet_deals, "3_rankMap": rankMapMobiles,"5_rankMap": rankMapTablets }
     mc.set(str(userId), mem_cache_val)
 def __populateFeaturedDeals():
-    all_category_fd = []
+    print "Populating featured deals....."
-    mobile_fd = []
+    featuredDealsMobiles = {}
-    tablet_fd = []
+    featuredDealsTablets = {}
-    activeFeaturedDeals = get_mongo_connection().Catalog.FeaturedDeals.find({'startDate':{'$lte':to_java_date(datetime.now())},'endDate':{'$gte':to_java_date(datetime.now())}}).sort({'rank':pymongo.ASCENDING})
+    activeFeaturedDeals = get_mongo_connection().Catalog.FeaturedDeals.find({'startDate':{'$lte':to_java_date(datetime.now())},'endDate':{'$gte':to_java_date(datetime.now())}}).sort([('rank',pymongo.DESCENDING)])
     for activeFeaturedDeal in activeFeaturedDeals:
-        for k,v in activeFeaturedDeal['rankDetails']:
-            featuredDeal = FeaturedDeals(activeFeaturedDeal['sku'], int(k), activeFeaturedDeal['thresholdPrice'], int(v))
+        deals = get_mongo_connection().Catalog.Deals.find({"skuBundleId":activeFeaturedDeal.get('skuBundleId'),"$or":[{"showDeal":1}, {"prepaidDeal":1}]})
-            if featuredDeal.category_id == 0:
+        for deal in deals:
-                all_category_fd.append(featuredDeal)
+            if deal.get('available_price') <= activeFeaturedDeal.get('thresholdPrice'):
+                f_deal = {'skuBundleId':activeFeaturedDeal.get('skuBundleId'), 'thresholdPrice':activeFeaturedDeal.get('thresholdPrice'), 'rank':activeFeaturedDeal.get('rank'),'category_id':activeFeaturedDeal.get('category_id')}
-            elif featuredDeal.category_id == 3:
+                if activeFeaturedDeal.get('category_id') == 3:
-                mobile_fd.append(featuredDeal)
+                    featuredDealsMobiles[activeFeaturedDeal.get('rank')] = f_deal
-            elif featuredDeal.category_id == 5:
+                else:
-                tablet_fd.append(featuredDeal)
+                    featuredDealsTablets[activeFeaturedDeal.get('rank')] = f_deal
-            else:
+                break
-                continue
-    mc.set("featured_deals_category_"+str(0), all_category_fd, 3600)
-    mc.set("featured_deals_category_"+str(3), mobile_fd, 3600)
+    mc.set("featured_deals", {3:featuredDealsMobiles,5:featuredDealsTablets}, 600)
-    mc.set("featured_deals_category_"+str(5), tablet_fd, 3600)
+    print mc.get("featured_deals")
 def getNewDeals(userId, category_id, offset, limit, sort, direction, filterData=None):
     if not bool(mc.get("category_cash_back")):
         populateCashBack()
-    try:
-        if mc.get("featured_deals_category_"+str(category_id)) is None:
-            __populateFeaturedDeals()
-    except:
-        pass
-    rank = 1
     dealsListMap = []
     user_specific_deals = mc.get(str(userId))
     if user_specific_deals is None:
         __populateCache(userId)
         user_specific_deals = mc.get(str(userId))
     else:
         print "Getting user deals from cache"
     category_specific_deals = user_specific_deals.get(category_id)
+    insert_featured_deals = False
     if sort is None or direction is None:
+        insert_featured_deals = True
-        sorted_deals = sorted(category_specific_deals, key = lambda x: (x['persPoints'],x['totalPoints'],x['bestSellerPoints'], x['nlcPoints'], x['rank']),reverse=True)
+        rankMap = user_specific_deals.get(str(category_id)+"_rankMap")
     else:
         if sort == "bestSellerPoints":
             sorted_deals = sorted(category_specific_deals, key = lambda x: (x['bestSellerPoints'], x['rank'], x['nlcPoints']),reverse=True)
         else:
             if direction == -1:
                 rev = False
             sorted_deals = sorted(category_specific_deals, key = lambda x: (x['available_price']),reverse=rev)
     print "============================"
+    filtered_deals = []
     if filterData is not None:
         try:
-            sorted_deals = filterDeals(sorted_deals, filterData)
+            filtered_deals = filterDeals(category_specific_deals, filterData)
         except:
             traceback.print_exc()
+    if not insert_featured_deals:
-    sortedMap = {}
+        sortedMap = {}
-    rankMap = {}
+        rankMap = {}
-    rank = 0
+        rank = 0
-    for sorted_deal in sorted_deals:
+        for sorted_deal in sorted_deals:
+            if len(filtered_deals) > 0 and  sorted_deal['skuBundleId'] not in filtered_deals:
+                continue
-        if sortedMap.get(sorted_deal['skuBundleId']) is None:
+            if sortedMap.get(sorted_deal['skuBundleId']) is None:
-            sortedMap[sorted_deal['skuBundleId']] = {rank:[sorted_deal]}
+                sortedMap[sorted_deal['skuBundleId']] = {rank:[sorted_deal]}
-            rankMap[rank] = (sortedMap[sorted_deal['skuBundleId']].values())[0]
+                rankMap[rank] = (sortedMap[sorted_deal['skuBundleId']].values())[0]
-            rank = rank +1
+                rank = rank +1
-        else:
+            else:
-            for temp_list in sortedMap.get(sorted_deal['skuBundleId']).itervalues():
+                for temp_list in sortedMap.get(sorted_deal['skuBundleId']).itervalues():
-                temp_list.append(sorted_deal)
+                    temp_list.append(sorted_deal)
-            rankMap[(sortedMap.get(sorted_deal['skuBundleId']).keys())[0]] = temp_list
+                rankMap[(sortedMap.get(sorted_deal['skuBundleId']).keys())[0]] = temp_list
+    else:
+        filterMap = {}
+        rank = 0
+        if len(filtered_deals) > 0:
+            try:
+                od = collections.OrderedDict(sorted(rankMap.items()))
+            except:
+                od = ordereddict.OrderedDict(sorted(rankMap.items()))
+            for k, v in od.iteritems():
+                if v[0].get('skuBundleId') in filtered_deals:
+                    filterMap[rank] = v
+                    rank =rank+1
+            rankMap = filterMap
     for dealList in [rankMap.get(k, []) for k in range(offset, offset+limit)]:
         temp = []
+        if dealList is None or len(dealList)==0:
+            continue
         for d in dealList:
             item = list(get_mongo_connection().Catalog.MasterData.find({'_id':d['_id']}))
             if len(item) ==0:
                 continue
             item[0]['persPoints'] = d['persPoints']
                 brandsFiltered = deals
             for deal in deals:
                 if str(int(deal['brand_id'])) in toFilter:
                     brandsFiltered.append(deal)
     if len(dealFiltered) == 0:
-        return brandsFiltered
+        return [trend['skuBundleId'] for trend in brandsFiltered]
-    return [i for i in dealFiltered for j in brandsFiltered if i['_id']==j['_id']]
+    return [i['skuBundleId'] for i in dealFiltered for j in brandsFiltered if i['_id']==j['_id']]
 def getDeals(userId, category_id, offset, limit, sort, direction):
     if not bool(mc.get("category_cash_back")):
         populateCashBack()
     return data
 def getAllFeaturedDeals(offset, limit):
     data = []
     collection = get_mongo_connection().Catalog.FeaturedDeals
-    cursor = collection.find({'endDate':{'$gte':to_java_date(datetime.now())}}).skip(offset).limit(limit)
+    cursor = collection.find({})
     for val in cursor:
-        master = list(get_mongo_connection().Catalog.MasterData.find({'_id':val['sku']}))
+        master = list(get_mongo_connection().Catalog.MasterData.find({'skuBundleId':val['skuBundleId']}))
         if len(master) > 0:
             val['brand'] = master[0]['brand']
             val['source_product_name'] = master[0]['source_product_name']
             val['skuBundleId'] = master[0]['skuBundleId']
+            val['category'] = 'Mobiles' if val['category_id'] == 3 else 'Tablets'
         else:
             val['brand'] = ""
             val['source_product_name'] = ""
             val['skuBundleId'] = ""
+            val['category'] = ""
         data.append(val)
     return data
 def addFeaturedDeal(data, multi):
+    collection = get_mongo_connection().Catalog.FeaturedDeals
+    cursor = collection.find({'skuBundleId':data['skuBundleId']})
+    master = get_mongo_connection().Catalog.MasterData.find_one({'skuBundleId':data['skuBundleId']})
-    if multi !=1:
+    if master is None:
-        collection = get_mongo_connection().Catalog.FeaturedDeals
+        return {0:"BundleId is wrong"}
+    data['category_id'] = master['category_id']
-        cursor = collection.find({'sku':data['sku'],'startDate':{'$lte':data['startDate']},'endDate':{'$gte':data['endDate']}})
+    exist = collection.find({'rank':data['rank'],'category_id':data['category_id']})
-        if cursor.count() > 0:
+    if cursor.count() > 0:
-            return {0:"Sku information already present."}
+        return {0:"SkuBundleId information already present."}
-        else:
-            collection.insert(data)
+    elif exist.count() >0:
-            get_mongo_connection().Catalog.MasterData.update({'_id':data['sku']},{"$set":{'updatedOn':to_java_date(datetime.now())}},multi=False)
-            return {1:"Data added successfully"}
+        return {0:"Rank already assigned bundleId %s"%(exist[0]['skuBundleId'])}
     else:
-        skuIds = __getBundledSkusfromSku(data['sku'])
-        for sku in skuIds:
-            data['sku'] = sku.get('_id')
-            collection = get_mongo_connection().Catalog.FeaturedDeals
-            cursor = collection.find({'sku':data['sku'],'startDate':{'$lte':data['startDate']},'endDate':{'$gte':data['endDate']}})
-            if cursor.count() > 0:
-                continue
-            else:
-                data.pop('_id',None)
-                collection.insert(data)
+        collection.insert(data)
-        get_mongo_connection().Catalog.MasterData.update({'skuBundleId':sku.get('skuBundleId')},{"$set":{'updatedOn':to_java_date(datetime.now())}},multi=True)
         return {1:"Data added successfully"}
 def searchCollection(class_name, sku, skuBundleId):
     data = []
     collection = get_mongo_connection().Catalog[class_name]
     returnObj = []
     for deal in all_deals:
         item = list(get_mongo_connection().Catalog.MasterData.find({'_id':deal['_id']}))
         returnObj.append(getItemObjForStaticDeals(item[0]))
     return returnObj
+def searchDummyDeals(search_term , limit):
+    data = []
+    uniqueMap = {}
+    if search_term is not None:
+        terms = search_term.split(' ')
+        outer_query = []
+        for term in terms:
+            outer_query.append({"source_product_name":re.compile(term, re.IGNORECASE)})
+        try:
+            collection = get_mongo_connection().Catalog.MasterData.find({"$and":outer_query,'source_id':{'$in':SOURCE_MAP.keys()}})
+            for record in collection:
+                data.append(record)
+        except:
+            pass
+    else:
+        collection = get_mongo_connection().Catalog.MasterData.find({'source_id':{'$in':SOURCE_MAP.keys()}})
+        for record in collection:
+            data.append(record)
+    for x in data:
+        if not uniqueMap.has_key(x['skuBundleId']):
+            uniqueMap[x['skuBundleId']] = {'source_product_name':x['source_product_name'],'skuBundleId':x['skuBundleId']}
+    return uniqueMap.values()[0:limit]
 def main():
     #generateRedirectUrl(101,1)
+    print datetime.now()
+    x=  getNewDeals(47, 3, 0, 500, None, None, None)
-    print getDummyDeals(3, 0, 10)
+    print datetime.now()
     #print addPayout("10", "55db82c0bcabd7fc59e0a71")
+    #data = {'skuBundleId':32111,'rank':200,'thresholdPrice':10000,'startDate':to_java_date(datetime.now()),'endDate':to_java_date(datetime.now)}
+    #print addFeaturedDeal(data, None)
+    #getAllFeaturedDeals(0, 50)
 if __name__=='__main__':
     main()

Subversion Repositories SmartDukaan

(root)/trunk/PyDTR/src/dtr/storage/Mongo.py – Rev 17366 → 17367