Subversion Repositories SmartDukaan

from bson.objectid import ObjectId
from datetime import datetime, timedelta
from dtr.config import PythonPropertyReader
from dtr.main import Store
from dtr.dao import FeaturedDeals
from dtr.storage import DataService
from dtr.storage.DataService import price_preferences, brand_preferences, \
    user_actions, Brands
from dtr.storage.MemCache import MemCache
from dtr.utils.utils import to_java_date
from elixir import *
from operator import itemgetter
import pymongo
import re
import traceback
import random

con = None

DataService.initialize(db_hostname="localhost")
mc = MemCache("127.0.0.1")

SOURCE_MAP = {1:'AMAZON',2:'FLIPKART',3:'SNAPDEAL',4:'SAHOLIC'}

def get_mongo_connection(host='localhost', port=27017):
    global con
    if con is None:
        print "Establishing connection %s host and port %d" %(host,port)
        try:
            con = pymongo.MongoClient(host, port)
        except Exception, e:
            print e
            return None
    return con

def populateCashBack():
    print "Populating cashback"
    cashBackMap = {}
    itemCashBackMap = {}
    cashBack = list(get_mongo_connection().Catalog.CategoryCashBack.find())
    for row in cashBack:
        temp_map = {}
        temp_list = []
        if cashBackMap.has_key(row['source_id']):
            arr = cashBackMap.get(row['source_id'])
            for val in arr:
                temp_list.append(val)
            temp_map[row['category_id']] = row
            temp_list.append(temp_map)
            cashBackMap[row['source_id']] = temp_list 
        else:
            temp_map[row['category_id']] = row
            temp_list.append(temp_map)
            cashBackMap[row['source_id']] = temp_list
    itemCashBack = list(get_mongo_connection().Catalog.ItemCashBack.find())
    for row in itemCashBack:
        if not itemCashBackMap.has_key(row['skuId']):
            itemCashBackMap[row['skuId']] = row
    mc.set("item_cash_back", itemCashBackMap, 24 * 60 * 60)
    mc.set("category_cash_back", cashBackMap, 24 * 60 * 60)

def addCategoryDiscount(data):
    collection = get_mongo_connection().Catalog.CategoryDiscount
    query = []
    data['brand'] = data['brand'].strip().upper()
    data['discountType'] = data['discountType'].upper().strip()
    query.append({"brand":data['brand']})
    query.append({"category_id":data['category_id']})
    r = collection.find({"$and":query})
    if r.count() > 0:
        return {0:"Brand & Category info already present."}
    else:
        collection.insert(data)
        get_mongo_connection().Catalog.MasterData.update({'brand':data['brand'],'category_id':data['category_id']},{"$set":{'updatedOn':to_java_date(datetime.now())}},multi=True)
        return {1:"Data added successfully"}

def updateCategoryDiscount(data,_id):
    try:
        collection = get_mongo_connection().Catalog.CategoryDiscount
        collection.update({'_id':ObjectId(_id)},{"$set":{'min_discount':data['min_discount'],'max_discount':data['max_discount'],'discountType':data['discountType'].upper().strip()}},upsert=False, multi = False)
        get_mongo_connection().Catalog.MasterData.update({'brand':data['brand'],'category_id':data['category_id']},{"$set":{'updatedOn':to_java_date(datetime.now())}},multi=True)
        return {1:"Data updated successfully"}
    except:
        return {0:"Data not updated."}
    

def getAllCategoryDiscount():
    data = []
    collection = get_mongo_connection().Catalog.CategoryDiscount
    cursor = collection.find()
    for val in cursor:
        data.append(val)
    return data

def __getBundledSkusfromSku(sku):
    masterData =  get_mongo_connection().Catalog.MasterData.find_one({"_id":sku},{"skuBundleId":1})
    if masterData is not None:
        return list(get_mongo_connection().Catalog.MasterData.find({"skuBundleId":masterData.get('skuBundleId')},{'_id':1,'skuBundleId':1}))
    else:
        return []

def addSchemeDetailsForSku(data, multi):
    if multi ==1:
        skuIds = __getBundledSkusfromSku(data['sku'])
        for sku in skuIds:
            collection = get_mongo_connection().Catalog.SkuSchemeDetails
            data['sku'] = sku.get('_id')
            data['addedOn'] = to_java_date(datetime.now())
            data.pop('_id',None)
            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"}
    else:
        collection = get_mongo_connection().Catalog.SkuSchemeDetails
        data['addedOn'] = to_java_date(datetime.now())
        collection.insert(data)
        get_mongo_connection().Catalog.MasterData.update({'_id':data['sku']},{"$set":{'updatedOn':to_java_date(datetime.now())}},multi=False)
        return {1:"Data added successfully"}

def getAllSkuWiseSchemeDetails(offset, limit):
    data = []
    collection = get_mongo_connection().Catalog.SkuSchemeDetails
    cursor = collection.find().skip(offset).limit(limit)
    for val in cursor:
        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']
        else:
            val['brand'] = ""
            val['source_product_name'] = ""
            val['skuBundleId'] = ""
        data.append(val)
    return data

