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

             raise InventoryServiceException(108, "Some unforeseen error while updating inventory")
     session.commit()
     #**Update item availability cache**#
     for item_id in item_ids:
-        __update_item_availability_cache(item_id)
+        clear_item_availability_cache(item_id)
-        __check_risky_item(item_id)
 def __send_alert_for_negative_reserved(item, reserved, warehouse):
     itemName = " ".join([str(item.id), str(item.brand), str(item.modelName), str(item.modelNumber), str(item.color)])
     EmailAttachmentSender.mail('cnc.center@shop2020.in', '5h0p2o2o', 'amar.kumar@shop2020.in', 'Negative reserved: ' + str(reserved) + ' for Item Id: ' + itemName + ' warehouse id: ' + str(warehouse.id), None)
         current_inventory_snapshot.reserved = 0
     # added the difference in the current inventory
     current_inventory_snapshot.availability = current_inventory_snapshot.availability + quantity
     session.commit()
     #**Update item availability cache**#
-    __update_item_availability_cache(itemId)
+    clear_item_availability_cache(itemId)
     if current_inventory_snapshot.availability < 0:
         item = __get_item_from_master(itemId)
         __send_alert_for_negative_availability(item, current_inventory_snapshot.availability, get_Warehouse(warehouseId))
-    __check_risky_item(itemId)
 def add_bad_inventory(itemId, warehouseId, quantity):
     bad_inventory_snapshot = BadInventorySnapshot.get_by(item_id=itemId, warehouse_id=warehouseId)
     if not bad_inventory_snapshot:
         bad_inventory_snapshot = BadInventorySnapshot()
     reservation.promised_shipping_timestamp = promised_shipping_timestamp
     reservation.reserved = quantity
     session.commit()
     #**Update item availability cache**#
-    __update_item_availability_cache(item_id)
+    clear_item_availability_cache(item_id)
-    __check_risky_item(item_id)
     return True
 def reduce_reservation_count(item_id, warehouse_id, source_id, order_id, quantity):
     if not warehouse_id:
         raise InventoryServiceException(101, "bad warehouse_id")
             reservation.delete()
         else:
             reservation.reserved -= quantity
         session.commit()
         #**Update item availability cache**#
-        __update_item_availability_cache(item_id)
+        clear_item_availability_cache(item_id)
-        __check_risky_item(item_id)
         if current_inventory_snapshot.reserved < 0:
             item = __get_item_from_master(item_id)
             __send_alert_for_negative_reserved(item, current_inventory_snapshot.reserved, get_Warehouse(warehouse_id))
         return True
     except:
         print "Unexpected error:", sys.exc_info()[0]
         return False
-def get_item_availability_for_location(item_id):
+def get_item_availability_for_location(item_id, source_id):
-    item_availability = ItemAvailabilityCache.get_by(itemId=item_id)
+    item_availability = ItemAvailabilityCache.get_by(itemId=item_id, sourceId = source_id)
     if item_availability:
         return [item_availability.warehouseId, item_availability.expectedDelay, item_availability.billingWarehouseId, item_availability.sellingPrice, item_availability.totalAvailability]
     else:
-        __update_item_availability_cache(item_id)
+        __update_item_availability_cache(item_id, source_id)
+            ##Check risky status for the source
+        __check_risky_item(item_id, source_id)
-        return get_item_availability_for_location(item_id)
+        return get_item_availability_for_location(item_id, source_id)
-def clear_item_availability_cache():
+def clear_item_availability_cache(item_id = None):
+    if item_id:
+        ItemAvailabilityCache.query.filter_by(itemId = item_id).delete()
+    else:
-    ItemAvailabilityCache.query.delete()
+        ItemAvailabilityCache.query.delete()
     session.commit()
-def __update_item_availability_cache(item_id):
+def __update_item_availability_cache(item_id, source_id):
     """
     Determines the warehouse that should be used to fulfil an order for the given item.
     Algorithm explained at https://sites.google.com/a/shop2020.in/virtual-w-h-and-inventory/technical-details
     It will be ensured that every item has either a preferred vendor specified or at least for one vendor its transfer price should be defined.
 . Id of the warehouse which was finally picked up.
     Parameters:
      - itemId
     """
-    item = __get_item_from_master(item_id)
+    item = __get_item_from_source(item_id, source_id)
     item_pricing = {}
     for vendorItemPricing in VendorItemPricing.query.filter_by(item_id=item_id).all():
         item_pricing[vendorItemPricing.vendor_id] = vendorItemPricing
     warehouses = {}
         expectedDelay = 0
     else:
         expectedDelay = int(item.expectedDelay)
     if total_availability <= 0:
-        expectedDelay = expectedDelay + __get_expected_procurement_delay(item)
+        expectedDelay = expectedDelay + __get_expected_procurement_delay(item.id, item.preferredVendor)
-        expectedDelay = expectedDelay + __get_vendor_holiday_delay(item, expectedDelay)
+        expectedDelay = expectedDelay + __get_vendor_holiday_delay(item.preferredVendor, expectedDelay)
     else:
         if warehouse.transferDelayInHours:
             expectedDelay = expectedDelay + warehouse.transferDelayInHours / 24
     total_availability = 0
     for entry in CurrentInventorySnapshot.query.filter_by(item_id = item_id).all():
         total_availability += entry.availability - entry.reserved
