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',5:"SHOPCLUES.COM"}

COLLECTION_MAP = {

                  'ExceptionalNlc':'skuBundleId',

                  'SkuDealerPrices':'skuBundleId',

                  'SkuDiscountInfo':'skuBundleId',

                  'SkuSchemeDetails':'skuBundleId',

                  }

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

    collection = get_mongo_connection().Catalog.SkuSchemeDetails

    result = collection.find_one({'skuBundleId':data['skuBundleId']})

    if result is None:

        collection.insert(data)

        get_mongo_connection().Catalog.MasterData.update({'skuBundleId':data['skuBundleId']},{"$set":{'updatedOn':to_java_date(datetime.now())}},multi=True)

        return {1:"Data added successfully"}

    return {1:"BundleId info already present"}

def getAllSkuWiseSchemeDetails(offset, limit):

    data = []

    collection = get_mongo_connection().Catalog.SkuSchemeDetails

    cursor = collection.find().skip(offset).limit(limit)

    for val in cursor:

        master = get_mongo_connection().Catalog.MasterData.find_one({'skuBundleId':val['skuBundleId']})

        if master is not None:

            val['brand'] = master['brand']

            val['source_product_name'] = master['source_product_name']

        else:

            val['brand'] = ""

            val['source_product_name'] = ""

        data.append(val)

    return data

