WebSVN – SmartDukaan – Diff – //trunk/PyProj/src/shop2020/model/v1/catalog/script/AmazonHistoryPopulator.py

 from shop2020.model.v1.catalog.impl import DataService
 from shop2020.model.v1.catalog.impl.DataService import Amazonlisted, Item, \
 Category, SourcePercentageMaster,SourceCategoryPercentage, SourceItemPercentage, AmazonPromotion, AmazonScrapingHistory, \
 ItemVatMaster, CategoryVatMaster
 from shop2020.thriftpy.model.v1.order.ttypes import OrderSource
-from shop2020.thriftpy.model.v1.catalog.ttypes import CompetitionCategory, SalesPotential,\
+from shop2020.thriftpy.model.v1.catalog.ttypes import CompetitionCategory, \
 Decision, RunType, AmazonPromotionType
-from shop2020.model.v1.catalog.script import SellerCentralInventoryReport, AmazonAsyncScraper
+from shop2020.model.v1.catalog.script import AmazonAsyncScraper
-from shop2020.clients.CatalogClient import CatalogClient
 from shop2020.clients.InventoryClient import InventoryClient
 from shop2020.clients.TransactionClient import TransactionClient
-import urllib2
 import time
 from datetime import date, datetime, timedelta
-from shop2020.utils import EmailAttachmentSender
-from shop2020.utils.EmailAttachmentSender import get_attachment_part
 import math
 import simplejson as json
 import xlwt
 import optparse
 import sys
-import smtplib
-from email.mime.text import MIMEText
+from operator import itemgetter
-import email
-from email.mime.multipart import MIMEMultipart
-import email.encoders
-import mechanize
-import cookielib
 config_client = ConfigClient()
 host = config_client.get_property('staging_hostname')
 syncPrice=config_client.get_property('sync_price_on_marketplace')
 amazonLongTermActivePromotions = []
 amazonShortTermActivePromotions = []
 saleMap = {}
 DataService.initialize(db_hostname=host)
-amScraper = AmazonAsyncScraper.AmazonAsyncScraper()
+amScraper = AmazonAsyncScraper.Products("AKIAII3SGRXBJDPCHSGQ", "B92xTbNBTYygbGs98w01nFQUhbec1pNCkCsKVfpg", "AF6E3O0VE0X4D")
-class __AmazonAsinPrice:
-    def __init__(self, asin, price):
-        self.asin = asin
-        self.price = price
 class __AmazonItemInfo:
     def __init__(self, asin, nlc, courierCost, sku, product_group, brand, model_name, model_number, color, weight, parent_category, risky, vatRate, runType, parent_category_name, sourcePercentage, ourInventory, state_id):
         self.asin = asin
         self.sourcePercentage = sourcePercentage
         self.ourInventory = ourInventory
         self.state_id = state_id
 class __AmazonDetails:
-    def __init__(self, sku, ourSp, ourRank, lowestSellerName,lowestSellerSp,secondLowestSellerName, secondLowestSellerSp, thirdLowestSellerName, thirdLowestSellerSp, totalSeller, multipleListings):
+    def __init__(self, sku, ourSp, ourRank, lowestSellerName,lowestSellerSp,secondLowestSellerName, secondLowestSellerSp, thirdLowestSellerName, thirdLowestSellerSp, totalSeller, multipleListings, \
+                 promoPrice, isPromotion, lowestSellerShippingTime, lowestSellerRating, secondLowestSellerShippingTime, secondLowestSellerRating, thirdLowestSellerShippingTime , \
+                 thirdLowestSellerRating, lowestSellerType, secondLowestSellerType, thirdLowestSellerType):
         self.sku =sku
         self.ourSp = ourSp
         self.ourRank = ourRank
         self.lowestSellerName = lowestSellerName
         self.lowestSellerSp = lowestSellerSp
         self.secondLowestSellerName = secondLowestSellerName
         self.secondLowestSellerSp = secondLowestSellerSp
         self.thirdLowestSellerName = thirdLowestSellerName
         self.thirdLowestSellerSp = thirdLowestSellerSp
         self.totalSeller = totalSeller
         self.multipleListings = multipleListings
+        self.promoPrice = promoPrice
+        self.isPromotion = isPromotion
+        self.lowestSellerShippingTime =lowestSellerShippingTime
+        self.lowestSellerRating = lowestSellerRating
+        self.secondLowestSellerShippingTime = secondLowestSellerShippingTime
+        self.secondLowestSellerRating = secondLowestSellerRating
+        self.thirdLowestSellerShippingTime= thirdLowestSellerShippingTime
+        self.thirdLowestSellerRating = thirdLowestSellerRating
+        self.lowestSellerType = lowestSellerType
+        self.secondLowestSellerType = secondLowestSellerType
+        self.thirdLowestSellerType = thirdLowestSellerType
 class __AmazonPricing:
     def __init__(self, ourSp, ourTp, lowestPossibleTp, lowestPossibleSp):
         self.ourTp = ourTp
     if fbaSaleSnapshot.item_id==0:
         return 0
     else:
         return fbaSaleSnapshot.totalOrderCount
