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

     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.logistics.ttypes import DeliveryType, PickUpType
 from shop2020.thriftpy.model.v1.catalog.ttypes import BillingType, \
     InventoryServiceException, WarehouseType, ItemType, InventoryType
 from shop2020.thriftpy.model.v1.order.ttypes import TransactionServiceException, \
     TransactionStatus, OrderStatus, DelayReason, ExtraTransactionProcessingType, \
 import os
 import sys
 import time
 import traceback
 from shop2020.thriftpy.model.v1.user.ttypes import VoucherType
+from shop2020.clients.AlertClient import AlertClient
 logging.basicConfig(level=logging.DEBUG)
 PREPAID_SHIPPING_CUTOFF_TIME = 15
 COD_SHIPPING_CUTOFF_TIME = 12
                 try:
                     warehouse_client = WarehouseClient().get_client()
                     # Fetching GOOD w/h corresponding to the virtual one here
                     if warehouse.billingWarehouseId is None:
                         warehouse = catalog_client.getWarehouses(None, InventoryType.GOOD, warehouse.vendor.id, order.warehouse_id, 0)[0]
+                        order.fulfilmentWarehouseId = warehouse.id
                     if ItemType.SERIALIZED == item.type:
                         inventoryItem = warehouse_client.getInventoryItem(serialNumber)
                     else:
-                        inventoryItem = warehouse_client.getNonSeralizedInventoryItem(itemNumbers[index], item_id, warehouse.id)
+                        inventoryItem = warehouse_client.getNonSeralizedInventoryItem(itemNumbers[index], item_id, order.fulfilmentWarehouseId)
                     if (inventoryItem.itemId != item_id):
                         catalog_client = CatalogClient().get_client()
                         item = catalog_client.getItem(inventoryItem.itemId)
                         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)
                     if ItemType.SERIALIZED == item.type:
-                        inventoryItem = warehouse_client.scanSerializedItemForOrder(serialNumber, ScanType.SALE, orderId, warehouse.id, 1, order.warehouse_id)
+                        inventoryItem = warehouse_client.scanSerializedItemForOrder(serialNumber, ScanType.SALE, orderId, order.fulfilmentWarehouseId, 1, order.warehouse_id)
                     else:
-                        inventoryItem = warehouse_client.scanForOrder(inventoryItem, ScanType.SALE, 1, order.id, warehouse.id, order.warehouse_id)
+                        inventoryItem = warehouse_client.scanForOrder(inventoryItem, ScanType.SALE, 1, order.id, order.fulfilmentWarehouseId, order.warehouse_id)
                     lineitem.transfer_price = inventoryItem.unitPrice
                     order.vendorId = inventoryItem.supplierId
+                    catalog_client = CatalogClient().get_client()
                 except WarehouseServiceException as e:
                     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()
                 catalog_client.addInventory(item.id, warehouse.id, -1 * lineitem.quantity)
         __update_inventory_reservation(order)
-        order.fulfilmentWarehouseId = warehouse.id
         session.commit()
         return True
     else:
         return False
         for order in orders:
             if order.id in orderIds:
                 order.status = OrderStatus.SHIPPED_FROM_WH
                 order.statusDescription = "Order shipped from warehouse"
                 order.shipping_timestamp = current_timestamp
+                try:
+                    print "Trying to schedule alert"
+                    monitoredEntity = MonitoredEntity();
+                    monitoredEntity.entityType=EntityType.COURIER;
+                    monitoredEntity.eventType=OrderStatus.SHIPPED_FROM_WH;
+                    monitoredEntity.entityIdentifier="orderId = " + str(order.id);
+                    seconds_epoch = time.time()
+                    #Warn alert time is taken as 15 hrs
+                    warn_time = (seconds_epoch+15*3600)*1000
+                    #Critical alert time is taken as 25 hrs
+                    critical_time = (seconds_epoch+25*3600)*1000
+                    monitoredEntity.warnExpiryTime = warn_time
+                    monitoredEntity.criticalExpiryTime = critical_time
+                    monitoredEntity.description="warehouseId = " + str(warehouseId) + " providerId = " + str(providerId) + " orderId = "  + str(order.id);
+                    print monitoredEntity
+                    print monitoredEntity.description
+                    print monitoredEntity.warnExpiryTime
+                    print monitoredEntity.entityIdentifier
+                    alert_client = AlertClient().get_client()
+                    alert_client.scheduleAlert(monitoredEntity)
+                except Exception as e:
+                    print e
         session.commit()
         try:
             enqueue_shipping_confirmation_email(orders)
         except Exception as e:
             #raise TransactionServiceException(102, "No order found for the awb: " + awb)
             continue
         order.status = OrderStatus.SHIPPED_TO_LOGST
         order.statusDescription = "Order picked up by Courier Company"
         order.pickup_timestamp = pickup_timestamp