def addSkuDiscountInfo(data, multi):
    if multi != 1:
        collection = get_mongo_connection().Catalog.SkuDiscountInfo
        cursor = collection.find({"sku":data['sku']})
        if cursor.count() > 0:
            return {0:"Sku information already present."}
        else:
            collection.insert(data)
            get_mongo_connection().Catalog.MasterData.update({'_id':data['sku']},{"$set":{'updatedOn':to_java_date(datetime.now())}},multi=False)
            return {1:"Data added successfully"}
    else:
        skuIds = __getBundledSkusfromSku(data['sku'])
        for sku in skuIds:
            data['sku'] = sku.get('_id')
            collection = get_mongo_connection().Catalog.SkuDiscountInfo
            cursor = collection.find({"sku":data['sku']})
            if cursor.count() > 0:
                continue
            else:
                data.pop('_id',None)
                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 getallSkuDiscountInfo(offset, limit):
    data = []
    collection = get_mongo_connection().Catalog.SkuDiscountInfo
    cursor = collection.find().skip(offset).limit(limit)
    for val in cursor:
        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']
        else:
            val['brand'] = ""
            val['source_product_name'] = ""
            val['skuBundleId'] = ""
        data.append(val)
    return data

def updateSkuDiscount(data,_id):
    try:
        collection = get_mongo_connection().Catalog.SkuDiscountInfo
        collection.update({'_id':ObjectId(_id)},{"$set":{'min_discount':data['min_discount'],'max_discount':data['max_discount'],'discountType':data['discountType'].upper().strip()}},upsert=False, multi = False)
        get_mongo_connection().Catalog.MasterData.update({'_id':data['sku']},{"$set":{'updatedOn':to_java_date(datetime.now())}},multi=False)
        return {1:"Data updated successfully"}
    except:
        return {0:"Data not updated."}


def addExceptionalNlc(data, multi):
    if multi!=1:
        collection = get_mongo_connection().Catalog.ExceptionalNlc
        cursor = collection.find({"sku":data['sku']})
        if cursor.count() > 0:
            return {0:"Sku information already present."}
        else:
            collection.insert(data)
            get_mongo_connection().Catalog.MasterData.update({'_id':data['sku']},{"$set":{'updatedOn':to_java_date(datetime.now())}},multi=False)
            return {1:"Data added successfully"}
    else:
        skuIds = __getBundledSkusfromSku(data['sku'])
        for sku in skuIds:
            data['sku'] = sku.get('_id')
            collection = get_mongo_connection().Catalog.ExceptionalNlc
            cursor = collection.find({"sku":data['sku']})
            if cursor.count() > 0:
                continue
            else:
                data.pop('_id',None)
                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 getAllExceptionlNlcItems(offset, limit):
    data = []
    collection = get_mongo_connection().Catalog.ExceptionalNlc
    cursor = collection.find().skip(offset).limit(limit)
    for val in cursor:
        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']
        else:
            val['brand'] = ""
            val['source_product_name'] = ""
            val['skuBundleId'] = ""
        data.append(val)
    return data

def getMerchantOrdersByUser(userId, page=1, window=50, searchMap={}):
    if searchMap is None:
        searchMap = {}
    if page==None:
        page = 1
        
    if window==None:
        window = 50
    result = {}
    skip = (page-1)*window
    
    if userId is not None:
        searchMap['userId'] = userId
    collection = get_mongo_connection().Dtr.merchantOrder
    cursor = collection.find(searchMap).sort("orderId",-1)
    total_count = cursor.count()
    pages = total_count/window + (0 if total_count%window==0 else 1)  
    print "total_count", total_count
    if total_count > skip:
        cursor = cursor.skip(skip).limit(window)
        orders = []
        for order in cursor:
            del(order["_id"])
            orders.append(order)
        result['data'] = orders
        result['window'] = window
        result['totalCount'] = total_count 
        result['currCount'] = cursor.count()
        result['totalPages'] = pages
        result['currPage'] = page    
        return result
    else:
        return result

def getRefunds(userId, page=1, window=10):
    if page==None:
        page = 1
        
    if window==None:
        window = 10
    result = {}
    skip = (page-1)*window
    collection = get_mongo_connection().Dtr.refund
    cursor = collection.find({"userId":userId})
    total_count = cursor.count()
    pages = total_count/window + (0 if total_count%window==0 else 1)  
    print "total_count", total_count
    if total_count > skip:
        cursor = cursor.skip(skip).limit(window).sort([('batch',-1)])
        refunds = []
        for refund in cursor:
            del(refund["_id"])
            refunds.append(refund)
        result['data'] = refunds
        result['window'] = window
        result['totalCount'] = total_count 
        result['currCount'] = cursor.count()
        result['totalPages'] = pages
        result['currPage'] = page    
        return result
    else:
        return result
    
def getPendingRefunds(userId):
    print type(userId)
    result = get_mongo_connection().Dtr.merchantOrder\
        .aggregate([
                    {'$match':{'subOrders.cashBackStatus':Store.CB_APPROVED, 'userId':userId}},
                    {'$unwind':"$subOrders"},
                    {'$match':{'subOrders.cashBackStatus':Store.CB_APPROVED}},
                    { 
                     '$group':{
                               '_id':None,
                               'amount': { '$sum':'$subOrders.cashBackAmount'},
                               }
                     }
                ])['result']

    if len(result)>0:
        result = result[0]        
        result.pop("_id")
    else:
        result={}
        result['amount'] = 0.0
    result['nextCredit'] = datetime.strftime(next_weekday(datetime.now(), int(PythonPropertyReader.getConfig('CREDIT_DAY_OF_WEEK'))),"%Y-%m-%d %H:%M:%S")
    return result

def getPendingCashbacks(userId):
    result = get_mongo_connection().Dtr.merchantOrder\
        .aggregate([
                    {'$match':{'subOrders.cashBackStatus':Store.CB_PENDING, 'userId':userId}},
                    {'$unwind':"$subOrders"},
                    {'$match':{'subOrders.cashBackStatus':Store.CB_PENDING}},
                    { 
                     '$group':{
                               '_id':None,
                               'amount': { '$sum':'$subOrders.cashBackAmount'},
                               }
                     }
                ])['result']

    if len(result)>0:
        result = result[0]        
        result.pop("_id")
    else:
        result={}
        result['amount'] = 0.0
    return result