-def syncAsin():
+#def syncAsin():
-#    notListedOnAmazon = []
+##    notListedOnAmazon = []
-#    diffAsins = []
+##    diffAsins = []
-#    login_url = "https://sellercentral.amazon.in/gp/homepage.html"
+##    login_url = "https://sellercentral.amazon.in/gp/homepage.html"
-#    br = SellerCentralInventoryReport.login(login_url)
+##    br = SellerCentralInventoryReport.login(login_url)
-#    report_url = "https://sellercentral.amazon.in/gp/upload-download-utils/requestReport.html?type=OpenListingReport&marketplaceID=44571&Request+Report="
+##    report_url = "https://sellercentral.amazon.in/gp/upload-download-utils/requestReport.html?type=OpenListingReport&marketplaceID=44571&Request+Report="
-#    br = SellerCentralInventoryReport.requestReport(br,report_url)
+##    br = SellerCentralInventoryReport.requestReport(br,report_url)
-#    status_url="https://sellercentral.amazon.in/gp/upload-download-utils/reportStatusData.html"
+##    status_url="https://sellercentral.amazon.in/gp/upload-download-utils/reportStatusData.html"
-#    br, page = SellerCentralInventoryReport.checkStatus(br,status_url)
+##    br, page = SellerCentralInventoryReport.checkStatus(br,status_url)
-#    br, batchId = SellerCentralInventoryReport.getReportBatchId(br,page)
+##    br, batchId = SellerCentralInventoryReport.getReportBatchId(br,page)
-#    print "*********************************"
+##    print "*********************************"
-#    print "Batch Id for request is ",batchId
+##    print "Batch Id for request is ",batchId
-#    print "*********************************"
+##    print "*********************************"
-#    ready = False
+##    ready = False
-#    retryCount = 0
+##    retryCount = 0
-#    while not ready:
+##    while not ready:
-#        if retryCount == 10:
+##        if retryCount == 10:
-#            print "File not available for download after multiple retries"
+##            print "File not available for download after multiple retries"
-#            sys.exit(1)
+##            sys.exit(1)
-#        br, download_link = SellerCentralInventoryReport.downloadReport(br,batchId,status_url)
+##        br, download_link = SellerCentralInventoryReport.downloadReport(br,batchId,status_url)
-#        if download_link is not None:
+##        if download_link is not None:
-#            ready= True
+##            ready= True
-#            continue
+##            continue
-#        print "File not ready for download yet.Will try again after 30 seconds."
+##        print "File not ready for download yet.Will try again after 30 seconds."
-#        retryCount+=1
+##        retryCount+=1
-#        time.sleep(30)
+##        time.sleep(30)
-#    fPath = SellerCentralInventoryReport.fetchFile(download_link['href'],br,batchId)
+##    fPath = SellerCentralInventoryReport.fetchFile(download_link['href'],br,batchId)
-    fPath = "/tmp/9940651090.txt"
+#    fPath = "/tmp/9940651090.txt"
-    global amazonAsinPrice
+#    global amazonAsinPrice
-    for line in open(fPath):
+#    for line in open(fPath):
-        l = line.split('\t')
+#        l = line.split('\t')
-        if (str(l[0]).startswith('FBA') or str(l[0]).startswith('FBB')):
+#        if (str(l[0]).startswith('FBA') or str(l[0]).startswith('FBB')):
-            obj = __AmazonAsinPrice(l[1],l[2])
+#            obj = __AmazonAsinPrice(l[1],l[2])
-            amazonAsinPrice[l[0]] = obj
+#            amazonAsinPrice[l[0]] = obj
-#Can be used to sync asins, not doing due to multiple asins corresponding to one itemId
+##Can be used to sync asins, not doing due to multiple asins corresponding to one itemId
-#    systemAsins = session.query(Item,Amazonlisted).join((Amazonlisted,Item.id==Amazonlisted.itemId)).all()
+##    systemAsins = session.query(Item,Amazonlisted).join((Amazonlisted,Item.id==Amazonlisted.itemId)).all()
-#    for systemAsin in systemAsins:
+##    for systemAsin in systemAsins:
-#        item = systemAsin[0]
+##        item = systemAsin[0]
-#        amListed = systemAsin[1]
+##        amListed = systemAsin[1]
-#        if amazonAsinPrice.get('FBA'+str(item.id)) is None:
+##        if amazonAsinPrice.get('FBA'+str(item.id)) is None:
-#            temp=[]
+##            temp=[]
-#            temp.append(item)
+##            temp.append(item)
-#            temp.append(amListed)
+##            temp.append(amListed)
-#            notListedOnAmazon.append(temp)
+##            notListedOnAmazon.append(temp)
-#            continue
+##            continue
-#        else:
+##        else:
-#            temp=[]
+##            temp=[]
-#            temp.append(item)
+##            temp.append(item)
-#            temp.append(amListed)
+##            temp.append(amListed)
-#            if item.asin!=((amazonAsinPrice.get('FBA'+str(item.id))).asin).strip():
+##            if item.asin!=((amazonAsinPrice.get('FBA'+str(item.id))).asin).strip():
-#                diffAsins.append(temp)
+##                diffAsins.append(temp)
-#                continue
+##                continue
-#
+##
-#    for diffAsin in diffAsins:
+##    for diffAsin in diffAsins:
-#        item = diffAsin[0]
+##        item = diffAsin[0]
-#        amListed = diffAsin[1]
+##        amListed = diffAsin[1]
-#        item.asin = ((amazonAsinPrice.get('FBA'+str(item.id))).asin).strip()
+##        item.asin = ((amazonAsinPrice.get('FBA'+str(item.id))).asin).strip()
-#        amListed.asin = ((amazonAsinPrice.get('FBA'+str(item.id))).asin).strip()
+##        amListed.asin = ((amazonAsinPrice.get('FBA'+str(item.id))).asin).strip()
-#    session.commit()
+##    session.commit()
-#    session.close()
+##    session.close()
 def fetchFbaSale():
     global saleMap
     transaction_client = TransactionClient().get_client()
     fbaSaleSnapshot = transaction_client.getAmazonFbaSalesSnapshotForDays(4)
     global amazonLongTermActivePromotions
     global amazonShortTermActivePromotions
     itemInfo = []
     inventory_client = InventoryClient().get_client()
     fbaAvailableInventorySnapshot = inventory_client.getAllAvailableAmazonFbaItemInventory()
