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

 from reportlab.rl_config import defaultPageSize
 from shop2020.clients.CatalogClient import CatalogClient
 from shop2020.clients.HelperClient import HelperClient
 from shop2020.clients.LogisticsClient import LogisticsClient
 from shop2020.clients.PaymentClient import PaymentClient
-from shop2020.clients.PurchaseClient import PurchaseClient
 from shop2020.clients.UserClient import UserClient
 from shop2020.clients.WarehouseClient import WarehouseClient
-from shop2020.config.client.ConfigClient import ConfigClient
 from shop2020.model.v1 import order
 from shop2020.model.v1.order.impl.DataService import Transaction, LineItem, \
     Order, BatchNoGenerator, InvoiceIDGenerator, TransactionRequiringExtraProcessing, \
     OrderInventory, Alert, PaymentSettlement, EBSSettlementSummary
 from shop2020.model.v1.order.impl.model.ReturnOrder import ReturnOrder
 from shop2020.thriftpy.generic.ttypes import ExceptionType
 from shop2020.thriftpy.logistics.ttypes import DeliveryType
 from shop2020.thriftpy.model.v1.catalog.ttypes import BillingType, \
-    InventoryServiceException
+    InventoryServiceException, WarehouseType, ItemType, InventoryType
 from shop2020.thriftpy.model.v1.order.ttypes import TransactionServiceException, \
     TransactionStatus, OrderStatus, DelayReason, ExtraTransactionProcessingType, \
     HotspotAction, TimeoutSummary, OrderStatusGroups
 from shop2020.thriftpy.payments.ttypes import PaymentException
-from shop2020.thriftpy.purchase.ttypes import PurchaseOrder, LineItem as POLineItem
+from shop2020.thriftpy.warehouse.ttypes import ScanType, \
-from shop2020.thriftpy.warehouse.ttypes import ScanType, WarehouseServiceException
+    WarehouseServiceException
 from shop2020.utils.EmailAttachmentSender import mail, get_attachment_part
 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
             logistics_info = logistics_client.getLogisticsInfo(order.customer_pincode, item_id, DeliveryType.PREPAID)
             current_time = datetime.datetime.now()
             logistics_info.deliveryTime = adjust_delivery_time(current_time, logistics_info.deliveryTime)
             logistics_info.shippingTime = adjust_delivery_time(current_time, logistics_info.shippingTime)
             order.warehouse_id = logistics_info.warehouseId
+            order.fulfilmentWarehouseId = logistics_info.fulfilmentWarehouseId
             order.logistics_provider_id = logistics_info.providerId
             order.airwaybill_no = logistics_info.airway_billno
             order.tracking_id = order.airwaybill_no
             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)
             order.promised_delivery_time = order.expected_delivery_time
             catalog_client = CatalogClient().get_client()
-            catalog_client.reserveItemInWarehouse(item_id, logistics_info.warehouseId, order.lineitems[0].quantity)
+            catalog_client.reserveItemInWarehouse(item_id, logistics_info.fulfilmentWarehouseId, order.lineitems[0].quantity)
             try:
                 item_pricing = catalog_client.getItemPricing(item_id, -1)
                 order.lineitems[0].transfer_price = item_pricing.transferPrice
             except:
             current_time = datetime.datetime.now()
             logistics_info.deliveryTime = adjust_delivery_time(current_time, logistics_info.deliveryTime)
             logistics_info.shippingTime = adjust_delivery_time(current_time, logistics_info.shippingTime)
             order.warehouse_id = logistics_info.warehouseId
+            order.fulfilmentWarehouseId = logistics_info.fulfilmentWarehouseId
             order.logistics_provider_id = logistics_info.providerId
             order.airwaybill_no = logistics_info.airway_billno
             order.tracking_id = order.airwaybill_no
             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)
             order.promised_delivery_time = order.expected_delivery_time
             catalog_client = CatalogClient().get_client()
-            catalog_client.reserveItemInWarehouse(item_id, logistics_info.warehouseId, order.lineitems[0].quantity)
+            catalog_client.reserveItemInWarehouse(item_id, logistics_info.fulfilmentWarehouseId, order.lineitems[0].quantity)
             try:
                 item_pricing = catalog_client.getItemPricing(item_id, -1)
                 order.lineitems[0].transfer_price = item_pricing.transferPrice
             except:
         return False
 def accept_order(orderId):
     logging.info("Accepting order no: " + str(orderId))
     order = get_order(orderId)