def __populateCache(userId):
    print "Populating memcache for userId",userId
    outer_query = []
    outer_query.append({"showDeal":1})
    query = {}
    query['$gte'] = -100
    outer_query.append({'totalPoints':query})
    brandPrefMap = {}
    pricePrefMap = {}
    actionsMap = {}
    brand_p = session.query(price_preferences).filter_by(user_id=userId).all()
    for x in brand_p:
        pricePrefMap[x.category_id] = [x.min_price,x.max_price]
    for x in session.query(brand_preferences).filter_by(user_id=userId).all():
        temp_map = {}
        if brandPrefMap.has_key((x.brand).strip().upper()):
            val = brandPrefMap.get((x.brand).strip().upper())
            temp_map[x.category_id] = 1 if x.status == 'show' else 0
            val.append(temp_map)
        else:
            temp = []
            temp_map[x.category_id] = 1 if x.status == 'show' else 0
            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}).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
        elif actionsMap.get(deal['_id']) == 1:
            fav_weight = 1.5
        else:
            fav_weight = 1
        
        if brandPrefMap.get(deal['brand'].strip().upper()) is not None:
            brand_weight = 1
            for brandInfo in brandPrefMap.get(deal['brand'].strip().upper()):
                if brandInfo.get(deal['category_id']) is not None:
                    if brandInfo.get(deal['category_id']) == 1:
                        brand_weight = 2.0
        else:
            brand_weight = 1
        
        if pricePrefMap.get(deal['category_id']) is not None:
        
            if deal['available_price'] >= pricePrefMap.get(deal['category_id'])[0] and deal['available_price'] <= pricePrefMap.get(deal['category_id'])[1]:
                asp_weight = 1.5
            elif  deal['available_price'] >= pricePrefMap.get(deal['category_id'])[0] - 0.5 * pricePrefMap.get(deal['category_id'])[0] and deal['available_price'] <= pricePrefMap.get(deal['category_id'])[1] + 0.5 * pricePrefMap.get(deal['category_id'])[1]:
                asp_weight = 1.2
            else:
                asp_weight = 1
        else:
            asp_weight = 1
        
        persPoints = deal['totalPoints'] * fav_weight * brand_weight * asp_weight
        deal['persPoints'] = persPoints
        
        if deal['category_id'] ==3:
            mobile_deals.append(deal)
        elif deal['category_id'] ==5:
            tablet_deals.append(deal)
        else:
            continue
        all_category_deals.append(deal)
    
    session.close()
    mem_cache_val = {3:mobile_deals, 5:tablet_deals, 0:all_deals}
    mc.set(str(userId), mem_cache_val)
    

def __populateFeaturedDeals():
    all_category_fd = []
    mobile_fd = []
    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.ASCENDING})
    for activeFeaturedDeal in activeFeaturedDeals:
        for k,v in activeFeaturedDeal['rankDetails']:
            featuredDeal = FeaturedDeals(activeFeaturedDeal['sku'], int(k), activeFeaturedDeal['thresholdPrice'], int(v))
            if featuredDeal.category_id == 0:
                all_category_fd.append(featuredDeal)
            elif featuredDeal.category_id == 3:
                mobile_fd.append(featuredDeal)
            elif featuredDeal.category_id == 5:
                tablet_fd.append(featuredDeal)
            else:
                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_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
    dealsMap = {}
    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)
    
    if sort is None or direction is None:
        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 = True
            else:
                rev = False
            sorted_deals = sorted(category_specific_deals, key = lambda x: (x['available_price']),reverse=rev)
    
    
    print "============================"
    if filterData is not None:
        try:
            sorted_deals = filterDeals(sorted_deals, filterData)
        except:
            traceback.print_exc()    
    
    for d in sorted_deals[offset:offset+limit]:
        item = list(get_mongo_connection().Catalog.MasterData.find({'_id':d['_id']}))
        if not dealsMap.has_key(item[0]['identifier']):
            item[0]['dealRank'] = rank
            item[0]['persPoints'] = d['persPoints']
            if d['dealType'] == 1 and d['source_id'] ==1:
                item[0]['marketPlaceUrl'] = "http://www.amazon.in/dp/%s"%(item[0]['identifier'].strip())
            elif d['source_id'] ==3:
                item[0]['marketPlaceUrl'] = item[0]['marketPlaceUrl']+'?supc='+item[0].get('identifier')
            else:
                pass 
            try:
                cashBack = getCashBack(item[0]['_id'], item[0]['source_id'], item[0]['category_id'])
                if not cashBack or cashBack.get('cash_back_status')!=1:
                    item[0]['cash_back_type'] = 0
                    item[0]['cash_back'] = 0
                else:
                    item[0]['cash_back_type'] = int(cashBack['cash_back_type'])
                    item[0]['cash_back'] = cashBack['cash_back']
            except:
                print "Error in adding cashback to deals"
                item[0]['cash_back_type'] = 0
                item[0]['cash_back'] = 0
            dealsMap[item[0]['identifier']] = item[0]
            
            rank +=1
    return sorted(dealsMap.values(), key=itemgetter('dealRank'))


