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

     to_t_vendor_item_pricing, to_t_source
 from shop2020.model.v1.catalog.impl.DataService import Item, Warehouse, \
     ItemInventoryHistory, CurrentInventorySnapshot, ItemInfo, ItemChangeLog, \
     Category, EntityIDGenerator, VendorItemPricing, VendorItemMapping, Vendor, \
     SimilarItems, ProductNotification, Source, SourceItemPricing, AuthorizationLog, \
-    MissedInventoryUpdate, VendorItemProcurementDelay, VendorHolidays
+    MissedInventoryUpdate, BadInventorySnapshot, VendorItemProcurementDelay, \
+    VendorHolidays
 from shop2020.thriftpy.model.v1.catalog.ttypes import InventoryServiceException, \
-    status, ItemShippingInfo, HolidayType
+    status, ItemShippingInfo, HolidayType, InventoryType, WarehouseType
 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 log_entry, to_py_date, log_risky_flag
 from sqlalchemy import desc, asc
 from sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound
 from sqlalchemy.sql.expression import and_, or_, distinct, func
 from string import Template
 from urllib2 import HTTPBasicAuthHandler
+import calendar
 import datetime
 import sys
 import urllib2
-import calendar
 from functools import partial
 import threading
 to_addresses = ["cnc.center@shop2020.in", "ashutosh.saxena@shop2020.in"]
 def update_inventory_history(warehouse_id, timestamp, availability):
     warehouse = get_Warehouse(warehouse_id)
     if not warehouse:
         raise InventoryServiceException(107, "Warehouse? Where?")
-    vendors = get_vendors_for_warehouse(warehouse_id)
-    if len(vendors) > 1:
-        raise InventoryServiceException(110, "Multiple vendors found for warehouse !")
-    vendor = vendors[0]
+    vendor = warehouse.vendor_id
     time = datetime.datetime.now()
     for item_key, quantity in availability.iteritems():
         try:
             vendor_item_mapping = VendorItemMapping.query.filter_by(vendor=vendor, item_key=item_key).one();
             item = vendor_item_mapping.item
         raise InventoryServiceException(107, "Warehouse? Where?")
     time = datetime.datetime.now()
     warehouse.lastCheckedOn = time
     warehouse.vendorString = timestamp
-    vendors = get_vendors_for_warehouse(warehouse_id)
-    if len(vendors) > 1:
-        raise InventoryServiceException(110, "Multiple vendors found for warehouse !")
-    vendor = vendors[0]
+    vendor = warehouse.vendor_id
     session.commit()
     for item_key, quantity in availability.iteritems():
         try:
             vendor_item_mapping = VendorItemMapping.query.filter_by(vendor=vendor, item_key=item_key).one();
             item = vendor_item_mapping.item
 def __send_mail_for_missing_key(item_key, quantity, warehouse_id):
     missedInventoryUpdate = MissedInventoryUpdate.get_by(itemKey = item_key, warehouseId = warehouse_id)
     # One email per product key mismatch
     if not missedInventoryUpdate:
-        EmailAttachmentSender.mail('cnc.center@shop2020.in', '5h0p2o2o', ['mandeep.dhir@shop2020.in', 'chaitnaya.vats@shop2020.in'], 'Skipped inventory update for ' + item_key + ' quantity ' + str(quantity) + ' warehouse id: ' + str(warehouse_id), None)
+        EmailAttachmentSender.mail('cnc.center@shop2020.in', '5h0p2o2o', ['mandeep.dhir@shop2020.in', 'chaitnaya.vats@shop2020.in', 'asghar.bilgrami@shop2020.in'], 'Skipped inventory update for ' + item_key + ' quantity ' + str(quantity) + ' warehouse id: ' + str(warehouse_id), None)
         missedInventoryUpdate = MissedInventoryUpdate()
         missedInventoryUpdate.itemKey = item_key
         missedInventoryUpdate.quantity = quantity
         missedInventoryUpdate.isIgnored = 1
         missedInventoryUpdate.timestamp = datetime.datetime.now()
     current_inventory_snapshot.availibility = current_inventory_snapshot.availibility + quantity
     session.commit()
     if current_inventory_snapshot.availibility < 0:
         __send_alert_for_negative_availability(get_item(itemId), current_inventory_snapshot.availibility, get_Warehouse(warehouseId))
     check_risky_item(get_item(itemId))