-    item_availability_cache = ItemAvailabilityCache.get_by(itemId=item_id)
+    item_availability_cache = ItemAvailabilityCache.get_by(itemId=item_id, sourceId=source_id)
     if item_availability_cache is None:
         item_availability_cache = ItemAvailabilityCache()
         item_availability_cache.itemId = item_id
+        item_availability_cache.sourceId = source_id
     item_availability_cache.warehouseId = int(warehouse_retid)
     item_availability_cache.expectedDelay = expectedDelay
     item_availability_cache.billingWarehouseId = billingWarehouseId
     item_availability_cache.sellingPrice = item.sellingPrice
     item_availability_cache.totalAvailability = total_availability
                 max_availability = availability
             total_availability += availability
     return [warehouse_retid, total_availability]
-def __get_expected_procurement_delay(item):
+def __get_expected_procurement_delay(item_id, preferredVendor):
     procurementDelay = 2
     try:
-        if item.preferredVendor:
+        if preferredVendor:
-            delays = VendorItemProcurementDelay.query.filter_by(vendor_id = item.preferredVendor, item_id = item.id).all()
+            delays = VendorItemProcurementDelay.query.filter_by(vendor_id = preferredVendor, item_id = item_id).all()
         else:
-            delays = VendorItemProcurementDelay.query.filter_by(item_id = item.id).all()
+            delays = VendorItemProcurementDelay.query.filter_by(item_id = item_id).all()
         procurementDelay= min([delay.procurementDelay for delay in delays])
     except Exception as e:
         print e
     return procurementDelay
-def __get_vendor_holiday_delay(item, expectedDelay):
+def __get_vendor_holiday_delay(preferredVendor, expectedDelay):
     holidayDelay = 0
     try:
-        if item.preferredVendor:
+        if preferredVendor:
-            holidays = VendorHolidays.query.filter_by(vendor_id = item.preferredVendor).all()
+            holidays = VendorHolidays.query.filter_by(vendor_id = preferredVendor).all()
             currentDate = datetime.date.today()
             expectedDate = currentDate + datetime.timedelta(days = expectedDelay)
             for holiday in holidays:
                 if holiday.holidayType == HolidayType.WEEKLY and holiday.holidayValue != calendar.SUNDAY:
                     if currentDate.weekday() > holiday.holidayValue:
             quantity = 0
         currentInventorySnapshot = CurrentInventorySnapshot.get_by(item_id = itemId, warehouse_id = warehouseId)
         if currentInventorySnapshot:
             currentInventorySnapshot.availability = quantity
-            __update_item_availability_cache(itemId)
+            clear_item_availability_cache(itemId)
-            __check_risky_item(currentInventorySnapshot.item_id)
         else:
             add_inventory(itemId, warehouseId, quantity)
     else:
         raise InventoryServiceException(101, 'VendorMapping not found for: ' + itemKey)
     session.commit()
 def reset_availability_for_warehouse(warehouseId):
     for currentInventorySnapshot in CurrentInventorySnapshot.query.filter_by(warehouse_id=warehouseId).all():
         currentInventorySnapshot.availability = 0
-        __update_item_availability_cache(currentInventorySnapshot.item_id)
+        clear_item_availability_cache(currentInventorySnapshot.item_id)
-        __check_risky_item(currentInventorySnapshot.item_id)
     session.commit()
 def __send_mail(subject, message):
     try:
 def update_vendor_string(warehouseId, vendorString):
     warehouse = get_Warehouse(warehouseId)
     warehouse.vendorString = vendorString
     session.commit()
-def __check_risky_item(item_id):
-    ## We should get the list of strings which will identify to the catalog servers
-    client = CatalogClient("catalog_service_server_host_master", "catalog_service_server_port").get_client()
-    client.validateRiskyStatus(item_id)
-    client = CatalogClient("catalog_service_server_host_hotspot", "catalog_service_server_port").get_client()
-    client = CatalogClient().get_client()
 def __get_item_from_master(item_id):
     client = CatalogClient("catalog_service_server_host_master", "catalog_service_server_port").get_client()
-    return client.getItem(item_id)
     return client.getItem(item_id)
+def __check_risky_item(item_id, source_id):
+    ## We should get the list of strings which will identify to the catalog servers
+    if source_id == 1:
+        client = CatalogClient("catalog_service_server_host_master", "catalog_service_server_port").get_client()
+        client.validateRiskyStatus(item_id)
+    if source_id == 2:
+        client = CatalogClient("catalog_service_server_host_hotspot", "catalog_service_server_port").get_client()
+        client.validateRiskyStatus(item_id)
+def __get_item_from_source(item_id, source_id):
+    if source_id == 1:
+        client = CatalogClient("catalog_service_server_host_master", "catalog_service_server_port").get_client()
+        return client.getItem(item_id)
+    if source_id == 2:
+        client = CatalogClient("catalog_service_server_host_hotspot", "catalog_service_server_port").get_client()
+        return client.getItem(item_id)

Subversion Repositories SmartDukaan

(root)//trunk/PyProj/src/shop2020/model/v1/inventory/impl/DataAcessors.py – Rev 5966 → 5978