Subversion Repositories SmartDukaan

Rev

Rev 14118 | Rev 14120 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
13755 kshitij.so 1 
import pymongo
2 
from elixir import *
3 
from shop2020.model.v1.catalog.impl import DataService
4 
from shop2020.model.v1.catalog.impl.DataService import Item
5 
from shop2020.clients.InventoryClient import InventoryClient
6 
from dtr.utils.utils import to_java_date
7 
from datetime import datetime, timedelta
8 
import time
9 
 
10 
DataService.initialize(db_hostname='localhost')
11 
 
12 
con = None
13 
SOURCE_MAP = {'AMAZON':1,'FLIPKART':2,'SNAPDEAL':3,'SAHOLIC':4}
14 
DISCOUNT_TYPE = {'MRP':1,'DP':2}
15 
LATEST_UPDATED_ITEMS = []
16 
 
17 
now = datetime.now()
18 
 
19 
class __SkuInfo:
20 
 
21 
    def __init__(self, _id, skuBundleId, category_id, mrp, available_price, source_id, rank, maxNlc, minNlc, schemeAmount, minDiscount, \
14035 kshitij.so 22 
                 maxDiscount, discountType, dp, nlcPoints, bestSellerPoints, totalPoints, status, in_stock, maxprice, brand):
13755 kshitij.so 23 
        self._id = _id
24 
        self.skuBundleId = skuBundleId
25 
        self.category_id = category_id
26 
        self.mrp = mrp
27 
        self.available_price = available_price
28 
        self.source_id = source_id
29 
        self.rank = rank
30 
        self.maxNlc = maxNlc
31 
        self.minNlc = minNlc
32 
        self.schemeAmount = schemeAmount
33 
        self.minDiscount = minDiscount
34 
        self.maxDiscount = maxDiscount
35 
        self.discountType = discountType
36 
        self.dp = dp
37 
        self.nlcPoints = nlcPoints
38 
        self.bestSellerPoints = bestSellerPoints
13824 kshitij.so 39 
        self.totalPoints = totalPoints
40 
        self.status = status
41 
        self.in_stock = in_stock
42 
        self.maxprice = maxprice
14035 kshitij.so 43 
        self.brand = brand
13755 kshitij.so 44 
 
45 
 
46 
def get_mongo_connection(host='localhost', port=27017):
47 
    global con
48 
    if con is None:
49 
        print "Establishing connection %s host and port %d" %(host,port)
50 
        try:
51 
            con = pymongo.MongoClient(host, port)
52 
        except Exception, e:
53 
            print e
54 
            return None
55 
    return con
56 
 
57 
def populateStuff():
58 
    print "Inside populate"
59 
    global LATEST_UPDATED_ITEMS
60 
    """Fetch latest updated items across portals
61 
       and calculate max and min R-Nlc"""
62 
    offset= 0
63 
    while(True):
64 
        print "Fetching records offset %d and limit %d" %(offset,300)
65 
        topSkus = list(get_mongo_connection().Catalog.MasterData.find( {"$and":[{'updatedOn': { "$gt": to_java_date(now - timedelta(hours=4))} }, { 'source_id' : { "$in": SOURCE_MAP.values() } }] }).skip(offset).limit(300))
66 
        if len((topSkus)) == 0:
67 
            break
68 
        #topSkus = collection.find( {'_id':664})
69 
        for sku in topSkus:
13908 kshitij.so 70 
            """Fix this """
71 
            #TODO Compute deal flags else where.
13755 kshitij.so 72 
            info = __SkuInfo(sku['_id'], sku['skuBundleId'], sku['category_id'], sku['mrp'], sku['available_price'], sku['source_id'], sku['rank'], None, None, 0.0, None, \
14035 kshitij.so 73 
                             None, None, None, None, None, None, sku['status'], sku['in_stock'],None,sku['brand'].strip().upper())
13755 kshitij.so 74 
            exceptionalNlc = list(get_mongo_connection().Catalog.ExceptionalNlc.find( {"$and" : [ {'sku':info._id}, {'overrideNlc':1} ]} ))
75 
            if len(exceptionalNlc) > 0:
76 
                """Exceptional nlc found, no need to calculate max and min R-nlc"""
77 
                info.maxNlc = exceptionalNlc[0]['maxNlc']
78 
                info.minNlc = exceptionalNlc[0]['minNlc']