-    print "length****"
     print len(fbaAvailableInventorySnapshot)
     for fbaInventoryItem in fbaAvailableInventorySnapshot:
         d_amazon_listed = Amazonlisted.get_by(itemId=fbaInventoryItem.item_id)
         if d_amazon_listed is None:
-            print "amazon listed is none"
             continue
         if d_amazon_listed.overrrideWanlc:
             wanlc = d_amazon_listed.exceptionalWanlc
         else:
             wanlc = inventory_client.getWanNlcForSource(fbaInventoryItem.item_id,OrderSource.AMAZON)
         if scp is not None:
             sourcePercentage = scp
         else:
             spm = SourcePercentageMaster.get_by(source=OrderSource.AMAZON)
             sourcePercentage = spm
-        print "$$$$$$$$$$$$$$$$$"
-        print fbaInventoryItem
         if fbaInventoryItem.location==0:
             sku = 'FBA'+str(fbaInventoryItem.item_id)
             state_id = 1
         elif fbaInventoryItem.location==1:
             sku = 'FBB'+str(fbaInventoryItem.item_id)
             state_id = 2
         else:
-            print "continue*****"
             continue
         cc = computeCourierCost(it.weight)
-        if amazonAsinPrice.get(sku) is None:
-            asin = ''
-        elif amazonAsinPrice.get(sku).asin is None:
-            asin = ''
-        else:
-            asin = amazonAsinPrice.get(sku).asin
-        amazonItemInfo = __AmazonItemInfo(asin, wanlc,cc, sku, it.product_group, it.brand, it.model_name, it.model_number, it.color, it.weight, category.parent_category_id, it.risky, None, runType, parent_category.display_name,sourcePercentage,fbaInventoryItem.availability,state_id)
+        amazonItemInfo = __AmazonItemInfo(None, wanlc,cc, sku, it.product_group, it.brand, it.model_name, it.model_number, it.color, it.weight, category.parent_category_id, it.risky, None, runType, parent_category.display_name,sourcePercentage,fbaInventoryItem.availability,state_id)
-        print amazonItemInfo
         itemInfo.append(amazonItemInfo)
     amPromotions = AmazonPromotion.query.filter(AmazonPromotion.startDate<=time).filter(AmazonPromotion.endDate>=time).filter(AmazonPromotion.promotionType==AmazonPromotionType.LONGTERM).filter(AmazonPromotion.promotionActive==True) \
     .group_by(AmazonPromotion.sku).order_by(desc(AmazonPromotion.addedOn)).all()
     for amPromotion in amPromotions:
         amazonLongTermActivePromotions.append(amPromotion.sku)
     amPromotions = AmazonPromotion.query.filter(AmazonPromotion.startDate<=time).filter(AmazonPromotion.endDate>=time).filter(AmazonPromotion.promotionType==AmazonPromotionType.SHORTTERM).filter(AmazonPromotion.promotionActive==True) \
     .group_by(AmazonPromotion.sku).order_by(desc(AmazonPromotion.addedOn)).all()
     for amPromotion in amPromotions:
         amazonShortTermActivePromotions.append(amPromotion.sku)
     session.close()
-    print "item info length"
-    print len(itemInfo)
     return itemInfo
