WebSVN – SmartDukaan – Diff – /trunk/PyProj/src/shop2020/model/v1/order/impl/DataAccessors.py

 import re
 import sys
 import time
 import traceback
 import urllib
+from shop2020.utils.caching.SimpleCaching import memoized
 #Start:- Added By Manish Sharma for Creating a new Ticket: Category- RTO Refund on 21-Jun-2013
 #End:- Added By Manish Sharma for Creating a new Ticket: Category- RTO Refund on 21-Jun-2013
             logistics_client = LogisticsClient().get_client()
             #FIXME line item is only one now. If multiple will come, need to fix.
             item_id = order.lineitems[0].item_id
             if pickUp == PickUpType.RUNNER or pickUp == PickUpType.SELF:
                 current_time = datetime.datetime.now()
-                logistics_info = logistics_client.getLogisticsInfo(order.customer_pincode, item_id, DeliveryType.PREPAID, pickUp)
-                order.logistics_provider_id = logistics_info.providerId
                 if pdu.isFofo:
+                    logistics_info = logistics_client.getLogisticsInfo(order.customer_pincode, item_id, DeliveryType.PREPAID, pickUp, -1)
+                else:
-                    ###For fofo always use RQuick - Surface i.e. 48
+                    stateMaster = fetchStateMaster()
-                    ##Changed to Self pickup for now i.e. 4
+                    stateId = -1
-                    order.logistics_provider_id = 4
+                    for k, v in stateMaster.iteritems():
-                    logistics_info.deliveryTime = logistics_info.shippingTime + 1
+                        if v.stateName == order.customer_state:
+                            stateId = k
-#                    if fofoWarehousesMap:
+                            break
-#                        order.fulfilmentWarehouseId = fofoWarehousesMap.get(item_id).id
+                    logistics_info = logistics_client.getLogisticsInfo(order.customer_pincode, item_id, DeliveryType.PREPAID, pickUp, stateId)
-#                        order.warehouse_id = fofoWarehousesMap.get(item_id).billingWarehouseId
+                order.logistics_provider_id = logistics_info.providerId
                 order.warehouse_id = logistics_info.warehouseId
                 order.fulfilmentWarehouseId = logistics_info.fulfilmentWarehouseId
                 logistics_info.deliveryTime = adjust_delivery_time(current_time, logistics_info.deliveryTime)
             elif order.source == OrderSource.WEBSITE:
                 try:
                     #Get the id and location of actual warehouse that'll be used to fulfil this order.
                     inventory_client = InventoryClient().get_client()
-                    fulfilmentWhId, expected_delay, billingWarehouseId, sellingPrice, totalAvailability, weight = inventory_client.getItemAvailabilityAtLocation(item_id, 1)
+                    fulfilmentWhId, expected_delay, billingWarehouseId, sellingPrice, totalAvailability, weight = inventory_client.getItemAvailabilityAtLocation(item_id, 1, -1)
                 except Exception as ex:
                     raise TransactionServiceException(103, "Unable to fetch inventory information about this item.")
                 expectedDelayMap[item_id] = expected_delay
                 if billingWarehouseIdMap.has_key(billingWarehouseId):
             else:
                 try:
                     #Get the id and location of actual warehouse that'll be used to fulfil this order.
                     inventory_client = InventoryClient().get_client()
-                    fulfilmentWhId, expected_delay, billingWarehouseId, sellingPrice, totalAvailability, weight = inventory_client.getItemAvailabilityAtLocation(item_id, 1)
+                    fulfilmentWhId, expected_delay, billingWarehouseId, sellingPrice, totalAvailability, weight = inventory_client.getItemAvailabilityAtLocation(item_id, 1, -1)
                 except Exception as ex:
                     raise TransactionServiceException(103, "Unable to fetch inventory information about this item.")
                 expectedDelayMap[item_id] = expected_delay
                 if billingWarehouseIdMap.has_key(billingWarehouseId):
     if warehouse_id == order.warehouse_id:
         raise TransactionServiceException(118, "You have selected the current warehouse again. Nothing to do")
     lineitem = order.lineitems[0]
-    catalog_client = CatalogClient().get_client()
+    userClient = UserClient().get_client()
     inventoryClient = InventoryClient().get_client()
     try:
         warehouse = inventoryClient.getWarehouse(warehouse_id)
     except:
         raise TransactionServiceException(119, "No warehouse with id" + str(warehouse_id))
     if not warehouse.billingWarehouseId:
         raise TransactionServiceException(119, "Shifting of warehouse allowed to warehouse with billing support only")
     # If One gives a billing warehouse for warehouse shift, we should assign order to the GOOD warehouse
     # present within it with maximum availability
+    userClient, isFofo = __is_Fofo(userClient, order.customer_id)
+    stateId = warehouse.state.id
     vendorWarehouse = None
     if warehouse.id == warehouse.billingWarehouseId:
-        warehouses = inventoryClient.getWarehouses(None, InventoryType.GOOD, 0, 0, warehouse.id)
-        if warehouses:
-            itemInventory = inventoryClient.getItemInventoryByItemId(lineitem.item_id)
+        itemAvailability = inventoryClient.getItemAvailabilityAtLocation(lineitem.item_id, sourceId, stateId)
-            vendorWarehouse = warehouses[0]
-            maxAvailability = 0
-            for goodWarehouse in warehouses:
-                if itemInventory.availability.has_key(goodWarehouse.id) and maxAvailability < itemInventory.availability[goodWarehouse.id]:
-                    vendorWarehouse = goodWarehouse
-                    maxAvailability = itemInventory.availability[goodWarehouse.id]
-            # Use preferred vendor's warehouse if not available anywhere
-            '''
-            if not maxAvailability:
-                item = catalog_client.getItem(lineitem.item_id)
-                if item.preferredVendor:
-                    for goodWarehouse in warehouses:
-                        if goodWarehouse.vendor.id == item.preferredVendor:
-                            warehouse = goodWarehouse
-            '''
-        else:
-            pass
     #if vendorWarehouse is None or vendorWarehouse.billingWarehouseId != warehouse.id:
     #assign it to first vendorwarehouse available with
-    #inventoryClient.reserveItemInWarehouse(lineitem.item_id, warehouse.id, sourceId, order.id, to_java_date(order.created_timestamp), to_java_date(order.promised_shipping_time), lineitem.quantity)
     if order.productCondition != ProductCondition.BAD:
-        inventoryClient.updateReservationForOrder(lineitem.item_id, vendorWarehouse.id, sourceId, order.id, to_java_date(order.created_timestamp), to_java_date(order.promised_shipping_time), lineitem.quantity)
+        inventoryClient.updateReservationForOrder(lineitem.item_id, itemAvailability[0], sourceId, order.id, to_java_date(order.created_timestamp), to_java_date(order.promised_shipping_time), lineitem.quantity)
     #__update_inventory_reservation(order)
     if order.status == OrderStatus.ACCEPTED:
         __update_transfer_price(order, vendorWarehouse.id)
     order.warehouse_id = vendorWarehouse.billingWarehouseId
     order.fulfilmentWarehouseId = vendorWarehouse.id
     order.status = OrderStatus.CANCEL_REQUEST_CONFIRMED
     order.statusDescription = "Cancellation request confirmed"
     session.commit()
     refund_order(order.id, "crm-team", "As per Customer's Request")
+@memoized(3600)
+def __is_Fofo(userClient, user_id):
+    if not userClient or not userClient.isAlive():
+        userClient = UserClient().get_client()
+    return userClient, userClient.getPrivateDealUser(user_id).isFofo
 def move_orders_to_correct_warehouse():
     completedOrders = []
     pendingOrders = ""
     orders = Order.query.filter(Order.status.in_(tuple([OrderStatus.SUBMITTED_FOR_PROCESSING, OrderStatus.INVENTORY_LOW, OrderStatus.LOW_INV_PO_RAISED, OrderStatus.LOW_INV_REVERSAL_IN_PROCESS]))).order_by(Order.promised_shipping_time).all()
-    logistics_client = LogisticsClient().get_client()
     inventoryClient = InventoryClient().get_client()
+    userClient = UserClient().get_client()
     #warehouses = inventoryClient.getWarehouses(None, None, None, None, None)
     for order in orders:
+        stateMaster = fetchStateMaster()
+        stateId = -1
+        userClient, isFofo = __is_Fofo(userClient, order.customer_id)
+        if isFofo:
+            for k, v in stateMaster.iteritems():
+                if v.stateName == order.customer_state:
+                    stateId = k
+                    break
         lineitem = order.lineitems[0]
         try:
-            if not logistics_client or not logistics_client.isAlive():
+            if not inventoryClient or not inventoryClient.isAlive():
-                logistics_client = LogisticsClient().get_client()
+                inventoryClient = InventoryClient().get_client()
-            logistics_info = logistics_client.getLogisticsEstimation(lineitem.item_id, order.customer_pincode, order.cod)
+            fulfilmentWarehouseId = inventoryClient.getItemAvailabilityAtLocation(lineitem.item_id, sourceId, stateId)[0]
-            if order.fulfilmentWarehouseId != logistics_info.fulfilmentWarehouseId:
+            if order.fulfilmentWarehouseId != fulfilmentWarehouseId:
-                if not inventoryClient or not inventoryClient.isAlive():
-                    inventoryClient = InventoryClient().get_client()
-                netavailability = inventoryClient.getItemAvailibilityAtWarehouse(logistics_info.fulfilmentWarehouseId, lineitem.item_id)
+                netavailability = inventoryClient.getItemAvailibilityAtWarehouse(fulfilmentWarehouseId, lineitem.item_id)
                 if netavailability >= lineitem.quantity:
                     try:
-                        print "++++" + str(order.id) + "=" + str(order.fulfilmentWarehouseId) + "->"+ str(logistics_info.fulfilmentWarehouseId)
+                        print "++++" + str(order.id) + "=" + str(order.fulfilmentWarehouseId) + "->"+ str(fulfilmentWarehouseId)
-                        change_warehouse(order.id, logistics_info.fulfilmentWarehouseId)
+                        change_warehouse(order.id, fulfilmentWarehouseId)
                         completedOrders.append(order.id)
                     except:
                         print "++++" + str(order.id)
                         pendingOrders = pendingOrders + str(order.id) + "|"
         except:

Subversion Repositories SmartDukaan

(root)/trunk/PyProj/src/shop2020/model/v1/order/impl/DataAccessors.py – Rev 23442 → 23446