def filterDeals(deals, filterData):
    dealFiltered = []
    brandsFiltered = []
    filterArray = filterData.split('|')
    for data in filterArray:
        try:
            filter, info = data.split(':')
        except Exception as ex:
            traceback.print_exc()
            continue
        if filter == 'dealFilter':
            toFilter = info.split('^')
            print "deal filter ",toFilter
            if 'deals' in toFilter:
                dealFiltered = deals
                continue
            for filterVal in toFilter:
                if filterVal == 'dod':
                    for deal in deals:
                        if deal['dealType'] == 1:
                            dealFiltered.append(deal)
        elif filter == 'brandFilter':
            toFilter = info.split('^')
            print "brand filter ",toFilter
            if len(toFilter) == 0 or (len(toFilter)==1 and toFilter[0]==''):
                brandsFiltered = deals
            for deal in deals:
                if str(int(deal['brand_id'])) in toFilter:
                    brandsFiltered.append(deal)
    if len(dealFiltered) == 0:
        return brandsFiltered
    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()
    rank = 1
    deals = {}
    outer_query = []
    outer_query.append({"showDeal":1})
    query = {}
    query['$gt'] = 0
    outer_query.append({'totalPoints':query})
    if category_id in (3,5):
        outer_query.append({'category_id':category_id})
    if sort is None or direction is None:
        direct = -1
        print outer_query
        data = list(get_mongo_connection().Catalog.Deals.find({"$and":outer_query}).sort([('totalPoints',direct),('bestSellerPoints',direct),('nlcPoints',direct),('rank',direct)]).skip(offset).limit(limit))
    else:
        print outer_query
        direct = direction
        if sort == "bestSellerPoints":
            print "yes,sorting by bestSellerPoints"
            data = list(get_mongo_connection().Catalog.Deals.find({"$and":outer_query}).sort([('bestSellerPoints',direct),('rank',direct),('nlcPoints',direct)]).skip(offset).limit(limit))
        else:
            data = list(get_mongo_connection().Catalog.Deals.find({"$and":outer_query}).sort([(sort,direct)]).skip(offset).limit(limit))
    for d in data:
        item = list(get_mongo_connection().Catalog.MasterData.find({'_id':d['_id']}))
        if not deals.has_key(item[0]['identifier']):
            item[0]['dealRank'] = rank
            try:
                cashBack = getCashBack(item[0]['_id'], item[0]['source_id'], item[0]['category_id'])
                if not cashBack or cashBack.get('cash_back_status')!=1:
                    item[0]['cash_back_type'] = 0
                    item[0]['cash_back'] = 0
                else:
                    item[0]['cash_back_type'] = int(cashBack['cash_back_type'])
                    item[0]['cash_back'] = cashBack['cash_back']
            except:
                print "Error in adding cashback to deals"
                item[0]['cash_back_type'] = 0
                item[0]['cash_back'] = 0
            deals[item[0]['identifier']] = item[0]
            
            rank +=1
    return sorted(deals.values(), key=itemgetter('dealRank'))

def getItem(skuId):
    if not bool(mc.get("category_cash_back")):
        populateCashBack()
    try:
        skuData = list(get_mongo_connection().Catalog.MasterData.find({'_id':int(skuId)}))
        for sku in skuData:
            try:
                cashBack = getCashBack(sku['_id'], sku['source_id'], sku['category_id'])
                if not cashBack or cashBack.get('cash_back_status')!=1:
                    sku['cash_back_type'] = 0
                    sku['cash_back'] = 0
                else:
                    sku['cash_back_type'] = cashBack['cash_back_type']
                    sku['cash_back'] = cashBack['cash_back']
            except:
                print "Error in adding cashback to deals"
                sku['cash_back_type'] = 0
                sku['cash_back'] = 0
            sku['in_stock'] = int(sku['in_stock'])
            sku['is_shortage'] = int(sku['is_shortage'])
            sku['category_id'] = int(sku['category_id'])
            sku['status'] = int(sku['status'])
        return skuData
    except:
        return [{}]

def getCashBack(skuId, source_id, category_id):
    if not bool(mc.get("category_cash_back")):
        populateCashBack()
    itemCashBackMap = mc.get("item_cash_back")
    itemCashBack = itemCashBackMap.get(skuId)
    if itemCashBack is not None:
        return itemCashBack
    cashBackMap = mc.get("category_cash_back")
    sourceCashBack = cashBackMap.get(source_id)
    if sourceCashBack is not None and len(sourceCashBack) > 0:
        for cashBack in sourceCashBack:
            if cashBack.get(category_id) is None:
                continue
            else:
                return cashBack.get(category_id)
    else:
        return {}

def getDealRank(identifier, source_id, userId):
    if source_id in (1,2,4,5):
        skuData = list(get_mongo_connection().Catalog.MasterData.find({'identifier':identifier.strip(), 'source_id':source_id}))
    elif source_id == 3:
        skuData = list(get_mongo_connection().Catalog.MasterData.find({'secondaryIdentifier':identifier.strip(), 'source_id':source_id}))
    else:
        return {'rank':0, 'description':'Source not valid'}
    if len(skuData) == 0:
        return {'rank':0, 'description':'No matching product identifier found'}
    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_id = skuData[0]['category_id']
    category_specific_deals = user_specific_deals.get(category_id)
    if category_specific_deals is None or len(category_specific_deals) ==0:
        return {'rank':0,'description':'Category specific deals is empty'}
    sorted_deals = sorted(category_specific_deals, key = lambda x: (x['persPoints'],x['totalPoints'],x['bestSellerPoints'], x['nlcPoints'], x['rank']),reverse=True)
    rank = 1
    for sorted_deal in sorted_deals:
        if sorted_deal['skuBundleId'] == skuData[0]['skuBundleId']:
            return {'rank':rank, 'description':'Rank found'}
        rank+=1
    return {'rank':0,'description':'Rank not found'}
    