+def getPriceAndAsin(itemInfo):
+    skus = []
+    for item in itemInfo:
+        skus.append(item.sku)
+    ourPricingForSku = amScraper.get_my_pricing_for_sku('A21TJRUUN4KGV', skus)
+    for item in itemInfo:
+        ourPricing = ourPricingForSku.get(item.sku)
+        if len(ourPricing.keys())==0:
+            item.ourSp = 0
+            item.promoPrice = 0
+            item.isPromotion = False
+        else:
+            item.ourSp = ourPricing.get('sellingPrice')
+            item.promoPrice = ourPricing.get('promoPrice')
+            item.isPromotion = ourPricing.get('promotion')
 def decideCategory(itemInfo):
     exceptionList, negativeMargin, cheapest, amongCheapestAndCanCompete, canCompete, almostCompete, cantCompete = [],[],[],[],[],[],[]
-    skuUrls = []
+    skus = []
-    #skuAsinMap = {}
     for item in itemInfo:
-        if item.asin is None or len(item.asin)==0:
-            temp = []
-            temp.append(item)
+        skus.append(item.sku)
-            temp.append("Asin not available")
-            exceptionList.append(temp)
-            continue
-        skuUrls.append('http://www.amazon.in/gp/offer-listing/'+item.asin+'/ref=olp_sort_ps')
+    aggResponse = amScraper.get_competitive_pricing_for_sku('A21TJRUUN4KGV', skus)
-    aggResponse = amScraper.read(skuUrls, True)
+    ourPricingForSku = amScraper.get_my_pricing_for_sku('A21TJRUUN4KGV', skus)
     for val in itemInfo:
-        print "Trying to get details of ",val.sku
-        if val.asin is None or len(val.asin)==0:
-            continue
-        scrapInfo = aggResponse.get(val.asin)
+        scrapInfo = aggResponse.get(val.sku)
-        print "Scraped info for asin is ",scrapInfo
-        if val.sku in amazonLongTermActivePromotions:
-            print "Sku in promotion, will handle it later.Moving to other..."
-            continue
-        if scrapInfo is None or val.nlc==0:
+        if len(scrapInfo)==0 or val.nlc==0 or len(ourPricingForSku.get(val.sku).keys())==0:
             temp = []
             temp.append(val)
             if val.nlc==0 or val.nlc is None:
                 temp.append("WANLC is 0")
+            elif len(ourPricingForSku.get(val.sku).keys())==0:
+                temp.append("Unable to fetch our price")
             else:
-                temp.append("Not able to fetch")
+                temp.append("Unable to fetch competitive pricing")
             exceptionList.append(temp)
             continue
+        val.asin = ourPricingForSku.get(val.sku).get('asin')
+        val.ourSp = ourPricingForSku.get(val.sku).get('sellingPrice')
+        val.promoPrice = ourPricingForSku.get(val.sku).get('promoPrice')
+        val.isPromo = ourPricingForSku.get(val.sku).get('promotion')
         iterator = 0
         sku, lowestSellerName,secondLowestSellerName, thirdLowestSellerName = ('',)*4
         ourSp, ourRank, lowestSellerSp, secondLowestSellerSp, thirdLowestSellerSp, ourTp, lowestPossibleSp, lowestPossibleTp = (0,)*8
+        lowestSellerShippingTime, lowestSellerRating, secondLowestSellerShippingTime, secondLowestSellerRating, thirdLowestSellerShippingTime , \
+        thirdLowestSellerRating, lowestSellerType, secondLowestSellerType, thirdLowestSellerType = (0,)*9
+        isPromo = False
         sku = val.sku
         scrapedSkuLocation = None
         multipleListings = False
-        for info in scrapInfo:
-            print "iterating scrap info"
+        ourSkuDetails = ourPricingForSku.get(val.sku)
-            if iterator ==3:
+        scrapInfo.append(ourSkuDetails)
-                break
-            if (info['sellerName']).strip()=='Saholic':
+        sortedScrapInfo =  sorted(scrapInfo, key=itemgetter('promoPrice','notOurSku'))
-                if ourRank>0:
+        for info in sortedScrapInfo:
-                    multipleListings = True
+            if  not info.notOurSku:
-                ourSp = info['sellerPrice']
+                ourSp = info.sellingPrice
-                ourRank = iterator+1
+                promoPrice = info.promoPrice
-                if val.state_id==1:
-                    #It means sku starts with FBA
-                    fbaPrice = (amazonAsinPrice.get(val.sku)).price
-                    try:
-                        if ourSp==fbaPrice:
-                            scrapedSkuLocation = val.state_id
-                    except:
-                        scrapedSkuLocation = None
-                elif val.state_id==2:
-                    #It means sku starts with FBB
-                    fbbPrice = (amazonAsinPrice.get(val.sku)).price
-                    try:
-                        if ourSp==fbbPrice:
+                isPromo = info.promotion
-                            scrapedSkuLocation = val.state_id
-                    except:
-                        scrapedSkuLocation = None
-                else:
-                    scrapedSkuLocation = None
+                ourRank = iterator + 1
-                if scrapedSkuLocation is None:
-                    print "fishy...confused for ", val.sku
             if iterator == 0:
-                lowestSellerName = info['sellerName']
+                lowestSellerSp = info['promoPrice']
+                lowestSellerShippingTime = info['shippingTime']
-                lowestSellerSp = info['sellerPrice']
+                lowestSellerRating = info['rating']
+                lowestSellerType = info['fulfillmentChannel']
             if iterator == 1:
-                secondLowestSellerName = info['sellerName']
+                secondLowestSellerSp = info['promoPrice']
+                secondLowestSellerShippingTime = info['shippingTime']
-                secondLowestSellerSp = info['sellerPrice']
+                secondLowestSellerRating = info['rating']
+                secondLowestSellerType = info['fulfillmentChannel']
             if iterator == 2:
-                thirdLowestSellerName = info['sellerName']
+                thirdLowestSellerSp = info['promoPrice']
+                thirdLowestSellerShippingTime = info['shippingTime']
-                thirdLowestSellerSp = info['sellerPrice']
+                thirdLowestSellerRating = info['rating']
+                thirdLowestSellerType = info['fulfillmentChannel']
             iterator += 1
         print "terminating iterator"
-        #if cheapestSkuLocation!=val.state_id
-        if ourSp==0 or scrapedSkuLocation is None:
-            print "Sku not present in top 3.Getting price from amazonAsinPrice...or multiple listings"
-            if ourSp==0:
-                ourRank = 999 #Due to pagination and large no of sellers.Taking it as dummy value, means we are not in top 3
-                ourSp = (amazonAsinPrice.get(val.sku)).price
-                if ourSp is None or ourSp==0:
-                    temp = []
-                    temp.append(val)
-                    temp.append("Price not available")
-                    exceptionList.append(temp)
-                    continue
-            else:
-                #determine rank
-                if ourSp <= lowestSellerSp or lowestSellerSp==0:
-                    ourRank = 1
-                elif ourSp > lowestSellerSp and (ourSp <= secondLowestSellerSp or secondLowestSellerSp==0):
-                    ourRank = 2
-                elif ourSp > secondLowestSellerSp and (ourSp<=thirdLowestSellerSp or thirdLowestSellerSp==0):
-                    ourRank = 3
-                else:
-                    ourRank = 999
-        if multipleListings:
-            print "multiple listings..."
-            ourSp = (amazonAsinPrice.get(val.sku)).price
-            if ourSp is None or ourSp==0:
-                temp = []
-                temp.append(val)
-                temp.append("Price not available")
-                exceptionList.append(temp)
-                continue
-            if ourSp <= lowestSellerSp:
-                    ourRank = 1
-            elif ourSp > lowestSellerSp and (ourSp <= secondLowestSellerSp or secondLowestSellerSp==0):
-                ourRank = 2
-            elif ourSp > secondLowestSellerSp and (ourSp<=thirdLowestSellerSp or thirdLowestSellerSp==0):
-                ourRank = 3
-            else:
-                ourRank = 999
         print "Creating object am details",val.sku
-        amDetails = __AmazonDetails(sku, float(ourSp), ourRank, lowestSellerName,float(lowestSellerSp),secondLowestSellerName, float(secondLowestSellerSp), thirdLowestSellerName, float(thirdLowestSellerSp),len(scrapInfo),multipleListings)
+        amDetails = __AmazonDetails(sku, float(ourSp), ourRank, lowestSellerName,float(lowestSellerSp),secondLowestSellerName, float(secondLowestSellerSp), thirdLowestSellerName, float(thirdLowestSellerSp),len(scrapInfo),multipleListings,promoPrice,isPromo, \
+                    lowestSellerShippingTime ,lowestSellerRating, secondLowestSellerShippingTime, secondLowestSellerRating, thirdLowestSellerShippingTime , thirdLowestSellerRating, lowestSellerType, secondLowestSellerType, thirdLowestSellerType)
         print "am details obj created"
         try:
             print "inside val getter"
             itemVatMaster = ItemVatMaster.query.filter(and_(ItemVatMaster.itemId==int(val.sku[3:]), ItemVatMaster.stateId==val.state_id)).first()
             if itemVatMaster is None:
                 d_item = Item.query.filter_by(id=int(val.sku[3:])).first()
                 if d_item is None:
                     raise
                 else:
-                    vatMaster = CategoryVatMaster.query.filter(and_(CategoryVatMaster.categoryId==d_item.category, CategoryVatMaster.minVal<=amDetails.ourSp,  CategoryVatMaster.maxVal>=amDetails.ourSp,  CategoryVatMaster.stateId == val.state_id)).first()
+                    vatMaster = CategoryVatMaster.query.filter(and_(CategoryVatMaster.categoryId==d_item.category, CategoryVatMaster.minVal<=amDetails.promoPrice,  CategoryVatMaster.maxVal>=amDetails.promoPrice,  CategoryVatMaster.stateId == val.state_id)).first()
                 if vatMaster is None:
                     raise
                 else:
                     val.vatRate = vatMaster.vatPercent
                     print "vat fetched"
             print "vat exception"
             temp = []
             temp.append(val)
             temp.append("Vat not available")
             exceptionList.append(temp)
-            print "added in exception list"
             continue
         ourTp = getOurTp(amDetails,val,val.sourcePercentage)
         lowestPossibleTp = getLowestPossibleTp(amDetails,val,val.sourcePercentage)
         lowestPossibleSp = getLowestPossibleSp(amDetails,val,val.sourcePercentage)
             temp.append(amDetails)
             temp.append(amPricing)
             cheapest.append(temp)
             continue
