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

 @author: Chandranshu
 '''
 from datetime import date, timedelta
 from elixir import *
+from random import randrange
 from reportlab.lib.units import inch
 from reportlab.pdfgen.canvas import Canvas
 from reportlab.rl_config import defaultPageSize
+from shop2020.clients.AlertClient import AlertClient
 from shop2020.clients.CatalogClient import CatalogClient
 from shop2020.clients.HelperClient import HelperClient
+from shop2020.clients.InventoryClient import InventoryClient
 from shop2020.clients.LogisticsClient import LogisticsClient
 from shop2020.clients.PaymentClient import PaymentClient
 from shop2020.clients.UserClient import UserClient
 from shop2020.clients.WarehouseClient import WarehouseClient
 from shop2020.model.v1 import order
 from shop2020.model.v1.order.impl.DataService import Transaction, LineItem, \
     Order, BatchNoGenerator, InvoiceIDGenerator, TransactionRequiringExtraProcessing, \
     OrderInventory, Alert, PaymentSettlement, EBSSettlementSummary, \
     CodVerificationAgent, Attribute, RechargeVoucherTracker
 from shop2020.model.v1.order.impl.model.ReturnOrder import ReturnOrder
-from shop2020.thriftpy.generic.ttypes import ExceptionType
 from shop2020.thriftpy.alert.ttypes import MonitoredEntity, EntityType
+from shop2020.thriftpy.generic.ttypes import ExceptionType
 from shop2020.thriftpy.logistics.ttypes import DeliveryType, PickUpType
-from shop2020.thriftpy.model.v1.catalog.ttypes import BillingType, \
+from shop2020.thriftpy.model.v1.inventory.ttypes import BillingType, \
-    InventoryServiceException, WarehouseType, ItemType, InventoryType
+    InventoryServiceException, WarehouseType, InventoryType
+from shop2020.thriftpy.model.v1.catalog.ttypes import ItemType
 from shop2020.thriftpy.model.v1.order.ttypes import TransactionServiceException, \
     TransactionStatus, OrderStatus, DelayReason, ExtraTransactionProcessingType, \
     HotspotAction, TimeoutSummary, OrderStatusGroups, OrderType
+from shop2020.thriftpy.model.v1.user.ttypes import VoucherType
 from shop2020.thriftpy.payments.ttypes import PaymentException
 from shop2020.thriftpy.warehouse.ttypes import ScanType, \
     WarehouseServiceException
-from shop2020.utils.EmailAttachmentSender import mail, get_attachment_part,\
+from shop2020.utils.EmailAttachmentSender import mail, get_attachment_part, \
     mail_html
 from shop2020.utils.Utils import to_py_date, to_java_date
 from sqlalchemy.orm.exc import NoResultFound, MultipleResultsFound
 from sqlalchemy.sql import func
 from sqlalchemy.sql.expression import and_, or_, desc, not_, distinct, select
 from string import Template
 from textwrap import dedent
 import datetime
+import httplib
 import logging
 import os
 import sys
 import time
 import traceback
-from shop2020.thriftpy.model.v1.user.ttypes import VoucherType
-from random import randrange
-from shop2020.clients.AlertClient import AlertClient
-import httplib
 import urllib
 logging.basicConfig(level=logging.DEBUG)
 PREPAID_SHIPPING_CUTOFF_TIME = 15
 COD_SHIPPING_CUTOFF_TIME = 12
             order.expected_shipping_time = (current_time + datetime.timedelta(days=logistics_info.shippingTime)).replace(hour=PREPAID_SHIPPING_CUTOFF_TIME, minute=0, second=0)
             order.promised_shipping_time = order.expected_shipping_time
             order.expected_delivery_time = (current_time + datetime.timedelta(days=logistics_info.deliveryTime)).replace(hour=PREPAID_SHIPPING_CUTOFF_TIME, minute=0, second=0)
             order.promised_delivery_time = order.expected_delivery_time
-            catalog_client = CatalogClient().get_client()
+            inventory_client = InventoryClient().get_client()
-            catalog_client.reserveItemInWarehouse(item_id, logistics_info.fulfilmentWarehouseId, order.lineitems[0].quantity)
+            inventory_client.reserveItemInWarehouse(item_id, logistics_info.fulfilmentWarehouseId, order.lineitems[0].quantity)
             try:
-                item_pricing = catalog_client.getItemPricing(item_id, -1)
+                item_pricing = inventory_client.getItemPricing(item_id, -1)
                 order.lineitems[0].transfer_price = item_pricing.transferPrice
             except:
                 print "Not able to get transfer price. Skipping"
+            catalog_client = CatalogClient().get_client()
             voucherAmount = catalog_client.getVoucherAmount(item_id, VoucherType.SPICEDECK_MOBILE)
             if voucherAmount:
                 __create_recharge_voucher_tracker(order, voucherAmount, VoucherType.SPICEDECK_MOBILE)
     elif new_status == TransactionStatus.COD_IN_PROCESS:
             order.expected_shipping_time = (current_time + datetime.timedelta(days=logistics_info.shippingTime)).replace(hour=COD_SHIPPING_CUTOFF_TIME, minute=0, second=0)
             order.promised_shipping_time = order.expected_shipping_time
             order.expected_delivery_time = (current_time + datetime.timedelta(days=logistics_info.deliveryTime)).replace(hour=COD_SHIPPING_CUTOFF_TIME, minute=0, second=0)
             order.promised_delivery_time = order.expected_delivery_time
-            catalog_client = CatalogClient().get_client()
+            inventory_client = InventoryClient().get_client()
-            catalog_client.reserveItemInWarehouse(item_id, logistics_info.fulfilmentWarehouseId, order.lineitems[0].quantity)
+            inventory_client.reserveItemInWarehouse(item_id, logistics_info.fulfilmentWarehouseId, order.lineitems[0].quantity)
             try:
-                item_pricing = catalog_client.getItemPricing(item_id, -1)
+                item_pricing = inventory_client.getItemPricing(item_id, -1)
                 order.lineitems[0].transfer_price = item_pricing.transferPrice
             except:
                 print "Not able to get transfer price. Skipping"
+            catalog_client = CatalogClient().get_client()
             voucherAmount = catalog_client.getVoucherAmount(item_id, VoucherType.SPICEDECK_MOBILE)
             if voucherAmount:
                 __create_recharge_voucher_tracker(order, voucherAmount, VoucherType.SPICEDECK_MOBILE)
     session.commit()
         else:
             raise TransactionServiceException(115, "Payment capture failed.")
 def __amend_fulfilment_warehouse(order):
     itemId = order.lineitems[0].item_id
-    catalogClient = CatalogClient().get_client()
+    inventoryClient = InventoryClient().get_client()
-    inventory = catalogClient.getItemInventoryByItemId(itemId)
+    inventory = inventoryClient.getItemInventoryByItemId(itemId)
     if not (inventory.availability.has_key(order.fulfilmentWarehouseId) and inventory.availability[order.fulfilmentWarehouseId]):
-        for warehouse in catalogClient.getWarehouses(WarehouseType.OURS, InventoryType.GOOD, 0, order.warehouse_id, 0):
+        for warehouse in inventoryClient.getWarehouses(WarehouseType.OURS, InventoryType.GOOD, 0, order.warehouse_id, 0):
             if inventory.availability.has_key(warehouse.id) and inventory.availability[warehouse.id] >= inventory.reserved[warehouse.id] + order.lineitems[0].quantity:
-                catalogClient.reduceReservationCount(itemId, order.fulfilmentWarehouseId, order.lineitems[0].quantity)
+                inventoryClient.reduceReservationCount(itemId, order.fulfilmentWarehouseId, order.lineitems[0].quantity)
-                catalogClient.reserveItemInWarehouse(itemId, warehouse.id, order.lineitems[0].quantity)
+                inventoryClient.reserveItemInWarehouse(itemId, warehouse.id, order.lineitems[0].quantity)
                 order.fulfilmentWarehouseId = warehouse.id
                 break
 def add_billing_details(orderId, invoice_number, serialNumbers, itemNumbers, billedBy, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
     if jacketNumber is None or jacketNumber <= 0:
         order.billed_by = billedBy
         # Letting the billing process fail in cases where we are unable to
         # fill in transfer price
         try:
-            catalog_client = CatalogClient().get_client()
+            inventory_client = InventoryClient().get_client()
-            warehouse = catalog_client.getWarehouse(fulfilmentWarehouseId)
+            warehouse = inventory_client.getWarehouse(fulfilmentWarehouseId)
-            item_pricing = catalog_client.getItemPricing(item_id, warehouse.vendor.id)
+            item_pricing = inventory_client.getItemPricing(item_id, warehouse.vendor.id)
             lineitem.transfer_price = item_pricing.transferPrice
             order.vendorId = warehouse.vendor.id
         except InventoryServiceException as e:
             print sys.exc_info()[0]
             print e.message
                     print sys.exc_info()[0]
                     print 'Could not scan out orders due to: ' + e.message
                     raise TransactionServiceException(110, e.message)
         else:
             if not warehouse.isAvailabilityMonitored:
-                catalog_client = CatalogClient().get_client()
+                inventory_client = InventoryClient().get_client()
-                catalog_client.addInventory(item.id, warehouse.id, -1 * lineitem.quantity)
+                inventory_client.addInventory(item.id, warehouse.id, -1 * lineitem.quantity)
         __update_inventory_reservation(order)
         order.fulfilmentWarehouseId = warehouse.id
         session.commit()
         return True
     from_user = 'cnc.center@shop2020.in'
     from_pwd = '5h0p2o2o'
     subject = "Pickup request from " + order.customer_city
     try:
-        catalog_client = CatalogClient().get_client()
+        inventory_client = InventoryClient().get_client()
-        warehouse = catalog_client.getWarehouse(order.warehouse_id)
+        warehouse = inventory_client.getWarehouse(order.warehouse_id)
         logistics_client = LogisticsClient().get_client()
         provider = logistics_client.getProvider(providerId)
         to_addr = provider.details[DeliveryType.PREPAID].email
         raw_message = '''
     from_user = 'help@shop2020.in'
     from_pwd = '5h0p2o2o'
     subject = 'Pickup details'
     filename = "/tmp/" +  str(order.id) +".pdf"
     try:
-        catalog_client = CatalogClient().get_client()
+        inventory_client = InventoryClient().get_client()
-        warehouse = catalog_client.getWarehouse(order.warehouse_id)
+        warehouse = inventory_client.getWarehouse(order.warehouse_id)
         logistics_client = LogisticsClient().get_client()
         provider = logistics_client.getProvider(providerId)
         provider_name = provider.name
         order.received_return_timestamp = datetime.datetime.now()
     else:
         return False
     # For OUR warehouses, we need to scan in items for every return
-    catalogClient = CatalogClient().get_client()
+    inventoryClient = InventoryClient().get_client()
-    warehouse = catalogClient.getWarehouse(order.warehouse_id)
+    warehouse = inventoryClient.getWarehouse(order.warehouse_id)
     if warehouse.billingType == BillingType.OURS:
         scanMap = {
             OrderStatus.RTO_RECEIVED_PRESTINE : ScanType.SALE_RET,
             OrderStatus.RTO_RECEIVED_DAMAGED  : ScanType.SALE_RET_UNUSABLE,
             OrderStatus.RTO_LOST_IN_TRANSIT   : ScanType.LOST_IN_TRANSIT,
+        }
         if scanMap.has_key(order.status):
             scanType = scanMap[order.status]
             lineitem = order.lineitems[0]