def getCashBackDetails(identifier, source_id):
    if not bool(mc.get("category_cash_back")):
        populateCashBack()
        
    """Need to add item level cashback, no data available right now."""
    
    if source_id in (1,2,4,5):
        skuData = list(get_mongo_connection().Catalog.MasterData.find({'identifier':identifier.strip(), 'source_id':source_id}))
    elif source_id == 3:
        skuData = list(get_mongo_connection().Catalog.MasterData.find({'secondaryIdentifier':identifier.strip(), 'source_id':source_id}))
    else:
        return {}
    if len(skuData) > 0:
        itemCashBackMap = mc.get("item_cash_back")
        itemCashBack = itemCashBackMap.get(skuData[0]['_id'])
        if itemCashBack is not None:
            return itemCashBack
        cashBackMap = mc.get("category_cash_back")
        sourceCashBack = cashBackMap.get(source_id)
        if sourceCashBack is not None and len(sourceCashBack) > 0:
            for cashBack in sourceCashBack:
                if cashBack.get(skuData[0]['category_id']) is None:
                    continue
                else:
                    return cashBack.get(skuData[0]['category_id'])
        else:
            return {} 
    else:
        return {}
    
def getImgSrc(identifier, source_id):
    skuData = None
    if source_id in (1,2,4,5):
        skuData = get_mongo_connection().Catalog.MasterData.find_one({'identifier':identifier.strip(), 'source_id':source_id})
    elif source_id == 3:
        skuData = get_mongo_connection().Catalog.MasterData.find_one({'secondaryIdentifier':identifier.strip(), 'source_id':source_id})
    if skuData is None:
        return {}
    else:
        return {'thumbnail':skuData.get('thumbnail')}
    
def next_weekday(d, weekday):
    days_ahead = weekday - d.weekday()
    if days_ahead <= 0: # Target day already happened this week
        days_ahead += 7
    return d + timedelta(days_ahead)
    

def getAllDealerPrices(offset, limit):
    data = []
    collection = get_mongo_connection().Catalog.SkuDealerPrices
    cursor = collection.find().skip(offset).limit(limit)
    for val in cursor:
        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']
        else:
            val['brand'] = ""
            val['source_product_name'] = ""
            val['skuBundleId'] = ""
        data.append(val)
    return data

def addSkuDealerPrice(data, multi):
    if multi != 1:
        collection = get_mongo_connection().Catalog.SkuDealerPrices
        cursor = collection.find({"sku":data['sku']})
        if cursor.count() > 0:
            return {0:"Sku information already present."}
        else:
            collection.insert(data)
            get_mongo_connection().Catalog.MasterData.update({'_id':data['sku']},{"$set":{'updatedOn':to_java_date(datetime.now())}},multi=False)
            return {1:"Data added successfully"}
    else:
        skuIds = __getBundledSkusfromSku(data['sku'])
        for sku in skuIds:
            data['sku'] = sku.get('_id')
            collection = get_mongo_connection().Catalog.SkuDealerPrices
            cursor = collection.find({"sku":data['sku']})
            if cursor.count() > 0:
                continue
            else:   
                data.pop('_id',None)
                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 updateSkuDealerPrice(data, _id):
    try:
        collection = get_mongo_connection().Catalog.SkuDealerPrices
        collection.update({'_id':ObjectId(_id)},{"$set":{'dp':data['dp']}},upsert=False, multi = False)
        get_mongo_connection().Catalog.MasterData.update({'_id':data['sku']},{"$set":{'updatedOn':to_java_date(datetime.now())}},multi=False)
        return {1:"Data updated successfully"}
    except:
        return {0:"Data not updated."}

def updateExceptionalNlc(data, _id):
    try:
        collection = get_mongo_connection().Catalog.ExceptionalNlc
        collection.update({'_id':ObjectId(_id)},{"$set":{'maxNlc':data['maxNlc'], 'minNlc':data['minNlc'], 'overrideNlc':data['overrideNlc']}},upsert=False, multi = False)
        get_mongo_connection().Catalog.MasterData.update({'_id':data['sku']},{"$set":{'updatedOn':to_java_date(datetime.now())}},multi=False)
        return {1:"Data updated successfully"}
    except:
        return {0:"Data not updated."}

def resetCache(userId):
    try:
        mc.delete(userId)
        return {1:'Cache cleared.'}
    except:
        return {0:'Unable to clear cache.'}
    
def updateCollection(data, multi):
    print data
    if multi!=1:
        try:
            collection = get_mongo_connection().Catalog[data['class']]
            class_name = data.pop('class')
            if class_name == "SkuSchemeDetails":
                data['addedOn'] = to_java_date(datetime.now())
            _id = data.pop('oid')
            result = collection.update({'_id':ObjectId(_id)},{"$set":data},upsert=False, multi = False)
            if class_name != "Notifications":
                record = list(collection.find({'_id':ObjectId(_id)}))
                if class_name !="CategoryDiscount":
                    get_mongo_connection().Catalog.MasterData.update({'_id':record[0]['sku']},{"$set":{'updatedOn':to_java_date(datetime.now())}})
                else:
                    get_mongo_connection().Catalog.MasterData.update({'brand':re.compile(record[0]['brand'], re.IGNORECASE),'category_id':record[0]['category_id']}, \
                                                                     {"$set":{'updatedOn':to_java_date(datetime.now())}},upsert=False,multi=True)
            return {1:"Data updated successfully"}
        except Exception as e:
            print e
            return {0:"Data not updated."}
    else:
        try:
            collection = get_mongo_connection().Catalog[data['class']]
            class_name = data.pop('class')
            _id = data.pop('oid')
            record = list(collection.find({'_id':ObjectId(_id)}))
            skuIds = __getBundledSkusfromSku(record[0]['sku'])
            for sku in skuIds:
                if class_name == "SkuSchemeDetails":
                    data['addedOn'] = to_java_date(datetime.now())
                data['sku'] = sku.get('_id')
                data.pop('_id',None)
                collection.update({'sku':sku.get('_id')},{"$set":data},upsert=False,multi=False)
            get_mongo_connection().Catalog.MasterData.update({'skuBundleId':sku.get('skuBundleId')},{"$set":{'updatedOn':to_java_date(datetime.now())}},multi=True)
            return {1:"Data updatedsuccessfully"}
        except Exception as e:
            print e
            return {0:"Data not updated."}
        
    
