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

 Created on 23-Mar-2010
 @author: ashish
 '''
 from elixir import *
+from functools import partial
 from pydoc import Helper
 from shop2020.clients.HelperClient import HelperClient
 from shop2020.clients.TransactionClient import TransactionClient
 from shop2020.config.client.ConfigClient import ConfigClient
 from shop2020.model.v1.catalog.impl import DataService
 from shop2020.model.v1.catalog.impl.CategoryManager import CategoryManager
 from shop2020.model.v1.catalog.impl.Convertors import to_t_item, to_t_source
 from shop2020.model.v1.catalog.impl.DataService import Item, Warehouse, \
-    ItemInventoryHistory, CurrentInventorySnapshot, ItemChangeLog, \
+    ItemInventoryHistory, CurrentInventorySnapshot, ItemChangeLog, Category, \
-    Category, EntityIDGenerator, VendorItemPricing, VendorItemMapping, Vendor, \
+    EntityIDGenerator, VendorItemPricing, VendorItemMapping, Vendor, SimilarItems, \
-    SimilarItems, ProductNotification, Source, SourceItemPricing, AuthorizationLog, \
+    ProductNotification, Source, SourceItemPricing, AuthorizationLog, \
     MissedInventoryUpdate, BadInventorySnapshot, VendorItemProcurementDelay, \
     VendorHolidays, ItemAvailabilityCache
 from shop2020.thriftpy.model.v1.catalog.ttypes import InventoryServiceException, \
-    status, ItemShippingInfo, HolidayType, InventoryType, ItemType
+    status, ItemShippingInfo, HolidayType, InventoryType, WarehouseType, ItemType
 from shop2020.thriftpy.model.v1.order.ttypes import AlertType
 from shop2020.utils import EmailAttachmentSender
 from shop2020.utils.EmailAttachmentSender import mail
 from shop2020.utils.Utils import to_py_date, log_risky_flag
 from sqlalchemy import desc, asc
 from string import Template
 from urllib2 import HTTPBasicAuthHandler
 import calendar
 import datetime
 import sys
+import threading
 import urllib2
-from functools import partial
-import threading
 to_addresses = ["cnc.center@shop2020.in", "ashutosh.saxena@shop2020.in"]
 from_user = "cnc.center@shop2020.in"
 from_pwd = "5h0p2o2o"
 def is_active(item_id):
     t_item_shipping_info = ItemShippingInfo()
     try:
         item = get_item(item_id)
         t_item_shipping_info.isRisky = item.risky
-        warehouse_ids = None
+        warehouse_id = get_item_availability_for_location(item.id)[0]
-        if item.isWarehousePreferenceSticky:
+        if item.risky and item.status == status.ACTIVE:
-            warehouse_ids = [w.id for w in Warehouse.query.filter_by(shippingWarehouseId = item.preferredWarehouse, inventoryType = InventoryType._VALUES_TO_NAMES[InventoryType.GOOD]).all()]
+            availability = 0
-        availability = __get_item_availability(item, warehouse_ids)
+            currentInventorySnapshot = CurrentInventorySnapshot.query.filter_by(item_id = item.id, warehouse_id = warehouse_id).all()
-        if item.risky and availability <= 0 and item.status == status.ACTIVE:
+            if not currentInventorySnapshot or currentInventorySnapshot[0].availibility <= currentInventorySnapshot[0].reserved:
-            add_status_change_log(item, status.PAUSED_BY_RISK)
+                add_status_change_log(item, status.PAUSED_BY_RISK)
-            item.status = status.PAUSED_BY_RISK
+                item.status = status.PAUSED_BY_RISK
-            item.status_description = "This item is currently out of stock"
+                item.status_description = "This item is currently out of stock"
-            session.commit()
+                session.commit()
-            __send_mail_for_oos_item(item)
+                __send_mail_for_oos_item(item)
-            #This will clear cache from tomcat
+                #This will clear cache from tomcat
-            __clear_homepage_cache()
+                __clear_homepage_cache()
+            else:
+                availability = currentInventorySnapshot[0].availibility
+        else:
+            availability = item.get_total_inventory
         t_item_shipping_info.isActive = (item.status == status.ACTIVE)
         t_item_shipping_info.quantity = availability
     except InventoryServiceException:
         print "[ERROR] Unexpected error:", sys.exc_info()[0]
     return t_item_shipping_info
     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.preferredWarehouse:
-        if item.preferredWarehouse != ds_item.preferredWarehouse:
-            newPreferredWareHouseName = get_Warehouse(item.preferredWarehouse).displayName
-            oldPreferredWareHouseName = 'None'
-            if ds_item.preferredWarehouse:
-                oldPreferredWareHouseName = get_Warehouse(ds_item.preferredWarehouse).displayName
-            message += "Preferred warehouse is changed from '{0}' to '{1}'.\n".format(oldPreferredWareHouseName, newPreferredWareHouseName)
-        ds_item.preferredWarehouse = item.preferredWarehouse
-    if item.defaultWarehouse:
-        ds_item.defaultWarehouse = item.defaultWarehouse
     if item.preferredVendor:
         if item.preferredVendor != ds_item.preferredVendor:
             newPreferredVendorName = get_Vendor(item.preferredVendor).name
             oldPreferredVendorName = 'None'
     if item.expectedDelay is not None:
         ds_item.expectedDelay = item.expectedDelay
     else:
         ds_item.expectedDelay = 0
-    if item.preferredWarehouse:
-        ds_item.preferredWarehouse = item.preferredWarehouse
-    if item.defaultWarehouse:
-        ds_item.defaultWarehouse = item.defaultWarehouse
     if item.preferredVendor:
         ds_item.preferredVendor = item.preferredVendor
     # Check if a similar item already exists in our database
     """
 def check_risky_item(item):
     if not item.risky:
         return
-    warehouse_ids = None
-    if item.isWarehousePreferenceSticky :
+    warehouse_id = get_item_availability_for_location(item.id)[0]
-        warehouse_ids = [w.id for w in Warehouse.query.filter_by(shippingWarehouseId = item.preferredWarehouse, inventoryType = InventoryType._VALUES_TO_NAMES[InventoryType.GOOD]).all()]
+    currentInventorySnapshot = CurrentInventorySnapshot.query.filter_by(item_id = item.id, warehouse_id = warehouse_id).all()
-    availability = __get_item_availability(item, warehouse_ids)
+    if not currentInventorySnapshot or currentInventorySnapshot[0].availability <= currentInventorySnapshot[0].reserved:
-    if availability <= 0:
         if item.status == status.ACTIVE:
             change_item_status(item.id, status.PAUSED_BY_RISK)
             __send_mail_for_oos_item(item)
     else:
         if item.status == status.PAUSED_BY_RISK:
 def __update_item_availability_cache(item_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
-    If item's Preferred warehouse is present
-        If item marked sticky
-            use GOOD type warehouse at preferred warehouse with maximum availability.
+    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.
-            If not available at any, then use THIRD_PARTY warehouse without billing support
-            corresponding to preferred warehouse where available.
-            If still not available, then use any GOOD type warehouse with billing support.
+    This is needed to associate an item with at least one vendor so that in default case when its available no where, we know from where to procure it.
-        else
-            if availability > 0 at least one of GOOD type warehouses in preferred warehouse
+    if item available at any OUR-GOOD warehouse
-                use GOOD type warehouse at preferred warehouse with maximum availability
+        // OUR-GOOD warehouses have inventory risk; So, we empty them first!
-    If available at no warehouse
+        // We can start with minimum transfer price criterion but down the line we can also bring in Inventory age
-        use any GOOD type warehouse at default warehouse
+        assign OUR-GOOD warehouse with minimum transfer price
     else
-        if available at any warehouse of type GOOD with billing support
+        if Preferred vendor is specified and marked Sticky
-            use warehouse of type GOOD with billing support with maximum availability
+            // Always purchase from Preferred if its marked sticky
+            assign preferred vendor's THIRDPARTY GOOD/VIRTUAL warehouse
         else
-            if preferred warehouse is present and availability at preferred warehouse's corresponding ThirdPartyWarehouse without billing support > 0
+            if item available in a THIRDPARTY GOOD/VIRTUAL warehouse
-                preferred warehouse's corresponding ThirdPartyWarehouse without billing support with maximum availability
+                assign THIRDPARTY GOOD/VIRTUAL warehouse where item is available with minimal transfer delay followed by minimum transfer price
             else
+                // Item not available at any warehouse, OURS or THIRDPARTY
+                If Preferred vendor is specified
-                use ThirdPartyWarehouse without billing support with maximum availability
+                    assign preferred vendor's THIRDPARTY GOOD/VIRTUAL warehouse
+                else
+                    assign THIRDPARTY GOOD/VIRTUAL warehouse with minimum transfer price
     Returns an ordered list of size 4 with following elements in the given order:
 . Logistics location of the warehouse which was finally picked up to ship the order.
 . Expected delay added by the category manager.
 . Id of the warehouse which was finally picked up.
     Parameters:
      - itemId
     """
     item = Item.get_by(id=item_id)
-    warehouse_ids = []
+    item_pricing = {}
-    goodBillableWarehouses = []
+    for vendorItemPricing in VendorItemPricing.query.filter_by(item=item).all():
-    goodBillableWarehousesAtPreferredShippingLocation = []
+        item_pricing[vendorItemPricing.vendor_id] = vendorItemPricing
+    warehouses = {}
-    goodBillableWarehousesAtDefaultShippingLocation = []
+    ourGoodWarehouses = {}
-    nonBillableWarehouses = []
+    thirdpartyWarehouses = {}
-    nonBillableWarehousesCorrespondingToPreferredShippingLocation = []
+    preferredThirdpartyWarehouses = {}
     for warehouse in Warehouse.query.all():
         if (warehouse.inventoryType == InventoryType._VALUES_TO_NAMES[InventoryType.BAD]):
             continue
-        if warehouse.shippingWarehouseId == item.defaultWarehouse and warehouse.inventoryType == InventoryType._VALUES_TO_NAMES[InventoryType.GOOD] and warehouse.billingWarehouseId:
+        warehouses[warehouse.id] = warehouse
-            goodBillableWarehousesAtDefaultShippingLocation.append(warehouse.id)
+        if warehouse.warehouseType == WarehouseType._VALUES_TO_NAMES[WarehouseType.OURS]:
-        if warehouse.billingWarehouseId is None:
+            if warehouse.inventoryType == InventoryType._VALUES_TO_NAMES[InventoryType.GOOD]:
-            nonBillableWarehouses.append(warehouse.id)
+                ourGoodWarehouses[warehouse.id] = warehouse
+        else:
-        warehouse_ids.append(warehouse.id)
+            thirdpartyWarehouses[warehouse.id] = warehouse
-        if warehouse.billingWarehouseId and warehouse.inventoryType == InventoryType._VALUES_TO_NAMES[InventoryType.GOOD]:
+            if item.preferredVendor == warehouse.vendor_id and warehouse.inventoryType == InventoryType._VALUES_TO_NAMES[InventoryType.GOOD]:
-            goodBillableWarehouses.append(warehouse.id)
-            if item.preferredWarehouse and item.preferredWarehouse == warehouse.shippingWarehouseId:
+                preferredThirdpartyWarehouses[warehouse.id] = warehouse
-                goodBillableWarehousesAtPreferredShippingLocation.append(warehouse.id)
-                nonBillableWarehousesCorrespondingToPreferredShippingLocation.extend([w.id for w in Warehouse.query.filter_by(vendor_id = warehouse.vendor_id, billingWarehouseId = None).all()])
     warehouse_retid = -1
     total_availability = 0
-    '''
-    If warehouse preference is set and it is sticky then we should fulfil this order from this warehouse only.
-    But we still need to calculate total availability across warehouses.
-    '''
-    if (item.isWarehousePreferenceSticky and item.preferredWarehouse):
-        [warehouse_retid, total_availability] = __get_warehouse_with_max_availability(goodBillableWarehousesAtPreferredShippingLocation, item)
-        if warehouse_retid == -1:
-            [warehouse_retid, total_availability] = __get_warehouse_with_max_availability(nonBillableWarehousesCorrespondingToPreferredShippingLocation, item)
-            if warehouse_retid == -1:
-                warehouse_retid = goodBillableWarehousesAtPreferredShippingLocation[0]
-                if item.preferredVendor:
-                    warehousesWithPreferredVendorAtPreferredShippingLocation = Warehouse.query.filter_by(shippingWarehouseId = item.preferredWarehouse, inventoryType = InventoryType._VALUES_TO_NAMES[InventoryType.GOOD], vendor_id = item.preferredVendor).all()
+    [warehouse_retid, total_availability] = __get_warehouse_with_min_transfer_price(ourGoodWarehouses, item, item_pricing, False)
-                    if warehousesWithPreferredVendorAtPreferredShippingLocation:
-                        warehouse_retid = warehousesWithPreferredVendorAtPreferredShippingLocation[0].id
-    elif (not item.isWarehousePreferenceSticky and item.preferredWarehouse):
-        [warehouse_retid, total_availability] = __get_warehouse_with_max_availability(goodBillableWarehousesAtPreferredShippingLocation, item)
     if warehouse_retid == -1:
-        [warehouse_retid, total_availability] = __get_warehouse_with_max_availability(warehouse_ids, item)
-        if warehouse_retid == -1:
-            warehouse_retid = goodBillableWarehousesAtDefaultShippingLocation[0]
+        if item.preferredVendor and item.isWarehousePreferenceSticky:
-            if item.preferredVendor:
-                warehousesWithPreferredVendorAtDefaultShippingLocation = Warehouse.query.filter_by(shippingWarehouseId = item.defaultWarehouse, inventoryType = InventoryType._VALUES_TO_NAMES[InventoryType.GOOD], vendor_id = item.preferredVendor).all()
-                if warehousesWithPreferredVendorAtDefaultShippingLocation:
+            warehouse_retid = preferredThirdpartyWarehouses.keys()[0]
-                    warehouse_retid = warehousesWithPreferredVendorAtDefaultShippingLocation[0].id
         else:
-            [warehouse_retid, total_availability] = __get_warehouse_with_max_availability(goodBillableWarehouses, item)
+            [warehouse_retid, total_availability] = __get_warehouse_with_min_transfer_delay(thirdpartyWarehouses, item, item_pricing)
             if warehouse_retid == -1:
-                if item.preferredWarehouse:
+                if item.preferredVendor:
-                    [warehouse_retid, total_availability] = __get_warehouse_with_max_availability(nonBillableWarehousesCorrespondingToPreferredShippingLocation, item)
+                    warehouse_retid = preferredThirdpartyWarehouses.keys()[0]
-                    if warehouse_retid == -1:
+                else:
-                        # Availability at Good Billable warehouses is Zero, so can safely use all warehouse_ids to capture the thirdparty virtual/good one
-                        [warehouse_retid, total_availability] = __get_warehouse_with_max_availability(warehouse_ids, item)
+                    [warehouse_retid, total_availability] = __get_warehouse_with_min_transfer_price(thirdpartyWarehouses, item, item_pricing, True)
-    warehouse = Warehouse.get_by(id=warehouse_retid)
+    warehouse = warehouses[warehouse_retid]
     billingWarehouseId = warehouse.billingWarehouseId
     # Fetching billing warehouse of a Good billable warehouse corresponding to the virtual one
     if warehouse.billingWarehouseId is None:
         for warehouse in Warehouse.query.filter_by(vendor_id = warehouse.vendor_id, inventoryType = InventoryType._VALUES_TO_NAMES[InventoryType.GOOD]).all():
             if warehouse.billingWarehouseId:
                 billingWarehouseId = warehouse.billingWarehouseId
     if expectedDelay is None:
         print 'expectedDelay field for this item was Null. Resetting it to 0'
         expectedDelay = 0
     else:
         expectedDelay = int(item.expectedDelay)
     if total_availability <= 0:
         expectedDelay = expectedDelay + __get_expected_procurement_delay(item)
         expectedDelay = expectedDelay + __get_vendor_holiday_delay(item, expectedDelay)
+    if warehouse.transferDelayInHours:
+        expectedDelay += warehouse.transferDelayInHours / 24
     item_availability_cache = ItemAvailabilityCache.get_by(itemId=item_id)
     if item_availability_cache is None:
         item_availability_cache = ItemAvailabilityCache()
         item_availability_cache.itemId = item_id
     item_availability_cache.warehouseId = int(warehouse_retid)
     item_availability_cache.expectedDelay = expectedDelay
     item_availability_cache.billingWarehouseId = billingWarehouseId
     item_availability_cache.sellingPrice = item.sellingPrice
     session.commit()
+def __get_warehouse_with_min_transfer_price(warehouses, item, item_pricing, ignoreAvailability):
+    warehouse_retid = -1
+    minTransferPrice = None
+    total_availability = 0
+    warehousesWithAvailability = {}
+    if not ignoreAvailability:
+        if item.currentInventory:
+            for entry in item.currentInventory:
+                if entry.availibility > entry.reserved:
+                    warehousesWithAvailability[entry.warehouse_id] = entry
+    for warehouse in warehouses.values():
+        if not ignoreAvailability:
+            if warehousesWithAvailability.has_key(warehouse.id):
+                entry = warehousesWithAvailability[warehouse.id]
+                total_availability += entry.availibility - entry.reserved
+            else:
+                continue
+        # Missing transfer price cases should not impact warehouse assignment
+        transferPrice = None
+        if item_pricing.has_key(warehouse.vendor_id):
+            transferPrice = item_pricing[warehouse.vendor_id].transfer_price
+        if minTransferPrice is None or (transferPrice and minTransferPrice > transferPrice):
+            warehouse_retid = warehouse.id
+            minTransferPrice = transferPrice
+    return [warehouse_retid, total_availability]
+def __get_warehouse_with_min_transfer_delay(warehouses, item, item_pricing):
+    minTransferDelay = None
+    minTransferDelayWarehouses = {}
+    total_availability = 0
+    if item.currentInventory:
+        for entry in item.currentInventory:
+            if warehouses.has_key(entry.warehouse_id):
+                warehouse = warehouses[entry.warehouse_id]
+                if entry.availibility > entry.reserved:
+                    total_availability += entry.availibility - entry.reserved
+                    transferDelay = warehouse.transferDelayInHours
+                    if minTransferDelay is None or minTransferDelay >= transferDelay:
+                        if minTransferDelay != transferDelay:
+                            minTransferDelayWarehouses = {}
+                        minTransferDelayWarehouses[warehouse.id] = warehouse
+                        minTransferDelay = transferDelay
+    return [__get_warehouse_with_min_transfer_price(minTransferDelayWarehouses, item, item_pricing, False)[0], total_availability]
 def __get_warehouse_with_max_availability(warehouse_ids, item):
     warehouse_retid = -1
     max_availability = 0
     total_availability = 0
                     if holidayDate >=  currentDate and holidayDate <= expectedDate:
                         holidayDelay = holidayDelay + 1
     except Exception as e:
         print e
     return holidayDelay
 def get_warehouses_for_item(item_id):
     if not item_id:
         raise InventoryServiceException(101, "bad item_id")
     item = get_item(item_id)
     '''
     if(vendorId == -1):
         total = 0
         try:
             item_pricings = []
-            if item.preferredWarehouse is not None:
+            if item.preferredVendor is not None:
-                warehouse = Warehouse.query.filter_by(id=item.preferredWarehouse).first()
-                item_pricing = VendorItemPricing.query.filter_by(item=item, vendor=warehouse.vendor).first()
+                item_pricing = VendorItemPricing.query.filter_by(item=item, vendor_id=item.preferredVendor).first()
                 if item_pricing:
                     item_pricings.append(item_pricing)
             else :
                 item_pricings = VendorItemPricing.query.filter_by(item=item).all()
             if item_pricings:

Subversion Repositories SmartDukaan

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