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

 from reportlab.lib.units import inch, mm
 from reportlab.pdfgen.canvas import Canvas
 from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Image, \
     BaseDocTemplate, Frame, PageTemplate, Table, TableStyle
 from reportlab.rl_config import defaultPageSize
-from shop2020.clients.AlertClient import AlertClient
 from shop2020.clients.CRMClient import CRMClient
 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.model.v1.order.impl.model.TelecomCircle import TelecomCircle
 from shop2020.model.v1.order.impl.model.UserWallet import UserWallet
 from shop2020.model.v1.order.impl.model.UserWalletHistory import \
     UserWalletHistory
 from shop2020.model.v1.user.impl.Converters import to_t_address
-from shop2020.thriftpy.alert.ttypes import MonitoredEntity, EntityType
 from shop2020.thriftpy.crm.ttypes import *
 from shop2020.thriftpy.logistics.ttypes import DeliveryType, PickUpType
 from shop2020.thriftpy.model.v1.catalog.ttypes import ItemType, ItemCondition
 from shop2020.thriftpy.model.v1.inventory.ttypes import BillingType, \
     InventoryServiceException, WarehouseType, InventoryType, VatType, ItemInventory, \
             if order == None or order.status not in [OrderStatus.SHIPPED_FROM_WH, OrderStatus.DELIVERED_AT_STORE, OrderStatus.SHIPPED_TO_LOGST, OrderStatus.SHIPPED_TO_DESTINATION_CITY, OrderStatus.REACHED_DESTINATION_CITY, OrderStatus.FIRST_DELIVERY_ATTEMPT_MADE, OrderStatus.DELIVERY_SUCCESS]:
                 return False
             order.status = OrderStatus.RTO_IN_TRANSIT
             order.delivery_timestamp = datetime.datetime.now()
             order.statusDescription = "Order Returned to Origin"
-            try:
-                alert_client = AlertClient().get_client()
-                alert_client.endMonitoringEntity(EntityType.COURIER, "orderId = " + str(order.id))
-            except Exception as e:
-                print "Exception in ending alert in MarkOrderAsRTO method"
-                print e
         update_trust_level(orders[0])
         session.commit()
     else:
         if selectedOrder == None or selectedOrder.status not in [OrderStatus.SHIPPED_FROM_WH, OrderStatus.DELIVERED_AT_STORE, OrderStatus.SHIPPED_TO_LOGST, OrderStatus.SHIPPED_TO_DESTINATION_CITY, OrderStatus.REACHED_DESTINATION_CITY, OrderStatus.FIRST_DELIVERY_ATTEMPT_MADE, OrderStatus.DELIVERY_SUCCESS]:
             return False
         selectedOrder.status = OrderStatus.RTO_IN_TRANSIT
         selectedOrder.delivery_timestamp = datetime.datetime.now()
         selectedOrder.statusDescription = "Order Returned to Origin"
         update_trust_level(selectedOrder)
         session.commit()
-        try:
-            alert_client = AlertClient().get_client()
-            alert_client.endMonitoringEntity(EntityType.COURIER, "orderId = " + str(selectedOrder.id))
-        except Exception as e:
-            print "Exception in ending alert in MarkOrderAsRTO method"
-            print e
     return True
 def get_order(order_id):
     order = Order.get_by(id=order_id)
     if not order:
         orders = Order.query.filter(Order.id.in_(orderIds)).filter_by(warehouse_id = warehouseId, logistics_provider_id = providerId, status = OrderStatus.BILLED).all()
         for order in orders:
             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);