def addNegativeDeals(data, multi):
    if multi !=1: 
        collection = get_mongo_connection().Catalog.NegativeDeals
        cursor = collection.find({"sku":data['sku']})
        if cursor.count() > 0:
            return {0:"Sku information already present."}
        else:
            collection.insert(data)
            return {1:"Data added successfully"}
    else:
        skuIds = __getBundledSkusfromSku(data['sku'])
        for sku in skuIds:
            data['sku'] = sku.get('_id')
            collection = get_mongo_connection().Catalog.NegativeDeals
            cursor = collection.find({"sku":data['sku']})
            if cursor.count() > 0:
                continue
            else:
                data.pop('_id',None)
                collection.insert(data)
        return {1:"Data added successfully"}

def getAllNegativeDeals(offset, limit):
    data = []
    collection = get_mongo_connection().Catalog.NegativeDeals
    cursor = collection.find().skip(offset).limit(limit)
    for val in cursor:
        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']
        else:
            val['brand'] = ""
            val['source_product_name'] = ""
            val['skuBundleId'] = ""
        data.append(val)
    return data

def getAllManualDeals(offset, limit):
    data = []
    collection = get_mongo_connection().Catalog.ManualDeals
    cursor = collection.find().skip(offset).limit(limit)
    for val in cursor:
        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']
        else:
            val['brand'] = ""
            val['source_product_name'] = ""
            val['skuBundleId'] = ""
        data.append(val)
    return data
    
def addManualDeal(data, multi):
    if multi !=1:
        collection = get_mongo_connection().Catalog.ManualDeals
        cursor = collection.find({'sku':data['sku']})
        if cursor.count() > 0:
            return {0:"Sku information already present."}
        else:
            collection.insert(data)
            get_mongo_connection().Catalog.MasterData.update({'_id':data['sku']},{"$set":{'updatedOn':to_java_date(datetime.now())}},multi=False)
            return {1:"Data added successfully"}
    else:
        skuIds = __getBundledSkusfromSku(data['sku'])
        for sku in skuIds:
            data['sku'] = sku.get('_id')
            collection = get_mongo_connection().Catalog.ManualDeals
            cursor = collection.find({'sku':data['sku']})
            if cursor.count() > 0:
                continue
            else:
                data.pop('_id',None)
                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 deleteDocument(data):
    print data
    try:
        collection = get_mongo_connection().Catalog[data['class']]
        class_name = data.pop('class')
        _id = data.pop('oid')
        record = list(collection.find({'_id':ObjectId(_id)}))
        collection.remove({'_id':ObjectId(_id)})
        if class_name != "Notifications":
            if class_name !="CategoryDiscount":
                get_mongo_connection().Catalog.MasterData.update({'_id':record[0]['sku']},{"$set":{'updatedOn':to_java_date(datetime.now())}})
            else:
                get_mongo_connection().Catalog.MasterData.update({'brand':re.compile(record[0]['brand'], re.IGNORECASE),'category_id':record[0]['category_id']}, \
                                                                 {"$set":{'updatedOn':to_java_date(datetime.now())}},upsert=False,multi=True)
        return {1:"Document deleted successfully"}
    except Exception as e:
        print e
        return {0:"Document not deleted."}

def searchMaster(offset, limit, search_term):
    data = []
    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()}}).skip(offset).limit(limit)
            for record in collection:
                data.append(record)
        except:
            pass
    else:
        collection = get_mongo_connection().Catalog.MasterData.find({'source_id':{'$in':SOURCE_MAP.keys()}}).skip(offset).limit(limit)
        for record in collection:
            data.append(record)
    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)
    for val in cursor:
        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']
        else:
            val['brand'] = ""
            val['source_product_name'] = ""
            val['skuBundleId'] = ""
        data.append(val)
    return data
    
def addFeaturedDeal(data, multi):
    if multi !=1:
        collection = get_mongo_connection().Catalog.FeaturedDeals
        cursor = collection.find({'sku':data['sku'],'startDate':{'$lte':data['startDate']},'endDate':{'$gte':data['endDate']}})
        if cursor.count() > 0:
            return {0:"Sku information already present."}
        else:
            collection.insert(data)
            get_mongo_connection().Catalog.MasterData.update({'_id':data['sku']},{"$set":{'updatedOn':to_java_date(datetime.now())}},multi=False)
            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)
        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]
    if class_name == "Notifications":
        cursor = collection.find({'skuBundleId':skuBundleId})
        for val in cursor:
            master = list(get_mongo_connection().Catalog.MasterData.find({'skuBundleId':val['skuBundleId']}))
            if len(master) > 0:
                val['brand'] = master[0]['brand']
                val['model_name'] = master[0]['model_name']
                val['skuBundleId'] = master[0]['skuBundleId']
            else:
                val['brand'] = ""
                val['model_name'] = ""
                val['skuBundleId'] = val['skuBundleId']
            data.append(val)
        return data
    if sku is not None:
        cursor = collection.find({'sku':sku})
        for val in cursor:
            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']
            else:
                val['brand'] = ""
                val['source_product_name'] = ""
                val['skuBundleId'] = ""
            data.append(val)
        return data
    else:
        skuIds = get_mongo_connection().Catalog.MasterData.find({'skuBundleId':skuBundleId}).distinct('_id')
        for sku in skuIds:
            cursor = collection.find({'sku':sku})
            for val in cursor:
                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']
                else:
                    val['brand'] = ""
                    val['source_product_name'] = ""
                    val['skuBundleId'] = ""
                data.append(val)
        return data