13824 kshitij.so 79 
                info.maxprice = exceptionalNlc[0]['maxNlc']
13755 kshitij.so 80 
                LATEST_UPDATED_ITEMS.append(info)
81 
                continue
82 
 
83 
            skuSchemeDetails = list(get_mongo_connection().Catalog.SkuSchemeDetails.find( {'sku':info._id}).sort([('addedOn',pymongo.DESCENDING)]).limit(1))
84 
            if len(skuSchemeDetails) > 0:
85 
                """Sku scheme details, populate scheme amount (Recently added)"""
13824 kshitij.so 86 
 
87 
                #TODO Add start date and end date of scehems
88 
 
13755 kshitij.so 89 
                info.schemeAmount = float(skuSchemeDetails[0]['schemeAmount'])
90 
 
91 
            skuDealerPrices = list(get_mongo_connection().Catalog.SkuDealerPrices.find( {'sku':info._id} ) )
92 
            if len(skuDealerPrices) > 0:
93 
                info.dp = skuDealerPrices[0]['dp']
94 
            skuDiscount = list(get_mongo_connection().Catalog.SkuDiscountInfo.find( {'sku':info._id} ) )
95 
            if len(skuDiscount) > 0:
96 
                """Sku rule found, populate max , min Discount and discount type"""
97 
                info.maxDiscount = skuDiscount[0]['max_discount']
98 
                info.minDiscount = skuDiscount[0]['min_discount']
99 
                info.discountType = DISCOUNT_TYPE.get(skuDiscount[0]['discountType'].upper())
100 
                LATEST_UPDATED_ITEMS.append(info)
101 
                continue
102 
 
14035 kshitij.so 103 
            categoryDiscount = list(get_mongo_connection().Catalog.CategoryDiscount.find( {"$and" : [{'brand':sku['brand'].strip().upper()}, {'category_id':sku['category_id']} ]} ))
13755 kshitij.so 104 
            if len(categoryDiscount) > 0:
105 
                info.maxDiscount = categoryDiscount[0]['max_discount']
106 
                info.minDiscount = categoryDiscount[0]['min_discount']
107 
                info.discountType = DISCOUNT_TYPE.get(categoryDiscount[0]['discountType'].upper())
108 
 
109 
            LATEST_UPDATED_ITEMS.append(info)
110 
        offset = offset + 300
111 
    for lol in LATEST_UPDATED_ITEMS:
112 
        print lol.__dict__
113 
 
114 
 
115 
def calculateNlc():
116 
    global LATEST_UPDATED_ITEMS
117 
    populated = 0
118 
    while(populated <= len(LATEST_UPDATED_ITEMS)):
119 
        inventory_client = InventoryClient().get_client()
120 
        for obj in LATEST_UPDATED_ITEMS[populated:300+populated]:
121 
            if obj.maxNlc > 0 and obj.minNlc > 0:
122 
                continue
123 
            saholic_sku = list(get_mongo_connection().Catalog.MasterData.find( {"$and":[{'skuBundleId': obj.skuBundleId}, { 'source_id' : SOURCE_MAP.get('SAHOLIC')}] }))
124 
            identifier = None
125 
            if len(saholic_sku) > 0:
126 
                identifier = saholic_sku[0]['identifier']
127 
            if obj.discountType == DISCOUNT_TYPE.get('MRP'):
128 
                if obj.mrp == 0:
129 
                    """Now mrp is zero, so we have to use saholic MRP"""
130 
                    if identifier is not None:
131 
                        it = Item.query.filter_by(catalog_item_id=identifier).first()
132 
                        obj.mrp = it.mrp
133 
                if obj.mrp > 0:
134 
                    obj.minNlc = obj.mrp - (obj.mrp * obj.maxDiscount/100) - obj.schemeAmount
13824 kshitij.so 135 
                    obj.maxNlc = obj.mrp - (obj.mrp * obj.minDiscount/100) - obj.schemeAmount
13982 kshitij.so 136 
                    obj.maxprice = obj.maxNlc
13755 kshitij.so 137 
            elif obj.discountType == DISCOUNT_TYPE.get('DP'):
138 
                if obj.dp == 0:
139 
                    """Now dp is zero, so we have to use saholic minimum dp for item"""
140 
                    if identifier is not None:
141 
                        it = Item.query.filter_by(catalog_item_id=identifier).first()
142 
                        try:
143 
                            vendorPricing = inventory_client.getAllItemPricing(it.id)
144 
                            min_dp = min(pricing.dealerPrice for pricing in vendorPricing)
145 
                            obj.dp = min_dp
146 
                        except:
147 
                            pass
148 
                if obj.dp > 0:
149 
                    obj.minNlc = obj.dp - (obj.dp * obj.maxDiscount/100) - obj.schemeAmount
13824 kshitij.so 150 
                    obj.maxNlc = obj.dp - (obj.dp * obj.minDiscount/100) - obj.schemeAmount
151 
                    obj.maxprice = obj.maxNlc
13755 kshitij.so 152 
            else:
153 
                """No rule found, use saholic min nlc as max and min R-Nlc"""
154 
                if identifier is not None:
155 
                    it = Item.query.filter_by(catalog_item_id=identifier).first()
156 
                    try:
157 
                        vendorPricing = inventory_client.getAllItemPricing(it.id)
158 
                        min_nlc = min(pricing.nlc for pricing in vendorPricing)
159 
                        obj.maxNlc = min_nlc
13824 kshitij.so 160 
                        obj.minNlc = min_nlc
161 
                        obj.maxprice = obj.maxNlc
13755 kshitij.so 162 
                    except:
163 
                        pass
164 
        populated = populated + 300
165 
        time.sleep(10)
166 
 
167 
def calculateNlcPoints():
168 
    global LATEST_UPDATED_ITEMS
169 
    for sku in LATEST_UPDATED_ITEMS:
170 
        if sku.maxNlc and sku.minNlc:
13824 kshitij.so 171 
 
172 
            """Create map - TODO"""
173 
 
174 
            if sku.status == 2:
175 
                eolWeight = .60
176 
            else:
177 
                eolWeight = 1.0
178 
            if sku.category_id == 3:
179 
                basePointPercentage = 5.0
180 
                maxNlcPoints = 200
181 
            elif sku.category_id == 5:
182 
                basePointPercentage = 8.0
183 
                maxNlcPoints = 150
184 
            else:
185 
                basePointPercentage = 10.0
186 
                maxNlcPoints = 150
13755 kshitij.so 187 
            discFromMinNlc = (sku.minNlc - sku.available_price)/sku.available_price *100
188 
            discFromMaxNlc = (sku.maxNlc - sku.available_price)/sku.available_price *100
189 
            if discFromMinNlc > 0:
13824 kshitij.so 190 
                nlcPoints = 100/basePointPercentage * discFromMinNlc
13755 kshitij.so 191 
            elif discFromMinNlc < 0 and discFromMaxNlc > 0:
192 
                nlcPoints = 0
193 
            else:
13824 kshitij.so 194 
                nlcPoints = 100/basePointPercentage * discFromMinNlc
195 
            if (min(nlcPoints,maxNlcPoints)) > 0:
196 
                sku.nlcPoints = (min(nlcPoints,maxNlcPoints)) * eolWeight
197 
            else:
198 
                sku.nlcPoints = (min(nlcPoints,maxNlcPoints))
13755 kshitij.so 199 
        else:
200 
            sku.nlcPoints = 0
201 
 
202 
def commitData():
203 
    global LATEST_UPDATED_ITEMS
204 
    for sku in LATEST_UPDATED_ITEMS:
205 
        #get_mongo_connection().Catalog.Deals.update({'_id':sku._id},{'$set' : sku.__dict__},upsert=True,multi=True)
14020 amit.gupta 206 
        get_mongo_connection().Catalog.Deals.update({'_id':sku._id},{"$set":sku.__dict__},upsert=True)
13755 kshitij.so 207 
 
208 
 
209 
def addBestSellerPoints():
210 
    allItems = list(get_mongo_connection().Catalog.Deals.find({}))
211 
    for sku in allItems:
13824 kshitij.so 212 
        bestSellerPoints = list(get_mongo_connection().Catalog.BestSellerPoints.find( {"$and":[{'min_rank': { "$lte": sku['rank'] } }, {'max_rank': { "$gte": sku['rank'] } } , { 'category_id' : sku['category_id'] }, { 'source_id' : sku['source_id'] }] } ))
13755 kshitij.so 213 
        if len(bestSellerPoints) > 0:
13824 kshitij.so 214 
            print bestSellerPoints[0]['points']
215 
            if (bestSellerPoints[0]['points']) > 0:
216 
                sku['bestSellerPoints'] = (bestSellerPoints[0]['points']) * bestSellerPoints[0]['weightage']
217 
            else:
218 
                sku['bestSellerPoints'] = (bestSellerPoints[0]['points'])
13755 kshitij.so 219 
        else:
13824 kshitij.so 220 
            sku['bestSellerPoints'] = -100
14114 kshitij.so 221 
        #sku['totalPoints'] = sku['bestSellerPoints'] + sku['nlcPoints']
222 
        get_mongo_connection().Catalog.Deals.update({'_id':sku['_id']},{'$set':{'bestSellerPoints':sku['bestSellerPoints']}},multi=False)
223 
 
224 
    for sku in allItems:
225 
        deal_item = list(get_mongo_connection().Catalog.Deals.find({'skuBundleId':sku['skuBundleId']}).sort('bestSellerPoints',pymongo.DESCENDING).limit(1))
14119 kshitij.so 226 
        if sku['source_id'] == 4 and deal_item[0]['source_id']!=4:
14114 kshitij.so 227 
            weight = .2
228 
        else:
229 
            weight = 1
230 
        if deal_item[0]['bestSellerPoints'] > 0:
231 
            sku['catalogBestSellerPoints'] = deal_item[0]['bestSellerPoints'] * weight
232 
        else:
233 
            sku['catalogBestSellerPoints'] = deal_item[0]['bestSellerPoints']
234 
 
235 
        sku['totalPoints'] = sku['catalogBestSellerPoints'] + sku['nlcPoints']
236 
        get_mongo_connection().Catalog.Deals.update({'_id':sku['_id']},{'$set':{'catalogBestSellerPoints':sku['catalogBestSellerPoints'],'totalPoints':sku['totalPoints']}},multi=False)
237 
 
13755 kshitij.so 238 
 
13828 kshitij.so 239 
def elimiateSimilarDeals():
13912 kshitij.so 240 
    allItems = get_mongo_connection().Catalog.Deals.find().distinct('skuBundleId')
241 
    for skuBundleId in allItems:
242 
        print skuBundleId
243 
        similarItems = list(get_mongo_connection().Catalog.Deals.find({'skuBundleId':skuBundleId}).sort([('available_price',pymongo.ASCENDING)]))
13828 kshitij.so 244 
        bestPrice = float("inf")
245 
        bestOne = None
246 
        bestSellerPoints = 0
247 
        toUpdate = []
248 
        for similarItem in similarItems:
13973 kshitij.so 249 
            if similarItem['in_stock'] == 0 or similarItem['maxprice'] is None or similarItem['maxprice'] < similarItem['available_price']:
13828 kshitij.so 250 
                get_mongo_connection().Catalog.Deals.update({ '_id' : similarItem['_id'] }, {'$set':{'showDeal':0 }})
251 
                continue
252 
            if similarItem['available_price'] < bestPrice:
253 
                bestOne = similarItem
254 
                bestPrice = similarItem['available_price']
255 
                bestSellerPoints = similarItem['bestSellerPoints']
256 
            elif similarItem['available_price'] == bestPrice and bestSellerPoints < similarItem['bestSellerPoints']:
257 
                bestOne = similarItem
258 
                bestPrice = similarItem['available_price']
259 
                bestSellerPoints = similarItem['bestSellerPoints']
260 
            else:
261 
                pass
262 
        if bestOne is not None:
263 
            for similarItem in similarItems:
264 
                toUpdate.append(similarItem['_id'])
265 
            toUpdate.remove(bestOne['_id'])
266 
            get_mongo_connection().Catalog.Deals.update({ '_id' : bestOne['_id'] }, {'$set':{'showDeal':1 }})
267 
        if len(toUpdate) > 0:
13908 kshitij.so 268 
            get_mongo_connection().Catalog.Deals.update({ '_id' : { "$in": toUpdate } }, {'$set':{'showDeal':0 }},upsert=False, multi=True)
13755 kshitij.so 269 
 
270 
def main():
271 
    populateStuff()
272 
    calculateNlc()
273 
    calculateNlcPoints()
274 
    commitData()
275 
    addBestSellerPoints()
13828 kshitij.so 276 
    elimiateSimilarDeals()
13755 kshitij.so 277 
 
13828 kshitij.so 278 
 
13755 kshitij.so 279 
if __name__=='__main__':
280 
    main()