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

 @author: ashish
 '''
 from elixir import *
 from functools import partial
 from shop2020.clients.CatalogClient import CatalogClient
+from shop2020.clients.LogisticsClient import LogisticsClient
 from shop2020.clients.TransactionClient import TransactionClient
 from shop2020.model.v1.inventory.impl import DataService
 from shop2020.model.v1.inventory.impl.Convertors import to_t_warehouse, \
-    to_t_itemidwarehouseid, to_t_state
+    to_t_itemidwarehouseid, to_t_state, to_t_item_location_availability
 from shop2020.model.v1.inventory.impl.DataService import Warehouse, \
     ItemInventoryHistory, CurrentInventorySnapshot, VendorItemPricing, \
     VendorItemMapping, Vendor, MissedInventoryUpdate, BadInventorySnapshot, \
-    VendorHolidays, ItemAvailabilityCache, \
+    VendorHolidays, ItemAvailabilityCache, CurrentReservationSnapshot, \
-    CurrentReservationSnapshot, IgnoredInventoryUpdateItems, ItemStockPurchaseParams, \
+    IgnoredInventoryUpdateItems, ItemStockPurchaseParams, OOSStatus, \
+    AmazonInventorySnapshot, StateMaster, HoldInventoryDetail, \
-    OOSStatus, AmazonInventorySnapshot, StateMaster, HoldInventoryDetail, AmazonFbaInventorySnapshot, \
+    AmazonFbaInventorySnapshot, SnapdealInventorySnapshot, FlipkartInventorySnapshot, \
-    SnapdealInventorySnapshot, FlipkartInventorySnapshot, SnapdealStockAtEOD, FlipkartStockAtEOD, StockWeightedNlcInfo
+    SnapdealStockAtEOD, FlipkartStockAtEOD, StockWeightedNlcInfo, \
+    ItemLocationAvailabilityCache
 from shop2020.thriftpy.model.v1.inventory.ttypes import \
-    InventoryServiceException, HolidayType, InventoryType, WarehouseType
+    InventoryServiceException, HolidayType, InventoryType, WarehouseType,\
+    ItemLocationAvailability, ItemPincodeAvailability
 from shop2020.thriftpy.model.v1.order.ttypes import AlertType
 from shop2020.thriftpy.purchase.ttypes import PurchaseServiceException
 from shop2020.utils import EmailAttachmentSender
 from shop2020.utils.EmailAttachmentSender import mail
 from shop2020.utils.Utils import to_py_date, to_java_date
 from sqlalchemy.sql import or_
 from sqlalchemy.sql.expression import and_, func, distinct, desc
 from sqlalchemy.sql.functions import count
 import calendar
 import datetime
+import math
 import sys
 import threading
-import math
+import json
+from shop2020.thriftpy.logistics.ttypes import LocationInfo
 to_addresses = ["khushal.bhatia@shop2020.in", "chaitnaya.vats@shop2020.in", "chandan.kumar@shop2020.in",'manoj.kumar@shop2020.in']
 mail_user = "cnc.center@shop2020.in"
 mail_password = "5h0p2o2o"
 skippedItems = { 175 : [27, 2160, 2175, 2163, 2158, 7128, 26, 2154],
 : [5839] }
+pincodePricingServiceabilityMap = {}
+warehouseMap = {}
+logisticsLocationWarehouseMap = {}
 OOS_CALCULATION_TIME = 23
+last_date = datetime.date.today()
+adjusted_dates={}
 def initialize(dbname='inventory', db_hostname="localhost"):
     DataService.initialize(dbname, db_hostname)
+    __populateWarehouseMap()
+def __populateWarehouseMap():
+    warehouses = Warehouse.query.filter(Warehouse.warehouseType.in_(['OURS', 'THIRD_PARTY'])).filter(Warehouse.inventoryType == 'GOOD').all()
+    for warehouse in warehouses:
+        warehouseMap[warehouse.id] = warehouse
+        if not logisticsLocationWarehouseMap.has_key(warehouse.logisticsLocation):
+            logisticsLocationWarehouseMap[warehouse.logisticsLocation] = []
+        logisticsLocationWarehouseMap[warehouse.logisticsLocation].append(warehouse.id)
 def get_Warehouse(warehouse_id):
     return Warehouse.get_by(id=warehouse_id)
 def get_vendor(vendorId):
     session.commit()
     #**Update item availability cache**#
     clear_item_availability_cache(item_id)
     return True
+def get_item_pincode_availability(pin_code, itemPricingMap):
+    returnMap = {}
+    missingItemPricingList = []
+    for item_id, pricing in itemPricingMap.iteritems():
+        if not pricing:
+            missingItemPricingList.append(item_id)
+    cc = CatalogClient().get_client()
+    items = cc.getItems(missingItemPricingList)
+    lc = LogisticsClient().get_client()
+    #Consider selling price if its missing in itempricing
+    for item in items:
+        itemPricingMap[item.id] = item.sellingPrice
+    pricingLocationInfoMap = __getLocationInfoMap(pin_code, itemPricingMap)
+    if pricingLocationInfoMap == -1:
+        returnMap = {"pincode_serviceable":False}
+    else:
+        #for item_id, sellingPrice in itemPricingMap.iteritems():
+        allLocations = pricingLocationInfoMap[1].keys()
+        itemLocationAvailability = ItemLocationAvailabilityCache()
+        itemLocationAvailabilityList = __get_item_location_availability_bulk(itemPricingMap.keys(), allLocations)
+        pricingLocationsMap = {}
+        for itemLocationAvailability in itemLocationAvailabilityList:
+            sellingPrice = itemPricingMap[itemLocationAvailability.item_id]
+            if pricingLocationInfoMap[sellingPrice] == -1:
+                continue
+            if not pricingLocationsMap.has_key(sellingPrice):
+                pricingLocationsMap[sellingPrice] = pricingLocationInfoMap[sellingPrice].keys()
+            if itemLocationAvailability.location_id not in pricingLocationsMap[sellingPrice]:
+                continue
+            if not returnMap.has_key(itemLocationAvailability.item_id):
+                returnMap[itemLocationAvailability.item_id] = ItemPincodeAvailability(vatQty = 0, totalQty = 0, minDeliveryDate=-1)
+            itemPincodeAvailability = ItemPincodeAvailability()
+            itemPincodeAvailability = returnMap[itemLocationAvailability.item_id]
+            locationInfo = LocationInfo()
+            locationInfo = pricingLocationInfoMap[sellingPrice][itemLocationAvailability.location_id]
+            locationQty = itemLocationAvailability.virtual_availability + itemLocationAvailability.physical_availability
+            if locationInfo.sameState:
+                itemPincodeAvailability.vatQty += locationQty
+            itemPincodeAvailability.totalQty += locationQty
+            itemPincodeAvailability.isCod = itemPincodeAvailability.isCod or locationInfo.isCod
+            itemPincodeAvailability.isOtg = itemPincodeAvailability.isOtg or locationInfo.isOtg
+            if itemPincodeAvailability.minDeliveryDate == -1:
+                itemPincodeAvailability.minDeliveryDate = itemLocationAvailability.min_transfer_delay + locationInfo.minDelay
+                itemPincodeAvailability.maxDeliveryDate = itemLocationAvailability.max_transfer_delay + locationInfo.maxDelay
+            else:
+                itemPincodeAvailability.minDeliveryDate = min(itemPincodeAvailability.minDeliveryDate, itemLocationAvailability.min_transfer_delay + locationInfo.minDelay)
+                itemPincodeAvailability.maxDeliveryDate = max(itemPincodeAvailability.maxDeliveryDate, itemLocationAvailability.max_transfer_delay + locationInfo.maxDelay)
+        for itemId, itemPincodeAvailability in returnMap.iteritems():
+            sellingPrice = itemPricingMap[itemId]
+            locationsMap = pricingLocationsMap[sellingPrice]
+            minDay = math.ceil(itemPincodeAvailability.minDeliveryDate)
+            maxDay = math.ceil(itemPincodeAvailability.maxDeliveryDate)
+            itemPincodeAvailability.minDeliveryDate, itemPincodeAvailability.maxDeliveryDate = __getDeliveryDate(minDay, itemPincodeAvailability.isCod, maxDay)
+    return json.dumps(returnMap)
+def __getLocationInfoMap(pin_code, itemPricingMap):
+    priceList = list(set(itemPricingMap.values())) + [1]
+    if not pincodePricingServiceabilityMap.has_key(pin_code):
+        pincodePricingServiceabilityMap[pin_code] = {}
+    pricingMap = pincodePricingServiceabilityMap[pin_code]
+    if pricingMap != -1:
+        missingInMap = []
+        for sellingPrice in priceList:
+            if not pricingMap.has_key(sellingPrice):
+                missingInMap.append(sellingPrice)
+        lc = LogisticsClient().get_client()
+        priceLocationInfoMap = lc.getLocationInfoMap(pin_code, missingInMap)
+        if not priceLocationInfoMap:
+            pricingMap = pincodePricingServiceabilityMap[pin_code] = -1
+        else:
+            for sellingPrice in missingInMap:
+                if priceLocationInfoMap[sellingPrice] == {}:
+                    pricingMap[sellingPrice] = -1
+                else:
+                    pricingMap[sellingPrice] = priceLocationInfoMap[sellingPrice]
+    return pricingMap
+def __getDeliveryDate(minDays, isCod, maxDays=None):
+    curTime = datetime.datetime.now()
+    if maxDays is None:
+        maxDays = minDays
+    if isCod and curTime.hour < 15:
+        maxDays = maxDays + 1
+    return __getAdjustedDate(minDays), __getAdjustedDate(maxDays)
+def __getAdjustedDate(days):
+    curDate = datetime.date.today()
+    if curDate == last_date:
+        if adjusted_dates.has_key(days):
+            return adjusted_dates[days]
+    else:
+        adjusted_dates = {}
+    lc = LogisticsClient().get_client()
+    adjusted_day = lc.adjustDeliveryDays(datetime.datetime.now(), to_java_date(days))
+    adjusted_date = to_java_date(datetime.datetime.combine(curDate, datetime.datetime.min.time()) + datetime.timedelta(days=adjusted_day))
+    adjusted_dates[days] = adjusted_date
+    return adjusted_date
 def reduce_reservation_count(item_id, warehouse_id, source_id, order_id, quantity):
     if not warehouse_id:
         raise InventoryServiceException(101, "bad warehouse_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, source_id)
+def get_item_location_availability(item_id, locations=[]):
+    if locations:
+        newLocations = locations + [-1]
+        itemisedItemLocationAvailability = ItemLocationAvailabilityCache.filter_by(itemId=item_id).filter(ItemLocationAvailability.locationId.in_(newLocations)).all()
+    else:
+        itemisedItemLocationAvailability = ItemLocationAvailabilityCache.filter_by(itemId=item_id).all()
+    if not itemisedItemLocationAvailability:
+        __update_item_location(item_id)
+        return get_item_location_availability(item_id, locations)
+    else:
+        thriftList = []
+        for itemLocationAvailability in itemisedItemLocationAvailability:
+            if itemLocationAvailability.location_id == -1:
+                itemisedItemLocationAvailability
+            else:
+                thriftList.append(to_t_item_location_availability(itemLocationAvailability))
+        return thriftList
+def __get_item_location_availability_bulk(item_ids, locations=[]):
+    query = ItemLocationAvailabilityCache.query.filter(ItemLocationAvailabilityCache.item_id.in_(item_ids))
+    allPopulated = query.filter(ItemLocationAvailabilityCache.location_id==-1).all()
+    if len(item_ids) > len(allPopulated):
+        for item_id in allPopulated:
+            if item_id not in item_ids:
+                __update_item_location(item_id)
+    if locations:
+        query.filter(ItemLocationAvailabilityCache.location_id.in_(locations)).all()
+    return query.all()
+def clear_item_location_availability_cache(item_id, locations=[]):
+    if type(item_id)==list:
+        ItemLocationAvailabilityCache.query.filter(ItemLocationAvailabilityCache.itemId.in_(item_id)).delete(synchronize_session='fetch')
+        session.commit()
+        t = threading.Thread(target=_task_update_item_availability_cache, args=(item_id,))
+        t.start()
+    elif item_id:
+        ItemLocationAvailabilityCache.query.filter_by(itemId = item_id).delete()
+    session.commit()
 def clear_item_availability_cache(item_id = None):
     print item_id
     if type(item_id)==list:
         ItemAvailabilityCache.query.filter(ItemAvailabilityCache.itemId.in_(item_id)).delete(synchronize_session='fetch')
         session.commit()
             except:
                 print "Could not update cache for "
                 continue
     return True
+def __update_item_location(item_id):
+    ignoredWhs = get_ignored_warehouses(item_id)
+    itemsnapshot = CurrentInventorySnapshot.query.filter_by(item_id = item_id).all()
+    locationsMap = {}
+    for row in itemsnapshot:
+        warehouse = warehouseMap[row.warehouse_id]
+        if row.warehouse_id in ignoredWhs:
+            continue
+        location = warehouse.logisticsLocation
+        if not locationsMap.has_key(location):
+            locationsMap[location] = {"physicalQty":0, "virtualQty":0,    "minTransferDelay":100, "maxTransferDelay":0}
+        locationMap = locationsMap[location]
+        if warehouse.type == 'THIRD_PARTY':
+            locationMap["virtualQty"] += max(0, row.availability - row.reserverd - row.held)
+            locationMap["minTransferDelay"] = min(locationMap["minTransferDelay"], row.transferDelayInHours/24)
+            locationMap["maxTransferDelay"] = max(locationMap["maxTransferDelay"], row.transferDelayInHours/24)
+        else:
+            locationMap["physicalQty"] += max(0, row.availability - row.reserverd - row.held)
+            locationMap["minTransferDelay"] = 0
+    for location, locationMap in locationsMap.iteritems():
+        if locationMap["virtualQty"] > 0 or locationMap["physicalQty"] > 0:
+            itemLocationAvailability = ItemLocationAvailabilityCache()
+            itemLocationAvailability.item_id = item_id
+            itemLocationAvailability.location_id = location
+            itemLocationAvailability.max_transfer_delay = locationMap["maxTransferDelay"]
+            itemLocationAvailability.min_transfer_delay = locationMap["minTransferDelay"]
+            itemLocationAvailability.virtual_availability = locationMap["virtualQty"]
+            itemLocationAvailability.physical_availability = locationMap["physicalQty"]
+    #Add location -1 for each item
+    itemLocationAvailability = ItemLocationAvailabilityCache()
+    itemLocationAvailability.item_id = item_id
+    itemLocationAvailability.location_id = -1
+    session.commit()
 def __update_item_availability_cache(item_id, source_id, item=None):
     """
     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

Subversion Repositories SmartDukaan

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