-        if (amDetails.lowestSellerSp > amPricing.lowestPossibleSp) and ((((float(amDetails.ourSp - amDetails.lowestSellerSp))/amDetails.ourSp)<=.01) or ((amDetails.ourSp - amDetails.lowestSellerSp)<=25)):
+        if (amDetails.lowestSellerSp > amPricing.lowestPossibleSp) and ((((float(amDetails.promoPrice - amDetails.lowestSellerSp))/amDetails.promoPrice)<=.01) or ((amDetails.promoPrice - amDetails.lowestSellerSp)<=25)):
             temp = []
             temp.append(val)
             temp.append(amDetails)
             temp.append(amPricing)
             amongCheapestAndCanCompete.append(temp)
     print "Created category..."
     return exceptionList, negativeMargin, cheapest, amongCheapestAndCanCompete, canCompete, almostCompete, cantCompete
 def getOurTp(amazonDetails,val,spm):
-    ourTp = amazonDetails.ourSp- amazonDetails.ourSp*(spm.commission/100+spm.emiFee/100)*(1+(spm.serviceTax/100))-(val.courierCost)*(1+(spm.serviceTax/100))*(1+(spm.serviceTax/100));
+    ourTp = amazonDetails.promoPrice- amazonDetails.promoPrice*(spm.commission/100+spm.emiFee/100)*(1+(spm.serviceTax/100))-(val.courierCost)*(1+(spm.serviceTax/100))*(1+(spm.serviceTax/100));
     return round(ourTp,2)
 def getLowestPossibleTp(amazonDetails,val,spm):
-    vat = (amazonDetails.ourSp/(1+(val.vatRate/100))-(val.nlc/(1+(val.vatRate/100))))*(val.vatRate/100)
+    vat = (amazonDetails.promoPrice/(1+(val.vatRate/100))-(val.nlc/(1+(val.vatRate/100))))*(val.vatRate/100)
-    inHouseCost = 15+vat+(spm.returnProvision/100)*amazonDetails.ourSp
+    inHouseCost = 15+vat+(spm.returnProvision/100)*amazonDetails.promoPrice
     lowest_possible_tp = val.nlc+inHouseCost
     return round(lowest_possible_tp,2)
 def getLowestPossibleSp(amazonDetails,val,spm):
     lowestPossibleSp = (val.nlc+(val.courierCost)*(1+(spm.serviceTax/100))*(1+(val.vatRate/100))+(15)*(1+(val.vatRate)/100))/(1-(spm.commission/100+spm.emiFee/100)*(1+(spm.serviceTax/100))*(1+(val.vatRate)/100)-(spm.returnProvision/100)*(1+(val.vatRate)/100));
         amazonScrapingHistory.lowestPossibleSp = amPricing.lowestPossibleSp
         amazonScrapingHistory.ourRank = amDetails.ourRank
         amazonScrapingHistory.ourInventory = val.ourInventory
         amazonScrapingHistory.lowestSellerName = amDetails.lowestSellerName
         amazonScrapingHistory.lowestSellerSp = amDetails.lowestSellerSp
+        amazonScrapingHistory.lowestSellerShippingTime = amDetails.lowestSellerShippingTime
+        amazonScrapingHistory.lowestSellerRating = amDetails.lowestSellerRating
+        amazonScrapingHistory.lowestSellerType = amDetails.lowestSellerType
         amazonScrapingHistory.secondLowestSellerName = amDetails.secondLowestSellerName
         amazonScrapingHistory.secondLowestSellerSp = amDetails.secondLowestSellerSp
+        amazonScrapingHistory.secondSellerShippingTime = amDetails.secondSellerShippingTime
+        amazonScrapingHistory.secondSellerRating = amDetails.secondSellerRating
+        amazonScrapingHistory.secondSellerType = amDetails.secondSellerType
         amazonScrapingHistory.thirdLowestSellerName = amDetails.thirdLowestSellerName
         amazonScrapingHistory.thirdLowestSellerSp = amDetails.thirdLowestSellerSp
+        amazonScrapingHistory.thirdSellerShippingTime = amDetails.thirdSellerShippingTime
+        amazonScrapingHistory.thirdSellerRating = amDetails.thirdSellerRating
+        amazonScrapingHistory.thirdSellerType = amDetails.thirdSellerType
         amazonScrapingHistory.wanlc = val.nlc
         amazonScrapingHistory.commission = spm.commission
         amazonScrapingHistory.competitorCommission = spm.competitorCommissionOther
         amazonScrapingHistory.returnProvision = spm.returnProvision
         amazonScrapingHistory.courierCost = val.courierCost
         amazonScrapingHistory.runType = RunType._NAMES_TO_VALUES.get(runType)
         amazonScrapingHistory.totalSeller = amDetails.totalSeller
         amazonScrapingHistory.competitiveCategory = CompetitionCategory.BUY_BOX
         amazonScrapingHistory.timestamp = timestamp
         amazonScrapingHistory.multipleListings = amDetails.multipleListings