-    if order.status in [OrderStatus.SUBMITTED_FOR_PROCESSING, OrderStatus.INVENTORY_LOW, OrderStatus.LOW_INV_PO_RAISED, OrderStatus.LOW_INV_REVERSAL_IN_PROCESS, OrderStatus.LOW_INV_NOT_AVAILABLE_AT_HOTSPOT]:
+    if order.status in [OrderStatus.SUBMITTED_FOR_PROCESSING, OrderStatus.INVENTORY_LOW, OrderStatus.LOW_INV_PO_RAISED, OrderStatus.LOW_INV_REVERSAL_IN_PROCESS, OrderStatus.LOW_INV_NOT_AVAILABLE_AT_HOTSPOT, OrderStatus.CAPTURE_IN_PROCESS]:
         if not order.cod:
             if order.transaction.status == TransactionStatus.AUTHORIZED:
                 __capture_txn(order)
         order.status = OrderStatus.ACCEPTED
         order.statusDescription = "Order Accepted"
             session.commit()
             raise TransactionServiceException(122, "Unable to capture payment due to connection issue.")
         else:
             raise TransactionServiceException(115, "Payment capture failed.")
-def add_billing_details(orderId, invoice_number, serialNumber, itemNumber, billedBy, jacketNumber, billingType, vendorId, authorize):
+def add_billing_details(orderId, invoice_number, serialNumber, itemNumber, billedBy, jacketNumber, billingType, fulfilmentWarehouseId, authorize):
     if jacketNumber is None or jacketNumber <= 0:
         raise TransactionServiceException(110, "Invalid jacket number")
     if billedBy is None or billedBy.strip() == "":
         raise TransactionServiceException(110, "Invalid Biller")
     order = Order.get_by(id=orderId)
     if not order:
         raise TransactionServiceException(101, "No order found for the given order id" + str(orderId))
+    lineitem = order.lineitems[0]
+    item_id = lineitem.item_id
+    catalog_client = CatalogClient().get_client()
+    item = catalog_client.getItem(item_id)
     if order.status == OrderStatus.ACCEPTED:
         order.jacket_number = jacketNumber
         if billingType == BillingType.OURS:
             if itemNumber is None or itemNumber.strip() == "":
                 raise TransactionServiceException(110, "Invalid item number")
             order.invoice_number = get_next_invoice_number()
-            lineitem = order.lineitems[0]
-            if lineitem.productGroup == "Handsets" and not serialNumber:
+            if ItemType.SERIALIZED == item.type and not serialNumber:
-                raise TransactionServiceException(110, "No Serial Number supplied for a handset.")
+                raise TransactionServiceException(110, "No Serial Number supplied")
             lineitem.item_number = itemNumber
             if serialNumber:
                 lineitem.serial_number = serialNumber
         else:
             order.invoice_number = invoice_number
         order.status = OrderStatus.BILLED
         order.statusDescription = "Order Billed"
         order.billing_timestamp = datetime.datetime.now()
         order.billed_by = billedBy
-        lineitem = order.lineitems[0]
-        item_id = lineitem.item_id
         # Not letting the billing process fail in cases where we are unable to
         # fill in transfer price
-        item_pricing = None
         try:
             catalog_client = CatalogClient().get_client()
+            warehouse = catalog_client.getWarehouse(fulfilmentWarehouseId)
-            item_pricing = catalog_client.getItemPricing(item_id, vendorId)
+            item_pricing = catalog_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
+            raise TransactionServiceException(110, 'Transfer price missing for itemId: ' + str(item_id) + ' and vendor: ' + str(warehouse.vendor.id))
-        order.vendorId = vendorId
-        lineitems = order.lineitems
-        # Putting NULL as transfer price for cases where its missing
-        if item_pricing is not None:
-            order.lineitems[0].transfer_price = item_pricing.transferPrice
-        # For Mahipal warehouse, we need to scan out items for every billed order
+        # For OUR warehouse, we need to scan out items for every billed order
-        if order.warehouse_id == 7:
+        if billingType == BillingType.OURS:
-            if lineitem.productGroup == "Handsets":
+            if ItemType.SERIALIZED == item.type:
                 try:
                     warehouse_client = WarehouseClient().get_client()
                     inventoryItem = warehouse_client.getInventoryItem(serialNumber)
                     if (inventoryItem.itemId != item_id):
+                        catalog_client = CatalogClient().get_client()
                         item = catalog_client.getItem(inventoryItem.itemId)
-                        lineitem = order.lineitems[0]
                         scanItemString = " ".join([str(item.brand), str(item.modelName), str(item.modelNumber), str(item.color)])
                         lineItemString = " ".join([str(lineitem.brand), str(lineitem.model_name), str(lineitem.model_number), str(lineitem.color)])
                         raise TransactionServiceException(110, 'Trying to scan ' + scanItemString + ' instead of ' + lineItemString)
+                    print order.fulfilmentWarehouseId, lineitem.quantity, order.warehouse_id
-                    inventoryItem = warehouse_client.scanSerializedItemForOrder(serialNumber, ScanType.SALE, orderId, order.warehouse_id)
+                    inventoryItem = warehouse_client.scanSerializedItemForOrder(serialNumber, ScanType.SALE, orderId, order.fulfilmentWarehouseId, lineitem.quantity, order.warehouse_id)
                     lineitem.transfer_price = inventoryItem.unitPrice
                     order.vendorId = inventoryItem.supplierId
                     catalog_client = CatalogClient().get_client()
