WebSVN – SmartDukaan – Diff – //trunk/PyProj/src/shop2020/model/v1/catalog/impl/DataAcessors.py

 import threading
 import urllib2
 import math
 sourceId = int(ConfigClient().get_property("sourceid"))
-to_addresses = ["khushal.bhatia@shop2020.in", "chandan.kumar@shop2020.in",  "chaitnaya.vats@shop2020.in"]
+to_addresses = ["kshitij.sood@shop2020.in"]
-to_store_addresses = ["rajveer.singh@shop2020.in"]
+to_store_addresses = ["kshitij.sood@shop2020.in"]
 mail_user = "cnc.center@shop2020.in"
 mail_password = "5h0p2o2o"
 source_name = "Saholic"
 source_url = "www.saholic.com"
 skippedItems = { 175 : [27, 2160, 2175, 2163, 2158, 7128, 26, 2154],
 : [5839] }
 def initialize(dbname='catalog', db_hostname="localhost"):
     DataService.initialize(dbname, db_hostname)
 def get_all_items_by_status(status, offset=0, limit=None):
     query = Item.query
     if status is not None:
         query = query.filter_by(status=status)
     query = query.order_by(Item.product_group, Item.brand, Item.model_number, Item.model_name).offset(offset)
     return item.status_description
 def update_item(item):
     if not item:
         raise InventoryServiceException(108, "Bad item in request")
     if not item.id:
         raise InventoryServiceException(101, "Missing id for update")
     validate_item_prices(item)
     ds_item = get_item(item.id)
     message = ""
     store_message = ""
     if not ds_item:
         raise InventoryServiceException(101, "Item missing in our database")
     if item.productGroup:
         ds_item.product_group = item.productGroup
     if item.brand:
         ds_item.brand = item.brand
     if item.modelNumber:
         ds_item.model_number = item.modelNumber
     ds_item.color = item.color
     ds_item.model_name = item.modelName
     ds_item.category = item.category
     if item.category in [10001, 10002, 10003, 10004, 10005]:
         ds_item.preferredInsurer = 1
     ds_item.comments = item.comments
     ds_item.catalog_item_id = item.catalogItemId
     if ds_item.activeOnStore and ds_item.mrp and item.mrp and ds_item.mrp != item.mrp:
         sp = get_store_pricing(item.id)
         if sp.maxPrice > item.mrp:
             sp.maxPrice = item.mrp
             store_message += "MRP is changed from {0} to {1}.\n".format(sp.maxPrice, item.mrp)
     if ds_item.activeOnStore and ds_item.sellingPrice and item.sellingPrice and ds_item.sellingPrice != item.sellingPrice:
         sp = get_store_pricing(item.id)
         if sp.minPrice < item.sellingPrice:
             store_message += "Saholic MOP Changed. DP {0} is less than Saholic MOP.\n".format(sp.minPrice)
     ds_item.mrp = item.mrp
     if ds_item.sellingPrice or item.sellingPrice:
         if ds_item.sellingPrice != item.sellingPrice:
             amazonItem = get_amazon_item_details(item.id)
             if amazonItem is not None:
                 amazonItem.fbaPrice = item.sellingPrice
                 amazonItem.sellingPrice=item.sellingPrice
+                amazonItem.mfnPriceLastUpdatedOn = datetime.datetime.now()
+                amazonItem.fbaPriceLastUpdatedOn = datetime.datetime.now()
             message += "Selling Price is changed from {0} to {1}.\n".format(ds_item.sellingPrice, item.sellingPrice)
     ds_item.sellingPrice = item.sellingPrice