-        if amDetails.secondLowestSellerName!='Saholic':
-            competitorSp = amDetails.secondLowestSellerSp
-        else:
-            competitorSp = amDetails.thirdLowestSellerSp
-        proposed_sp = max(competitorSp - max((20, competitorSp*0.002)), amPricing.lowestPossibleSp)
+        proposed_sp = max(amDetails.secondLowestSellerSp - max((20, amDetails.secondLowestSellerSp*0.002)), amPricing.lowestPossibleSp)
         proposed_tp = getTargetTp(proposed_sp,spm,val)
         amazonScrapingHistory.proposedSp = proposed_sp
         amazonScrapingHistory.proposedTp = proposed_tp
         amazonScrapingHistory.marginIncreasedPotential = proposed_tp - amPricing.ourTp
         amazonScrapingHistory.multipleListings = amDetails.multipleListings
         amazonScrapingHistory.lowestPossibleSp = amPricing.lowestPossibleSp
         amazonScrapingHistory.ourRank = amDetails.ourRank
         amazonScrapingHistory.ourInventory = val.ourInventory
         amazonScrapingHistory.lowestSellerName = amDetails.lowestSellerName
         amazonScrapingHistory.lowestSellerSp = amDetails.lowestSellerSp
+        amazonScrapingHistory.lowestSellerShippingTime = amDetails.lowestSellerShippingTime
+        amazonScrapingHistory.lowestSellerRating = amDetails.lowestSellerRating
+        amazonScrapingHistory.lowestSellerType = amDetails.lowestSellerType
         amazonScrapingHistory.secondLowestSellerName = amDetails.secondLowestSellerName
         amazonScrapingHistory.secondLowestSellerSp = amDetails.secondLowestSellerSp
+        amazonScrapingHistory.secondSellerShippingTime = amDetails.secondSellerShippingTime
+        amazonScrapingHistory.secondSellerRating = amDetails.secondSellerRating
+        amazonScrapingHistory.secondSellerType = amDetails.secondSellerType
         amazonScrapingHistory.thirdLowestSellerName = amDetails.thirdLowestSellerName
         amazonScrapingHistory.thirdLowestSellerSp = amDetails.thirdLowestSellerSp
+        amazonScrapingHistory.thirdSellerShippingTime = amDetails.thirdSellerShippingTime
+        amazonScrapingHistory.thirdSellerRating = amDetails.thirdSellerRating
+        amazonScrapingHistory.thirdSellerType = amDetails.thirdSellerType
         amazonScrapingHistory.wanlc = val.nlc
         amazonScrapingHistory.commission = spm.commission
         amazonScrapingHistory.competitorCommission = spm.competitorCommissionOther
         amazonScrapingHistory.returnProvision = spm.returnProvision
         amazonScrapingHistory.courierCost = val.courierCost
         amazonScrapingHistory.lowestPossibleSp = amPricing.lowestPossibleSp
         amazonScrapingHistory.ourRank = amDetails.ourRank
         amazonScrapingHistory.ourInventory = val.ourInventory
         amazonScrapingHistory.lowestSellerName = amDetails.lowestSellerName
         amazonScrapingHistory.lowestSellerSp = amDetails.lowestSellerSp
+        amazonScrapingHistory.lowestSellerShippingTime = amDetails.lowestSellerShippingTime
+        amazonScrapingHistory.lowestSellerRating = amDetails.lowestSellerRating
+        amazonScrapingHistory.lowestSellerType = amDetails.lowestSellerType
         amazonScrapingHistory.secondLowestSellerName = amDetails.secondLowestSellerName
         amazonScrapingHistory.secondLowestSellerSp = amDetails.secondLowestSellerSp
+        amazonScrapingHistory.secondSellerShippingTime = amDetails.secondSellerShippingTime
+        amazonScrapingHistory.secondSellerRating = amDetails.secondSellerRating
+        amazonScrapingHistory.secondSellerType = amDetails.secondSellerType
         amazonScrapingHistory.thirdLowestSellerName = amDetails.thirdLowestSellerName
         amazonScrapingHistory.thirdLowestSellerSp = amDetails.thirdLowestSellerSp
+        amazonScrapingHistory.thirdSellerShippingTime = amDetails.thirdSellerShippingTime
+        amazonScrapingHistory.thirdSellerRating = amDetails.thirdSellerRating
+        amazonScrapingHistory.thirdSellerType = amDetails.thirdSellerType
         amazonScrapingHistory.wanlc = val.nlc
         amazonScrapingHistory.commission = spm.commission
         amazonScrapingHistory.competitorCommission = spm.competitorCommissionOther
         amazonScrapingHistory.returnProvision = spm.returnProvision
         amazonScrapingHistory.courierCost = val.courierCost
         amazonScrapingHistory.lowestPossibleSp = amPricing.lowestPossibleSp
         amazonScrapingHistory.ourRank = amDetails.ourRank
         amazonScrapingHistory.ourInventory = val.ourInventory
         amazonScrapingHistory.lowestSellerName = amDetails.lowestSellerName
         amazonScrapingHistory.lowestSellerSp = amDetails.lowestSellerSp