+                    warehouse = catalog_client.getWarehouse(order.fulfilmentWarehouseId)
+                    # Fetching GOOD w/h corresponding to the virtual one here
-                    for lineitem in lineitems:
+                    if warehouse.billingWarehouseId is None:
-                        catalog_client.addInventory(item_id, order.warehouse_id, -1 * lineitem.quantity)
+                        warehouse = catalog_client.getWarehouses(None, InventoryType.GOOD, warehouse.vendor.id, order.warehouse_id, 0)[0]
+                        order.fulfilmentWarehouseId = warehouse.id
                 except WarehouseServiceException as e:
                     print sys.exc_info()[0]
                     print 'Could not scan out orders due to: ' + e.message
-                    if e.exceptionType == ExceptionType.ILLEGAL_ARGUMENTS:
-                        raise TransactionServiceException(110, e.message)
+                    raise TransactionServiceException(110, e.message)
-        try:
-            catalog_client = CatalogClient().get_client()
-            for lineitem in lineitems:
-                catalog_client.reduceReservationCount(item_id, order.warehouse_id, lineitem.quantity)
-        except Exception as e:
-            print sys.exc_info()[0]
-            print e.message
-            raise TransactionServiceException(110, 'Please contact with Engg. team, inventory could not be updated because of: ' + e.message)
+        __update_inventory_reservation(order)
         session.commit()
         return True
     else:
         return False
     return orders_not_picked_up
 def receive_return(order_id, receiveCondition):
     order = get_order(order_id)
-    # FIXME: For Mahipal warehouse, we need to scan in items for every sales return
-    if order.warehouse_id == 7:
-        try:
-            warehouse_client = WarehouseClient().get_client()
-            lineitem = order.lineitems[0]
-            # Inventory should not be updated for DOA returns
-            if order.status == OrderStatus.RTO_IN_TRANSIT:
-                warehouse_client.scanSerializedItemForOrder(lineitem.serial_number, ScanType.SALE_RET, order.id, order.warehouse_id)
-                # In case of RTOs increasing availibility only if we receive item in prestine state
-                if not receiveCondition:
-                    catalog_client = CatalogClient().get_client()
-                    catalog_client.addInventory(lineitem.item_id, order.warehouse_id, lineitem.quantity)
-            elif order.status in [OrderStatus.DOA_PICKUP_CONFIRMED, OrderStatus.DOA_RETURN_IN_TRANSIT]:
-                warehouse_client.scanSerializedItemForOrder(lineitem.serial_number, ScanType.DOA_IN, order.id, order.warehouse_id)
-        except:
-            print sys.exc_info()[0]
-            print 'Could not scan in sales return orders'
     if order.status in [OrderStatus.DOA_PICKUP_CONFIRMED, OrderStatus.DOA_RETURN_IN_TRANSIT]:
         if receiveCondition == 0:
             order.status = OrderStatus.DOA_RECEIVED_PRESTINE
             order.statusDescription = "DOA package received"
         elif receiveCondition == 1:
             order.statusDescription = "RTO lost in transit"
         order.received_return_timestamp = datetime.datetime.now()
         session.commit()
     else:
         return False
+    # For OUR warehouses, we need to scan in items for every return
+    catalogClient = CatalogClient().get_client()
+    warehouse = catalogClient.getWarehouse(order.warehouse_id)
+    if warehouse.billingType == BillingType.OURS:
+        try:
+            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,
+                OrderStatus.DOA_RECEIVED_PRESTINE : ScanType.DOA_IN,
+                OrderStatus.DOA_RECEIVED_DAMAGED  : ScanType.DOA_IN,
+                OrderStatus.DOA_LOST_IN_TRANSIT   : ScanType.LOST_IN_TRANSIT
+            }
+            scanType = scanMap[order.status]
+            if scanType:
+                lineitem = order.lineitems[0]
+                warehouseClient = WarehouseClient().get_client()
+                warehouseClient.scanSerializedItemForOrder(lineitem.serial_number, scanType, order.id, order.fulfilmentWarehouseId, lineitem.quantity, order.warehouse_id)
+        except Exception as e:
+            print sys.exc_info()[0]
+            print 'Could not scan in sales return orders' + str(e)
     return True
 def validate_doa(order_id, is_valid):
     order = get_order(order_id)
     if order.status != OrderStatus.DOA_RECEIVED_PRESTINE:
 def validate_return_product(order_id, is_usable):
     order = get_order(order_id)
     if order.status != OrderStatus.RET_RECEIVED_PRESTINE:
         return False
