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, 'gross_price':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}).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:
-            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
-    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, "3_rankMap": rankMapMobiles,"5_rankMap": rankMapTablets }
+    mem_cache_val = {3:mobile_deals, 5:tablet_deals, 0:all_deals}
     mc.set(str(userId), mem_cache_val)
 def __populateFeaturedDeals():
-    print "Populating featured deals....."
+    all_category_fd = []
-    featuredDealsMobiles = {}
+    mobile_fd = []
-    featuredDealsTablets = {}
+    tablet_fd = []
-    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)])
+    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})
     for activeFeaturedDeal in activeFeaturedDeals:
+        for k,v in activeFeaturedDeal['rankDetails']:
-        deals = get_mongo_connection().Catalog.Deals.find({"skuBundleId":activeFeaturedDeal.get('skuBundleId'),"$or":[{"showDeal":1}, {"prepaidDeal":1}]})
+            featuredDeal = FeaturedDeals(activeFeaturedDeal['sku'], int(k), activeFeaturedDeal['thresholdPrice'], int(v))
-        for deal in deals:
+            if featuredDeal.category_id == 0:
-            if deal.get('available_price') <= activeFeaturedDeal.get('thresholdPrice'):
+                all_category_fd.append(featuredDeal)
-                f_deal = {'skuBundleId':activeFeaturedDeal.get('skuBundleId'), 'thresholdPrice':activeFeaturedDeal.get('thresholdPrice'), 'rank':activeFeaturedDeal.get('rank'),'category_id':activeFeaturedDeal.get('category_id')}
-                if activeFeaturedDeal.get('category_id') == 3:
+            elif featuredDeal.category_id == 3:
-                    featuredDealsMobiles[activeFeaturedDeal.get('rank')] = f_deal
+                mobile_fd.append(featuredDeal)
-                else:
+            elif featuredDeal.category_id == 5:
-                    featuredDealsTablets[activeFeaturedDeal.get('rank')] = f_deal
+                tablet_fd.append(featuredDeal)
-                break
+            else:
+                continue
+    mc.set("featured_deals_category_"+str(0), all_category_fd, 3600)
-    mc.set("featured_deals", {3:featuredDealsMobiles,5:featuredDealsTablets}, 600)
+    mc.set("featured_deals_category_"+str(3), mobile_fd, 3600)
-    print mc.get("featured_deals")
+    mc.set("featured_deals_category_"+str(5), tablet_fd, 3600)
 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
-        rankMap = user_specific_deals.get(str(category_id)+"_rankMap")
+        sorted_deals = sorted(category_specific_deals, key = lambda x: (x['persPoints'],x['totalPoints'],x['bestSellerPoints'], x['nlcPoints'], x['rank']),reverse=True)
     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:
-            filtered_deals = filterDeals(category_specific_deals, filterData)
+            sorted_deals = filterDeals(sorted_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 = []
         for d in dealList:
             item = list(get_mongo_connection().Catalog.MasterData.find({'_id':d['_id']}))
             if len(item) ==0:
                 brandsFiltered = deals
             for deal in deals:
                 if str(int(deal['brand_id'])) in toFilter:
                     brandsFiltered.append(deal)
     if len(dealFiltered) == 0:
-        return [trend['skuBundleId'] for trend in brandsFiltered]
+        return brandsFiltered
-    return [i['skuBundleId'] for i in dealFiltered for j in brandsFiltered if i['_id']==j['_id']]
+    return [i 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({})
+    cursor = collection.find({'endDate':{'$gte':to_java_date(datetime.now())}}).skip(offset).limit(limit)
     for val in cursor:
-        master = list(get_mongo_connection().Catalog.MasterData.find({'skuBundleId':val['skuBundleId']}))
+        master = list(get_mongo_connection().Catalog.MasterData.find({'_id':val['sku']}))
         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 master is None:
+    if multi !=1:
-        return {0:"BundleId is wrong"}
+        collection = get_mongo_connection().Catalog.FeaturedDeals
-    data['category_id'] = master['category_id']
-    exist = collection.find({'rank':data['rank'],'category_id':data['category_id']})
+        cursor = collection.find({'sku':data['sku'],'startDate':{'$lte':data['startDate']},'endDate':{'$gte':data['endDate']}})
-    if cursor.count() > 0:
+        if cursor.count() > 0:
-        return {0:"SkuBundleId information already present."}
+            return {0:"Sku information already present."}
+        else:
-    elif exist.count() >0:
+            collection.insert(data)
+            get_mongo_connection().Catalog.MasterData.update({'_id':data['sku']},{"$set":{'updatedOn':to_java_date(datetime.now())}},multi=False)
-        return {0:"Rank already assigned bundleId %s"%(exist[0]['skuBundleId'])}
+            return {1:"Data added successfully"}
     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 datetime.now()
+    print getDummyDeals(3, 0, 10)
     #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 17365 → 17366