def __getBrandIdForBrand(brandName, category_id):
    brandInfo = Brands.query.filter(Brands.category_id==category_id).filter(Brands.name == brandName).all()
    if brandInfo is None or len(brandInfo)!=1:
        raise
    else:
        return brandInfo[0].id

def addNewItem(data):
    try:
        data['updatedOn'] = to_java_date(datetime.now())
        data['addedOn'] = to_java_date(datetime.now())
        data['priceUpdatedOn'] = to_java_date(datetime.now())
        max_id = list(get_mongo_connection().Catalog.MasterData.find().sort([('_id',pymongo.DESCENDING)]).limit(1))
        max_bundle = list(get_mongo_connection().Catalog.MasterData.find().sort([('skuBundleId',pymongo.DESCENDING)]).limit(1))
        data['_id'] = max_id[0]['_id'] + 1
        data['skuBundleId'] = max_bundle[0]['skuBundleId'] + 1
        data['identifier'] = str(data['identifier'])
        data['secondaryIdentifier'] = str(data['secondaryIdentifier'])
        data['brand_id'] = __getBrandIdForBrand(data['brand'], data['category_id'])
        get_mongo_connection().Catalog.MasterData.insert(data)
        return {1:'Data added successfully'}
    except Exception as e:
        print e
        return {0:'Unable to add data.'}
    finally:
        session.close()
    
def addItemToExistingBundle(data):
    try:
        data['updatedOn'] = to_java_date(datetime.now())
        data['addedOn'] = to_java_date(datetime.now())
        data['priceUpdatedOn'] = to_java_date(datetime.now())
        max_id = list(get_mongo_connection().Catalog.MasterData.find().sort([('_id',pymongo.DESCENDING)]).limit(1))
        data['_id'] = max_id[0]['_id'] + 1
        data['identifier'] = str(data['identifier'])
        data['secondaryIdentifier'] = str(data['secondaryIdentifier'])
        data['brand_id'] = __getBrandIdForBrand(data['brand'], data['category_id'])
        get_mongo_connection().Catalog.MasterData.insert(data)
        return {1:'Data added successfully.'}
    except Exception as e:
        print e
        return {0:'Unable to add data.'}
    finally:
        session.close()

def updateMaster(data, multi):
    try:
        print data
        if multi != 1:
            _id = data.pop('_id')
            skuBundleId = data.pop('skuBundleId')
            data['updatedOn'] = to_java_date(datetime.now())
            data['identifier'] = str(data['identifier'])
            data['secondaryIdentifier'] = str(data['secondaryIdentifier'])
            data['brand_id'] = __getBrandIdForBrand(data['brand'], data['category_id'])
            get_mongo_connection().Catalog.MasterData.update({'_id':_id},{"$set":data},upsert=False)
            return {1:'Data updated successfully.'}
        else:
            _id = data.pop('_id')
            skuBundleId = data.pop('skuBundleId')
            data['updatedOn'] = to_java_date(datetime.now())
            data['identifier'] = str(data['identifier'])
            data['secondaryIdentifier'] = str(data['secondaryIdentifier'])
            data['brand_id'] = __getBrandIdForBrand(data['brand'], data['category_id'])
            get_mongo_connection().Catalog.MasterData.update({'_id':_id},{"$set":data},upsert=False)
            similarItems = get_mongo_connection().Catalog.MasterData.find({'skuBundleId':skuBundleId})
            for item in similarItems:
                if item['_id'] == _id:
                    continue
                item['updatedOn'] = to_java_date(datetime.now())
                item['thumbnail'] = data['thumbnail']
                item['category'] = data['category']
                item['category_id'] = data['category_id']
                item['tagline'] = data['tagline']
                item['is_shortage'] = data['is_shortage']
                item['mrp'] = data['mrp']
                item['status'] = data['status']
                item['maxPrice'] = data['maxPrice']
                item['brand_id'] = data['brand_id']
                similar_item_id = item.pop('_id')
                get_mongo_connection().Catalog.MasterData.update({'_id':similar_item_id},{"$set":item},upsert=False)
            return {1:'Data updated successfully.'}
    finally:
        session.close()

def getLiveCricScore():
    return mc.get('liveScore')

def addBundleToNotification(data):
    try:
        collection = get_mongo_connection().Catalog.Notifications
        cursor = collection.find({'skuBundleId':data['skuBundleId']})
        if cursor.count() > 0:
            return {0:"SkuBundleId information already present."}
        else:
            collection.insert(data)
            return {1:'Data updated successfully.'}
    except:
        return {0:'Unable to add data.'}

def getAllNotifications(offset, limit):
    data = []
    collection = get_mongo_connection().Catalog.Notifications
    cursor = collection.find().skip(offset).limit(limit)
    for val in cursor:
        master = list(get_mongo_connection().Catalog.MasterData.find({'skuBundleId':val['skuBundleId']}))
        if len(master) > 0:
            val['brand'] = master[0]['brand']
            val['model_name'] = master[0]['model_name']
            val['skuBundleId'] = master[0]['skuBundleId']
        else:
            val['brand'] = ""
            val['model_name'] = ""
            val['skuBundleId'] = val['skuBundleId']
        data.append(val)
    return data

