WebSVN – SmartDukaan – Diff – /trunk/PyProj/src/shop2020/logistics/service/impl/DataAccessor.py

 from shop2020.clients.CatalogClient import CatalogClient
 from shop2020.clients.InventoryClient import InventoryClient
 from shop2020.logistics.service.impl import DataService
 from shop2020.logistics.service.impl.DataService import Awb, AwbUpdate, Provider, \
     DeliveryEstimate, WarehouseAllocation, PublicHolidays, \
-    ServiceableLocationDetails, PickupStore, Locations
+    ServiceableLocationDetails, PickupStore, Locations, ProviderCosting
 from shop2020.thriftpy.logistics.ttypes import LogisticsServiceException, \
-    DeliveryType, LogisticsLocationInfo, LocationInfo, ProviderInfo
+    DeliveryType, LogisticsLocationInfo, LocationInfo, ProviderInfo, DeliveryEstimateAndCosting
 from shop2020.thriftpy.model.v1.inventory.ttypes import Warehouse, BillingType, \
     WarehouseType
 from shop2020.utils.Utils import log_entry, to_py_date, to_java_date
 from sqlalchemy.sql import or_
 import datetime
 serviceable_location_cache = {}
 delivery_estimate_cache = {}
 warehouse_location_cache = {}
 location_state={}
 state_locations = {}
+provider_costing_sheet = {}
+DELHIVERY = 3
 #pincode location map is ab
 #{'110001':{1:{"sameState":False, "providerInfo":{1:(1,1), 2:(1,1)}}},}
 pincode_locations = {}
 #{(dest_pin, provider):(otgAvailable,providerCodLimit, websiteCodLimit, storeCodLimit, providerPrepaidLimit)}
     __cache_warehouse_locations()
     __cache_serviceable_location_details_table()
     __cache_delivery_estimate_table()
     __cache_locations()
     __cache_pincode_estimates()
+    __cache_courier_costing_table()
     close_session()
     print "Done cache population at: " + str(datetime.datetime.now())
 def __cache_locations():
     locations = Locations.query.all()
 def __cache_delivery_estimate_table():
     delivery_estimates = DeliveryEstimate.query.all()
     for delivery_estimate in delivery_estimates:
         delivery_estimate_cache[delivery_estimate.destination_pin, delivery_estimate.provider_id, delivery_estimate.warehouse_location]\
-        =delivery_estimate.delivery_time, delivery_estimate.delivery_delay
+        =delivery_estimate.delivery_time, delivery_estimate.delivery_delay, delivery_estimate.providerZoneCode
 def __cache_serviceable_location_details_table():
     serviceable_locations = ServiceableLocationDetails.query.filter(or_("exp!=0","cod!=0"))
     for serviceable_location in serviceable_locations:
         try:
 def __cache_warehouse_locations():
     client = InventoryClient().get_client()
     #client.getAllWarehouses(True)
     for warehouse in client.getAllWarehouses(True):
         warehouse_location_cache[warehouse.billingWarehouseId]=warehouse.logisticsLocation
+def __cache_courier_costing_table():
+    allCostings = ProviderCosting.query.all()
+    for costing in allCostings:
+        if provider_costing_sheet.has_key(costing.provider_id):
+            costingMap = provider_costing_sheet.get(costing.provider_id)
+            costingMap[costing.zoneCode] = costing
+            provider_costing_sheet[costing.provider_id] = costingMap
+        else:
+            costingMap = {}
+            costingMap[costing.zoneCode] = costing
+            provider_costing_sheet[costing.provider_id] = costingMap
 def get_provider(provider_id):
     provider =  Provider.get_by(id=provider_id)
     return provider
         deliveryEstimate = DeliveryEstimate.get_by(provider_id = logisticsLocationInfo.providerId, destination_pin = logisticsLocationInfo.pinCode, warehouse_location = logisticsLocationInfo.warehouseId)
         if deliveryEstimate:
             deliveryEstimate.warehouse_location= logisticsLocationInfo.warehouseId
             deliveryEstimate.delivery_time= logisticsLocationInfo.deliveryTime
             deliveryEstimate.delivery_delay= logisticsLocationInfo.delivery_delay