+        try:
+            monitoredEntity = MonitoredEntity();
+            monitoredEntity.entityType=EntityType.COURIER;
+            monitoredEntity.eventType=OrderStatus.SHIPPED_TO_LOGST
+            monitoredEntity.entityIdentifier="orderId = " + str(order.id);
+            seconds_epoch = time.time()
+            #Warn alert time is taken as 15 hrs
+            warn_time = (seconds_epoch+15*3600)*1000
+            #Critical alert time is taken as 25 hrs
+            critical_time = (seconds_epoch+25*3600)*1000
+            monitoredEntity.warnExpiryTime = warn_time
+            monitoredEntity.criticalExpiryTime = critical_time
+            monitoredEntity.description="providerId = " + str(provider_id) + "   " + pickup_details
+            alert_client = AlertClient().get_client()
+            alert_client.updateMonitoredObject(monitoredEntity)
+        except Exception as e:
+            print e
     session.commit()
 def get_orders_not_picked_up(provider_id):
     current_time = datetime.datetime.now()
     to_datetime = datetime.datetime(current_time.year, current_time.month, current_time.day)
         if order.first_dlvyatmp_timestamp is None:
             order.first_dlvyatmp_timestamp = timestamp
         order.delivery_timestamp = timestamp
         order.receiver = receiver
         update_trust_level(order)
+        try:
+            alert_client = AlertClient().get_client()
+            alert_client.endMonitoringEntity(EntityType.COURIER, "orderId = " + order.id)
+        except Exception as e:
+            print e
     session.commit()
 def mark_order_as_delivered(orderId, deliveryTimestamp, receiver):
     order = Order.get_by(id=orderId)
     if order == None or order.status not in [OrderStatus.SHIPPED_FROM_WH, OrderStatus.SHIPPED_TO_LOGST, OrderStatus.SHIPPED_TO_DESTINATION_CITY, OrderStatus.REACHED_DESTINATION_CITY, OrderStatus.FIRST_DELIVERY_ATTEMPT_MADE, OrderStatus.DOA_PICKUP_REQUEST_RAISED, OrderStatus.DOA_PICKUP_CONFIRMED, OrderStatus.RET_REQUEST_RECEIVED, OrderStatus.RET_PICKUP_CONFIRMED, OrderStatus.RET_REQUEST_AUTHORIZED, OrderStatus.RET_PICKUP_REQUEST_RAISED, OrderStatus.RTO_IN_TRANSIT, OrderStatus.BILLED, OrderStatus.RECEIVED_AT_STORE]:
         order.receiver = receiver
     order.status = OrderStatus.DELIVERY_SUCCESS
     order.statusDescription = "Order delivered"
     update_trust_level(order)
     session.commit()
+    try:
+        alert_client = AlertClient().get_client()
+        alert_client.endMonitoringEntity(EntityType.COURIER, "orderId = " + order.id)
+    except Exception as e:
+        print e
 def mark_order_as_received_at_store(orderId, deliveryTimestamp):
     order = Order.get_by(id=orderId)
     if order != None or order.status in [OrderStatus.SHIPPED_FROM_WH, OrderStatus.SHIPPED_TO_LOGST, OrderStatus.SHIPPED_TO_DESTINATION_CITY, OrderStatus.REACHED_DESTINATION_CITY, OrderStatus.FIRST_DELIVERY_ATTEMPT_MADE, OrderStatus.DELIVERED_AT_STORE]:
         order.status = OrderStatus.RECEIVED_AT_STORE
         order.status = OrderStatus.RTO_IN_TRANSIT
         order.delivery_timestamp, reason = detail.split('|')
         order.statusDescription = "Order Returned to Origin:" + reason
         update_trust_level(order)
     session.commit()
+    try:
+        alert_client = AlertClient().get_client()
+        alert_client.endMonitoringEntity(EntityType.COURIER, "orderId = " + order.id)
+    except Exception as e:
+        print e
 def get_rto_orders(provider_id):
     current_time = datetime.datetime.now()
     to_datetime = datetime.datetime(current_time.year, current_time.month, current_time.day)
     rto_orders = Order.query.filter_by(logistics_provider_id = provider_id).filter_by(status=OrderStatus.RTO_IN_TRANSIT).filter(Order.delivery_timestamp <= to_datetime).all()
         if order == None or order.status not in [OrderStatus.SHIPPED_FROM_WH, OrderStatus.SHIPPED_TO_LOGST]:
             #raise TransactionServiceException(102, "No order found for the awb: " + awb)
             continue
         order.status = OrderStatus.SHIPPED_TO_DESTINATION_CITY
         order.statusDescription = "Left Out of Origin City"