+    scanType = ScanType.SALE_RET_UNUSABLE
     if is_usable:
         order.status = OrderStatus.RET_PRODUCT_USABLE
         order.statusDescription = "Return product usable"
-        lineitem = order.lineitems[0]
+        scanType = ScanType.SALE_RET
-        if order.warehouse_id == 7:
-            catalog_client = CatalogClient().get_client()
-            catalog_client.addInventory(lineitem.item_id, order.warehouse_id, lineitem.quantity)
     else:
         order.status = OrderStatus.RET_PRODUCT_UNUSABLE
         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()
+    warehouse = catalogClient.getWarehouse(order.warehouse_id)
+    if warehouse.billingType == BillingType.OURS:
+        lineitem = order.lineitems[0]
+        warehouse_client = WarehouseClient().get_client()
+        warehouse_client.scanSerializedItemForOrder(lineitem.serial_number, scanType, order.id, order.fulfilmentWarehouseId, lineitem.quantity, order.warehouse_id)
     return True
 def reship_order(order_id):
     """
     If the order is in RTO_RECEIVED_PRESTINE or DOA_CERT_INVALID state, it does the following:
             __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()
+    warehouse = catalogClient.getWarehouse(order.warehouse_id)
-    if order.warehouse_id == 7:
+    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]
             warehouseClient = WarehouseClient().get_client()
-            warehouseClient.scanSerializedItemForOrder(lineitem.serial_number, ScanType.SALE_RET, order.id, order.warehouse_id)
+            warehouseClient.scanSerializedItemForOrder(lineitem.serial_number, ScanType.SALE_RET, order.id, order.fulfilmentWarehouseId, lineitem.quantity, order.warehouse_id)
-            # Increasing availability as well here
-            catalogClient = CatalogClient().get_client()
-            catalogClient.addInventory(lineitem.item_id, order.warehouse_id, lineitem.quantity)
     order.status = status_transition[order.status]
     order.refund_timestamp = datetime.datetime.now()
     order.refunded_by = refunded_by
     order.refund_reason = reason
     Reduce the reservation count for all line items of the given order.
     '''
     try:
         catalog_client = CatalogClient().get_client()
         for lineitem in order.lineitems:
-            catalog_client.reduceReservationCount(lineitem.item_id, order.warehouse_id, lineitem.quantity);
+            catalog_client.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()
     logistics_client = LogisticsClient().get_client()
     item_id = new_order.lineitems[0].item_id
     logistics_info = logistics_client.getLogisticsInfo(new_order.customer_pincode, item_id, is_cod) #TODO: We should be able to pass another flag to suggest ignoring the inventory situation.
     logistics_info.deliveryTime = adjust_delivery_time(current_time, logistics_info.deliveryTime)
     new_order.warehouse_id = logistics_info.warehouseId
+    new_order.fulfilmentWarehouseId = logistics_info.fulfilmentWarehouseId
     new_order.logistics_provider_id = logistics_info.providerId
     new_order.airwaybill_no = logistics_info.airway_billno
     new_order.tracking_id = new_order.airwaybill_no
     new_order.expected_delivery_time = current_time + datetime.timedelta(days=logistics_info.deliveryTime)
     new_order.promised_delivery_time = new_order.expected_delivery_time
     if should_copy_billing_info:
         new_order.invoice_number = order.invoice_number
         new_order.billed_by = order.billed_by
         new_order.warehouse_id = order.warehouse_id
+        new_order.fulfilmentWarehouseId = order.fulfilmentWarehouseId
         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()
-        catalog_client.reserveItemInWarehouse(item_id, logistics_info.warehouseId, new_order.lineitems[0].quantity)
+        catalog_client.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.")
-    catalog_client.reserveItemInWarehouse(item_id, order.warehouse_id, lineitem.quantity)
+    catalog_client.reserveItemInWarehouse(item_id, order.fulfilmentWarehouseId, lineitem.quantity)
-    catalog_client.reduceReservationCount(lineitem.item_id, order.warehouse_id, 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
     catalog_client = CatalogClient().get_client()
     try:
         warehouse = catalog_client.getWarehouse(warehouse_id)
     except:
         raise TransactionServiceException(119, "No warehouse with id" + str(warehouse_id))
+    if warehouse.billingWarehouseId is None or warehouse.inventoryType != InventoryType.GOOD:
+        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)
-    catalog_client.reduceReservationCount(lineitem.item_id, order.warehouse_id, lineitem.quantity)
+    __update_inventory_reservation(order)
+    order.warehouse_id = warehouse.billingWarehouseId
-    order.warehouse_id = warehouse_id
+    order.fulfilmentWarehouseId = warehouse_id
     session.commit()
     return order
 def add_delay_reason(order_id, reason, further_delay, delayReasonText):
     '''

Subversion Repositories SmartDukaan

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