+            deliveryEstimate.providerZoneCode = logisticsLocationInfo.zoneCode
         else:
             deliveryEstimate = DeliveryEstimate()
             deliveryEstimate.destination_pin= logisticsLocationInfo.pinCode
             deliveryEstimate.provider = provider
             deliveryEstimate.warehouse_location= logisticsLocationInfo.warehouseId
             deliveryEstimate.delivery_time= logisticsLocationInfo.deliveryTime
             deliveryEstimate.delivery_delay= logisticsLocationInfo.delivery_delay
+            deliveryEstimate.providerZoneCode = logisticsLocationInfo.zoneCode
     session.commit()
 #End:- Added by Manish Sharma for Multiple Pincode Updation on 05-Jul-2013
 def get_first_delivery_estimate_for_wh_location(pincode, whLocation):
         awb.is_available = False
         session.commit()
         return awb.awb_number
     except:
         raise LogisticsServiceException(103, "Unable to get an AWB for the given Provider: " + str(providerId))
+def get_costing_and_delivery_estimate_for_pincode(pincode, transactionAmount, isCod, weight, billingWarehouseId):
+    deliveryEstimate = {}
+    logsiticsCosting = {}
+    providerCostingMap = {}
+    serviceability = {}
+    for providerId in serviceable_location_cache.keys():
+        if serviceable_location_cache.has_key(providerId) and serviceable_location_cache.get(providerId).has_key(pincode):
+            dest_code, exp, iscod, otgAvailable, websiteCodLimit, storeCodLimit, providerPrepaidLimit = serviceable_location_cache.get(providerId).get(pincode)
+            if isCod and iscod:
+                serviceability[providerId] = serviceable_location_cache.get(providerId).get(pincode)
+            elif isCod and not iscod:
+                continue
+            else:
+                serviceability[providerId] = serviceable_location_cache.get(providerId).get(pincode)
+    warehouse_location = warehouse_location_cache.get(billingWarehouseId)
+    if warehouse_location is None:
+        warehouse_location = 0
+    noCostFoundCount = 0
+    if len(serviceability)>0:
+        for providerId, serviceableDetails in serviceability.items():
+            delivery_time = delivery_estimate_cache[pincode, providerId, warehouse_location][0]
+            delivery_delay = delivery_estimate_cache[pincode, providerId, warehouse_location][1]
+            zoneCode = delivery_estimate_cache[pincode, providerId, warehouse_location][2]
+            sla = delivery_time + delivery_delay
+            if deliveryEstimate.has_key(sla):
+                estimate = deliveryEstimate.get(sla)
+                estimate.append(providerId)
+                deliveryEstimate[sla] = estimate
+            else:
+                estimate = []
+                estimate.append(providerId)
+                deliveryEstimate[sla] = estimate
+            logisticsCost = 0
+            codCollectionCharges = 0
+            logisticsCostObj = None
+            if provider_costing_sheet.has_key(providerId) and provider_costing_sheet.get(providerId).has_key(zoneCode):
+                logisticsCostObj = provider_costing_sheet.get(providerId).get(zoneCode)
+                logisticsCost = logisticsCostObj.initialLogisticsCost
+                if weight > logisticsCostObj.initialWeightUpperLimit:
+                    additionalWeight = weight-logisticsCostObj.initialWeightUpperLimit
+                    additionalCostMultiplier = additionalWeight/logisticsCostObj.additionalUnitWeight
+                    additionalCost = additionalCostMultiplier*logisticsCostObj.additionalUnitLogisticsCost
+                    logisticsCost = logisticsCost + additionalCost
+                if isCod:
+                    if logisticsCostObj.codCollectionFactor:
+                        codCollectionCharges = max(logisticsCostObj.minimumCodCollectionCharges, transactionAmount*logisticsCostObj.codCollectionFactor)
+                        logisticsCost = logisticsCost + max(logisticsCostObj.minimumCodCollectionCharges, transactionAmount*logisticsCostObj.codCollectionFactor)
+                    else:
+                        codCollectionCharges = logisticsCostObj.minimumCodCollectionCharges
+                        logisticsCost = logisticsCost + logisticsCostObj.minimumCodCollectionCharges
+                if logsiticsCosting.has_key(logisticsCost):
+                    costingList = logsiticsCosting.get(logisticsCost)
+                    costingList.append(providerId)
+                    logsiticsCosting[logisticsCost] = costingList
+                else:
+                    costingList = []
+                    costingList.append(providerId)
+                    logsiticsCosting[logisticsCost] = costingList
+                providerCostingMap[providerId] = [logisticsCost,codCollectionCharges]
+            else:
+                noCostFoundCount = noCostFoundCount +1
+                continue
+    else:
+        raise LogisticsServiceException(101, "No provider assigned for pincode: " + str(pincode))
+    if noCostFoundCount == len(serviceability):
+        raise LogisticsServiceException(101, "No Costing Found for this pincode: " + str(pincode) +" for any of the provider")
+    allSla = sorted(deliveryEstimate.keys())
+    if len(allSla)==1:
+        allEligibleProviders = deliveryEstimate.get(allSla[0])
+        if len(allEligibleProviders)==1:
+            costingDetails = providerCostingMap.get(allEligibleProviders[0])
+            delEstCostObj = DeliveryEstimateAndCosting()
+            delEstCostObj.logistics_provider_id = allEligibleProviders[0]
+            delEstCostObj.pincode = pincode
+            delEstCostObj.deliveryTime = delivery_estimate_cache[pincode, allEligibleProviders[0], warehouse_location][0]
+            delEstCostObj.delivery_delay = delivery_estimate_cache[pincode, allEligibleProviders[0], warehouse_location][1]
+            delEstCostObj.codAllowed = serviceability[allEligibleProviders[0]][2]
+            delEstCostObj.otgAvailable = serviceability[allEligibleProviders[0]][3]
+            delEstCostObj.logisticsCost = costingDetails[0]-costingDetails[1]
+            delEstCostObj.codCollectionCharges = costingDetails[1]
+            return delEstCostObj
+        else:
+            costingListOrder = []
+            for providerId in allEligibleProviders:
+                costingDetails = providerCostingMap.get(allEligibleProviders[0])
+                if costingDetails[0] not in costingListOrder:
+                    costingListOrder.append(costingDetails[0])
+            if DELHIVERY in allEligibleProviders:
+                delihiveryCosting = providerCostingMap.get(DELHIVERY)
+                considerCost = min(min(costingListOrder)+10, delihiveryCosting[0])
+                if considerCost == delihiveryCosting[0]:
+                    delEstCostObj = DeliveryEstimateAndCosting()
+                    delEstCostObj.logistics_provider_id = DELHIVERY
+                    delEstCostObj.pincode = pincode
+                    delEstCostObj.deliveryTime = delivery_estimate_cache[pincode, DELHIVERY, warehouse_location][0]
+                    delEstCostObj.delivery_delay = delivery_estimate_cache[pincode, DELHIVERY, warehouse_location][1]
+                    delEstCostObj.codAllowed = serviceability[DELHIVERY][2]
+                    delEstCostObj.otgAvailable = serviceability[DELHIVERY][3]
+                    delEstCostObj.logisticsCost = delihiveryCosting[0]-delihiveryCosting[1]
+                    delEstCostObj.codCollectionCharges = delihiveryCosting[1]
+                    return delEstCostObj
+                else:
+                    considerCost = considerCost -10
+                    eligibleProviders = logsiticsCosting.get(considerCost)
+                    costingDetails = providerCostingMap.get(eligibleProviders[0])
+                    delEstCostObj = DeliveryEstimateAndCosting()
+                    delEstCostObj.logistics_provider_id = eligibleProviders[0]
+                    delEstCostObj.pincode = pincode
+                    delEstCostObj.deliveryTime = delivery_estimate_cache[pincode, eligibleProviders[0], warehouse_location][0]
+                    delEstCostObj.delivery_delay = delivery_estimate_cache[pincode, eligibleProviders[0], warehouse_location][1]
+                    delEstCostObj.codAllowed = serviceability[eligibleProviders[0]][2]
+                    delEstCostObj.otgAvailable = serviceability[eligibleProviders[0]][3]
+                    delEstCostObj.logisticsCost = costingDetails[0]-costingDetails[1]
+                    delEstCostObj.codCollectionCharges = costingDetails[1]
+                    return delEstCostObj
+            else:
+                costingListOrder = sorted(costingListOrder)
+                eligibleProviders = logsiticsCosting.get(costingListOrder[0])
+                costingDetails = providerCostingMap.get(eligibleProviders[0])
+                delEstCostObj = DeliveryEstimateAndCosting()
+                delEstCostObj.logistics_provider_id = eligibleProviders[0]
+                delEstCostObj.pincode = pincode
+                delEstCostObj.deliveryTime = delivery_estimate_cache[pincode, eligibleProviders[0], warehouse_location][0]
+                delEstCostObj.delivery_delay = delivery_estimate_cache[pincode, eligibleProviders[0], warehouse_location][1]
+                delEstCostObj.codAllowed = serviceability[eligibleProviders[0]][2]
+                delEstCostObj.otgAvailable = serviceability[eligibleProviders[0]][3]
+                delEstCostObj.logisticsCost = costingDetails[0]-costingDetails[1]
+                delEstCostObj.codCollectionCharges = costingDetails[1]
+                return delEstCostObj
+    else:
+        if allSla[1]-allSla[0]!=1:
+            allEligibleProviders = deliveryEstimate.get(allSla[0])
+            if len(allEligibleProviders)==1:
+                costingDetails = providerCostingMap.get(allEligibleProviders[0])
+                delEstCostObj = DeliveryEstimateAndCosting()
+                delEstCostObj.logistics_provider_id = allEligibleProviders[0]
+                delEstCostObj.pincode = pincode
+                delEstCostObj.deliveryTime = delivery_estimate_cache[pincode, allEligibleProviders[0], warehouse_location][0]
+                delEstCostObj.delivery_delay = delivery_estimate_cache[pincode, allEligibleProviders[0], warehouse_location][1]
+                delEstCostObj.codAllowed = serviceability[allEligibleProviders[0]][2]
+                delEstCostObj.otgAvailable = serviceability[allEligibleProviders[0]][3]
+                delEstCostObj.logisticsCost = costingDetails[0]-costingDetails[1]
+                delEstCostObj.codCollectionCharges = costingDetails[1]
+                return delEstCostObj
+            else:
+                costingListOrder = []
+                for providerId in allEligibleProviders:
+                    costingDetails = providerCostingMap.get(allEligibleProviders[0])
+                    if costingDetails[0] not in costingListOrder:
+                        costingListOrder.append(costingDetails[0])
+                if DELHIVERY in allEligibleProviders:
+                    delihiveryCosting = providerCostingMap.get(DELHIVERY)
+                    considerCost = min(min(costingListOrder)+10, delihiveryCosting[0])
+                    if considerCost == delihiveryCosting[0]:
+                        delEstCostObj = DeliveryEstimateAndCosting()
+                        delEstCostObj.logistics_provider_id = DELHIVERY
+                        delEstCostObj.pincode = pincode
+                        delEstCostObj.deliveryTime = delivery_estimate_cache[pincode, DELHIVERY, warehouse_location][0]
+                        delEstCostObj.delivery_delay = delivery_estimate_cache[pincode, DELHIVERY, warehouse_location][1]
+                        delEstCostObj.codAllowed = serviceability[DELHIVERY][2]
+                        delEstCostObj.otgAvailable = serviceability[DELHIVERY][3]
+                        delEstCostObj.logisticsCost = delihiveryCosting[0]-delihiveryCosting[1]
+                        delEstCostObj.codCollectionCharges = delihiveryCosting[1]
+                        return delEstCostObj
+                    else:
+                        considerCost = considerCost -10
+                        eligibleProviders = logsiticsCosting.get(considerCost)
+                        costingDetails = providerCostingMap.get(eligibleProviders[0])
+                        delEstCostObj = DeliveryEstimateAndCosting()
+                        delEstCostObj.logistics_provider_id = eligibleProviders[0]
+                        delEstCostObj.pincode = pincode
+                        delEstCostObj.deliveryTime = delivery_estimate_cache[pincode, eligibleProviders[0], warehouse_location][0]
+                        delEstCostObj.delivery_delay = delivery_estimate_cache[pincode, eligibleProviders[0], warehouse_location][1]
+                        delEstCostObj.codAllowed = serviceability[eligibleProviders[0]][2]
+                        delEstCostObj.otgAvailable = serviceability[eligibleProviders[0]][3]
+                        delEstCostObj.logisticsCost = costingDetails[0]-costingDetails[1]
+                        delEstCostObj.codCollectionCharges = costingDetails[1]
+                        return delEstCostObj
+                else:
+                    costingListOrder = sorted(costingListOrder)
+                    eligibleProviders = logsiticsCosting.get(costingListOrder[0])
+                    costingDetails = providerCostingMap.get(eligibleProviders[0])
+                    delEstCostObj = DeliveryEstimateAndCosting()
+                    delEstCostObj.logistics_provider_id = eligibleProviders[0]
+                    delEstCostObj.pincode = pincode
+                    delEstCostObj.deliveryTime = delivery_estimate_cache[pincode, eligibleProviders[0], warehouse_location][0]
+                    delEstCostObj.delivery_delay = delivery_estimate_cache[pincode, eligibleProviders[0], warehouse_location][1]
+                    delEstCostObj.codAllowed = serviceability[eligibleProviders[0]][2]
+                    delEstCostObj.otgAvailable = serviceability[eligibleProviders[0]][3]
+                    delEstCostObj.logisticsCost = costingDetails[0]-costingDetails[1]
+                    delEstCostObj.codCollectionCharges = costingDetails[1]
+                    return delEstCostObj
+        else:
+            allEligibleProviders = deliveryEstimate.get(allSla[0])
+            secondBestEligibleProviders = deliveryEstimate.get(allSla[1])
+            for providerId in secondBestEligibleProviders:
+                allEligibleProviders.append(providerId)
+            costingListOrder = []
+            for providerId in allEligibleProviders:
+                costingDetails = providerCostingMap.get(allEligibleProviders[0])
+                if costingDetails[0] not in costingListOrder:
+                    costingListOrder.append(costingDetails[0])
+            if DELHIVERY in allEligibleProviders:
+                delihiveryCosting = providerCostingMap.get(DELHIVERY)
+                considerCost = min(min(costingListOrder)+10, delihiveryCosting[0])
+                if considerCost == delihiveryCosting[0]:
+                    delEstCostObj = DeliveryEstimateAndCosting()
+                    delEstCostObj.logistics_provider_id = DELHIVERY
+                    delEstCostObj.pincode = pincode
+                    delEstCostObj.deliveryTime = delivery_estimate_cache[pincode, DELHIVERY, warehouse_location][0]
+                    delEstCostObj.delivery_delay = delivery_estimate_cache[pincode, DELHIVERY, warehouse_location][1]
+                    delEstCostObj.codAllowed = serviceability[DELHIVERY][2]
+                    delEstCostObj.otgAvailable = serviceability[DELHIVERY][3]
+                    delEstCostObj.logisticsCost = delihiveryCosting[0]-delihiveryCosting[1]
+                    delEstCostObj.codCollectionCharges = delihiveryCosting[1]
+                    return delEstCostObj
+                else:
+                    considerCost = considerCost -10
+                    eligibleProviders = logsiticsCosting.get(considerCost)
+                    costingDetails = providerCostingMap.get(eligibleProviders[0])
+                    delEstCostObj = DeliveryEstimateAndCosting()
+                    delEstCostObj.logistics_provider_id = eligibleProviders[0]
+                    delEstCostObj.pincode = pincode
+                    delEstCostObj.deliveryTime = delivery_estimate_cache[pincode, eligibleProviders[0], warehouse_location][0]
+                    delEstCostObj.delivery_delay = delivery_estimate_cache[pincode, eligibleProviders[0], warehouse_location][1]
+                    delEstCostObj.codAllowed = serviceability[eligibleProviders[0]][2]
+                    delEstCostObj.otgAvailable = serviceability[eligibleProviders[0]][3]
+                    delEstCostObj.logisticsCost = costingDetails[0]-costingDetails[1]
+                    delEstCostObj.codCollectionCharges = costingDetails[1]
+                    return delEstCostObj
+            else:
+                costingListOrder = sorted(costingListOrder)
+                eligibleProviders = logsiticsCosting.get(costingListOrder[0])
+                costingDetails = providerCostingMap.get(eligibleProviders[0])
+                delEstCostObj = DeliveryEstimateAndCosting()
+                delEstCostObj.logistics_provider_id = eligibleProviders[0]
+                delEstCostObj.pincode = pincode
+                delEstCostObj.deliveryTime = delivery_estimate_cache[pincode, eligibleProviders[0], warehouse_location][0]
+                delEstCostObj.delivery_delay = delivery_estimate_cache[pincode, eligibleProviders[0], warehouse_location][1]
+                delEstCostObj.codAllowed = serviceability[eligibleProviders[0]][2]
+                delEstCostObj.otgAvailable = serviceability[eligibleProviders[0]][3]
+                delEstCostObj.logisticsCost = costingDetails[0]-costingDetails[1]
+                delEstCostObj.codCollectionCharges = costingDetails[1]
+                return delEstCostObj

Subversion Repositories SmartDukaan

(root)/trunk/PyProj/src/shop2020/logistics/service/impl/DataAccessor.py – Rev 19420 → 19421