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

 @author: ashish
 '''
 from elixir import *
 from functools import partial
-from pydoc import Helper
+from shop2020.clients.CatalogClient import CatalogClient
 from shop2020.clients.HelperClient import HelperClient
-from shop2020.clients.TransactionClient import TransactionClient
+from shop2020.clients.InventoryClient import InventoryClient
 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, \
+from shop2020.model.v1.catalog.impl.DataService import Item, ItemChangeLog, \
-    ItemInventoryHistory, CurrentInventorySnapshot, ItemChangeLog, Category, \
-    EntityIDGenerator, VendorItemPricing, VendorItemMapping, Vendor, SimilarItems, \
+    Category, EntityIDGenerator, SimilarItems, ProductNotification, Source, \
-    ProductNotification, Source, SourceItemPricing, AuthorizationLog, \
-    MissedInventoryUpdate, BadInventorySnapshot, VendorItemProcurementDelay, \
-    VendorHolidays, ItemAvailabilityCache, VoucherItemMapping
+    SourceItemPricing, AuthorizationLog, VoucherItemMapping
-from shop2020.thriftpy.model.v1.catalog.ttypes import InventoryServiceException, \
+from shop2020.thriftpy.model.v1.catalog.ttypes import status, ItemShippingInfo, \
-    status, ItemShippingInfo, HolidayType, InventoryType, WarehouseType, ItemType
+    ItemType
-from shop2020.thriftpy.model.v1.order.ttypes import AlertType
+from shop2020.thriftpy.model.v1.inventory.ttypes import \
+    InventoryServiceException
 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 sqlalchemy.orm.exc import MultipleResultsFound, NoResultFound
-from sqlalchemy.sql.expression import and_, or_, distinct, func
+from sqlalchemy.sql.expression import or_, distinct, func
 from string import Template
-from urllib2 import HTTPBasicAuthHandler
-import calendar
 import datetime
 import sys
 import threading
 import urllib2
-from shop2020.clients.CatalogClient import CatalogClient
 to_addresses = ["cnc.center@shop2020.in", "ashutosh.saxena@shop2020.in"]
 from_user = "cnc.center@shop2020.in"
 from_pwd = "5h0p2o2o"
 skippedItems = { 175 : [27, 2160, 2175, 2163, 2158, 7128, 26, 2154],
 def is_active(item_id):
     t_item_shipping_info = ItemShippingInfo()
     try:
         item = get_item(item_id)
         t_item_shipping_info.isRisky = item.risky
+        client = InventoryClient().get_client()
-        warehouse_id = get_item_availability_for_location(item.id)[0]
+        itemInfo = client.getItemAvailabilityAtLocation(item.id)
+        warehouse_id = itemInfo[0]
         if item.risky and item.status == status.ACTIVE:
+            availability = client.getItemAvailibilityAtWarehouse(warehouse_id, item_id)
-            availability = 0
+            if availability <= 0:
-            currentInventorySnapshot = CurrentInventorySnapshot.query.filter_by(item_id = item.id, warehouse_id = warehouse_id).all()
-            if not currentInventorySnapshot or currentInventorySnapshot[0].availability <= currentInventorySnapshot[0].reserved:
                 add_status_change_log(item, status.PAUSED_BY_RISK)
                 item.status = status.PAUSED_BY_RISK
                 item.status_description = "This item is currently out of stock"
                 session.commit()
                 __send_mail_for_oos_item(item)
                 #This will clear cache from tomcat
                 __clear_homepage_cache()
-            else:
-                availability = currentInventorySnapshot[0].availability - currentInventorySnapshot[0].reserved
         else:
-            availability = item.get_total_inventory
+            availability = itemInfo[4]
         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
 def get_item_status_description(itemId):
     item = get_item(itemId)
     return item.status_description
-def get_Warehouse(warehouse_id):
-    return Warehouse.get_by(id=warehouse_id)
-def get_Vendor(vendorId):
-    return Vendor.get_by(id=vendorId)
-def get_all_warehouses_by_status(status):
-    return Warehouse.query.all()
-def get_all_warehouses_for_item(item_id):
-    item = get_item(item_id)
-    if not item:
-        raise InventoryServiceException(108, "Some unforeseen error while obtaining item")
-    return item.get_all_warehouses
-def get_all_items_for_warehouse(warehouse_id):
-    warehouse = get_Warehouse(warehouse_id)
-    if not warehouse:
-        raise InventoryServiceException(108, "bad warehouse")
-    return warehouse.all_items
-def add_warehouse(warehouse):
-    if not warehouse:
-        raise InventoryServiceException(108, "Bad warehouse")
-    if get_Warehouse(warehouse.id):
-        #warehouse is already present.
-        raise InventoryServiceException(101, "Warehouse already present")
-    ds_warehouse = Warehouse()
-    ds_warehouse.location = warehouse.location
-    ds_warehouse.status = status.ACTIVE
-    ds_warehouse.addedOn = datetime.datetime.now()
-    ds_warehouse.lastCheckedOn = datetime.datetime.now()
-    ds_warehouse.tinNumber = warehouse.tinNumber
-    ds_warehouse.pincode = warehouse.pincode
-    ds_warehouse.billingType = warehouse.billingType
-    ds_warehouse.billingWarehouseId = warehouse.billingWarehouseId
-    ds_warehouse.displayName = warehouse.displayName
-    ds_warehouse.inventoryType = InventoryType._VALUES_TO_NAMES[warehouse.inventoryType]
-    ds_warehouse.isAvailabilityMonitored = warehouse.isAvailabilityMonitored
-    ds_warehouse.logisticsLocation = warehouse.logisticsLocation
-    ds_warehouse.shippingWarehouseId = warehouse.shippingWarehouseId
-    ds_warehouse.transferDelayInHours = warehouse.transferDelayInHours
-    ds_warehouse.vendor = get_Vendor(warehouse.vendor.id)
-    ds_warehouse.warehouseType = WarehouseType._VALUES_TO_NAMES[warehouse.warehouseType]
-    if warehouse.vendorString:
-        ds_warehouse.vendorString = warehouse.vendorString
-    session.commit()
-    return ds_warehouse.id
 def update_item(item):
     if not item:
         raise InventoryServiceException(108, "Bad item in request")
     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 = get_Vendor(item.preferredVendor).name
+            newPreferredVendorName = inventoryClient.getVendor(item.preferredVendor).name
             oldPreferredVendorName = 'None'
             if ds_item.preferredVendor:
-                oldPreferredVendorName = get_Vendor(ds_item.preferredVendor).name
+                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"
         ds_item.expectedDelay = 0
     preferredVendorName = "None"
     if item.preferredVendor:
         ds_item.preferredVendor = item.preferredVendor
+        inventoryClient = InventoryClient().get_client()
-        preferredVendorName = get_Vendor(item.preferredVendor).name
+        preferredVendorName = inventoryClient.getVendor(item.preferredVendor).name
     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
     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, preferredVendorName)
     __send_mail(subject, message)
     return ds_item.id
-def update_inventory_history(warehouse_id, timestamp, availability):
-    warehouse = get_Warehouse(warehouse_id)
-    if not warehouse:
-        raise InventoryServiceException(107, "Warehouse? Where?")
-    vendor = warehouse.vendor
-    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
-        except:
-            continue
-        try:
-            item_inventory_history = ItemInventoryHistory()
-            item_inventory_history.warehouse = warehouse
-            item_inventory_history.item = item
-            item_inventory_history.timestamp = time
-            item_inventory_history.availability = quantity
-        except:
-            raise InventoryServiceException(108, "Some unforeseen error while updating inventory")
-    session.commit()
-def update_inventory(warehouse_id, timestamp, availability):
-    warehouse = get_Warehouse(warehouse_id)
-    if not warehouse:
-        raise InventoryServiceException(107, "Warehouse? Where?")
-    time = datetime.datetime.now()
-    warehouse.lastCheckedOn = time
-    warehouse.vendorString = timestamp
-    vendor = warehouse.vendor
-    session.commit()
-    items = []
-    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
-            items.append(item)
-        except:
-            print 'Skipping update for ' + item_key + ' quantity ' + str(quantity) + ' warehouse id: ' + str(warehouse_id)
-            __send_mail_for_missing_key(item_key, quantity, warehouse_id)
-            continue
-        try:
-            current_inventory_snapshot = CurrentInventorySnapshot.get_by(item=item, warehouse=warehouse)
-            if not current_inventory_snapshot:
-                current_inventory_snapshot = CurrentInventorySnapshot()
-                current_inventory_snapshot.item = item
-                current_inventory_snapshot.warehouse = warehouse
-                current_inventory_snapshot.availability = 0
-                current_inventory_snapshot.reserved = 0
-            # added the difference in the current inventory
-            current_inventory_snapshot.availability = current_inventory_snapshot.availability + quantity
-            try:
-                if quantity > 0 and __get_item_reserved(item) > 0:
-                    cl = TransactionClient().get_client()
-                    #FIXME hardcoding for warehouse id
-                    cl.addAlert(AlertType.NEW_INVENTORY_ALERT, 5, "Inventory received for item " + item.brand + " " + item.model_name + " " + item.model_number + " " +  item.color)
-            except:
-                print "Not able to raise alert for incoming inventory"
-            if current_inventory_snapshot.availability < 0:
-                __send_alert_for_negative_availability(item, current_inventory_snapshot.availability, warehouse)
-        except:
-            raise InventoryServiceException(108, "Some unforeseen error while updating inventory")
-        session.commit()
-        #**Update item availability cache**#
-        for item in items:
-            __update_item_availability_cache(item.id)
-            check_risky_item(item)
-def __send_alert_for_negative_reserved(item, reserved, warehouse):
-    itemName = " ".join([str(item.id), str(item.brand), str(item.model_name), str(item.model_number), str(item.color)])
-    EmailAttachmentSender.mail('cnc.center@shop2020.in', '5h0p2o2o', 'mandeep.dhir@shop2020.in', 'Negative reserved: ' + str(reserved) + ' for Item Id: ' + itemName + ' warehouse id: ' + str(warehouse.id), None)
-def __send_alert_for_negative_availability(item, availability, warehouse):
-    itemName = " ".join([str(item.id), str(item.brand), str(item.model_name), str(item.model_number), str(item.color)])
-    # EmailAttachmentSender.mail('cnc.center@shop2020.in', '5h0p2o2o', 'mandeep.dhir@shop2020.in', 'Negative availability ' + str(availability) + ' for Item id: ' + itemName + ' warehouse id: ' + str(warehouse.id), None)
-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', '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()
-        missedInventoryUpdate.warehouseId = warehouse_id
-        session.commit()
-    else:
-        missedInventoryUpdate.quantity += quantity
-        session.commit()
-def add_inventory(itemId, warehouseId, quantity):
-    current_inventory_snapshot = CurrentInventorySnapshot.get_by(item_id=itemId, warehouse_id=warehouseId)
-    if not current_inventory_snapshot:
-        current_inventory_snapshot = CurrentInventorySnapshot()
-        current_inventory_snapshot.item_id = itemId
-        current_inventory_snapshot.warehouse_id = warehouseId
-        current_inventory_snapshot.availability = 0
-        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)
-    if current_inventory_snapshot.availability < 0:
-        __send_alert_for_negative_availability(get_item(itemId), current_inventory_snapshot.availability, get_Warehouse(warehouseId))
-    check_risky_item(get_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()
-        bad_inventory_snapshot.item_id = itemId
-        bad_inventory_snapshot.warehouse_id = warehouseId
-        bad_inventory_snapshot.availability = 0
-    # added the difference in the current inventory
-    bad_inventory_snapshot.availability += quantity
-    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):
-    return Item.get_by(id=item_id).currentInventory
-def retire_warehouse(warehouse_id):
-    if not warehouse_id:
-        raise InventoryServiceException(101, "Bad warehouse id")
-    warehouse = get_Warehouse(warehouse_id)
-    if not warehouse:
-        raise InventoryServiceException(108, "warehouse id not present")
-    warehouse.status = status.DELETED;
-    session.commit()
 def retire_item(item_id):
     if not item_id:
         raise InventoryServiceException(101, "bad item id")
     item = get_item(item_id)
     if not item:
         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 get_item_availability_for_warehouse(warehouse_id, item_id):
-    if not warehouse_id:
-        raise InventoryServiceException(101, "bad warehouse_id")
-    if not item_id:
+def check_risky_item(item_id):
-        raise InventoryServiceException(101, "bad item_id")
-    warehouse = get_Warehouse(warehouse_id)
-    if not warehouse:
-        raise InventoryServiceException(108, "warehouse does not exist")
     item = get_item(item_id)
-    if not item:
-        raise InventoryServiceException(108, "item does not exist")
-    query = CurrentInventorySnapshot.query.filter_by(warehouse_id = warehouse_id)
-    query = query.filter_by(item_id = item.id)
-    try:
-        current_inventory_snapshot = query.one()
-        return current_inventory_snapshot.availability - current_inventory_snapshot.reserved
-    except:
-        return 0
-    """
-    current_inventory_snapshot = CurrentInventorySnapshot.query.filter(CurrentInventorySnapshot.warehouse_id == warehouse_id, CurrentInventorySnapshot.item_id == item_id).one()
-    if not current_inventory_snapshot:
-        return 0
-    else:
-        return current_inventory_snapshot.availability
-    """
-def check_risky_item(item):
     if not item.risky:
         return
+    client = InventoryClient().get_client()
-    warehouse_id = get_item_availability_for_location(item.id)[0]
+    itemInfo = client.getItemAvailabilityAtLocation(item.id)
+    warehouse_id = itemInfo[0]
-    currentInventorySnapshot = CurrentInventorySnapshot.query.filter_by(item_id = item.id, warehouse_id = warehouse_id).all()
+    availability = client.getItemAvailibilityAtWarehouse(warehouse_id, item.id)
-    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:
             change_item_status(item.id, status.ACTIVE)
     session.commit()
-'''
-This method returns quantity of a particular item across all warehouses whose ids is provided
-if warehouse_ids is null it checks for inventory in all warehouses.
-'''
-def __get_item_availability(item, warehouse_ids):
-    if warehouse_ids is None:
-        all_inventory = CurrentInventorySnapshot.query.filter_by(item = item).all()
-        availability = 0
-        reserved = 0
-        for currInv in all_inventory:
-            availability = availability + currInv.availability
-            reserved = reserved + currInv.reserved
-        return availability - reserved
-    else:
-        total_availability = 0
-        for current_inventory_snapshot in CurrentInventorySnapshot.query.filter(CurrentInventorySnapshot.warehouse_id.in_(warehouse_ids)).filter_by(item_id = item.id).all():
-            total_availability += current_inventory_snapshot.availability - current_inventory_snapshot.reserved
-        return total_availability
-def __get_item_reserved(item):
-    all_inventory = CurrentInventorySnapshot.query.filter_by(item = item).all()
-    reserved = 0
-    for currInv in all_inventory:
-        reserved = reserved + currInv.reserved
-    return reserved
-def reserve_item_in_warehouse(item_id, warehouse_id, quantity):
-    if not warehouse_id:
-        raise InventoryServiceException(101, "bad warehouse_id")
-    item = get_item(item_id)
-    if not item:
-        raise InventoryServiceException(101, "bad item_id")
-    query = CurrentInventorySnapshot.query.filter_by(warehouse_id = warehouse_id, item_id = item_id)
-    try:
-        current_inventory_snapshot = query.one()
-    except:
-        current_inventory_snapshot = CurrentInventorySnapshot()
-        current_inventory_snapshot.warehouse_id = warehouse_id
-        current_inventory_snapshot.item_id = item_id
-        current_inventory_snapshot.availability = 0
-        current_inventory_snapshot.reserved = 0
-    current_inventory_snapshot.reserved = current_inventory_snapshot.reserved + quantity
-    session.commit()
-    #**Update item availability cache**#
-    __update_item_availability_cache(item_id)
-    check_risky_item(item)
-    return True
-def reduce_reservation_count(item_id, warehouse_id, quantity):
-    if not warehouse_id:
-        raise InventoryServiceException(101, "bad warehouse_id")
-    item = get_item(item_id)
-    if not item:
-        raise InventoryServiceException(101, "bad item_id")
-    query = CurrentInventorySnapshot.query.filter_by(warehouse_id = warehouse_id, item_id = item_id)
-    try:
-        current_inventory_snapshot = query.one()
-        current_inventory_snapshot.reserved = current_inventory_snapshot.reserved - quantity
-        session.commit()
-        #**Update item availability cache**#
-        __update_item_availability_cache(item_id)
-        check_risky_item(item)
-        if current_inventory_snapshot.reserved < 0:
-            __send_alert_for_negative_reserved(get_item(item_id), current_inventory_snapshot.reserved, get_Warehouse(warehouse_id))
-        return True
-    except:
-        print "Unexpected error:", sys.exc_info()[0]
-        return False
 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.model_number = modelNumber
         item.updatedOn = current_timestamp
     session.commit()
     return True
-def get_item_availability_for_location(item_id):
-    item_availability = ItemAvailabilityCache.get_by(itemId=item_id)
-    if item_availability:
-        return [item_availability.warehouseId, item_availability.expectedDelay, item_availability.billingWarehouseId, item_availability.sellingPrice]
-    else:
-        __update_item_availability_cache(item_id)
-        return get_item_availability_for_location(item_id)
-def clear_item_availability_cache():
-    ItemAvailabilityCache.query.delete()
-    session.commit()
-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
-    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.
-    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.
-    if item available at any OUR-GOOD warehouse
-        // OUR-GOOD warehouses have inventory risk; So, we empty them first!
-        // We can start with minimum transfer price criterion but down the line we can also bring in Inventory age
-        assign OUR-GOOD warehouse with minimum transfer price
-    else
-        if Preferred vendor is specified and marked Sticky
-            // Always purchase from Preferred if its marked sticky
-            assign preferred vendor's THIRDPARTY GOOD/VIRTUAL warehouse
-        else
-            if item available in a THIRDPARTY GOOD/VIRTUAL warehouse
-                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
-                    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)
-    item_pricing = {}
-    for vendorItemPricing in VendorItemPricing.query.filter_by(item=item).all():
-        item_pricing[vendorItemPricing.vendor_id] = vendorItemPricing
-    warehouses = {}
-    ourGoodWarehouses = {}
-    thirdpartyWarehouses = {}
-    preferredThirdpartyWarehouses = {}
-    for warehouse in Warehouse.query.all():
-        if (warehouse.inventoryType == InventoryType._VALUES_TO_NAMES[InventoryType.BAD]):
-            continue
-        warehouses[warehouse.id] = warehouse
-        if warehouse.warehouseType == WarehouseType._VALUES_TO_NAMES[WarehouseType.OURS]:
-            if warehouse.inventoryType == InventoryType._VALUES_TO_NAMES[InventoryType.GOOD]:
-                ourGoodWarehouses[warehouse.id] = warehouse
-        else:
-            thirdpartyWarehouses[warehouse.id] = warehouse
-            if item.preferredVendor == warehouse.vendor_id and warehouse.inventoryType == InventoryType._VALUES_TO_NAMES[InventoryType.GOOD]:
-                preferredThirdpartyWarehouses[warehouse.id] = warehouse
-    warehouse_retid = -1
-    total_availability = 0
-    [warehouse_retid, total_availability] = __get_warehouse_with_min_transfer_price(ourGoodWarehouses, item, item_pricing, False)
-    if warehouse_retid == -1:
-        if item.preferredVendor and item.isWarehousePreferenceSticky:
-            [warehouse_retid, total_availability] = __get_warehouse_with_min_transfer_delay(preferredThirdpartyWarehouses, item, item_pricing)
-            if warehouse_retid == -1:
-                warehouse_retid = preferredThirdpartyWarehouses.keys()[0]
-        else:
-            [warehouse_retid, total_availability] = __get_warehouse_with_min_transfer_delay(thirdpartyWarehouses, item, item_pricing)
-            if warehouse_retid == -1:
-                if item.preferredVendor:
-                    warehouse_retid = preferredThirdpartyWarehouses.keys()[0]
-                else:
-                    [warehouse_retid, total_availability] = __get_warehouse_with_min_transfer_price(thirdpartyWarehouses, item, item_pricing, True)
-    warehouse = warehouses[warehouse_retid]
-    billingWarehouseId = warehouse.billingWarehouseId
-    # Fetching billing warehouse of a Good billable warehouse corresponding to the virtual one
-    if not warehouse.billingWarehouseId:
-        for w in Warehouse.query.filter_by(vendor_id = warehouse.vendor_id, inventoryType = InventoryType._VALUES_TO_NAMES[InventoryType.GOOD]).all():
-            if w.billingWarehouseId:
-                billingWarehouseId = w.billingWarehouseId
-                break
-    expectedDelay = item.expectedDelay
-    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)
-    else:
-        if warehouse.transferDelayInHours:
-            expectedDelay = 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.availability > 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.availability - 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.availability > entry.reserved:
-                    total_availability += entry.availability - 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 item.currentInventory:
-        for entry in item.currentInventory:
-            if entry.warehouse_id in warehouse_ids:
-                availability = entry.availability - entry.reserved
-                if availability > max_availability:
-                    warehouse_retid = entry.warehouse_id
-                    max_availability = availability
-                total_availability += availability
-    return [warehouse_retid, total_availability]
-def __get_expected_procurement_delay(item):
-    procurementDelay = 2
-    try:
-        if item.preferredVendor:
-            delays = VendorItemProcurementDelay.query.filter_by(vendor_id = item.preferredVendor, item_id = item.id).all()
-        else:
-            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):
-    holidayDelay = 0
-    try:
-        if item.preferredVendor:
-            holidays = VendorHolidays.query.filter_by(vendor_id = item.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:
-                        holidayDate = currentDate + datetime.timedelta(days=holiday.holidayValue-currentDate.weekday(), weeks=1)
-                    else:
-                        holidayDate = currentDate + datetime.timedelta(days=holiday.holidayValue-currentDate.weekday())
-                    if holidayDate >=  currentDate and holidayDate <= expectedDate:
-                        holidayDelay = holidayDelay + 1
-                elif holiday.holidayType == HolidayType.MONTHLY:
-                    holidayDate = datetime.date(currentDate.year, currentDate.month, holiday.holidayValue)
-                    if holidayDate >=  currentDate and holidayDate <= expectedDate:
-                        holidayDelay = holidayDelay + 1
-                elif holiday.holidayType == HolidayType.SPECIFIC:
-                    holidayValue = str(holiday.holidayValue)
-                    holidayDate = datetime.date(int(holidayValue[:4]), int(holidayValue[4:6]), int(holidayValue[6:8]))
-                    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 not item:
-        raise InventoryServiceException(101, "bad item")
-    warehouses = item.currentInventory.warehouse
-    return warehouses
 def get_child_categories(category):
     cm = CategoryManager()
     cat = cm.getCategory(category)
     return cat.children_category_ids if cat else None
 def get_category_object():
     object = Category.get_by(id=1).object
     return object
-def get_item_pricing(item_id, vendorId):
-    item = Item.query.filter_by(id=item_id).first()
-    if item is None:
-        raise InventoryServiceException(101, "Bad Item")
-    '''
-    if vendor id is -1 then we calculate an average transfer price to be populated
-    at the time of order creation. This will be later updated with actual transfer price
-    at the time of billing.
-    '''
-    if(vendorId == -1):
-        total = 0
-        try:
-            item_pricings = []
-            if item.preferredVendor is not None:
-                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:
-                for item_pricing in item_pricings:
-                    total += item_pricing.transfer_price
-                avg = total / len(item_pricings)
-                item_pricing.transfer_price = avg
-            else:
-                item_pricing = VendorItemPricing()
-                item_pricing.transfer_price = item.sellingPrice
-                vendor = Vendor()
-                vendor.id = vendorId
-                item_pricing.vendor = vendor
-                item_pricing.item = item
-            return item_pricing
-        except:
-            raise InventoryServiceException(101, "Item pricing not found ")
-    vendor = Vendor.get_by(id=vendorId)
-    try:
-        item_pricing = VendorItemPricing.query.filter_by(vendor=vendor, item=item).one()
-        return item_pricing
-    except MultipleResultsFound:
-        raise InventoryServiceException(110, "Multiple pricing information present for Vendor: " + vendor.name + " and Item: " + str(item_id))
-    except NoResultFound:
-        raise InventoryServiceException(111, "Missing pricing information for Vendor: " + vendor.name + " and Item: " + str(item_id))
 def add_category(t_category):
     category = Category.get_by(id=t_category.id)
     if category is None:
         category = Category()
     category.id = t_category.id
     return Category.query.filter_by(id=id).first()
 def get_all_categories():
     return Category.query.all()
-def get_all_item_pricing(item_id):
-    item = Item.query.filter_by(id=item_id).first()
-    if item is None:
-        raise InventoryServiceException(101, "Bad Item")
-    item_pricing = VendorItemPricing.query.filter_by(item=item).all()
-    return item_pricing
-def get_item_mappings(item_id):
-    item = Item.query.filter_by(id=item_id).first()
-    if item is None:
-        raise InventoryServiceException(101, "Bad Item")
-    item_mappings = VendorItemMapping.query.filter_by(item=item).all()
-    return item_mappings
-def add_vendor_pricing(vendorItemPricing):
-    if not vendorItemPricing:
-        raise InventoryServiceException(108, "Bad vendorItemPricing in request")
-    vendorId = vendorItemPricing.vendorId
-    itemId = vendorItemPricing.itemId
-    try:
-        vendor = Vendor.query.filter_by(id=vendorId).one()
-    except:
-        raise InventoryServiceException(101, "Vendor not found for vendorId " + str(vendorId))
-    try:
-        item = Item.query.filter_by(id=itemId).one()
-    except:
-        raise InventoryServiceException(101, "Item not found for itemId " + str(itemId))
-    validate_vendor_prices(to_t_item(item), vendorItemPricing)
-    try:
-        ds_vendorItemPricing = VendorItemPricing.query.filter(and_(VendorItemPricing.vendor==vendor, VendorItemPricing.item==item)).one()
-    except:
-        ds_vendorItemPricing = VendorItemPricing()
-        ds_vendorItemPricing.vendor = vendor
-        ds_vendorItemPricing.item = item
-    subject = ""
-    message = ""
-    if vendorItemPricing.mop:
-        ds_vendorItemPricing.mop = vendorItemPricing.mop
-    if vendorItemPricing.dealerPrice:
-        ds_vendorItemPricing.dealerPrice = vendorItemPricing.dealerPrice
-    if vendorItemPricing.transferPrice:
-        if vendorItemPricing.transferPrice != ds_vendorItemPricing.transfer_price:
-            message = "Transfer price for Item '{0}' \nand Vendor:{1} is changed from {2} to {3}.".format(__get_product_name(item), vendor.name, ds_vendorItemPricing.transfer_price, vendorItemPricing.transferPrice)
-            subject = "Alert:Change in Transfer Price"
-        ds_vendorItemPricing.transfer_price = vendorItemPricing.transferPrice
-    session.commit()
-    if subject:
-        __send_mail(subject, message)
-    return
-def add_vendor_item_mapping(key, vendorItemMapping):
-    if not vendorItemMapping:
-        raise InventoryServiceException(108, "Bad vendorItemMapping in request")
-    vendorId = vendorItemMapping.vendorId
-    itemId = vendorItemMapping.itemId
-    try:
-        vendor = Vendor.query.filter_by(id=vendorId).one()
-    except:
-        raise InventoryServiceException(101, "Vendor not found for vendorId " + str(vendorId))
-    try:
-        item = Item.query.filter_by(id=itemId).one()
-    except:
-        raise InventoryServiceException(101, "Item not found for vendorId " + str(itemId))
-    try:
-        ds_vendorItemMapping = VendorItemMapping.query.filter(and_(VendorItemMapping.vendor==vendor, VendorItemMapping.item==item, VendorItemMapping.item_key==key)).one()
-    except:
-        ds_vendorItemMapping = VendorItemMapping()
-        ds_vendorItemMapping.vendor = vendor
-        ds_vendorItemMapping.item = item
-    ds_vendorItemMapping.item_key = vendorItemMapping.itemKey
-    session.commit()
-    # Marking the missed inventory as not ignored as the catalog dashboard user has updated their key
-    for missedInventoryUpdate in MissedInventoryUpdate.query.filter_by(itemKey = vendorItemMapping.itemKey).all():
-        missedInventoryUpdate.isIgnored = 0
-    session.commit()
-    return
 def validate_item_prices(item):
     if item.mrp == None or item.sellingPrice == None or item.mrp == "" or item.sellingPrice == "":
         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))
     if vendorPrices.mop != "" and vendorPrices.transferPrice != "" and vendorPrices.transferPrice > vendorPrices.mop:
         print "[BAD MOP and TP:] for {0} {1} {2} {3}. TP={4}. MOP={5}, Vendor={6}".format(item.productGroup, item.brand, item.modelNumber, item.color, str(vendorPrices.transferPrice), str(vendorPrices.mop), str(vendorPrices.vendorId))
         raise InventoryServiceException(101, "[BAD MOP and TP:] for {0} {1} {2} {3}. TP={4}. MOP={5}, Vendor={6}".format(item.productGroup, item.brand, item.modelNumber, item.color, str(vendorPrices.transferPrice), str(vendorPrices.mop), str(vendorPrices.vendorId)))
     return
-def get_all_vendors():
-    return Vendor.query.all()
 def check_color_valid(color):
     if color is not None:
         color = color.strip().lower()
         if color != '' and color != 'na' and color != 'blank' and color != '(blank)':
             return True
 def send_product_notifications():
     product_notifications = ProductNotification.query.all()
     for product_notification in product_notifications:
         item = product_notification.item
+        client = InventoryClient().get_client()
-        availability = __get_item_availability(item, None)
+        availability = client.getItemAvailabilityAtLocation(item.id)[4]
         if item.status == status.ACTIVE and (not item.risky or availability > 0):
             __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
             except:
                 print "Unable to clear home page cache" + res.read()
     except:
         print "Unable to clear cache, still should continue with other operations"
-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 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.availability), 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
 def get_product_notifications(start_datetime):
     '''
     Returns a list of Product Notification objects each representing user requests for notification
     '''
     query = ProductNotification.query
         session.query(Item.id).limit(1).one()
         return True
     except:
         return False
-def add_vendor(vendor):
-    if not vendor:
-        raise InventoryServiceException(108, "Bad vendor")
-    if get_Vendor(vendor.id):
-        #vendor is already present.
-        raise InventoryServiceException(101, "Vendor already present")
-    ds_vendor = Vendor()
-    ds_vendor.id = vendor.id
-    ds_vendor.name = vendor.name
-    session.commit()
-    return ds_vendor.id
-def add_warehouse_vendor_mapping(warehouse_id, VendorId):
-    return True
 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
     try:
         EmailAttachmentSender.mail('cnc.center@shop2020.in', '5h0p2o2o', ['abhishek.mathur@shop2020.in', 'chaitnaya.vats@shop2020.in'], "Item is out of stock. ID: " + str(item.id)  + " " + str(item.brand) +  " " + str(item.model_name) + " " + str(item.model_number)+ " " + str(item.color), None)
     except Exception as e:
         print e
-def mark_missed_inventory_updates_as_processed(itemKey, warehouseId):
-    MissedInventoryUpdate.query.filter_by(itemKey = itemKey, warehouseId = warehouseId).delete()
-    session.commit()
-def get_item_keys_to_be_processed(warehouseId):
-    return [i.itemKey for i in MissedInventoryUpdate.query.filter_by(warehouseId = warehouseId, isIgnored = 0)]
-def reset_availability(itemKey, vendorId, quantity, warehouseId):
-    vendorItemMapping = VendorItemMapping.get_by(vendor_id = vendorId, item_key = itemKey)
-    if vendorItemMapping:
-        itemId = vendorItemMapping.item_id
-        if skippedItems.has_key(warehouseId) and itemId in skippedItems[warehouseId]:
-            quantity = 0
-        currentInventorySnapshot = CurrentInventorySnapshot.get_by(item_id = itemId, warehouse_id = warehouseId)
-        if currentInventorySnapshot:
-            currentInventorySnapshot.availability = quantity
-            __update_item_availability_cache(itemId)
-            check_risky_item(currentInventorySnapshot.item)
-        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)
-        check_risky_item(currentInventorySnapshot.item)
-    session.commit()
 def __send_mail(subject, message):
     try:
         thread = threading.Thread(target=partial(mail, from_user, from_pwd, to_addresses, subject, message))
         thread.start()
     except Exception as ex:
         print ex
-def get_shipping_locations():
-    shippingLocationIds = {}
-    warehouses = Warehouse.query.all()
-    for warehouse in warehouses:
-        if warehouse.shippingWarehouseId:
-            shippingLocationIds[warehouse.shippingWarehouseId] = 1
-    shippingLocations = []
-    for shippingLocationId in shippingLocationIds:
-        shippingLocations.append(get_Warehouse(shippingLocationId))
-    return shippingLocations
-def get_inventory_snapshot(warehouseId):
-    query = CurrentInventorySnapshot.query
-    if warehouseId:
-        query = query.filter_by(warehouse_id = warehouseId)
-    itemInventoryMap = {}
-    for row in query.all():
-        if not itemInventoryMap.has_key(row.item_id):
-            itemInventoryMap[row.item_id] = []
-        itemInventoryMap[row.item_id].append(row)
-    return itemInventoryMap
 def get_clearance_sale_catalog_ids():
     all_status = [status.ACTIVE, status.PAUSED, status.PAUSED_BY_RISK]
     query = Item.query.filter_by(clearance=True)
     query = query.filter(Item.status.in_(all_status))
     query = query.group_by(Item.catalog_item_id).order_by(desc(Item.startDate)).order_by(Item.catalog_item_id)
     clearance_sales = query.all()
     return [item.catalog_item_id for item in clearance_sales]
-def update_vendor_string(warehouseId, vendorString):
-    warehouse = get_Warehouse(warehouseId)
-    warehouse.vendorString = vendorString
-    session.commit()

Subversion Repositories SmartDukaan

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