+    item_temp = get_item(item.id)
+    print "temp",item_temp.sellingPrice
+    print "object",item.sellingPrice
+    if (item_temp.sellingPrice != item.sellingPrice):
+        amazonItem = get_amazon_item_details(item.id)
+        if amazonItem is not None:
+            amazonItem.fbaPrice = item.sellingPrice
+            amazonItem.sellingPrice=item.sellingPrice
+            amazonItem.mfnPriceLastUpdatedOn = datetime.datetime.now()
+            amazonItem.fbaPriceLastUpdatedOn = datetime.datetime.now()
     ds_item.weight = item.weight
     ds_item.showSellingPrice = item.showSellingPrice
     if item.asin:
         ds_item.asin = item.asin
     ds_item.holdInventory = item.holdInventory
     ds_item.defaultInventory = item.defaultInventory
     if item.startDate:
         ds_item.startDate = to_py_date(item.startDate)
         ds_item.startDate = ds_item.startDate.replace(hour=0,second=0,minute=0)
         if item.itemStatus == status.COMING_SOON and ds_item.startDate < datetime.datetime.now()  :
             item.itemStatus = status.ACTIVE
         if item.itemStatus == status.PHASED_OUT:
             message += "Item is phased out."
         ds_item.status = item.itemStatus
     if item.status_description:
         ds_item.status_description = item.status_description
     if item.retireDate:
         ds_item.retireDate = to_py_date(item.retireDate)
     else:
         ds_item.retireDate = None
     if item.expectedArrivalDate:
         ds_item.expectedArrivalDate = to_py_date(item.expectedArrivalDate)
     else:
         ds_item.expectedArrivalDate = None
     if item.comingSoonStartDate:
         ds_item.comingSoonStartDate = to_py_date(item.comingSoonStartDate)
         ds_item.comingSoonStartDate = ds_item.comingSoonStartDate.replace(hour=0,second=0,minute=0)
     else:
         ds_item.comingSoonStartDate = None
     ds_item.feature_id = item.featureId
     ds_item.feature_description = item.featureDescription
     if ds_item.bestDealText or item.bestDealText:
         if item.bestDealText != ds_item.bestDealText:
             message += "Promotion text is changed from '{0}' to '{1}'.\n".format(ds_item.bestDealText, item.bestDealText)
     ds_item.bestDealText = item.bestDealText
     ds_item.bestDealValue = item.bestDealValue
     ds_item.bestSellingRank = item.bestSellingRank
     if ds_item.bestDealsDetailsText or item.bestDealsDetailsText:
         if item.bestDealsDetailsText != ds_item.bestDealsDetailsText:
             message += "Best deals details text is changed from '{0}' to '{1}'.\n".format(ds_item.bestDealsDetailsText, item.bestDealsDetailsText)
     ds_item.bestDealsDetailsText = item.bestDealsDetailsText
     if ds_item.bestDealsDetailsLink or item.bestDealsDetailsLink:
         if item.bestDealsDetailsLink != ds_item.bestDealsDetailsLink:
             message += "Best deals details link is changed from '{0}' to '{1}'.\n".format(ds_item.bestDealsDetailsLink, item.bestDealsDetailsLink)
     ds_item.bestDealsDetailsLink = item.bestDealsDetailsLink
     ds_item.defaultForEntity = item.defaultForEntity
     if ds_item.risky or item.risky:
         if ds_item.risky != item.risky:
             message += "Risky flag is changed to '{0}'.\n".format(set)
     ds_item.risky = item.risky
     ds_item.type = ItemType._VALUES_TO_NAMES[item.type]
     ds_item.hasItemNo = item.hasItemNo
     if item.expectedDelay is not None:
         ds_item.expectedDelay = item.expectedDelay
     if item.preferredVendor:
         if item.preferredVendor != ds_item.preferredVendor:
             inventoryClient = InventoryClient().get_client()
             newPreferredVendorName = inventoryClient.getVendor(item.preferredVendor).name
             oldPreferredVendorName = 'None'
             if ds_item.preferredVendor:
                 oldPreferredVendorName = inventoryClient.getVendor(ds_item.preferredVendor).name
             message += "Preferred vendor is changed from '{0}' to '{1}'.\n".format(oldPreferredVendorName, newPreferredVendorName)
         ds_item.preferredVendor = item.preferredVendor
     if item.isWarehousePreferenceSticky != ds_item.isWarehousePreferenceSticky:
         flag = "ON" if item.isWarehousePreferenceSticky else "OFF"
         message += "Warehouse preference sticky is {0}.\n".format(flag)
     ds_item.isWarehousePreferenceSticky = item.isWarehousePreferenceSticky
     ds_item.updatedOn = datetime.datetime.now()
     ds_item.activeOnStore = item.activeOnStore
     session.commit();
     subject = "Item '{0}' is updated in Catalog. Id is {1}".format(__get_product_name(ds_item),ds_item.id)
     if message:
         __send_mail(subject, message)
     if store_message:
 def add_item(item):
     if not item:
         raise InventoryServiceException(108, "Bad item in request")
     if get_item(item.id):
         raise InventoryServiceException(101, "Item already exists")
     validate_item_prices(item)
     ds_item = Item()
     if item.productGroup:
         ds_item.product_group = item.productGroup
     if item.brand:
         ds_item.brand = item.brand
     if item.comments:
         ds_item.comments = item.comments
     if item.asin:
         ds_item.asin = item.asin
     ds_item.holdInventory = item.holdInventory
     ds_item.defaultInventory = item.defaultInventory
     ds_item.addedOn = datetime.datetime.now()
     ds_item.updatedOn = datetime.datetime.now()
     if item.startDate:
         ds_item.startDate = to_py_date(item.startDate)
         ds_item.startDate = ds_item.startDate.replace(hour=0,second=0,minute=0)
     if item.retireDate:
         ds_item.retireDate = to_py_date(item.retireDate)
     if item.comingSoonStartDate:
         ds_item.comingSoonStartDate = to_py_date(item.comingSoonStartDate)
     if item.expectedArrivalDate:
         ds_item.expectedArrivalDate = to_py_date(item.expectedArrivalDate)
     if item.mrp:
         ds_item.mrp = item.mrp
     if item.sellingPrice:
         ds_item.sellingPrice = item.sellingPrice
     if item.weight:
         ds_item.weight = item.weight
     if item.featureId:
         ds_item.feature_id = item.featureId
     if item.featureDescription:
         ds_item.feature_description = item.featureDescription
     #check if categories present. If yes, add them to system
     if item.bestDealValue:
         ds_item.bestDealValue = item.bestDealValue
     if item.bestDealText:
         ds_item.bestDealText = item.bestDealText
     if item.bestDealsDetailsText:
         ds_item.bestDealsDetailsText = item.bestDealsDetailsText
     if item.bestDealsDetailsLink:
         ds_item.bestDealsDetailsLink = item.bestDealsDetailsLink
     if item.bestSellingRank:
         ds_item.bestSellingRank = item.bestSellingRank
     ds_item.defaultForEntity = item.defaultForEntity
     ds_item.risky = item.risky
     ds_item.type = ItemType._VALUES_TO_NAMES[item.type]
     ds_item.hasItemNo = item.hasItemNo
     ds_item.activeOnStore = item.activeOnStore
     if item.expectedDelay is not None:
         ds_item.expectedDelay = item.expectedDelay
     else:
         ds_item.expectedDelay = 0
     preferredVendorName = "None"
     if item.preferredVendor:
         ds_item.preferredVendor = item.preferredVendor
         inventoryClient = InventoryClient().get_client()
         preferredVendorName = inventoryClient.getVendor(item.preferredVendor).name
     if item.preferredInsurer is not None:
         ds_item.preferredInsurer = item.preferredInsurer
     if item.catalogItemId:
         catalog_client = CatalogClient("catalog_service_server_host_master", "catalog_service_server_port").get_client()
         master_items = catalog_client.getItemsByCatalogId(item.catalogItemId)
         itemStatus = status.IN_PROCESS
         for masterItem in master_items:
         ds_item.status_description = "This item is in process."
     else:
         # Check if a similar item already exists in our database
         similar_item = Item.query.filter_by(brand=item.brand, model_number=item.modelNumber, model_name=item.modelName).first()
         print "[SIMILAR ITEM FOUND:] FOR {0} {1} {2}".format(item.brand, item.modelNumber, item.modelName)
         if similar_item is None or similar_item.catalog_item_id is None:
             # If there is no similar item in the database from before,
             # use the entity_id_generator
             entity_id = EntityIDGenerator.query.first()
             ds_item.catalog_item_id = entity_id.id + 1
             ds_item.catalog_item_id = similar_item.catalog_item_id
             ds_item.category = similar_item.category
             ds_item.product_group = similar_item.product_group
             ds_item.status = similar_item.status
             ds_item.status_description = similar_item.status_description
     session.commit();
     subject = "New item is added. Id is {0}".format(str(ds_item.id))
     message = "Category : {6}, Brand : {0}, Model : {1}, Model Number : {2}\nColor : {3}, Selling Price : {4}, Mrp : {5}, \nPromotion Text : {7}, Preferred Vendor: {8}".format(item.brand, item.modelNumber, item.modelName, item.color, item.sellingPrice, item.mrp, item.category, item.bestDealText,item.bestDealsDetailsText,item.bestDealsDetailsLink, preferredVendorName)
     __send_mail(subject, message)
     return ds_item.id
     if not item:
         raise InventoryServiceException(108, "item id not present")
     item.status = status.PHASED_OUT
     item.retireDate = datetime.datetime.now()
     session.commit()
 #need to implement threads based solution here
 def start_item_on(item_id, timestamp):
     if not item_id:
         raise InventoryServiceException(101, "bad item id")
     item = get_item(item_id)
     if not item:
         raise InventoryServiceException(108, "item id not present")
     item.status = status.ACTIVE
     item.startDate = datetime.datetime.fromtimestamp(to_py_date(timestamp))
     add_status_change_log(item, status.ACTIVE)
     session.commit()
 #need to implement threads here
 def retire_item_on(item_id, timestamp):
     if not item_id:
         raise InventoryServiceException(101, "bad item id")
     item = get_item(item_id)
     if not item:
         raise InventoryServiceException(108, "item id not present")
     item.status = status.PHASED_OUT
     item.retireDate = datetime.datetime.fromtimestamp(to_py_date(timestamp))
     add_status_change_log(item, status.PHASED_OUT)
     session.commit()
 def add_status_change_log(item, new_status):
     item_change_log = ItemChangeLog()
     item_change_log.new_status = new_status
     item_change_log.old_status = item.status
     item_change_log.timestamp = datetime.datetime.now()
     item_change_log.item = item
     session.commit()
 def change_item_status(item_id, new_status):
     if not item_id:
         raise InventoryServiceException(101, "bad item id")
     item = get_item(item_id)
     if not item:
         item.status_description = "This item has been phased out"
         __send_mail("Item '{0}' is Phased-Out. Item id is {1}".format(__get_product_name(item), item_id), "")
     elif item.status == status.DELETED:
         item.status_description = "This item has been deleted"
     elif item.status == status.PAUSED:
         item.status_description = "This item is currently out of stock"
     elif item.status == status.PAUSED_BY_RISK:
         item.status_description = "This item is currently out of stock"
         #This will clear cache from tomcat
         __clear_homepage_cache()
     elif item.status == status.ACTIVE:
         item.status_description = "This item is active"
     elif item.status == status.IN_PROCESS:
         item.status_description = "This item is in process"
     elif item.status == status.CONTENT_COMPLETE:
         item.status_description = "This item is in process"
     session.commit()
 def check_risky_item(item_id):
     item = get_item(item_id)
     if not item.risky:
         return
     client = InventoryClient().get_client()
     itemInfo = client.getItemAvailabilityAtLocation(item.id, sourceId)
     warehouse_id = itemInfo[0]
     availability = client.getItemAvailibilityAtWarehouse(warehouse_id, item.id)
     if availability <= 0:
         if item.status == status.ACTIVE:
             change_item_status(item.id, status.PAUSED_BY_RISK)
     else:
         if item.status == status.PAUSED_BY_RISK:
             change_item_status(item.id, status.ACTIVE)
             __send_mail_for_active_item(item.id, "Item '{0}' is Active. Item id is {1}".format(__get_product_name(item), item_id), "")
     session.commit()
 def mark_item_as_content_complete(entity_id, category, brand, modelName, modelNumber):
     '''
     Get all the items for this entityID and update category, brand, modelName and modelNumber for all.
     Update Status for only IN_PROCESS items to CONTENT_COMPLETE
     '''
             item_change_log = ItemChangeLog()
             item_change_log.old_status = item.status
             item_change_log.new_status = content_complete_status
             item_change_log.timestamp = current_timestamp
             item_change_log.item = item
         category_object = get_category(category)
         if category_object is not None:
             item.category = category
             item.product_group = category_object.display_name
         item.brand = brand
     return count
 def get_best_sellers_catalog_ids(start_index, stop_index, brand, category=-1):
     '''
     Returns the Best sellers for the given brand and category between the start and the stop index.
     Ignores the category if it's passed as -1 and the brand if it's passed as None.
     '''
     query = get_best_sellers_query(category, brand)
     best_sellers = query.all()[start_index:stop_index]
     return [item.catalog_item_id for item in best_sellers]
 def get_best_sellers_query(category, brand):
     '''
     Returns the query to be used for getting Best Sellers.
     Ignores the category if it's passed as -1 and the brand if it's passed as None.
     '''
     query = Item.query.filter_by(status=status.ACTIVE).filter(Item.bestSellingRank != None)
     if category != -1:
         all_categories = [category]
         child_categories = get_child_categories(category)
         if child_categories is not None:
             all_categories = all_categories + child_categories
         query = query.filter(Item.category.in_(all_categories))
     if brand is not None:
         query = query.filter_by(brand=brand)
     query = query.group_by(Item.catalog_item_id).order_by(asc(Item.bestSellingRank))
     return query
     '''
     count = get_best_deals_counting_query(func.count(distinct(Item.catalog_item_id)), category, None).scalar()
     if count is None:
         count = 0
     return count
 def get_best_deals_catalog_ids(start_index, stop_index, brand, category=-1):
     '''
     Returns the catalog_item_ids of best deal items for the given brand and category.
     Ignores the category if it's passed as -1 and the brand if it's passed as None.
     '''
     return [item.catalog_item_id for item in best_deal_items]
 def get_best_deals_counting_query(obj, category, brand):
     '''
     Returns the query to be used to select the best deals in the given brand and category.
     Ignores the category if it's passed as -1 and the brand if it's passed as None.
     '''
     query = session.query(obj).filter_by(status=status.ACTIVE).filter(Item.bestDealValue != None)
     if category != -1:
         all_categories = [category]
         child_categories = get_child_categories(category)
         if child_categories is not None:
             all_categories = all_categories + child_categories
         query = query.filter(Item.category.in_(all_categories))
     if brand is not None:
         query = query.filter_by(brand=brand)
     return query
     return [item.catalog_item_id for item in coming_soon_items]
 def get_coming_soon_counting_query(obj, category, brand):
     '''
     Returns the query to be used to select the coming soon product in the given brand and category.
     Ignores the category if it's passed as -1 and the brand if it's passed as None.
     '''
     query = session.query(obj).filter_by(status=status.COMING_SOON)
     if category != -1:
         all_categories = [category]
         child_categories = get_child_categories(category)
         if child_categories is not None:
             all_categories = all_categories + child_categories
         query = query.filter(Item.category.in_(all_categories))
     if brand is not None:
         query = query.filter_by(brand=brand)
     return query
     if category != -1:
         categories = [category]
     query = get_latest_arrivals_query(Item, categories, None)
     items = query.all()[0:limit]
     return get_thrift_item_list(items)
 def get_latest_arrivals_count(limit, category=-1):
     '''
     Returns the number of latest arrivals which will be displayed on the website.
     To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
     '''
     count = get_latest_arrivals_counting_query(func.count(distinct(Item.catalog_item_id)), categories, None).scalar()
     if count is None:
         count = 0
     count = min(count, limit)
     return count
 def get_latest_arrivals_catalog_ids(start_index, stop_index, brand, categories=[]):
     '''
     Returns the catalog_item_ids of the latest arrivals between the start and the stop index
     To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
     '''
     '''
     Returns the query to be used to count Latest arrivals.
     To ignore the categories, pass the list as empty. To ignore brand, pass it as null.
     '''
     query = session.query(obj).filter_by(status=status.ACTIVE)
     all_categories = []
     for category in categories:
         all_categories.append(category)
         child_categories = get_child_categories(category)
         if child_categories:
             all_categories = all_categories + child_categories
     if all_categories:
         query = query.filter(Item.category.in_(all_categories))
     if brand is not None:
         query = query.filter_by(brand=brand)
     return query
 def get_latest_arrivals_query(obj, categories, brand):
 def put_category_object(object):
     category = Category.get_by(id=1)
     if category is None:
         category = Category()
     category.object = object
     session.commit()
     return True
 def get_category_object():
     object = Category.get_by(id=1).object
 def add_category(t_category):
     category = Category.get_by(id=t_category.id)
     if category is None:
         category = Category()
     category.id = t_category.id
     category.label = t_category.label
     category.description = t_category.description
     category.display_name = t_category.display_name
     category.parent_category_id = t_category.parent_category_id
     session.commit()
     return True
 def get_category(id):
     return Category.query.filter_by(id=id).first()
         return
     if item.mrp < item.sellingPrice:
         print "[BAD MRP and SP:] for {0} {1} {2} {3}. MRP={4}, SP={5}".format(item.productGroup, item.brand, item.modelNumber, item.color, str(item.mrp), str(item.sellingPrice))
         raise InventoryServiceException(101, "[BAD MRP and SP:] for {0} {1} {2} {3}. MRP={4}, SP={5}".format(item.productGroup, item.brand, item.modelNumber, item.color, str(item.mrp), str(item.sellingPrice)))
     return
 def validate_vendor_prices(item, vendorPrices):
     if item.mrp != None and item.mrp != "" and vendorPrices.mop != "" and item.mrp <  vendorPrices.mop:
         print "[BAD MRP and MOP:] for {0} {1} {2} {3}. MRP={4}. MOP={5}, Vendor={6}".format(item.productGroup, item.brand, item.modelNumber, item.color, str(item.mrp), str(vendorPrices.mop), str(vendorPrices.vendorId))
         raise InventoryServiceException(101, "[BAD MRP and MOP:] for {0} {1} {2} {3}. MRP={4}. MOP={5}, Vendor={6}".format(item.productGroup, item.brand, item.modelNumber, item.color, str(item.mrp), str(vendorPrices.mop), str(vendorPrices.vendorId)))
     if vendorPrices.mop != "" and vendorPrices.transferPrice != "" and vendorPrices.transferPrice > vendorPrices.mop:
     # Check if a similar item already exists in our database
     for old_item in similar_items:
         if old_item.color != None and old_item.color.strip().lower() == color.strip().lower():
             item = old_item
             break
     # Check if a similar item already exists in our database with out valid color if similar item with same color is not found
     if item is None:
         for old_item in similar_items:
             if not check_color_valid(old_item.color):
                 item = old_item
         i = i + 1
         # get a similar item already existing in our database if similar item with valid color is not found
         if i == len(similar_items):
             similar_item = old_item
             color_of_similar_item = similar_item.color
     # Check if a similar item that is obtained above is having a valid color
     if check_color_valid(color_of_similar_item):
         # if a similar item that is obtained above is having a valid color and new item is about to be created with out valid color it is not done.
         # since for example if their is a item with red color in our database and we are creating a new item with no color for the same product which is wrong.
         if item is None and not check_color_valid(color):
             return similar_item.id
     if item is None:
         return 0
     else:
         return item.id
 def change_risky_flag(item_id, risky):
     item = get_item(item_id)
     if not item:
         raise InventoryServiceException(101, "Item missing in our database")
     try:
         __send_mail_for_active_item(item.id, "Item '{0}' is Active. Item id is {1}".format(__get_product_name(item), item_id), "")
     session.commit()
     flag = "ON" if risky else "OFF"
     subject = "Risky flag is {0} for Item {1}.".format(flag, __get_product_name(item))
     __send_mail(subject,"")
 def get_items_for_mastersheet(categoryName, brand):
     if not categoryName or not brand:
         raise InventoryServiceException(101, "Invalid category or brand in request")
     categories = ["Handsets", "Tablets", "Laptops"]
     query = Item.query.filter(Item.status != status.PHASED_OUT)
     if categoryName == "ALL":
         pass
     elif categoryName == "ALL Accessories":
         if child_categories is not None:
             child_categories.append(0)
             query = query.filter(Item.category.in_(child_categories))
     else:
         query = query.filter(Item.product_group == categoryName)
     if brand == "ALL":
         pass
     else:
         query = query.filter(Item.brand == brand)
     items = query.all()
     return_list = []
     for similar_item in similar_items:
         item_query = Item.query.filter_by(catalog_item_id=similar_item.catalog_item_id).limit(1)
         item = item_query.one()
         return_list.append(item)
     return get_thrift_item_list(return_list)
 def add_similar_item_catalog_id(itemId, catalog_item_id):
     if not itemId or not catalog_item_id:
         raise InventoryServiceException(101, "Bad itemId or catalogItemId in request")
     items_for_entity = get_items_by_catalog_id(catalog_item_id)
     if not len(items_for_entity):
         raise InventoryServiceException(101, "catalogItemId does not exists in database")
     s_items = SimilarItems.query.filter_by(item_id=itemId, catalog_item_id=catalog_item_id).all()
     if not len(s_items):
         s_item = SimilarItems()
         s_item.item_id=itemId
         s_item.catalog_item_id=catalog_item_id
         session.commit()
         return items_for_entity[0]
     else:
         raise InventoryServiceException(101, "Already exists")
 def delete_similar_item_catalog_id(itemId, catalog_item_id):
     if not itemId or not catalog_item_id:
         raise InventoryServiceException(101, "Bad itemId or catalogItemId in request")
     similar_item = SimilarItems.query.filter_by(item_id=itemId, catalog_item_id=catalog_item_id).all()
     if len(similar_item):
         similar_item[0].delete()
     session.commit()
     return True
         return 0
 def add_update_voucher_for_item(catalog_item_id, voucher_type, voucher_amount):
     if not catalog_item_id or not voucher_type or not voucher_amount:
         raise InventoryServiceException(101, "Bad catalogItemId or voucherType or voucherAmount in request")
     items_for_entity = get_items_by_catalog_id(catalog_item_id)
     if not len(items_for_entity):
         raise InventoryServiceException(101, "catalogItemId does not exists in database")
     for item in items_for_entity:
         itemId = item.id
         voucher = VoucherItemMapping.query.filter_by(item_id=itemId, voucherType=voucher_type).all()
         if not len(voucher):
             voucher = VoucherItemMapping()
             voucher.amount=voucher_amount
         else:
             voucher[0].amount=voucher_amount
     session.commit()
     return True
 def delete_voucher_for_item(catalog_item_id, voucher_type):
     if not catalog_item_id or not voucher_type:
         raise InventoryServiceException(101, "Bad catalogItemId or voucherType in request")
     items_for_entity = get_items_by_catalog_id(catalog_item_id)
     if not len(items_for_entity):
         raise InventoryServiceException(101, "catalogItemId does not exists in database")
     for item in items_for_entity:
         itemId = item.id
         voucher = VoucherItemMapping.query.filter_by(item_id=itemId, voucherType=voucher_type).all()
         if len(voucher):
             voucher[0].delete()
         if itemcountmap.has_key(item.id):
             itemcountmap[item.id] = itemcountmap.get(item.id) + 1
         else:
             client = InventoryClient().get_client()
             availability = client.getItemAvailabilityAtLocation(item.id, sourceId)[4]
             if item.status == status.ACTIVE and (not item.risky or availability > 0):
                 itemstatusmap[item.id] = True
             else:
                 itemstatusmap[item.id] = False
             itemcountmap[item.id] = 1
         if itemcountmap[item.id] > 1000:
             continue
         if itemstatusmap[item.id]:
             __enque_product_notification_email(product_notification.email, __get_product_name(item) , product_notification.addedOn, __get_product_url(item), item.id)
             product_notification.delete()
     session.commit()
     return True
 def __get_product_name(item):
     product_name = item.brand + " " + item.model_name + " " + item.model_number
     color = item.color
     if color is not None and color != 'NA':
         product_name = product_name + " (" + color + ")"
 def get_all_brands_by_category(category_id):
     catm = CategoryManager()
     child_categories = catm.getCategory(category_id).children_category_ids
     brands = session.query(distinct(Item.brand)).filter(Item.category.in_(child_categories)).all()
     return [brand[0] for brand in brands]
 def get_all_brands():
     brands = session.query(distinct(Item.brand)).order_by(Item.brand).all()
     return [brand[0] for brand in brands]
 def __enque_product_notification_email(email, product, date, url, itemId):
     html = """
         <html>
         <body>
         <div>
         <p>
             Hi,<br /><br />
             The product requested by you on $date is now available on $source_url.
             <br />
             We have limited stocks of this model at this moment. If you don't want to miss out, please place your order as soon as possible.
         </p>
         <p>
         <strong>Product: $product </strong>
         </p>
         <p>
         Click the link below to visit the product:
         <br/>
         $url
         </p>
         <p>
         Regards,<br/>
         </body>
         </html>
         """
     html = Template(html).substitute(dict(product=product,date=date,url=url,source_url=source_url,source_name=source_name))
     try:
         helper_client = HelperClient().get_client()
         helper_client.saveUserEmailForSending([email], "", "Product requested by you is available now.", html, str(itemId), "ProductNotification", [], [])
     except Exception as e:
         print e
 def get_item_pricing_by_source(itemId, sourceId):
     item = Item.query.filter_by(id=itemId).first()
     if item is None:
         raise InventoryServiceException(101, "Bad Item")
     source = Source.query.filter_by(id=sourceId).first()
     if source is None:
         raise InventoryServiceException(101, "Source not found for sourceId " + str(sourceId))
     item_pricing = SourceItemPricing.query.filter_by(source=source, item=item).first()
     if item_pricing is None:
         raise InventoryServiceException(101, "Pricing information not found for sourceId " + str(sourceId))
     return item_pricing
 def add_source_item_pricing(sourceItemPricing):
     if not sourceItemPricing:
         raise InventoryServiceException(108, "Bad sourceItemPricing in request")
     if not sourceItemPricing.sellingPrice:
         raise InventoryServiceException(101, "Selling Price is not defined for sourceId " + str(sourceItemPricing.sourceId))
     sourceId = sourceItemPricing.sourceId
     itemId = sourceItemPricing.itemId
     item = Item.query.filter_by(id=itemId).first()
     if item is None:
         raise InventoryServiceException(101, "Bad Item")
     source = Source.query.filter_by(id=sourceId).first()
     if source is None:
         raise InventoryServiceException(101, "Source not found for sourceId " + str(sourceId))
     ds_sourceItemPricing = SourceItemPricing.get_by(source=source, item=item)
     if ds_sourceItemPricing is None:
         ds_sourceItemPricing = SourceItemPricing()
         ds_sourceItemPricing.source = source
         ds_sourceItemPricing.item = item
     if sourceItemPricing.mrp:
         ds_sourceItemPricing.mrp = sourceItemPricing.mrp
     ds_sourceItemPricing.sellingPrice = sourceItemPricing.sellingPrice
     session.commit()
     item = Item.query.filter_by(id=itemId).first()
     if item is None:
         raise InventoryServiceException(101, "Bad Item")
     source_pricing = SourceItemPricing.query.filter_by(item=item).all()
     return source_pricing
 def get_item_for_source(item_id, sourceId):
     item = get_item(item_id)
     if sourceId == -1:
         return item
         print "No source pricing"
     return item
 def search_items(search_terms, offset, limit):
     query = Item.query
     search_terms = ['%' + search_term + '%' for search_term in search_terms]
     for search_term in search_terms:
         query_clause = []
         query_clause.append(Item.brand.like(search_term))
         query_clause.append(Item.model_number.like(search_term))
         query_clause.append(Item.model_name.like(search_term))
         query = query.filter(or_(*query_clause))
     query = query.order_by(Item.product_group, Item.brand, Item.model_number, Item.model_name).offset(offset)
     if limit:
         query = query.limit(limit)
     items = query.all()
     return items
 def get_search_result_count(search_terms):
     query = Item.query
     search_terms = ['%' + search_term + '%' for search_term in search_terms]
     for search_term in search_terms:
         query_clause = []
         query_clause.append(Item.brand.like(search_term))
         query_clause.append(Item.model_number.like(search_term))
         query_clause.append(Item.model_name.like(search_term))
         query = query.filter(or_(*query_clause))
     return query.count()
 def __clear_homepage_cache():
     try:
         # create a password manager
         password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm()
         # Add the username and password.
         configclient = ConfigClient()
         ips = configclient.get_property("production_servers_private_ips");
         ips = ips.split(" ")
         for ip in ips:
             try:
                 top_level_url = "http://" + ip + ":8080/"
                 password_mgr.add_password(None, top_level_url, "saholic", "shop2020")
                 handler = urllib2.HTTPBasicAuthHandler(password_mgr)
                 opener = urllib2.build_opener(handler)
                 # use the opener to fetch a URL
                 res = opener.open(top_level_url + "cache-admin/HomePageSnippets?_method=delete")
                 print "Successfully cleared home page cache" + res.read()
             except:
                 print "Unable to clear home page cache" + res.read()
     except:
         print "Unable to clear cache, still should continue with other operations"
 def get_product_notifications(start_datetime):
     '''
     Returns a list of Product Notification objects each representing user requests for notification
     '''
     query = ProductNotification.query
     if start_datetime:
         query = query.filter(ProductNotification.addedOn > start_datetime)
     notifications = query.order_by(desc('addedOn')).all()
     return notifications
 def get_product_notification_request_count(start_datetime):
     '''
     Returns list of items and the counts of product notification requests
     '''
     print start_datetime
     query = session.query(ProductNotification, func.count(ProductNotification.email).label('count'))
     if start_datetime:
         query = query.filter(ProductNotification.addedOn > start_datetime)
     counts = query.group_by(ProductNotification.item_id).order_by(desc('count')).all()
     return counts
 def close_session():
     if session.is_active:
 def __send_mail(subject, message, send_to  = to_addresses):
     try:
         thread = threading.Thread(target=partial(mail, mail_user, mail_password, send_to, subject, message))
         thread.start()
     except Exception as ex:
         print ex
 def get_vat_amount_for_item(itemId, price):
     item = Item.query.filter_by(id=itemId).first()
     vatPercentage = item.vatPercentage
     if vatPercentage is None:
         vatMaster = CategoryVatMaster.query.filter(and_(CategoryVatMaster.categoryId==item.category, CategoryVatMaster.minVal<=price,  CategoryVatMaster.maxVal>=price)).first()
         vatPercentage = vatMaster.vatPercent
         if  vatPercentage is None:
             vatPercentage = 0
     return (price*vatPercentage)/100
 def get_vat_percentage_for_item(itemId, stateId, price):
     itemVatMaster = ItemVatMaster.query.filter(and_(ItemVatMaster.itemId==itemId, ItemVatMaster.stateId==stateId)).first()
     if itemVatMaster is None:
             item = Item.query.filter_by(id=itemId).first()
             if item is None:
     return result
 def add_tag (displayName, catalogId):
     ent_tag = None
     if catalogId is None or (not is_valid_catalog_id(catalogId)):
         raise InventoryServiceException(id, "Invalid CatalogId")
     else:
         ent_tag = EntityTag()
         ent_tag.entityId = catalogId
     if displayName is None:
         raise InventoryServiceException(id, "Tag should not be empty")
     else:
         ent_tag.tag = displayName
     session.commit()
     return True
 def add_banner(bannerName, imageName,link, priority, isActive, hasMap):
     session.commit()
     return True
 def get_banner_details(name):
     banner = Banner.get_by(bannerName=name)
     return banner
 def get_active_banners():
     print "Data accessor"
     query= session.query(Banner)
     banner= query.filter_by(isActive =True).order_by(desc(Banner.priority)).all()
     query= session.query(BannerMap)
     bannermap= query.filter_by(bannerName=name).all()
     print "Banner is",
     print bannermap
     return bannermap
 def get_all_tags ():
     return [tuple[0] for tuple in session.query(EntityTag.tag).distinct().all()]
 def get_all_entities_by_tag_name(displayName):
     return [tuple[0] for tuple in session.query(EntityTag.entityId).filter_by(tag=displayName).all()]
 def delete_tag(displayName):
     session.query(EntityTag.entityId).filter_by(tag=displayName).delete()
     session.commit()
     return True
     insuranceAmount = 0.0
     if itemInsurerMapping.premiumType == PremiumType._NAMES_TO_VALUES.get("PERCENT"):
         insuranceAmount = price * (itemInsurerMapping.premiumAmount/100) * quantity
     else :
         insuranceAmount = itemInsurerMapping.premiumAmount * quantity
     return insuranceAmount
 def get_insurer(insurerId):
     return Insurer.get_by(id = insurerId)
 def get_all_entity_tags():
     entitiesTag = EntityTag.query.all()
     entityMap = {}
     for e in entitiesTag:
         if not entityMap.has_key(e.entityId):
             entityMap[e.entityId] = []
         entityMap[e.entityId].append(e.tag)
     return entityMap
 def get_all_insurers():
     print session.query(Insurer).all()
     return session.query(Insurer).all()
 def update_insurance_declared_amount(insurerId, amount):
     insurer = Insurer.get_by(id = insurerId)
     insurer.declaredAmount += amount
     session.commit()
     if insurer.declaredAmount > 0.9*insurer.creditedAmount:
         __send_mail("CRITICAL: Declared Insurance Amount is critical (Declared Amount - " + str(insurer.declaredAmount) + " and Credited Amount - " + str(insurer.creditedAmount) +")", "Please top up credited amount")
     elif insurer.declaredAmount > 0.8*insurer.creditedAmount:
         __send_mail("WARNING: Declared Insurance Amount is warning (Declared Amount - " + str(insurer.declaredAmount) + " and Credited Amount - " + str(insurer.creditedAmount) +")", "Please top up credited amount")
 def get_freebie_for_item(itemId):
     freebie = FreebieItem.get_by(itemId = itemId)
     if freebie is None:
         return 0
     else:
         return freebie.freebieItemId
 def add_or_update_freebie_for_item(freebieItem):
     freebie = FreebieItem.get_by(itemId = freebieItem.itemId)
     if freebie is None:
         freebie = FreebieItem()
         freebie.itemId = freebieItem.itemId
     if brandinfo is None:
         brandinfo = BrandInfo()
         brandinfo.itemId = brandInfo.itemId
         brandinfo.freebieItemId = brandInfo.freebieItemId
     session.commit()
 def get_brand_info():
     brandInfoMap = dict()
     brandInfoList = FreebieItem.query.all()
     for brandInfo in brandInfoList:
         brandInfoMap[brandInfo.name] = to_t_brand_info(brandInfo)
         sp.item_id = item.id
         sp.freebieItemId = tsp.freebieItemId
         sp.bestDealText = tsp.bestDealText
         sp.absoluteMinPrice = tsp.absoluteMinPrice
     session.commit()
 def validate_store_pricing(tsp):
     if tsp.minPrice > tsp.maxPrice:
         raise InventoryServiceException(101, "DP is more than MRP")
     item = get_item(tsp.itemId)
     if item.mrp and tsp.maxPrice > item.mrp:
         raise InventoryServiceException(101, "MRP is more than Saholic MRP")
-    if tsp.recommendedPrice < item.sellingPrice:
-        raise InventoryServiceException(101, "MOP is less than Saholic MOP.")
+    if tsp.recommendedPrice < item.sellingPrice:
+        raise InventoryServiceException(101, "MOP is less than Saholic MOP.")
     if tsp.recommendedPrice < tsp.minPrice or tsp.recommendedPrice >  tsp.maxPrice:
         raise InventoryServiceException(101, "MOP price must be in the range")
     if tsp.minPrice < item.sellingPrice:
         store_message = "Saholic MOP Changed. DP {0} is less than Saholic MOP.\n".format(tsp.minPrice)
         subject = "Item '{0}' is updated in Catalog. Id is {1}".format(__get_product_name(item),item.id)
         __send_mail(subject, store_message, to_store_addresses)
     return True
 def get_defalut_store_pricing(itemId):
     inventoryClient = InventoryClient().get_client()
     pricings = inventoryClient.getAllItemPricing(itemId)
     item = get_item(itemId)
     maxp = item.sellingPrice
     if item.mrp:
         maxp = item.mrp
     minp = 0
     rp = item.sellingPrice
     for pricing in pricings:
         if not minp or minp > pricing.dealerPrice:
             minp = pricing.dealerPrice
     minap = math.ceil(min(max(500, rp*0.1),rp))
     if minp > rp:
         minp = rp
     sp = tStorePricing()
     sp.minAdvancePrice = minap
     sp.maxPrice = maxp
     sp.freebieItemId = 0
     sp.bestDealText = ""
     return sp
 def get_store_pricing(itemId):
     store = StorePricing.get_by(item_id = itemId)
     if store is None:
         return get_defalut_store_pricing(itemId)
     sp = tStorePricing()
     sp.itemId = itemId
     sp.recommendedPrice = store.recommendedPrice
     sp.minPrice = store.minPrice
     sp.minAdvancePrice = store.minAdvancePrice
     sp.maxPrice = store.maxPrice
     sp.absoluteMinPrice = store.absoluteMinPrice
     amazonlisted = Amazonlisted.get_by(itemId=amazonItemId)
     return amazonlisted
 def update_amazon_item_details(amazonItemId,fbaPrice,sellingPrice,isFba,isNonFba,isInventoryOverride,handlingTime,isCustomTime):
     amazonlisted = Amazonlisted.get_by(itemId = amazonItemId)
-    amazonlisted.fbaPrice=fbaPrice
-    amazonlisted.sellingPrice=sellingPrice
     amazonlisted.isFba=isFba
     amazonlisted.isNonFba=isNonFba
     amazonlisted.isInventoryOverride=isInventoryOverride
     amazonlisted.handlingTime=handlingTime
     amazonlisted.isCustomTime=isCustomTime
+    if amazonlisted.sellingPrice != sellingPrice:
+        amazonlisted.mfnPriceLastUpdatedOn = datetime.datetime.now()
+        amazonlisted.sellingPrice=sellingPrice
+    if amazonlisted.fbaPrice != fbaPrice:
+        amazonlisted.fbaPriceLastUpdatedOn = datetime.datetime.now()
+        amazonlisted.fbaPrice=fbaPrice
     session.commit()
 def add_amazon_item(amazonlisted):
     if (not amazonlisted) or (not amazonlisted.itemid) or (not amazonlisted.asin):
         return
     amazonItem = Amazonlisted.get_by(itemId=amazonlisted.itemid)
     if amazonItem is None:
             amazon_item.ean=''
         if amazonlisted.upc:
             amazon_item.upc=amazonlisted.upc
         else:
             amazon_item.upc=''
-        if amazonlisted.sellingPrice:
-            amazon_item.sellingPrice=amazonlisted.sellingPrice
         if amazonlisted.fbaPrice:
             amazon_item.fbaPrice=amazonlisted.fbaPrice
+            amazon_item.fbaPriceLastUpdatedOn = datetime.datetime.now()
+        if amazonlisted.sellingPrice:
+            amazon_item.sellingPrice=amazonlisted.sellingPrice
+            amazon_item.mfnPriceLastUpdatedOn = datetime.datetime.now()
         if amazonlisted.isFba:
             amazon_item.isFba=amazonlisted.isFba
         if amazonlisted.isNonFba:
             amazon_item.isNonFba=amazonlisted.isNonFba
         if amazonlisted.isInventoryOverride:
         if amazonlisted.upc:
             amazonItem.upc=amazonlisted.upc
         else:
             amazonItem.upc=''
         if amazonlisted.sellingPrice:
-            amazonItem.sellingPrice=amazonlisted.sellingPrice
+            amazon_item.sellingPrice=amazonlisted.sellingPrice
+            amazonlisted.mfnPriceLastUpdatedOnSc = datetime.datetime.now()
+            amazonlisted.mfnPriceLastUpdatedOn = datetime.datetime.now()
         if amazonlisted.fbaPrice:
-            amazonItem.fbaPrice=amazonlisted.fbaPrice
+            amazon_item.fbaPrice=amazonlisted.fbaPrice
+            amazonlisted.fbaPriceLastUpdatedOnSc = datetime.datetime.now()
+            amazonlisted.fbaPriceLastUpdatedOn = datetime.datetime.now()
         if amazonlisted.isFba:
             amazonItem.isFba=amazonlisted.isFba
         if amazonlisted.isNonFba:
             amazonItem.isNonFba=amazonlisted.isNonFba
         if amazonlisted.isInventoryOverride:
         else:
             amazonItem.color=''
     else:
         return
     session.commit()
 def get_asin_items():
     from_date=datetime.datetime.now() - datetime.timedelta(days=10)
     return Item.query.filter(Item.updatedOn > from_date).all()
 def get_all_fba_listed_items():
     return Amazonlisted.query.filter(Amazonlisted.isFba==True).all()
 def get_all_nonfba_listed_items():
     return Amazonlisted.query.filter(Amazonlisted.isNonFba==True).all()
 def update_item_inventory(itemId,holdInventory,defaultInventory):
     item = get_item(itemId)
     item.holdInventory = holdInventory
     item.defaultInventory = defaultInventory
     session.commit()
+def update_timestamp_for_amazon_feeds(feedType,skuList,timestamp):
+    #amazonListed = get_all_amazon_listed_items()
+    fbaItems = []
+    mfnItems = []
+    if feedType == 'NonFbaPricing':
+        items = Amazonlisted.query.filter(Amazonlisted.isNonFba==True).filter(Amazonlisted.mfnPriceLastUpdatedOn > Amazonlisted.mfnPriceLastUpdatedOnSc).all()
+        for item in items:
+            mfnItems.append(item.itemId)
+        listToUpdate = list(set(mfnItems)-set(skuList))
+        for sku in listToUpdate:
+            amazonItem = Amazonlisted.get_by(itemId=sku)
+            amazonItem.mfnPriceLastUpdatedOnSc = to_py_date(timestamp)
+            session.commit()
+        return True
+    elif feedType == 'FbaPricing':
+        items = Amazonlisted.query.filter(Amazonlisted.isFba==True).filter(Amazonlisted.fbaPriceLastUpdatedOn > Amazonlisted.fbaPriceLastUpdatedOnSc).all()
+        for item in items:
+            fbaItems.append(item.itemId)
+        listToUpdate = list(set(fbaItems)-set(skuList))
+        for sku in listToUpdate:
+            amazonItem = Amazonlisted.get_by(itemId=sku)
+            amazonItem.fbaPriceLastUpdatedOnSc = to_py_date(timestamp)
+            session.commit()
+        return True
+    elif feedType== 'FullFbaPricing':
+        items = Amazonlisted.query.filter(Amazonlisted.isFba==True).all()
+        for item in items:
+            fbaItems.append(item.itemId)
+        listToUpdate = list(set(fbaItems)-set(skuList))
+        for sku in listToUpdate:
+            amazonItem = Amazonlisted.get_by(itemId=sku)
+            amazonItem.fbaPriceLastUpdatedOnSc = to_py_date(timestamp)
+            session.commit()
+        return True
+    elif feedType== 'FullNonFbaPricing':
+        items = Amazonlisted.query.filter(Amazonlisted.isNonFba==True).all()
+        for item in items:
+            mfnItems.append(item.itemId)
+        listToUpdate = list(set(mfnItems)-set(skuList))
+        for sku in listToUpdate:
+            amazonItem = Amazonlisted.get_by(itemId=sku)
+            amazonItem.mfnPriceLastUpdatedOnSc = to_py_date(timestamp)
+            session.commit()
+    else:
+        return False

Subversion Repositories SmartDukaan

(root)//trunk/PyProj/src/shop2020/model/v1/catalog/impl/DataAcessors.py – Rev 7761 → 7770