def addSkuDiscountInfo(data):

    collection = get_mongo_connection().Catalog.SkuDiscountInfo

    cursor = collection.find_one({"skuBundleId":data['skuBundleId']})

    if cursor is not None:

        return {0:"BundleId information already present."}

    else:

        collection.insert(data)

        get_mongo_connection().Catalog.MasterData.update({'skuBundleId':data['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 = get_mongo_connection().Catalog.MasterData.find_one({'skuBundleId':val['skuBundleId']})

        if master is not None:

            val['brand'] = master['brand']

            val['source_product_name'] = master['source_product_name']

        else:

            val['brand'] = ""

            val['source_product_name'] = ""

        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['skuBundleId']},{"$set":{'updatedOn':to_java_date(datetime.now())}},multi=True)

        return {1:"Data updated successfully"}

    except:

        return {0:"Data not updated."}

def addExceptionalNlc(data):

    collection = get_mongo_connection().Catalog.ExceptionalNlc

    cursor = collection.find_one({"skuBundleId":data['skuBundleId']})

    if cursor is not None:

        return {0:"BundleId information already present."}

    else:

        collection.insert(data)

        get_mongo_connection().Catalog.MasterData.update({'skuBundleId':data['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 = get_mongo_connection().Catalog.MasterData.find_one({'skuBundleId':val['skuBundleId']})

        if master is not None:

            val['brand'] = master['brand']

            val['source_product_name'] = master['source_product_name']

        else:

            val['brand'] = ""

            val['source_product_name'] = ""

        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({ "$or": [ { "showDeal": 1} , { "prepaidDeal": 1 } ] })

    query = {}

    query['$gt'] = -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,'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

        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

    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)

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

    sortedMap = {}

    rankMap = {}

    rank = 0

    for sorted_deal in sorted_deals:

        if sortedMap.get(sorted_deal['skuBundleId']) is None:

            sortedMap[sorted_deal['skuBundleId']] = {rank:[sorted_deal]}

            rankMap[rank] = (sortedMap[sorted_deal['skuBundleId']].values())[0]

            rank = rank +1

        else:

            for temp_list in sortedMap.get(sorted_deal['skuBundleId']).itervalues():

                temp_list.append(sorted_deal)

            rankMap[(sortedMap.get(sorted_deal['skuBundleId']).keys())[0]] = temp_list

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

            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

            try:

                item[0]['dp'] = d['dp']

                item[0]['showDp'] = d['showDp']

            except:

                item[0]['dp'] = 0.0

                item[0]['showDp'] = 0

            temp.append(item[0])

        if len(temp) > 1:

            temp = sorted(temp, key = lambda x: (x['available_price']),reverse=False)

        dealsListMap.append(temp)

    return dealsListMap

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,showDp=None):

    temp = []

    if not bool(mc.get("category_cash_back")):

        populateCashBack()

    try:

        skuData = get_mongo_connection().Catalog.MasterData.find_one({'_id':int(skuId)})

        if skuData is None:

            raise

        try:

            cashBack = getCashBack(skuData['_id'], skuData['source_id'], skuData['category_id'])

            if not cashBack or cashBack.get('cash_back_status')!=1:

                skuData['cash_back_type'] = 0

                skuData['cash_back'] = 0

            else:

                skuData['cash_back_type'] = cashBack['cash_back_type']

                skuData['cash_back'] = cashBack['cash_back']

        except:

            print "Error in adding cashback to deals"

            skuData['cash_back_type'] = 0

            skuData['cash_back'] = 0

        skuData['in_stock'] = int(skuData['in_stock'])

        skuData['is_shortage'] = int(skuData['is_shortage'])

        skuData['category_id'] = int(skuData['category_id'])

        skuData['status'] = int(skuData['status'])

        if showDp is not None:

            dealerPrice = get_mongo_connection().Catalog.SkuDealerPrices.find_one({'skuBundleId':skuData['skuBundleId']})

            skuData['dp'] = 0.0

            skuData['showDp'] = 0

            if dealerPrice is not None:

                skuData['dp'] = dealerPrice['dp']

                skuData['showDp'] = dealerPrice['showDp']

        temp.append(skuData)

        return temp

    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','maxNlc':None, 'minNlc':None,'status':None,'dp':None}

    if len(skuData) == 0:

        return {'rank':0, 'description':'No matching product identifier found','maxNlc':None, 'minNlc':None,'status':None,'dp':None}

    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)

    dealsData = get_mongo_connection().Catalog.Deals.find_one({'skuBundleId':skuData[0]['skuBundleId']})

    if dealsData is None:

        dealsData = {}

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

        return {'rank':0,'description':'Category specific deals is empty','maxNlc':dealsData.get('maxNlc'),'minNlc':dealsData.get('minNlc'),'status':dealsData.get('status'),'dp':dealsData.get('dp')}

    sorted_deals = sorted(category_specific_deals, key = lambda x: (x['persPoints'],x['totalPoints'],x['bestSellerPoints'], x['nlcPoints'], x['rank']),reverse=True)

    sortedMap = {}

    rankMap = {}

    rank = 0

    for sorted_deal in sorted_deals:

        if sortedMap.get(sorted_deal['skuBundleId']) is None:

            sortedMap[sorted_deal['skuBundleId']] = {rank:[sorted_deal]}

            rankMap[rank] = (sortedMap[sorted_deal['skuBundleId']].values())[0]

            rank = rank +1

        else:

            for temp_list in sortedMap.get(sorted_deal['skuBundleId']).itervalues():

                temp_list.append(sorted_deal)

            rankMap[(sortedMap.get(sorted_deal['skuBundleId']).keys())[0]] = temp_list

    for dealRank ,dealList in rankMap.iteritems():

        for d in dealList:

            if d['skuBundleId'] == skuData[0]['skuBundleId']:

                return {'rank':dealRank+1,'description':'Rank found','maxNlc':dealsData.get('maxNlc'),'minNlc':dealsData.get('minNlc'),'status':dealsData.get('status'),'dp':dealsData.get('dp')}

    return {'rank':0,'description':'Rank not found','maxNlc':dealsData.get('maxNlc'),'minNlc':dealsData.get('minNlc'),'status':dealsData.get('status'),'dp':dealsData.get('dp')}

def getCashBackDetails(identifier, source_id):

    if not bool(mc.get("category_cash_back")):

        populateCashBack()

    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 = get_mongo_connection().Catalog.MasterData.find_one({'skuBundleId':val['skuBundleId']})

        if master is not None:

            val['brand'] = master['brand']

            val['source_product_name'] = master['source_product_name']

        else:

            val['brand'] = ""

            val['source_product_name'] = ""

        val['showDp'] = int(val['showDp'])

        data.append(val)

    return data

def addSkuDealerPrice(data):

    collection = get_mongo_connection().Catalog.SkuDealerPrices

    cursor = collection.find_one({"skuBundleId":data['skuBundleId']})

    if cursor is not None:

        return {0:"BundleId information already present."}

    else:

        collection.insert(data)

        get_mongo_connection().Catalog.MasterData.update({'skuBundleId':data['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({'skuBundleId':data['skuBundleId']},{"$set":{'updatedOn':to_java_date(datetime.now())}},multi=True)

        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({'skuBundleId':data['skuBundleId']},{"$set":{'updatedOn':to_java_date(datetime.now())}},multi=True)

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

    print data

    try:

        collection = get_mongo_connection().Catalog[data['class']]

        class_name = data.pop('class')

        _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":

                if record[0].has_key('sku'):

                    field = '_id'

                    val = record[0]['sku']

                else:

                    field = 'skuBundleId'

                    val = record[0]['skuBundleId']

                get_mongo_connection().Catalog.MasterData.update({field:val},{"$set":{'updatedOn':to_java_date(datetime.now())}},upsert=False, multi = True)

            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)

        if class_name =='SkuDealerPrices':

            get_mongo_connection().Catalog.Deals.update({'skuBundleId':val},{"$set":data},upsert=False, multi=True)

        return {1:"Data updated successfully"}

    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 "inside detete document"

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

                print record[0]

                if record[0].has_key('sku'):

                    field = '_id'

                    val = record[0]['sku']

                else:

                    field = 'skuBundleId'

                    val = record[0]['skuBundleId']

                print "Updating master"

                print field

                print val

                get_mongo_connection().Catalog.MasterData.update({field:val},{"$set":{'updatedOn':to_java_date(datetime.now())}},multi=True)

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