def getBrandsForFilter(category_id):
    if mc.get("brandFilter") is None:
        print "Populating brand data for category_id %d" %(category_id)
        tabData, mobData = [], []
        mobileDeals = get_mongo_connection().Catalog.Deals.aggregate([
                                                                      {"$match":{"category_id":3,"showDeal":1,"totalPoints":{"$gte":-100}}
                                                                    },
                                                                 {"$group" : 
                                                                  {'_id':{'brand_id':'$brand_id','brand':'$brand'},'count':{'$sum':1}}
                                                                  }
                                                                ])
        
        tabletDeals = get_mongo_connection().Catalog.Deals.aggregate([
                                                                      {"$match":{"category_id":5,"showDeal":1,"totalPoints":{"$gte":-100}}
                                                                    },
                                                                 {"$group" : 
                                                                  {'_id':{'brand_id':'$brand_id','brand':'$brand'},'count':{'$sum':1}}
                                                                  }
                                                                ])
        
        allDeals = get_mongo_connection().Catalog.Deals.aggregate([
                                                                   {"$match":{"showDeal":1,"totalPoints":{"$gte":-100}}
                                                                    },
                                                                 {"$group" : 
                                                                  {'_id':{'brand_id':'$brand_id','brand':'$brand'},'count':{'$sum':1}}
                                                                  }
                                                                ])
        #print mobileDeals
        #print "==========Mobile data ends=========="
        
        #print tabletDeals
        #print "==========Tablet data ends=========="
        
        #print allDeals
        #print "==========All deal data ends========="
        
        for mobileDeal in mobileDeals['result']:
            if mobileDeal.get('_id').get('brand_id') != 0:
                tempMap = {}
                tempMap['brand'] = mobileDeal.get('_id').get('brand')
                tempMap['brand_id'] = mobileDeal.get('_id').get('brand_id')
                tempMap['count'] = mobileDeal.get('count')
                mobData.append(tempMap)
        
        for tabletDeal in tabletDeals['result']:
            if tabletDeal.get('_id').get('brand_id') != 0:
                tempMap = {}
                tempMap['brand'] = tabletDeal.get('_id').get('brand')
                tempMap['brand_id'] = tabletDeal.get('_id').get('brand_id')
                tempMap['count'] = tabletDeal.get('count')
                tabData.append(tempMap)
        
        
        brandMap = {}
        for allDeal in allDeals['result']:
            if allDeal.get('_id').get('brand_id') != 0:
                if brandMap.has_key(allDeal.get('_id').get('brand')):
                    brand_ids = brandMap.get(allDeal.get('_id').get('brand')).get('brand_ids')
                    brand_ids.append(allDeal.get('_id').get('brand_id'))
                    brandMap[allDeal.get('_id').get('brand')] = {'brand_ids':brand_ids,'count':brandMap.get(allDeal.get('_id').get('brand')).get('count') + allDeal.get('count')}
                else:
                    temp = []
                    temp.append(allDeal.get('_id').get('brand_id'))
                    brandMap[allDeal.get('_id').get('brand')] = {'brand_ids':temp,'count':allDeal.get('count')}
      
        mc.set("brandFilter",{0:brandMap, 3:mobData, 5:tabData}, 600)  
    
    return sorted(mc.get("brandFilter").get(category_id), key = lambda x: (-x['count'], x['brand']))

def getStaticDeals(offset, limit, category_id, direction):
    user_specific_deals = mc.get("staticDeals")
    if user_specific_deals is None:
        __populateStaticDeals()
        user_specific_deals = mc.get("staticDeals")
    rev = False
    if direction is None or direction == -1:
        rev=True
    return sorted((user_specific_deals.get(category_id))[offset:offset+limit],reverse=rev)

def __populateStaticDeals():
    print "Populating memcache for static deals"
    outer_query = []
    outer_query.append({"showDeal":1})
    query = {}
    query['$gte'] = -100
    outer_query.append({'totalPoints':query})
    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}).sort([('totalPoints',pymongo.DESCENDING),('bestSellerPoints',pymongo.DESCENDING),('nlcPoints',pymongo.DESCENDING),('rank',pymongo.DESCENDING)]))
    mobile_deals = []
    tablet_deals = []
    for deal in all_deals:
        item = get_mongo_connection().Catalog.MasterData.find({'_id':deal['_id']})
        if deal['category_id'] ==3:
            mobile_deals.append(getItemObjForStaticDeals(item[0]))
        elif deal['category_id'] ==5:
            tablet_deals.append(getItemObjForStaticDeals(item[0]))
        else:
            continue
    
    random.shuffle(mobile_deals,random.random)
    random.shuffle(tablet_deals,random.random)
    
    mem_cache_val = {3:mobile_deals, 5:tablet_deals}
    mc.set("staticDeals", mem_cache_val, 3600)

def getItemObjForStaticDeals(item):
    return {'marketPlaceUrl':item.get('marketPlaceUrl'),'available_price':item.get('available_price'),'source_product_name':item.get('source_product_name'),'thumbnail':item.get('thumbnail'),'source_id':int(item.get('source_id'))}
    
def main():
    #print getNewDeals(47, 3, 0, 20, None, None, "brandFilter:64")
    #mc.delete(str(-1))
    staticDeals = getStaticDeals(0,20,3)
    print "========="
    for y in staticDeals:
        print y
    
    
    
if __name__=='__main__':
    main()