-                adjustedDeliveryDays = adjust_delivery_time(datetime.datetime.now(), 1);
-                sec = datetime.datetime.now()
-                #Warn alert time is taken as 16 hrs
-                warn_time = (sec + timedelta(days=(adjustedDeliveryDays-1)) + timedelta(hours=16))
-                #Critical alert time is taken as 26 hrs
-                critical_time = (sec + timedelta(days=(adjustedDeliveryDays-1)) + timedelta(hours=26))
-                monitoredEntity.warnExpiryTime = int(warn_time.strftime("%s"))*1000
-                monitoredEntity.criticalExpiryTime = int(critical_time.strftime("%s"))*1000
-                monitoredEntity.description="warehouseId = " + str(warehouseId) + " providerId = " + str(providerId) + " orderId = "  + str(order.id);
-                alert_client = AlertClient().get_client()
-                alert_client.scheduleAlert(monitoredEntity)
-            except Exception as e:
-                print "Exception in scheduling alert in ShippedFromWarehouse method"
-                print e
-            '''
             session.commit()
         logisticsTxnIdOrdersMap = {}
         for order in orders:
             if order.logisticsTransactionId:
                 if logisticsTxnIdOrdersMap.has_key(order.logisticsTransactionId):
             if order.status != OrderStatus.SHIPPED_FROM_WH:
                 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);
-                adjustedDeliveryDays = adjust_delivery_time(datetime.datetime.now(), 2);
-                sec = datetime.datetime.now()
-                #Warn alert time is taken as 26 hrs
-                warn_time = (sec + timedelta(days=(adjustedDeliveryDays-2)) + timedelta(hours=26))
-                #Critical alert time is taken as 36 hrs
-                critical_time = (sec + timedelta(days=(adjustedDeliveryDays-1)) + timedelta(hours=36))
-                monitoredEntity.warnExpiryTime = int(warn_time.strftime("%s"))*1000
-                monitoredEntity.criticalExpiryTime = int(critical_time.strftime("%s"))*1000
-                monitoredEntity.description="providerId = " + str(provider_id)
-                alert_client = AlertClient().get_client()
-                alert_client.updateMonitoredObject(monitoredEntity)
-            except Exception as e:
-                print "Exception in updating alert in MarkOrdersAsPickedUp method"
-                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)
                 order.first_dlvyatmp_timestamp = order.delivery_timestamp
             order.receiver = receiver
             if order.pickupStoreId:
                 order.status = OrderStatus.DELIVERED_AT_STORE
                 order.statusDescription = "Order delivered At Store"
-                try:
-                    monitoredEntity = MonitoredEntity();
-                    monitoredEntity.entityType=EntityType.COURIER;
-                    monitoredEntity.eventType=OrderStatus.DELIVERED_AT_STORE;
-                    monitoredEntity.entityIdentifier="orderId = " + str(order.id);
-                    #adjustedDeliveryDays = adjust_delivery_time(datetime.datetime.now(), 1);
-                    sec = datetime.datetime.now()
-                    #Critical alert time is taken as 26 hrs
-                    critical_time = (sec + timedelta(hours=4))
-                    monitoredEntity.criticalExpiryTime = int(critical_time.strftime("%s"))*1000
-                    monitoredEntity.description="deliveryTimeAtStore = " + str(order.delivery_timestamp) + " orderId = "  + str(order.id);
-                    alert_client = AlertClient().get_client()
-                    alert_client.updateMonitoredObject(monitoredEntity)
-                except Exception as e:
-                    print e
             else:
                 order.status = OrderStatus.DELIVERY_SUCCESS
                 order.statusDescription = "Order delivered"
                 if order.insuranceDetails:
                     try:
                         return
                 if order.dataInsuranceDetails:
                     order.dataInsuranceDetails[0].startDate = order.delivery_timestamp
                     order.dataInsuranceDetails[0].expiryDate = order.delivery_timestamp + timedelta(days = 90)
-                try:
-                    alert_client = AlertClient().get_client()
-                    alert_client.endMonitoringEntity(EntityType.COURIER, "orderId = " + str(order.id))
-                except Exception as e:
-                    print "Exception in scheduling alert in ShippedFromWarehouse method"
-                    print e
     for logisticsTxnId, ordersList in logisticsTxnIdOrdersMap.iteritems():
         if enqueue_delivery_success_mail(logisticsTxnId, ordersList) :
             order = ordersList[0]
     #        payment_client = PaymentClient().get_client()
     #        payment_client.partiallyCapturePayment(order.transaction.id, order.total_amount, xferBy, xferTxnId, now())
     #        order.cod_reconciliation_timestamp = datetime.datetime.now()
     #        session.commit()
-        try:
-            alert_client = AlertClient().get_client()
-            alert_client.endMonitoringEntity(EntityType.COURIER, "orderId = " + str(order.id))
-        except Exception as e:
-            print "Exception in ending alert in MarkOrderAsDelivered method"
-            print e
     update_trust_level(grouppedOrdersList[0])
     session.commit()
 def mark_order_as_received_at_store(orderId, deliveryTimestamp):
         order.status = OrderStatus.RECEIVED_AT_STORE
         order.statusDescription = "Order received at store"
         order.delivery_timestamp = deliveryTimestamp
     session.commit()
     try:
-        alert_client = AlertClient().get_client()
-        alert_client.endMonitoringEntity(EntityType.COURIER, "orderId = " + str(order.id))
-    except Exception as e:
-        print e
-    try:
         enqueue_received_at_store_email(order)
     except Exception as e:
         print e
                 continue
                 #raise TransactionServiceException(103, "No order found for the awb:" + awb)
             order.status = OrderStatus.RTO_IN_TRANSIT
             order.delivery_timestamp, reason = detail.split('|')
             order.statusDescription = "Order Returned to Origin:" + reason
-            try:
-                alert_client = AlertClient().get_client()
-                alert_client.endMonitoringEntity(EntityType.COURIER, "orderId = " + str(order.id))
-            except Exception as e:
-                print "Exception in ending alert in MarkOrderAsRTO method"
-                print e
         update_trust_level(orders[0])
         session.commit()
 def get_rto_orders(provider_id):
     current_time = datetime.datetime.now()
                 continue
             order.status = OrderStatus.SHIPPED_TO_DESTINATION_CITY
             order.statusDescription = "Left Out of Origin City"
             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);
-                sec = datetime.datetime.now()
-                #Warn alert time is taken as 14 hrs less than expected delivery time
-                warn_time1 = (order.expected_delivery_time-timedelta(hours = 14))
-                warn_time2 = sec + timedelta(order.expected_delivery_time - order.expected_shipping_timestamp) - timedelta(sec - order.shipping_time)
-                warn_time = max(warn_time1, warn_time2)
-                #Critical alert time is taken as 13 hrs less than promised delivery time
-                critical_time1 = (order.expected_delivery_time-timedelta(hours = 10))
-                critical_time2  = sec + timedelta(order.expected_delivery_time - order.expected_shipping_timestamp) - timedelta(sec - order.shipping_time) + timedelta(hours = 5)
-                critical_time = max(critical_time1, critical_time2)
-                monitoredEntity.warnExpiryTime = int(warn_time.strftime("%s"))*1000
-                monitoredEntity.criticalExpiryTime = int(critical_time.strftime("%s"))*1000
-                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 "Exception in updating alert in MarkOrderAsLocalConnected method"
-                print e
             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)
                 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);
-                sec = datetime.datetime.now()
-                #Warn alert time is taken as expected delivery time
-                warn_time1 = (order.expected_delivery_time)
-                warn_time2 = sec + timedelta(order.expected_delivery_time - order.expected_shipping_time) - timedelta(sec - order.shipping_time)
-                warn_time = max(warn_time1, warn_time2)
-                #Critical alert time is taken as 13 hrs less than promised delivery time
-                critical_time1 = (order.expected_delivery_time + timedelta(hours = 5))
-                critical_time2  = sec + timedelta(order.expected_delivery_time - order.expected_shipping_time) - timedelta(sec - order.shipping_time) + timedelta(hours = 5)
-                critical_time = max(critical_time1, critical_time2)
-                monitoredEntity.warnExpiryTime = int(warn_time.strftime("%s"))*1000
-                monitoredEntity.criticalExpiryTime = int(critical_time.strftime("%s"))*1000
-                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 "Exception in updating alert in MarkOrderAsDestCityReached method"
-                print e
         session.commit()
 def mark_orders_as_firstDeliveryAttempted(provider_id, first_atdl_orders):
     for awb, detail in first_atdl_orders.iteritems():
         orders = None
                 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);
-                adjustedDeliveryDaysfor1day = adjust_delivery_time(datetime.datetime.now(), 1);
-                adjustedDeliveryDaysfor2days = adjust_delivery_time(datetime.datetime.now(), 2);
-                sec = datetime.datetime.now()
-                #Warn alert time is taken as 16 hrs
-                warn_time = (sec + timedelta(days=(adjustedDeliveryDaysfor1day-1)) + timedelta(hours=24))
-                #Critical alert time is taken as 26 hrs
-                critical_time = (sec + timedelta(days=(adjustedDeliveryDaysfor2days-2)) + timedelta(hours=48))
-                monitoredEntity.warnExpiryTime = int(warn_time.strftime("%s"))*1000
-                monitoredEntity.criticalExpiryTime = int(critical_time.strftime("%s"))*1000
-                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 "Exception in updating alert in MarkOrdersAsFirstDeliveryAttempted method"
-                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 35718 → 35734