-        order.local_connected_timestamp = timestamp
+        current_time = datetime.datetime.now()
+        order.local_connected_timestamp = datetime.datetime(current_time.year, current_time.month, current_time.day)
+        try:
+            monitoredEntity = MonitoredEntity();
+            monitoredEntity.entityType=EntityType.COURIER;
+            monitoredEntity.eventType=OrderStatus.SHIPPED_TO_DESTINATION_CITY
+            monitoredEntity.entityIdentifier="orderId = " + str(order.id);
+            #Warn alert time is taken as 15 hrs
+            warn_time = (order.promised_delivery_time-23*3600*1000)
+            #Critical alert time is taken as 25 hrs
+            critical_time = (order.promised_delivery_time-13*3600*1000)
+            monitoredEntity.warnExpiryTime = warn_time
+            monitoredEntity.criticalExpiryTime = critical_time
+            monitoredEntity.description="providerId = " + str(provider_id) + " destination city " + order.customer_city
+            alert_client = AlertClient().get_client()
+            alert_client.updateMonitoredObject(monitoredEntity)
+        except Exception as e:
+            print e
-    session.commit()
+        session.commit()
 def get_orders_not_local_connected(provider_id):
     current_time = datetime.datetime.now()
     to_datetime = datetime.datetime(current_time.year, current_time.month, current_time.day)
     orders_pending_local_connection = Order.query.filter_by(logistics_provider_id = provider_id).filter(Order.status.in_((OrderStatus.SHIPPED_FROM_WH, OrderStatus.SHIPPED_TO_LOGST))).filter(or_(Order.shipping_timestamp <= to_datetime, Order.pickup_timestamp <= to_datetime)).all()
             continue
             #raise TransactionServiceException(103, "No order found for the awb:" + awb)
         order.status = OrderStatus.REACHED_DESTINATION_CITY
         order.statusDescription = "Reached Destination City"
         order.reached_destination_timestamp = timestamp
+        try:
+            monitoredEntity = MonitoredEntity();
+            monitoredEntity.entityType=EntityType.COURIER;
+            monitoredEntity.eventType=OrderStatus.REACHED_DESTINATION_CITY
+            monitoredEntity.entityIdentifier="orderId = " + str(order.id);
+            warn_time = (order.promised_delivery_time)
+            critical_time = (order.promised_delivery_time+12*3600*1000)
+            monitoredEntity.warnExpiryTime = warn_time
+            monitoredEntity.criticalExpiryTime = critical_time
+            monitoredEntity.description="providerId = " + str(provider_id) + " destination city " + order.customer_city
+            alert_client = AlertClient().get_client()
+            alert_client.updateMonitoredObject(monitoredEntity)
+        except Exception as e:
+            print e
     session.commit()
 def mark_orders_as_firstDeliveryAttempted(provider_id, first_atdl_orders):
     for awb, detail in first_atdl_orders.iteritems():
         order = Order.query.filter_by(airwaybill_no=awb, logistics_provider_id = provider_id).first()
             continue
             #raise TransactionServiceException(103, "No order found for the awb:" + awb)
         order.status = OrderStatus.FIRST_DELIVERY_ATTEMPT_MADE
         order.first_dlvyatmp_timestamp, reason = detail.split('|')
         order.statusDescription = reason
+        try:
+            monitoredEntity = MonitoredEntity();
+            monitoredEntity.entityType=EntityType.COURIER;
+            monitoredEntity.eventType=OrderStatus.FIRST_DELIVERY_ATTEMPT_MADE
+            monitoredEntity.entityIdentifier="orderId = " + str(order.id);
+            seconds_epoch = time.time()
+            #Warn alert time is taken as 15 hrs
+            warn_time = (seconds_epoch+24*3600)*1000
+            #Critical alert time is taken as 25 hrs
+            critical_time = (seconds_epoch+36*3600)*1000
+            monitoredEntity.warnExpiryTime = warn_time
+            monitoredEntity.criticalExpiryTime = critical_time
+            monitoredEntity.description="providerId = " + str(provider_id) + " first attempt timestamp" + order.first_dlvyatmp_timestamp
+            alert_client = AlertClient().get_client()
+            alert_client.updateMonitoredObject(monitoredEntity)
+        except Exception as e:
+            print e
     session.commit()
 def get_orders_not_met_expected_delivery_date():
     current_time = datetime.datetime.now()
     today_datetime = datetime.datetime(current_time.year, current_time.month, current_time.day)

Subversion Repositories SmartDukaan

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