+        amazonScrapingHistory.lowestSellerShippingTime = amDetails.lowestSellerShippingTime
+        amazonScrapingHistory.lowestSellerRating = amDetails.lowestSellerRating
+        amazonScrapingHistory.lowestSellerType = amDetails.lowestSellerType
         amazonScrapingHistory.secondLowestSellerName = amDetails.secondLowestSellerName
         amazonScrapingHistory.secondLowestSellerSp = amDetails.secondLowestSellerSp
+        amazonScrapingHistory.secondSellerShippingTime = amDetails.secondSellerShippingTime
+        amazonScrapingHistory.secondSellerRating = amDetails.secondSellerRating
+        amazonScrapingHistory.secondSellerType = amDetails.secondSellerType
         amazonScrapingHistory.thirdLowestSellerName = amDetails.thirdLowestSellerName
         amazonScrapingHistory.thirdLowestSellerSp = amDetails.thirdLowestSellerSp
+        amazonScrapingHistory.thirdSellerShippingTime = amDetails.thirdSellerShippingTime
+        amazonScrapingHistory.thirdSellerRating = amDetails.thirdSellerRating
+        amazonScrapingHistory.thirdSellerType = amDetails.thirdSellerType
         amazonScrapingHistory.wanlc = val.nlc
         amazonScrapingHistory.commission = spm.commission
         amazonScrapingHistory.competitorCommission = spm.competitorCommissionOther
         amazonScrapingHistory.returnProvision = spm.returnProvision
         amazonScrapingHistory.courierCost = val.courierCost
         amazonScrapingHistory.lowestPossibleSp = amPricing.lowestPossibleSp
         amazonScrapingHistory.ourRank = amDetails.ourRank
         amazonScrapingHistory.ourInventory = val.ourInventory
         amazonScrapingHistory.lowestSellerName = amDetails.lowestSellerName
         amazonScrapingHistory.lowestSellerSp = amDetails.lowestSellerSp
+        amazonScrapingHistory.lowestSellerShippingTime = amDetails.lowestSellerShippingTime
+        amazonScrapingHistory.lowestSellerRating = amDetails.lowestSellerRating
+        amazonScrapingHistory.lowestSellerType = amDetails.lowestSellerType
         amazonScrapingHistory.secondLowestSellerName = amDetails.secondLowestSellerName
         amazonScrapingHistory.secondLowestSellerSp = amDetails.secondLowestSellerSp
+        amazonScrapingHistory.secondSellerShippingTime = amDetails.secondSellerShippingTime
+        amazonScrapingHistory.secondSellerRating = amDetails.secondSellerRating
+        amazonScrapingHistory.secondSellerType = amDetails.secondSellerType
         amazonScrapingHistory.thirdLowestSellerName = amDetails.thirdLowestSellerName
         amazonScrapingHistory.thirdLowestSellerSp = amDetails.thirdLowestSellerSp
+        amazonScrapingHistory.thirdSellerShippingTime = amDetails.thirdSellerShippingTime
+        amazonScrapingHistory.thirdSellerRating = amDetails.thirdSellerRating
+        amazonScrapingHistory.thirdSellerType = amDetails.thirdSellerType
         amazonScrapingHistory.wanlc = val.nlc
         amazonScrapingHistory.commission = spm.commission
         amazonScrapingHistory.competitorCommission = spm.competitorCommissionOther
         amazonScrapingHistory.returnProvision = spm.returnProvision
         amazonScrapingHistory.courierCost = val.courierCost
     if options.runType not in ('FULL','FAVOURITE'):
         print "Run type argument illegal."
         sys.exit(1)
     time.sleep(5)
     timestamp = datetime.now()
-    syncAsin()
     fetchFbaSale()
     itemInfo = populateStuff(timestamp,options.runType)
     itemsToPopulate = 0
+    toSync = 0
-    print len(itemInfo)
+    lenItems = len(itemInfo)
+    while(toSync < lenItems):
+        oldSync = toSync
+        if lenItems >= 20:
+            toSync = 20
+        else:
+            toSync = lenItems - oldSync
+        getPriceAndAsin(itemInfo[oldSync:toSync+oldSync])
+        toSync = oldSync + toSync
     while (len(itemInfo)>0):
-        if len(itemInfo) > 50:
+        if len(itemInfo) >= 20:
-            itemsToPopulate = 50
+            itemsToPopulate = 20
         else:
             itemsToPopulate = len(itemInfo)
         print itemsToPopulate
         exceptionList, negativeMargin, cheapest, amongCheapestAndCanCompete, canCompete, almostCompete, cantCompete = decideCategory(itemInfo[0:itemsToPopulate])
         itemInfo[0:itemsToPopulate] = []

Subversion Repositories SmartDukaan

(root)//trunk/PyProj/src/shop2020/model/v1/catalog/script/AmazonHistoryPopulator.py – Rev 12426 → 12430