+            catalogClient = CatalogClient().get_client()
             item = catalogClient.getItem(lineitem.item_id)
             warehouseClient = WarehouseClient().get_client()
             if item.type == ItemType.SERIALIZED:
                 warehouseClient.scanSerializedItemForOrder(lineitem.serial_number, scanType, order.id, order.fulfilmentWarehouseId, lineitem.quantity, order.warehouse_id)
             else:
         order.statusDescription = "Return product unusable"
         update_trust_level(order)
     session.commit()
     # For OUR warehouses, we need to scan in items for every return
-    catalogClient = CatalogClient().get_client()
+    inventoryClient = InventoryClient().get_client()
-    warehouse = catalogClient.getWarehouse(order.warehouse_id)
+    warehouse = inventoryClient.getWarehouse(order.warehouse_id)
     if warehouse.billingType == BillingType.OURS:
         lineitem = order.lineitems[0]
+        catalogClient = CatalogClient().get_client()
         item = catalogClient.getItem(lineitem.item_id)
         warehouse_client = WarehouseClient().get_client()
         if item.type == ItemType.SERIALIZED:
             warehouse_client.scanSerializedItemForOrder(lineitem.serial_number, scanType, order.id, order.fulfilmentWarehouseId, lineitem.quantity, order.warehouse_id)
         else:
             __update_inventory_reservation(order)
             order.statusDescription = "Order Cancelled due to payment flagged"
     # For orders that are cancelled after being billed, we need to scan in the scanned out
     # inventory item and change availability accordingly