-'''
-def get_item_inventoy(item_id):
+def add_bad_inventory(itemId, warehouseId, quantity):
-    inventory = Item.get_by(id=item_id).currentInventory
+    bad_inventory_snapshot = BadInventorySnapshot.get_by(item_id=itemId, warehouse_id=warehouseId)
-    if not inventory:
+    if not bad_inventory_snapshot:
+        bad_inventory_snapshot = BadInventorySnapshot()
+        bad_inventory_snapshot.item_id = itemId
+        bad_inventory_snapshot.warehouse_id = warehouseId
+        bad_inventory_snapshot.availability = 0
-        raise InventoryServiceException(108, "Some unforeseen error while updating inventory")
+    # added the difference in the current inventory
+    bad_inventory_snapshot.availability += quantity
-    return inventory
+    session.commit()
-'''
+    if bad_inventory_snapshot.availability < 0:
+        __send_alert_for_negative_availability(get_item(itemId), bad_inventory_snapshot.availability, get_Warehouse(warehouseId))
 def get_item_inventory_by_item_id(item_id):
     inventory = Item.get_by(id=item_id).currentInventory
     if not inventory:
         raise InventoryServiceException(108, "Some unforeseen error while updating inventory")
     return True
 def get_item_availability_for_location(warehouse_loc, 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
-    It first checks whether the preferred warehouse for that item is set or not. If set
+    If item's Preferred warehouse is present
+        If item marked sticky
-    and preference is sticky then that warehouse is used for fulfilment.
+            use GOOD type warehouse at preferred warehouse with maximum availability.
-    If preference is not sticky then we see if item is available in the preferred WH,
+            If not available at any, then use THIRD_PARTY warehouse without billing support
-    in which case that warehouse is used otherwise we use that warehouse which has the max
+            corresponding to preferred warehouse where available.
-    availability. And if there is no inventory for that item in any warehouses then we use
+            If still not available, then use any GOOD type warehouse with billing support.
-    default warehouse.
+        else
+            if availability > 0 at least one of GOOD type warehouses in preferred warehouse
-    If preference is not set in that case we just find the warehouse with max availability
+                use GOOD type warehouse at preferred warehouse with maximum availability
+    If available at no warehouse
-    and in case of zero inventory we use default warehouse
+        use any GOOD type warehouse at default warehouse
+    else
+        if available at any warehouse of type GOOD with billing support
+            use warehouse of type GOOD with billing support with maximum availability
+        else
+            if preferred warehouse is present and availability at preferred warehouse's corresponding ThirdPartyWarehouse without billing support > 0
+                preferred warehouse's corresponding ThirdPartyWarehouse without billing support with maximum availability
+            else
+                use ThirdPartyWarehouse without billing support with maximum availability
     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.
 . Id of the warehouse which was finally picked up.
 . Inventory size in the selected warehouse.
 . Expected delay added by the category manager.
     Parameters:
      - warehouse_loc
      - item_id
     """
     if warehouse_loc is None:
     if not item_id:
         raise InventoryServiceException(101, "Bad Item id")
     item = Item.get_by(id=item_id)
     logisticsLocation = warehouse_loc
+    warehouse_ids = []
+    goodBillableWarehouses = []
+    goodBillableWarehousesAtPreferredShippingLocation = []
+    goodBillableWarehousesAtDefaultShippingLocation = []
+    nonBillableWarehouses = []
+    nonBillableWarehousesCorrespondingToPreferredShippingLocation = []
+    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:
+            goodBillableWarehousesAtDefaultShippingLocation.append(warehouse.id)
+        if warehouse.billingWarehouseId is None:
+            nonBillableWarehouses.append(warehouse.id)
-    warehouses = Warehouse.query.filter_by(logisticsLocation=logisticsLocation).all()
+        if warehouse.logisticsLocation == logisticsLocation:
-    warehouse_ids = [warehouse.id for warehouse in warehouses]
+            warehouse_ids.append(warehouse.id)
+            if warehouse.billingWarehouseId and warehouse.inventoryType == InventoryType._VALUES_TO_NAMES[InventoryType.GOOD]:
+                goodBillableWarehouses.append(warehouse.id)
+                if item.preferredWarehouse and item.preferredWarehouse == warehouse.shippingWarehouseId:
+                    goodBillableWarehousesAtPreferredShippingLocation.append(warehouse.id)
+                    nonBillableWarehousesCorrespondingToPreferredShippingLocation.extend([w.id for w in Warehouse.query.filter_by(logisticsLocation=logisticsLocation, 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 is not None) :
+    if (item.isWarehousePreferenceSticky and item.preferredWarehouse):
+        [warehouse_retid, total_availability] = __get_warehouse_with_max_availability(goodBillableWarehousesAtPreferredShippingLocation, item)
-        warehouse_retid = item.preferredWarehouse
+        if warehouse_retid == -1:
-        warehouse = Warehouse.get_by(id=warehouse_retid)
+            [warehouse_retid, total_availability] = __get_warehouse_with_max_availability(nonBillableWarehousesCorrespondingToPreferredShippingLocation, item)
-        logisticsLocation = warehouse.logisticsLocation
+            if warehouse_retid == -1:
-        total_availability = __get_item_availability(item, [warehouse_retid])
+                warehouse_retid = goodBillableWarehousesAtPreferredShippingLocation[0]
-    #If preference is not sticky then this order should be fulfilled from preferred WH if inventory available
+    elif (not item.isWarehousePreferenceSticky and item.preferredWarehouse):
-    #otherwise we should check for its availability elsewhere and fulfil this order from there, but if it is not available anywhere
+        [warehouse_retid, total_availability] = __get_warehouse_with_max_availability(goodBillableWarehousesAtPreferredShippingLocation, item)
-    #then we should fulfil this order from its default warehouse.
-    elif (not item.isWarehousePreferenceSticky and item.preferredWarehouse is not None):
-        try:
+    if warehouse_retid == -1:
-            current_inventory_snapshot = CurrentInventorySnapshot.query.filter_by(warehouse_id = item.preferredWarehouse, item_id = item_id).one()
-            availability = current_inventory_snapshot.availibility - current_inventory_snapshot.reserved
+        [warehouse_retid, total_availability] = __get_warehouse_with_max_availability(warehouse_ids, item)
-        except Exception as e:
+        if warehouse_retid == -1:
+            warehouse_retid = goodBillableWarehousesAtDefaultShippingLocation[0]
-            print e
+        else:
-            availability = 0
+            [warehouse_retid, total_availability] = __get_warehouse_with_max_availability(goodBillableWarehouses, item)
-        if availability > 0:
+            if warehouse_retid == -1:
-            warehouse_retid = item.preferredWarehouse
+                if item.preferredWarehouse:
-            total_availability = availability
+                    [warehouse_retid, total_availability] = __get_warehouse_with_max_availability(nonBillableWarehousesCorrespondingToPreferredShippingLocation, item)
-        else :
-            [logisticsLocation, warehouse_retid, total_availability] = \
+                    if warehouse_retid == -1:
-                        __get_warehouse_with_max_availability(warehouse_loc = warehouse_loc, \
+                        # Availability at Good Billable warehouses is Zero, so can safely use all warehouse_ids to capture the thirdparty virtual/good one
-                                                            warehouse_ids = warehouse_ids, item = item)
+                        [warehouse_retid, total_availability] = __get_warehouse_with_max_availability(warehouse_ids, item)
-    else :
-        [logisticsLocation, warehouse_retid, total_availability] = \
+    warehouse = Warehouse.get_by(id=warehouse_retid)
-                        __get_warehouse_with_max_availability(warehouse_loc = warehouse_loc, \
+    billingWarehouseId = warehouse.billingWarehouseId
-                                                            warehouse_ids = warehouse_ids, item = item)
-    ## FIXME Assign warehouse 5 (9D2) for all the hotspot products.
+    # Fetching billing warehouse of a Good billable warehouse corresponding to the virtual one
-    #if warehouse_retid in [warehouse.id for warehouse in get_warehouses_for_vendor(1)]:
+    if warehouse.billingWarehouseId is None:
-    if int(warehouse_retid) in [1,2,3,4,5]:
+        for warehouse in Warehouse.query.filter_by(vendor_id = warehouse.vendor_id, inventoryType = InventoryType._VALUES_TO_NAMES[InventoryType.GOOD]).all():
-        warehouse_retid = 5
+            if warehouse.billingWarehouseId:
-        warehouse = Warehouse.get_by(id=warehouse_retid)
+                billingWarehouseId = warehouse.billingWarehouseId
+                break
-        logisticsLocation = warehouse.logisticsLocation
+    logisticsLocation = warehouse.logisticsLocation
     expectedDelay = item.expectedDelay
     if expectedDelay is None:
         print 'expectedDelay field for this item was Null. Resetting it to 0'
         expectedDelay = 0
     if total_availability <= 0:
         expectedDelay = expectedDelay + __get_expected_procurement_delay(item)
         expectedDelay = expectedDelay + __get_vendor_holiday_delay(item, expectedDelay)
-    return [logisticsLocation, int(warehouse_retid), total_availability, expectedDelay]
+    return [logisticsLocation, int(warehouse_retid), total_availability, expectedDelay, billingWarehouseId]
-def __get_warehouse_with_max_availability(warehouse_loc, warehouse_ids, item):
+def __get_warehouse_with_max_availability(warehouse_ids, item):
     warehouse_retid = -1
     max_availability = 0
     total_availability = 0
-    for warehouse_id in warehouse_ids:
-            try:
+    if item.currentInventory:
-                current_inventory_snapshot = CurrentInventorySnapshot.query.filter_by(warehouse_id = warehouse_id, item_id = item.id).one()
-                availability = current_inventory_snapshot.availibility - current_inventory_snapshot.reserved
-            except Exception as e:
+        for entry in item.currentInventory:
-                print e
+            if entry.warehouse_id in warehouse_ids:
-                availability = 0
+                availability = entry.availibility - entry.reserved
-            if availability > max_availability:
+                if availability > max_availability:
-                warehouse_retid = warehouse_id
+                    warehouse_retid = entry.warehouse_id
-                max_availability = availability
+                    max_availability = availability
-            total_availability = total_availability + availability
-    #If no warehouse could be found, use the default warehouse for this item
-    if warehouse_retid == -1:
-        # This is the case when all warehouses have exhausted their
-        # inventory of this item or no warehouse is available in this
-        # location.
-        warehouse_retid = int(item.defaultWarehouse)
-        warehouse = Warehouse.get_by(id=warehouse_retid)
-        warehouse_loc = warehouse.logisticsLocation
-        try:
-            current_inventory_snapshot = CurrentInventorySnapshot.query.filter_by(warehouse_id = warehouse_retid, item_id = item.id).one()
-            max_availability = current_inventory_snapshot.availibility - current_inventory_snapshot.reserved
-        except Exception as e:
-            print e
-            max_availability = 0
-        total_availability = max_availability
+                total_availability += availability
-    return [warehouse_loc, warehouse_retid, total_availability]
+    return [warehouse_retid, total_availability]
-'''
-def calculate_total_availability(warehouse_ids, item_id):
-    total_availability = 0
-    for warehouse_id in warehouse_ids:
-            try:
-                current_inventory_snapshot = CurrentInventorySnapshot.query.filter_by(warehouse_id = warehouse_id, item_id = item_id).one()
-                availability = current_inventory_snapshot.availibility - current_inventory_snapshot.reserved
-            except Exception as e:
-                print e
-                availability = 0
-            total_availability = total_availability + availability
-    return total_availability
-'''
 def __get_expected_procurement_delay(item):
     procurementDelay = 2
     try:
         if item.preferredVendor:
 def send_product_notifications():
     product_notifications = ProductNotification.query.all()
     for product_notification in product_notifications:
         item = product_notification.item
-        availability = __get_item_availability(item, None)
-        if availability > 0 and item.status == status.ACTIVE:
+        if item.status == status.ACTIVE:
             __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_pending_orders_inventory(vendor_id=1):
     """
     Returns a list of inventory stock for items for which there are pending orders.
     """
-    warehouse_ids = [warehouse.id for warehouse in get_warehouses_for_vendor(vendor_id)]
+    warehouse_ids = [warehouse.id for warehouse in Warehouse.query.filter_by(vendor_id = vendor_id)]
     pending_items_inventory = []
     if warehouse_ids:
         pending_items_inventory = session.query(CurrentInventorySnapshot.item_id, func.sum(CurrentInventorySnapshot.availibility), func.sum(CurrentInventorySnapshot.reserved)).filter(CurrentInventorySnapshot.warehouse_id.in_(warehouse_ids)).group_by(CurrentInventorySnapshot.item_id).having(func.sum(CurrentInventorySnapshot.reserved) > 0).all()
     return pending_items_inventory
     return ds_vendor.id
 def add_warehouse_vendor_mapping(warehouse_id, VendorId):
     return True
-def get_vendors_for_warehouse(warehouse_id):
-    try:
-        warehouse = Warehouse.get_by(id=warehouse_id)
-        return warehouse.vendors
-    except:
-        raise InventoryServiceException(108, "Bad Warehouse Id")
-def get_warehouses_for_vendor(vendorId):
-    try:
-        vendor = get_Vendor(vendorId)
-        return vendor.warehouses
-    except:
-        raise InventoryServiceException(108, "Bad Vendor Id")
 def add_authorization_log_for_item(itemId, username, reason):
     if not itemId or not username:
         raise InventoryServiceException(101, "Bad itemId or Invalid username in request")
     authorize_log = AuthorizationLog()
     authorize_log.item_id = itemId

Subversion Repositories SmartDukaan

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