-    catalogClient = CatalogClient().get_client()
+    inventoryClient = InventoryClient().get_client()
-    warehouse = catalogClient.getWarehouse(order.warehouse_id)
+    warehouse = inventoryClient.getWarehouse(order.warehouse_id)
     if warehouse.billingType == BillingType.OURS:
         if order.status in [OrderStatus.BILLED, OrderStatus.SHIPPED_TO_LOGST, OrderStatus.SHIPPED_FROM_WH] or (order.status == OrderStatus.CANCEL_REQUEST_CONFIRMED and order.previousStatus in [OrderStatus.BILLED, OrderStatus.SHIPPED_TO_LOGST, OrderStatus.SHIPPED_FROM_WH]):
             lineitem = order.lineitems[0]
+            catalogClient = CatalogClient().get_client()
             item = catalogClient.getItem(lineitem.item_id)
             warehouseClient = WarehouseClient().get_client()
             if ItemType.SERIALIZED == item.type:
                 warehouseClient.scanSerializedItemForOrder(lineitem.serial_number, ScanType.SALE_RET, order.id, order.fulfilmentWarehouseId, lineitem.quantity, order.warehouse_id)
             else:
 def __update_inventory_reservation(order):
     '''
     Reduce the reservation count for all line items of the given order.
     '''
     try:
-        catalog_client = CatalogClient().get_client()
+        inventoryClient = InventoryClient().get_client()
         for lineitem in order.lineitems:
-            catalog_client.reduceReservationCount(lineitem.item_id, order.fulfilmentWarehouseId, lineitem.quantity)
+            inventoryClient.reduceReservationCount(lineitem.item_id, order.fulfilmentWarehouseId, lineitem.quantity)
     except:
         print "Unable to reduce reservation count"
 def __clone_order(order, should_copy_billing_info, is_cod):
     current_time = datetime.datetime.now()
         new_order.accepted_timestamp = current_time
         new_order.billing_timestamp = current_time
         new_order.status = OrderStatus.BILLED
         new_order.statusDescription = 'Order Billed'
     else:
-        catalog_client = CatalogClient().get_client()
+        inventoryClient = InventoryClient().get_client()
-        catalog_client.reserveItemInWarehouse(item_id, logistics_info.fulfilmentWarehouseId, new_order.lineitems[0].quantity)
+        inventoryClient.reserveItemInWarehouse(item_id, logistics_info.fulfilmentWarehouseId, new_order.lineitems[0].quantity)
     return new_order
 def __create_return_order(order):
     ret_order = ReturnOrder(order)
     old_item = catalog_client.getItem(lineitem.item_id)
     item = catalog_client.getItem(item_id)
     if old_item.catalogItemId != item.catalogItemId:
         raise TransactionServiceException(121, "You can't ship a different item. You can only ship the same item in a different color.")
+    inventoryClient = InventoryClient().get_client()
-    catalog_client.reserveItemInWarehouse(item_id, order.fulfilmentWarehouseId, lineitem.quantity)
+    inventoryClient.reserveItemInWarehouse(item_id, order.fulfilmentWarehouseId, lineitem.quantity)
     __update_inventory_reservation(order)
     #TODO: Check that this new item has the same price
     lineitem.item_id = item_id
     lineitem.color = item.color
     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()
+    inventoryClient = InventoryClient().get_client()
     try:
-        warehouse = catalog_client.getWarehouse(warehouse_id)
+        warehouse = inventoryClient.getWarehouse(warehouse_id)
     except:
         raise TransactionServiceException(119, "No warehouse with id" + str(warehouse_id))
     if warehouse.billingWarehouseId is None:
         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
     if warehouse.id == warehouse.billingWarehouseId:
-        warehouses = catalog_client.getWarehouses(None, InventoryType.GOOD, 0, 0, warehouse.id)
+        warehouses = inventoryClient.getWarehouses(None, InventoryType.GOOD, 0, 0, warehouse.id)
         if warehouses:
-            itemInventory = catalog_client.getItemInventoryByItemId(lineitem.item_id)
+            itemInventory = inventoryClient.getItemInventoryByItemId(lineitem.item_id)
             warehouse = warehouses[0]
             maxAvailability = 0
             for goodWarehouse in warehouses:
                 if itemInventory.availability.has_key(goodWarehouse.id) and maxAvailability < itemInventory.availability[goodWarehouse.id]:
                     warehouse = goodWarehouse
                         if goodWarehouse.vendor.id == item.preferredVendor:
                             warehouse = goodWarehouse
         else:
             raise TransactionServiceException(119, "Shifting of warehouse allowed to GOOD inventory type warehouse with billing support")
-    catalog_client.reserveItemInWarehouse(lineitem.item_id, warehouse.id, lineitem.quantity)
+    inventoryClient.reserveItemInWarehouse(lineitem.item_id, warehouse.id, lineitem.quantity)
     __update_inventory_reservation(order)
     order.warehouse_id = warehouse.billingWarehouseId
     order.fulfilmentWarehouseId = warehouse.id
     session.commit()
         attribute.name = t_attribute.name
         attribute.value = t_attribute.value
         session.commit()
 def accept_order_for_item(itemId, quantity, fulfilmentWarehouseId, billingWarehouseId):
-    catalogClient = CatalogClient().get_client()
+    inventoryClient = InventoryClient().get_client()
-    inventory = catalogClient.getItemInventoryByItemId(itemId)
+    inventory = inventoryClient.getItemInventoryByItemId(itemId)
     orders = Order.query.filter(Order.fulfilmentWarehouseId != fulfilmentWarehouseId).filter(Order.warehouse_id == billingWarehouseId).filter(Order.status.in_(tuple([OrderStatus.SUBMITTED_FOR_PROCESSING, OrderStatus.COD_VERIFICATION_PENDING, OrderStatus.ACCEPTED, OrderStatus.INVENTORY_LOW, OrderStatus.LOW_INV_PO_RAISED, OrderStatus.LOW_INV_REVERSAL_IN_PROCESS]))).order_by(Order.expected_shipping_time).all()
     for order in orders:
         lineitem = order.lineitems[0]
         if lineitem.item_id == itemId and lineitem.quantity <= quantity:
-            warehouse = catalogClient.getWarehouse(order.fulfilmentWarehouseId)
+            warehouse = inventoryClient.getWarehouse(order.fulfilmentWarehouseId)
             if not warehouse.billingWarehouseId and warehouse.warehouseType == WarehouseType.THIRD_PARTY:
                 if (inventory.availability[fulfilmentWarehouseId] >= inventory.reserved[fulfilmentWarehouseId] + lineitem.quantity) and inventory.availability[order.fulfilmentWarehouseId] < inventory.reserved[order.fulfilmentWarehouseId]:
-                    catalogClient.reduceReservationCount(itemId, order.fulfilmentWarehouseId, quantity)
+                    inventoryClient.reduceReservationCount(itemId, order.fulfilmentWarehouseId, quantity)
-                    catalogClient.reserveItemInWarehouse(itemId, fulfilmentWarehouseId, quantity)
+                    inventoryClient.reserveItemInWarehouse(itemId, fulfilmentWarehouseId, quantity)
                     order.fulfilmentWarehouseId = fulfilmentWarehouseId
                     quantity -= lineitem.quantity
                     session.commit()
                     if not quantity:
                         break

Subversion Repositories SmartDukaan

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