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

             attr.value = attribute.value
     session.commit()
 def mark_orders_as_picked_up(provider_id, pickup_details):
     for awb, pickup_timestamp in pickup_details.iteritems():
+        orders = []
-        order = Order.query.filter_by(airwaybill_no=awb, logistics_provider_id = provider_id).first()
+        orders = Order.query.filter_by(airwaybill_no=awb, logistics_provider_id = provider_id).all()
-        if order == None or order.status != OrderStatus.SHIPPED_FROM_WH:
+        if orders == None or len(orders) ==0:
-            #raise TransactionServiceException(102, "No order found for the awb: " + awb)
             continue
+        for order in orders:
+            if order.status != OrderStatus.SHIPPED_FROM_WH:
+                continue
-        order.status = OrderStatus.SHIPPED_TO_LOGST
+            order.status = OrderStatus.SHIPPED_TO_LOGST
-        order.statusDescription = "Order picked up by Courier Company"
+            order.statusDescription = "Order picked up by Courier Company"
-        order.pickup_timestamp = pickup_timestamp
+            order.pickup_timestamp = pickup_timestamp
-        try:
+            try:
-            monitoredEntity = MonitoredEntity();
+                monitoredEntity = MonitoredEntity();
-            monitoredEntity.entityType=EntityType.COURIER;
+                monitoredEntity.entityType=EntityType.COURIER;
-            monitoredEntity.eventType=OrderStatus.SHIPPED_TO_LOGST
+                monitoredEntity.eventType=OrderStatus.SHIPPED_TO_LOGST
-            monitoredEntity.entityIdentifier="orderId = " + str(order.id);
+                monitoredEntity.entityIdentifier="orderId = " + str(order.id);
-            adjustedDeliveryDays = adjust_delivery_time(datetime.datetime.now(), 2);
+                adjustedDeliveryDays = adjust_delivery_time(datetime.datetime.now(), 2);
-            sec = datetime.datetime.now()
+                sec = datetime.datetime.now()
-            #Warn alert time is taken as 26 hrs
+                #Warn alert time is taken as 26 hrs
-            warn_time = (sec + timedelta(days=(adjustedDeliveryDays-2)) + timedelta(hours=26))
+                warn_time = (sec + timedelta(days=(adjustedDeliveryDays-2)) + timedelta(hours=26))
-            #Critical alert time is taken as 36 hrs
+                #Critical alert time is taken as 36 hrs
-            critical_time = (sec + timedelta(days=(adjustedDeliveryDays-1)) + timedelta(hours=36))
+                critical_time = (sec + timedelta(days=(adjustedDeliveryDays-1)) + timedelta(hours=36))
-            monitoredEntity.warnExpiryTime = int(warn_time.strftime("%s"))*1000
+                monitoredEntity.warnExpiryTime = int(warn_time.strftime("%s"))*1000
-            monitoredEntity.criticalExpiryTime = int(critical_time.strftime("%s"))*1000
+                monitoredEntity.criticalExpiryTime = int(critical_time.strftime("%s"))*1000
-            monitoredEntity.description="providerId = " + str(provider_id)
+                monitoredEntity.description="providerId = " + str(provider_id)
-            alert_client = AlertClient().get_client()
+                alert_client = AlertClient().get_client()
-            alert_client.updateMonitoredObject(monitoredEntity)
+                alert_client.updateMonitoredObject(monitoredEntity)
-        except Exception as e:
+            except Exception as e:
-            print "Exception in updating alert in MarkOrdersAsPickedUp method"
+                print "Exception in updating alert in MarkOrdersAsPickedUp method"
-            print 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)
     orders_not_picked_up = Order.query.filter_by(logistics_provider_id = provider_id).filter_by(status=OrderStatus.SHIPPED_FROM_WH).filter(Order.shipping_timestamp <= to_datetime).all()
     return orders_not_picked_up
 def mark_orders_as_delivered(provider_id, delivered_orders):
     for awb, detail in delivered_orders.iteritems():
+        orders = []
-        order = Order.query.filter_by(airwaybill_no=awb, logistics_provider_id = provider_id).first()
+        orders = Order.query.filter_by(airwaybill_no=awb, logistics_provider_id = provider_id).all()
-        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]:
+        if orders == None or len(orders) ==0:
             continue
+        for order in orders:
+            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]:
+                continue
-        timestamp, receiver = detail.split('|')
+            timestamp, receiver = detail.split('|')
-        order.delivery_timestamp = datetime.datetime.strptime(timestamp, "%Y-%m-%d %H:%M:%S")
+            order.delivery_timestamp = datetime.datetime.strptime(timestamp, "%Y-%m-%d %H:%M:%S")
-        if order.first_dlvyatmp_timestamp is None:
+            if order.first_dlvyatmp_timestamp is None:
-            order.first_dlvyatmp_timestamp = order.delivery_timestamp
+                order.first_dlvyatmp_timestamp = order.delivery_timestamp
-        order.receiver = receiver
+            order.receiver = receiver
-        if order.pickupStoreId:
+            if order.pickupStoreId:
-            order.status = OrderStatus.DELIVERED_AT_STORE
+                order.status = OrderStatus.DELIVERED_AT_STORE
-            order.statusDescription = "Order 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"
-            update_trust_level(order)
-            if order.insuranceDetails:
                 try:
-                    update_insurance_details(order)
+                    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);
-                except:
+                    sec = datetime.datetime.now()
-                    print "Error generating insurance file for order " + str(order.id)
+                    #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)
-                    session.rollback()
+                except Exception as e:
-                    return
+                    print e
+            else:
+                order.status = OrderStatus.DELIVERY_SUCCESS
+                order.statusDescription = "Order delivered"
+                update_trust_level(order)
-            if order.dataInsuranceDetails:
+                if order.insuranceDetails:
+                    try:
-                order.dataInsuranceDetails[0].startDate = order.delivery_timestamp
+                        update_insurance_details(order)
+                    except:
-                order.dataInsuranceDetails[0].expiryDate = order.delivery_timestamp + timedelta(days = 90)
+                        print "Error generating insurance file for order " + str(order.id)
+                        session.rollback()
+                        return
+                if order.dataInsuranceDetails:
+                    order.dataInsuranceDetails[0].startDate = order.delivery_timestamp
+                    order.dataInsuranceDetails[0].expiryDate = order.delivery_timestamp + timedelta(days = 90)
-            if enqueue_delivery_success_mail(order) :
+                if enqueue_delivery_success_mail(order) :
-                session.commit()
+                    session.commit()
-            else :
+                else :
-                session.rollback()
+                    session.rollback()
-            try:
+                try:
-                alert_client = AlertClient().get_client()
+                    alert_client = AlertClient().get_client()
-                alert_client.endMonitoringEntity(EntityType.COURIER, "orderId = " + str(order.id))
+                    alert_client.endMonitoringEntity(EntityType.COURIER, "orderId = " + str(order.id))
-            except Exception as e:
+                except Exception as e:
-                print "Exception in scheduling alert in ShippedFromWarehouse method"
+                    print "Exception in scheduling alert in ShippedFromWarehouse method"
-                print e
+                    print e
 def update_insurance_details(order):
     order.insuranceDetails[0].startDate = order.delivery_timestamp
     order.insuranceDetails[0].expiryDate = order.delivery_timestamp + timedelta(days = 365)
     filename = "/tmp/" + str(order.id) + "-insurance-policy.pdf"
     doc.docType = 1
     doc.docSource = order.id
     doc.document = pdfFile
 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]:
-        raise TransactionServiceException(101, "Either wrong order id or invalid state " + str(orderId))
-    # Provider is 4 is for self pickup and hardcoded. We should figure out a way to not to hard code.
-    if order.status == OrderStatus.BILLED and order.logistics_provider_id != 4:
-        raise TransactionServiceException(101, "Order is not marked for self pickup: " + str(orderId))
-    if 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.RTO_IN_TRANSIT, OrderStatus.BILLED, OrderStatus.RECEIVED_AT_STORE]:
+    singleOrder = Order.get_by(id=orderId)
-        order.delivery_timestamp = deliveryTimestamp
-        if order.first_dlvyatmp_timestamp is None:
-            order.first_dlvyatmp_timestamp = deliveryTimestamp
-        order.receiver = receiver
-    order.status = OrderStatus.DELIVERY_SUCCESS
-    order.statusDescription = "Order delivered"
-    update_trust_level(order)
-    if order.insuranceDetails:
-        try:
-            update_insurance_details(order)
-        except:
-            print "Error generating insurance file for order " + str(order.id)
-            session.rollback()
-            return
-    if order.dataInsuranceDetails:
-        order.dataInsuranceDetails[0].startDate = order.delivery_timestamp
-        order.dataInsuranceDetails[0].expiryDate = order.delivery_timestamp + timedelta(days = 90)
-    if order.source == 2:
+    grouppedOrdersList = []
-        sod = StoreOrderDetail.get_by(orderId = order.id)
-        sod.payStatus = StorePaymentStatus.FULL_PAY_RECEIVED
-    session.commit()
-    if order.pickupStoreId and order.cod:
+    if singleOrder.logisticsTransactionId:
-        __push_collection_to_hotspot(order, "SALE")
+        grouppedOrdersList = get_group_orders_by_logistics_txn_id(singleOrder.logisticsTransactionId)
+    else:
-    enqueue_delivery_success_mail(order)
+        grouppedOrdersList.append(singleOrder)
-#    if order.pickupStoreId:
-#        payment_client = PaymentClient().get_client()
-#        payment_client.createRefund(order.id, order.transaction.id, order.total_amount)
-#        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()
+    for order in grouppedOrdersList:
-    try:
+        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]:
+            raise TransactionServiceException(101, "Either wrong order id or invalid state " + str(orderId))
+        # Provider is 4 is for self pickup and hardcoded. We should figure out a way to not to hard code.
+        if order.status == OrderStatus.BILLED and order.logistics_provider_id != 4:
+            raise TransactionServiceException(101, "Order is not marked for self pickup: " + str(orderId))
+        if 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.RTO_IN_TRANSIT, OrderStatus.BILLED, OrderStatus.RECEIVED_AT_STORE]:
+            order.delivery_timestamp = deliveryTimestamp
+            if order.first_dlvyatmp_timestamp is None:
+                order.first_dlvyatmp_timestamp = deliveryTimestamp
+            order.receiver = receiver
+        order.status = OrderStatus.DELIVERY_SUCCESS
+        order.statusDescription = "Order delivered"
+        update_trust_level(order)
+        if order.insuranceDetails:
+            try:
+                update_insurance_details(order)
+            except:
+                print "Error generating insurance file for order " + str(order.id)
+                session.rollback()
+                return
+        if order.dataInsuranceDetails:
+            order.dataInsuranceDetails[0].startDate = order.delivery_timestamp
+            order.dataInsuranceDetails[0].expiryDate = order.delivery_timestamp + timedelta(days = 90)
+        if order.source == 2:
+            sod = StoreOrderDetail.get_by(orderId = order.id)
+            sod.payStatus = StorePaymentStatus.FULL_PAY_RECEIVED
+        session.commit()
+        if order.pickupStoreId and order.cod:
+            __push_collection_to_hotspot(order, "SALE")
+        enqueue_delivery_success_mail(order)
+    #    if order.pickupStoreId:
+    #        payment_client = PaymentClient().get_client()
+    #        payment_client.createRefund(order.id, order.transaction.id, order.total_amount)
+    #        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 = AlertClient().get_client()
-        alert_client.endMonitoringEntity(EntityType.COURIER, "orderId = " + str(order.id))
+            alert_client.endMonitoringEntity(EntityType.COURIER, "orderId = " + str(order.id))
-    except Exception as e:
+        except Exception as e:
-        print "Exception in ending alert in MarkOrderAsDelivered method"
+            print "Exception in ending alert in MarkOrderAsDelivered method"
-        print 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]:
 def mark_orders_as_rto(provider_id, returned_orders):
     for awb, detail in returned_orders.iteritems():
+        orders = None
-        order = Order.query.filter_by(airwaybill_no=awb, logistics_provider_id = provider_id).first()
+        orders = Order.query.filter_by(airwaybill_no=awb, logistics_provider_id = provider_id).all()
-        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]:
+        if orders == None or len(orders)==0:
             continue
+        for order in orders:
+            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]:
+                continue
-            #raise TransactionServiceException(103, "No order found for the awb:" + awb)
+                #raise TransactionServiceException(103, "No order found for the awb:" + awb)
-        order.status = OrderStatus.RTO_IN_TRANSIT
+            order.status = OrderStatus.RTO_IN_TRANSIT
-        order.delivery_timestamp, reason = detail.split('|')
+            order.delivery_timestamp, reason = detail.split('|')
-        order.statusDescription = "Order Returned to Origin:" + reason
+            order.statusDescription = "Order Returned to Origin:" + reason
-        update_trust_level(order)
+            update_trust_level(order)
-    session.commit()
+            session.commit()
-    try:
+            try:
-        alert_client = AlertClient().get_client()
+                alert_client = AlertClient().get_client()
-        alert_client.endMonitoringEntity(EntityType.COURIER, "orderId = " + str(order.id))
+                alert_client.endMonitoringEntity(EntityType.COURIER, "orderId = " + str(order.id))
-    except Exception as e:
+            except Exception as e:
-        print "Exception in ending alert in MarkOrderAsRTO method"
+                print "Exception in ending alert in MarkOrderAsRTO method"
-        print 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()
     orders_not_delivered = Order.query.filter_by(logistics_provider_id = provider_id).filter(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))).filter(or_(Order.shipping_timestamp <= upto_datetime, Order.pickup_timestamp <= upto_datetime)).all()
     return orders_not_delivered
 def mark_orders_as_local_connected(provider_id, local_connected_orders):
     for awb, timestamp in local_connected_orders.iteritems():
+        orders = None
-        order = Order.query.filter_by(airwaybill_no=awb, logistics_provider_id = provider_id).first()
+        orders = Order.query.filter_by(airwaybill_no=awb, logistics_provider_id = provider_id).all()
-        if order == None or order.status not in [OrderStatus.SHIPPED_FROM_WH, OrderStatus.SHIPPED_TO_LOGST]:
+        if orders == None or len(orders)==0:
-            #raise TransactionServiceException(102, "No order found for the awb: " + awb)
             continue
+        for order in orders:
+            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.status = OrderStatus.SHIPPED_TO_DESTINATION_CITY
-        order.statusDescription = "Left Out of Origin City"
+            order.statusDescription = "Left Out of Origin City"
-        current_time = datetime.datetime.now()
+            current_time = datetime.datetime.now()
-        order.local_connected_timestamp = datetime.datetime(current_time.year, current_time.month, current_time.day)
+            order.local_connected_timestamp = datetime.datetime(current_time.year, current_time.month, current_time.day)
-        try:
+            try:
-            monitoredEntity = MonitoredEntity();
+                monitoredEntity = MonitoredEntity();
-            monitoredEntity.entityType=EntityType.COURIER;
+                monitoredEntity.entityType=EntityType.COURIER;
-            monitoredEntity.eventType=OrderStatus.SHIPPED_TO_DESTINATION_CITY
+                monitoredEntity.eventType=OrderStatus.SHIPPED_TO_DESTINATION_CITY
-            monitoredEntity.entityIdentifier="orderId = " + str(order.id);
+                monitoredEntity.entityIdentifier="orderId = " + str(order.id);
-            sec = datetime.datetime.now()
+                sec = datetime.datetime.now()
-            #Warn alert time is taken as 14 hrs less than expected delivery time
+                #Warn alert time is taken as 14 hrs less than expected delivery time
-            warn_time1 = (order.expected_delivery_time-timedelta(hours = 14))
+                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_time2 = sec + timedelta(order.expected_delivery_time - order.expected_shipping_timestamp) - timedelta(sec - order.shipping_time)
-            warn_time = max(warn_time1, warn_time2)
+                warn_time = max(warn_time1, warn_time2)
-            #Critical alert time is taken as 13 hrs less than promised delivery time
+                #Critical alert time is taken as 13 hrs less than promised delivery time
-            critical_time1 = (order.expected_delivery_time-timedelta(hours = 10))
+                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_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)
+                critical_time = max(critical_time1, critical_time2)
-            monitoredEntity.warnExpiryTime = int(warn_time.strftime("%s"))*1000
+                monitoredEntity.warnExpiryTime = int(warn_time.strftime("%s"))*1000
-            monitoredEntity.criticalExpiryTime = int(critical_time.strftime("%s"))*1000
+                monitoredEntity.criticalExpiryTime = int(critical_time.strftime("%s"))*1000
-            monitoredEntity.description="providerId = " + str(provider_id) + " destination city " + order.customer_city
+                monitoredEntity.description="providerId = " + str(provider_id) + " destination city " + order.customer_city
-            alert_client = AlertClient().get_client()
+                alert_client = AlertClient().get_client()
-            alert_client.updateMonitoredObject(monitoredEntity)
+                alert_client.updateMonitoredObject(monitoredEntity)
-        except Exception as e:
+            except Exception as e:
-            print "Exception in updating alert in MarkOrderAsLocalConnected method"
+                print "Exception in updating alert in MarkOrderAsLocalConnected method"
-            print 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()
     return orders_pending_local_connection
 def mark_orders_as_destinationCityReached(provider_id, destination_city_reached_orders):
     for awb, timestamp in destination_city_reached_orders.iteritems():
+        orders = None
-        order = Order.query.filter_by(airwaybill_no=awb, logistics_provider_id = provider_id).first()
+        orders = Order.query.filter_by(airwaybill_no=awb, logistics_provider_id = provider_id).all()
-        if order == None or order.status not in [OrderStatus.SHIPPED_FROM_WH, OrderStatus.SHIPPED_TO_LOGST, OrderStatus.SHIPPED_TO_DESTINATION_CITY]:
+        if orders == None or len(orders)==0:
             continue
+        for order in orders:
+            if order == None or order.status not in [OrderStatus.SHIPPED_FROM_WH, OrderStatus.SHIPPED_TO_LOGST, OrderStatus.SHIPPED_TO_DESTINATION_CITY]:
+                continue
-            #raise TransactionServiceException(103, "No order found for the awb:" + awb)
+                #raise TransactionServiceException(103, "No order found for the awb:" + awb)
-        order.status = OrderStatus.REACHED_DESTINATION_CITY
+            order.status = OrderStatus.REACHED_DESTINATION_CITY
-        order.statusDescription = "Reached Destination City"
+            order.statusDescription = "Reached Destination City"
-        order.reached_destination_timestamp = timestamp
+            order.reached_destination_timestamp = timestamp
-        try:
+            try:
-            monitoredEntity = MonitoredEntity();
+                monitoredEntity = MonitoredEntity();
-            monitoredEntity.entityType=EntityType.COURIER;
+                monitoredEntity.entityType=EntityType.COURIER;
-            monitoredEntity.eventType=OrderStatus.REACHED_DESTINATION_CITY
+                monitoredEntity.eventType=OrderStatus.REACHED_DESTINATION_CITY
-            monitoredEntity.entityIdentifier="orderId = " + str(order.id);
+                monitoredEntity.entityIdentifier="orderId = " + str(order.id);
-            sec = datetime.datetime.now()
+                sec = datetime.datetime.now()
-            #Warn alert time is taken as expected delivery time
+                #Warn alert time is taken as expected delivery time
-            warn_time1 = (order.expected_delivery_time)
+                warn_time1 = (order.expected_delivery_time)
-            warn_time2 = sec + timedelta(order.expected_delivery_time - order.expected_shipping_timestamp) - timedelta(sec - order.shipping_time)
+                warn_time2 = sec + timedelta(order.expected_delivery_time - order.expected_shipping_timestamp) - timedelta(sec - order.shipping_time)
-            warn_time = max(warn_time1, warn_time2)
+                warn_time = max(warn_time1, warn_time2)
-            #Critical alert time is taken as 13 hrs less than promised delivery time
+                #Critical alert time is taken as 13 hrs less than promised delivery time
-            critical_time1 = (order.expected_delivery_time + timedelta(hours = 5))
+                critical_time1 = (order.expected_delivery_time + timedelta(hours = 5))
-            critical_time2  = sec + timedelta(order.expected_delivery_time - order.expected_shipping_timestamp) - timedelta(sec - order.shipping_time) + timedelta(hours = 5)
+                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)
+                critical_time = max(critical_time1, critical_time2)
-            monitoredEntity.warnExpiryTime = int(warn_time.strftime("%s"))*1000
+                monitoredEntity.warnExpiryTime = int(warn_time.strftime("%s"))*1000
-            monitoredEntity.criticalExpiryTime = int(critical_time.strftime("%s"))*1000
+                monitoredEntity.criticalExpiryTime = int(critical_time.strftime("%s"))*1000
-            monitoredEntity.description="providerId = " + str(provider_id) + " destination city " + order.customer_city
+                monitoredEntity.description="providerId = " + str(provider_id) + " destination city " + order.customer_city
-            alert_client = AlertClient().get_client()
+                alert_client = AlertClient().get_client()
-            alert_client.updateMonitoredObject(monitoredEntity)
+                alert_client.updateMonitoredObject(monitoredEntity)
-        except Exception as e:
+            except Exception as e:
-            print "Exception in updating alert in MarkOrderAsDestCityReached method"
+                print "Exception in updating alert in MarkOrderAsDestCityReached method"
-            print e
+                print e
-    session.commit()
+        session.commit()
 def mark_orders_as_firstDeliveryAttempted(provider_id, first_atdl_orders):
     for awb, detail in first_atdl_orders.iteritems():
+        orders = None
-        order = Order.query.filter_by(airwaybill_no=awb, logistics_provider_id = provider_id).first()
+        orders = Order.query.filter_by(airwaybill_no=awb, logistics_provider_id = provider_id).all()
-        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]:
+        if orders == None or len(orders)==0:
             continue
+        for order in orders:
+            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]:
+                continue
-            #raise TransactionServiceException(103, "No order found for the awb:" + awb)
+                #raise TransactionServiceException(103, "No order found for the awb:" + awb)
-        order.status = OrderStatus.FIRST_DELIVERY_ATTEMPT_MADE
+            order.status = OrderStatus.FIRST_DELIVERY_ATTEMPT_MADE
-        order.first_dlvyatmp_timestamp, reason = detail.split('|')
+            order.first_dlvyatmp_timestamp, reason = detail.split('|')
-        order.statusDescription = reason
+            order.statusDescription = reason
-        try:
+            try:
-            monitoredEntity = MonitoredEntity();
+                monitoredEntity = MonitoredEntity();
-            monitoredEntity.entityType=EntityType.COURIER;
+                monitoredEntity.entityType=EntityType.COURIER;
-            monitoredEntity.eventType=OrderStatus.FIRST_DELIVERY_ATTEMPT_MADE
+                monitoredEntity.eventType=OrderStatus.FIRST_DELIVERY_ATTEMPT_MADE
-            monitoredEntity.entityIdentifier="orderId = " + str(order.id);
+                monitoredEntity.entityIdentifier="orderId = " + str(order.id);
-            adjustedDeliveryDaysfor1day = adjust_delivery_time(datetime.datetime.now(), 1);
+                adjustedDeliveryDaysfor1day = adjust_delivery_time(datetime.datetime.now(), 1);
-            adjustedDeliveryDaysfor2days = adjust_delivery_time(datetime.datetime.now(), 2);
+                adjustedDeliveryDaysfor2days = adjust_delivery_time(datetime.datetime.now(), 2);
-            sec = datetime.datetime.now()
+                sec = datetime.datetime.now()
-            #Warn alert time is taken as 16 hrs
+                #Warn alert time is taken as 16 hrs
-            warn_time = (sec + timedelta(days=(adjustedDeliveryDaysfor1day-1)) + timedelta(hours=24))
+                warn_time = (sec + timedelta(days=(adjustedDeliveryDaysfor1day-1)) + timedelta(hours=24))
-            #Critical alert time is taken as 26 hrs
+                #Critical alert time is taken as 26 hrs
-            critical_time = (sec + timedelta(days=(adjustedDeliveryDaysfor2days-2)) + timedelta(hours=48))
+                critical_time = (sec + timedelta(days=(adjustedDeliveryDaysfor2days-2)) + timedelta(hours=48))
-            monitoredEntity.warnExpiryTime = int(warn_time.strftime("%s"))*1000
+                monitoredEntity.warnExpiryTime = int(warn_time.strftime("%s"))*1000
-            monitoredEntity.criticalExpiryTime = int(critical_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
+                monitoredEntity.description="providerId = " + str(provider_id) + " first attempt timestamp" + order.first_dlvyatmp_timestamp
-            alert_client = AlertClient().get_client()
+                alert_client = AlertClient().get_client()
-            alert_client.updateMonitoredObject(monitoredEntity)
+                alert_client.updateMonitoredObject(monitoredEntity)
-        except Exception as e:
+            except Exception as e:
-            print "Exception in updating alert in MarkOrdersAsFirstDeliveryAttempted method"
+                print "Exception in updating alert in MarkOrdersAsFirstDeliveryAttempted method"
-            print e
+                print e
-    session.commit()
+        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)
     orders_not_delivered = Order.query.filter(Order.status.in_((OrderStatus.SHIPPED_FROM_WH, OrderStatus.SHIPPED_TO_LOGST, OrderStatus.SHIPPED_TO_DESTINATION_CITY, OrderStatus.REACHED_DESTINATION_CITY))).filter(Order.expected_delivery_time <= today_datetime).all()
     return orders_not_picked_up
 def receive_return(order_id, receiveCondition, receiveFreebie, serialNumbers):
     order = get_order(order_id)
     scanFreebie = False
+    grouppedOrdersList = []
+    if order.logisticsTransactionId:
+        grouppedOrdersList = get_group_orders_by_logistics_txn_id(order.logisticsTransactionId)
+    else:
+        grouppedOrdersList.append(order)
+    orderCurrentStatus = order.status
     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 == 2:
             order.status = OrderStatus.RET_LOST_IN_TRANSIT
             order.statusDescription = "RETURN lost in transit"
         order.received_return_timestamp = datetime.datetime.now()
     elif order.status == OrderStatus.RTO_IN_TRANSIT :
+        for orderObj in grouppedOrdersList:
-        if receiveCondition == 0:
+            if receiveCondition == 0:
-            order.status = OrderStatus.RTO_RECEIVED_PRESTINE
+                orderObj.status = OrderStatus.RTO_RECEIVED_PRESTINE
-            order.statusDescription = "Returned to origin"
+                orderObj.statusDescription = "Returned to origin"
-            if order.freebieItemId:
+                if orderObj.freebieItemId:
-                scanFreebie = True
+                    scanFreebie = True
-        elif receiveCondition == 1:
+            elif receiveCondition == 1:
-            order.status = OrderStatus.RTO_RECEIVED_DAMAGED
+                orderObj.status = OrderStatus.RTO_RECEIVED_DAMAGED
-            order.statusDescription = "RTO received damaged"
+                orderObj.statusDescription = "RTO received damaged"
-        elif receiveCondition == 2:
+            elif receiveCondition == 2:
-            order.status = OrderStatus.RTO_LOST_IN_TRANSIT
+                orderObj.status = OrderStatus.RTO_LOST_IN_TRANSIT
-            order.statusDescription = "RTO lost in transit"
+                orderObj.statusDescription = "RTO lost in transit"
-        order.received_return_timestamp = datetime.datetime.now()
+            orderObj.received_return_timestamp = datetime.datetime.now()
     else:
         return False
     # For OUR warehouses, we need to scan in items for every return
             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
+        }
+        if orderCurrentStatus == OrderStatus.RTO_IN_TRANSIT:
+            for orderObj in grouppedOrdersList:
-        if scanMap.has_key(order.status):
+                if scanMap.has_key(orderObj.status):
-            scanType = scanMap[order.status]
+                    scanType = scanMap[orderObj.status]
-            lineitem = order.lineitems[0]
+                    lineitem = orderObj.lineitems[0]
-            catalogClient = CatalogClient().get_client()
+                    catalogClient = CatalogClient().get_client()
-            item = catalogClient.getItem(lineitem.item_id)
+                    item = catalogClient.getItem(lineitem.item_id)
-            warehouseClient = WarehouseClient().get_client()
+                    warehouseClient = WarehouseClient().get_client()
-            if warehouse.billingType == BillingType.OURS or scanType != ScanType.SALE_RET:
+                    if warehouse.billingType == BillingType.OURS or scanType != ScanType.SALE_RET:
-                if item.type == ItemType.SERIALIZED:
+                        if item.type == ItemType.SERIALIZED:
-                    if lineitem.quantity > 1:
+                            if lineitem.quantity > 1:
+                                serialNoList = lineitem.serial_number.split(',')
-                        if serialNumbers is None or len(serialNumbers)==0:
+                                for serialNumber in serialNoList:
+                                    warehouseClient.scanSerializedItemForOrder(serialNumber, scanType, orderObj.id, orderObj.fulfilmentWarehouseId, 1, orderObj.warehouse_id)
-                            return False
+                            else:
+                                warehouseClient.scanSerializedItemForOrder(lineitem.serial_number, scanType, orderObj.id, orderObj.fulfilmentWarehouseId, lineitem.quantity, orderObj.warehouse_id)
                         else:
+                            warehouseClient.scanForOrder(None, scanType, lineitem.quantity, orderObj.id, orderObj.fulfilmentWarehouseId, orderObj.warehouse_id)
+                    if warehouse.billingType == BillingType.OURS_EXTERNAL and scanType == ScanType.SALE_RET:
+                        warehouseClient.scanForOursExternalSaleReturn(orderObj.id, lineitem.transfer_price)
+                    if scanFreebie:
+                        warehouseClient.scanfreebie(orderObj.id, orderObj.freebieItemId, 0, scanType)
+        else:
+            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 warehouse.billingType == BillingType.OURS or scanType != ScanType.SALE_RET:
+                    if item.type == ItemType.SERIALIZED:
+                        if lineitem.quantity > 1:
+                            if serialNumbers is None or len(serialNumbers)==0:
+                                return False
+                            else:
-                            serialNoList = serialNumbers.split(',')
+                                serialNoList = serialNumbers.split(',')
-                            for serialNumber in serialNoList:
+                                for serialNumber in serialNoList:
-                                warehouseClient.scanSerializedItemForOrder(serialNumber, scanType, order.id, order.fulfilmentWarehouseId, 1, order.warehouse_id)
+                                    warehouseClient.scanSerializedItemForOrder(serialNumber, scanType, order.id, order.fulfilmentWarehouseId, 1, order.warehouse_id)
+                        else:
+                            warehouseClient.scanSerializedItemForOrder(lineitem.serial_number, scanType, order.id, order.fulfilmentWarehouseId, lineitem.quantity, order.warehouse_id)
                     else:
-                        warehouseClient.scanSerializedItemForOrder(lineitem.serial_number, scanType, order.id, order.fulfilmentWarehouseId, lineitem.quantity, order.warehouse_id)
-                else:
-                    warehouseClient.scanForOrder(None, scanType, lineitem.quantity, order.id, order.fulfilmentWarehouseId, order.warehouse_id)
+                        warehouseClient.scanForOrder(None, scanType, lineitem.quantity, order.id, order.fulfilmentWarehouseId, order.warehouse_id)
-            if warehouse.billingType == BillingType.OURS_EXTERNAL and scanType == ScanType.SALE_RET:
+                if warehouse.billingType == BillingType.OURS_EXTERNAL and scanType == ScanType.SALE_RET:
-                warehouseClient.scanForOursExternalSaleReturn(order.id, lineitem.transfer_price)
+                    warehouseClient.scanForOursExternalSaleReturn(order.id, lineitem.transfer_price)
-            if scanFreebie:
+                if scanFreebie:
-                warehouseClient.scanfreebie(order.id, order.freebieItemId, 0, scanType)
+                    warehouseClient.scanfreebie(order.id, order.freebieItemId, 0, scanType)
     session.commit()
     return True
 def validate_doa(order_id, is_valid):
     warehouse_client = WarehouseClient().get_client()
     catalog_client = CatalogClient().get_client()
     whStateId = None
     lineItemSize = 0
     individualInvoice = True
+    orderscansMap = {}
+    orderInventoryItemMap = {}
+    orderFulfilmentWarehouseMap = {}
     for order in ordersList:
+        scanList = []
+        inventoryItemList = []
         newTaxType = __getOrderTaxType(order)
         if order.taxType == 2:
             if newTaxType == 0:
                 raise TransactionServiceException(302, "C-Form billing is not allowed for same state for Order" + str(order.id))
         else:
         item = catalog_client.getItem(item_id)
         if ItemType.SERIALIZED == item.type and lineitem.quantity>2:
             individualInvoice=False
-        if order.type== OrderType.B2B:
+        if order.orderType== OrderType.B2B:
             individualInvoice=False
         lineItemSize = lineItemSize+1
         if order.status == OrderStatus.ACCEPTED:
                                 raise TransactionServiceException(310, "Trying to scan " + scanItemString + " instead of " + lineItemString+" Order Id- "+order.id)
                             if order.warehouse_id!= invItem[11]:
                                 if warehouseDbConnection.open:
                                     warehouseDbConnection.close()
                                 raise TransactionServiceException(311, "No Item residing in Billing Warehouse with this serial number " + serialNumber+" and Order Id:- "+str(order.id))
+                            if warehouse.id!= invItem[8]:
+                                warehouseDbConnection.rollback()
+                                if warehouseDbConnection.open:
+                                    warehouseDbConnection.close()
+                                raise TransactionServiceException(311, "No Item residing in Billing Warehouse with this serial number " + serialNumber+" in the vendor warehouse Id"+str(order.fulfilmentWarehouseId)+"and Order Id:- "+str(order.id))
                             if invItem[10] is not None and invItem[10]=='IN_TRANSIT':
                                 if warehouseDbConnection.open:
                                     warehouseDbConnection.close()
                                 raise TransactionServiceException(312, "Trying to Scan In-Transit Inventory " + serialNumber+" and Order Id:- "+str(order.id))
                             if invItem[9]=='MARKED_BAD' or invItem[9]=='DOA_IN' or invItem[9]=='DOA_OUT' or invItem[9]=='DOA_REJECTED' or invItem[9]=='SALE_RET_UNUSABLE' or invItem[9]=='BAD_SALE':
                                     warehouseDbConnection.close()
                                 raise TransactionServiceException(316, "Inventory Item scanning from vendor warehouse "+str(invItem[8])+" instead of order fulfillment warehouse "+str(warehouse.id)+" order id- "+str(order.id))
                             current_time = datetime.datetime.now()
                             insertScanSql = "insert into scanNew(inventoryItemId, warehouseId, type, scannedAt, quantity, orderId) values(%d,%d,'%s','%s',%d,%d)"%(invItem[0],warehouse.id,'SALE',current_time.strftime('%Y-%m-%d %H:%M:%S'),1,order.id)
+                            scanList.append(insertScanSql)
-                            whCursor.execute(insertScanSql)
+                            #whCursor.execute(insertScanSql)
                             updateInvItemSql = "update inventoryItem set currentQuantity = currentQuantity-1, lastScanType='SALE' where id=%d and serialnumber ='%s'"%(invItem[0],serialNumber)
+                            inventoryItemList.append(updateInvItemSql)
-                            whCursor.execute(updateInvItemSql)
+                            #whCursor.execute(updateInvItemSql)
                             lineitem.transfer_price = invItem[13]
                             lineitem.nlc = invItem[14]
                             order.vendorId = invItem[12]
-                        if warehouse.billingType == BillingType.OURS:
-                            if not inventory_client.isAlive():
-                                inventory_client = InventoryClient().get_client()
-                            inventory_client.addInventory(item.id, warehouse.id, -1)
                     else:
                         invItemSql = "select i.id, i.itemId, i.itemNumber, i.serialNumber, i.initialQuantity, i.currentQuantity, i.purchaseId, i.purchaseReturnId, i.currentWarehouseId, i.lastScanType, i.transferStatus, physicalWarehouseId, po.supplierId, l.unitPrice, l.nlc from inventoryItem i join purchase p on i.purchaseId = p.id join purchaseorder po on p.purchaseOrder_id = po.id join lineitem l on (i.itemId = l.itemId and po.id =l.purchaseOrder_id) where i.itemId = %d AND i.currentQuantity > 0 AND i.currentWarehouseId = %d AND i.physicalWarehouseId = %d AND i.lastScanType not in ('MARKED_BAD','DOA_IN','DOA_REJECTED','DOA_REPLACED') AND (i.transferStatus is NULL or i.transferStatus != 'IN_TRANSIT') AND i.itemNumber ='%s'"%(item.id,order.fulfilmentWarehouseId,order.warehouse_id,itemNumbers[0])
                         whCursor.execute(invItemSql)
                         invItems = whCursor.fetchall()
                         if invItems is None:
                             raise TransactionServiceException(317, "No Item in the inventory with this item number " + itemNumbers[0]+" in Vendor Warehouse Id- "+str(warehouse.id)+" Order Id:- "+str(order.id))
+                            if warehouseDbConnection.open:
-                            warehouseDbConnection.close()
+                                warehouseDbConnection.close()
                         totalCurrentQuantity =0
                         for invItem in invItems:
                             totalCurrentQuantity = totalCurrentQuantity + invItem[5]
                         orderQuantity = lineitem.quantity
                             else:
                                 break
                             current_time = datetime.datetime.now()
                             insertScanSql = "insert into scanNew(inventoryItemId, warehouseId, type, scannedAt, quantity, orderId) values(%d,%d,'%s','%s',%d,%d)"%(invItem[0],warehouse.id,'SALE',current_time.strftime('%Y-%m-%d %H:%M:%S'),scanQuantity,order.id)
+                            scanList.append(insertScanSql)
-                            whCursor.execute(insertScanSql)
+                            #whCursor.execute(insertScanSql)
                             updateInvItemSql = "update inventoryItem set currentQuantity = currentQuantity-%d, lastScanType='SALE' where id=%d "%(scanQuantity,invItem[0])
+                            inventoryItemList.append(updateInvItemSql)
-                            whCursor.execute(updateInvItemSql)
+                            #whCursor.execute(updateInvItemSql)
                             lineitem.transfer_price = invItem[13]
                             lineitem.nlc = invItem[14]
                             order.vendorId = invItem[12]
-                        if warehouse.billingType == BillingType.OURS:
-                            if not inventory_client.isAlive():
-                                inventory_client = InventoryClient().get_client()
-                            inventory_client.addInventory(item.id, warehouse.id, long(-1.0*lineitem.quantity))
                 else:
                     ''' Bad Serialized '''
                     if not warehouse.billingWarehouseId:
                         if not inventory_client.isAlive():
                             inventory_client = InventoryClient().get_client()
                                 raise TransactionServiceException(110, "Trying to scan " + scanItemString + " instead of " + lineItemString+" Order Id- "+order.id)
                             if order.warehouse_id!= invItem[11]:
                                 if warehouseDbConnection.open:
                                     warehouseDbConnection.close()
                                 raise TransactionServiceException(110, "No Item residing in Billing Warehouse with this serial number " + serialNumber+" and Order Id:- "+str(order.id))
+                            if order.fulfilmentWarehouseId!= invItem[8]:
+                                warehouseDbConnection.rollback()
+                                if warehouseDbConnection.open:
+                                    warehouseDbConnection.close()
+                                raise TransactionServiceException(311, "No Item residing in Billing Warehouse with this serial number " + serialNumber+" in the vendor warehouse Id"+str(order.fulfilmentWarehouseId)+"and Order Id:- "+str(order.id))
                             if invItem[10] is not None and invItem[10]=='IN_TRANSIT':
                                 if warehouseDbConnection.open:
                                     warehouseDbConnection.close()
                                 raise TransactionServiceException(110, "Trying to Scan In-Transit Inventory " + serialNumber+" and Order Id:- "+str(order.id))
                             if invItem[9]!='MARKED_BAD' or invItem[9]!='DOA_IN' or invItem[9]!='DOA_REJECTED' or invItem[9]!='SALE_RET_UNUSABLE':
                                 if warehouseDbConnection.open:
                                     warehouseDbConnection.close()
                                 raise TransactionServiceException(110, "Inventory Item scanning from vendor warehouse "+str(invItem[8])+" instead of order fulfillment warehouse "+str(warehouse.id)+" order id- "+str(order.id))
                             current_time = datetime.datetime.now()
                             insertScanSql = "insert into scanNew(inventoryItemId, warehouseId, type, scannedAt, quantity, orderId) values(%d,%d,'%s','%s',%d,%d)"%(invItem[0],warehouse.id,'BAD_SALE',current_time.strftime('%Y-%m-%d %H:%M:%S'),1,order.id)
+                            scanList.append(insertScanSql)
-                            whCursor.execute(insertScanSql)
+                            #whCursor.execute(insertScanSql)
                             updateInvItemSql = "update inventoryItem set currentQuantity = currentQuantity-1, lastScanType='BAD_SALE' where id=%d and serialnumber ='%s'"%(invItem[0],serialNumber)
+                            inventoryItemList.append(updateInvItemSql)
-                            whCursor.execute(updateInvItemSql)
+                            #whCursor.execute(updateInvItemSql)
                             lineitem.transfer_price = invItem[13]
                             lineitem.nlc = invItem[14]
                             order.vendorId = invItem[12]
                             else:
                                 break
                             current_time = datetime.datetime.now()
                             insertScanSql = "insert into scanNew(inventoryItemId, warehouseId, type, scannedAt, quantity, orderId) values(%d,%d,'%s','%s',%d,%d)"%(invItem[0],warehouse.id,'BAD_SALE',current_time.strftime('%Y-%m-%d %H:%M:%S'),scanQuantity,order.id)
+                            scanList.append(insertScanSql)
-                            whCursor.execute(insertScanSql)
+                            #whCursor.execute(insertScanSql)
                             updateInvItemSql = "update inventoryItem set currentQuantity = currentQuantity-%d, lastScanType='BAD_SALE' where id=%d "%(scanQuantity,invItem[0])
-                            whCursor.execute(updateInvItemSql)
+                            inventoryItemList.append(updateInvItemSql)
+                            #whCursor.execute(updateInvItemSql)
                             lineitem.transfer_price = invItem[13]
                             lineitem.nlc = invItem[14]
                             order.vendorId = invItem[12]
             else:
                 if not warehouse.isAvailabilityMonitored:
                     if not inventory_client.isAlive():
                         inventory_client = InventoryClient().get_client()
                     inventory_client.addInventory(item.id, warehouse.id, -1 * lineitem.quantity)
-            if order.freebieItemId:
-                inventoryItem = None
-                for freebieWhId in freebieWarehouseIdMap.get(order.id):
-                    try:
+            orderscansMap[order.id] = scanList
-                        warehouse_client = WarehouseClient().get_client()
+            orderInventoryItemMap[order.id] = inventoryItemList
-                        inventoryItem = warehouse_client.scanfreebie(orderId, order.freebieItemId, freebieWhId, ScanType.SALE);
-                    except Exception as e:
+            orderFulfilmentWarehouseMap[order.id] = warehouse
-                        print e.message
-                        raise TransactionServiceException(110,'Error in billing freebie for warehouseId ' + str(freebieWarehouseId))
-                attr = Attribute()
+    for order in ordersList:
-                attr.orderId = orderId
+        if billingType == BillingType.OURS:
-                attr.name = "freebie_tp"
+            scanList = orderscansMap.get(order.id)
-                attr.value = str(inventoryItem.unitPrice)
+            inventoryItemList = orderInventoryItemMap.get(order.id)
-                attr1 = Attribute()
+            fulfillmentWarehouse = orderFulfilmentWarehouseMap.get(order.id)
-                attr1.orderId = orderId
+            lineItem = order.lineitems[0]
-                attr1.name = "freebie_vendor"
-                attr1.value = str(inventoryItem.supplierId)
+            whCursor = warehouseDbConnection.cursor()
-                attr2 = Attribute()
-                attr2.orderId = orderId
+            for scan in scanList:
-                attr2.name = "freebie_nlc"
+                whCursor.execute(scan)
-                attr2.value = str(inventoryItem.nlc)
+            for invItem in inventoryItemList:
-            if order.productCondition != ProductCondition.BAD:
+                whCursor.execute(invItem)
-                '''
-                Reduce the reservation count for all line items of the given order.
+            if order.productCondition != ProductCondition.BAD:
-                '''
-                try:
+                if fulfillmentWarehouse.billingType == BillingType.OURS:
                     if not inventory_client.isAlive():
                         inventory_client = InventoryClient().get_client()
+                    inventory_client.addInventory(lineItem.item_id, fulfillmentWarehouse.id, long(-1.0*lineItem.quantity))
+        if order.freebieItemId:
+            inventoryItem = None
+            for freebieWhId in freebieWarehouseIdMap.get(order.id):
+                try:
+                    warehouse_client = WarehouseClient().get_client()
+                    inventoryItem = warehouse_client.scanfreebie(orderId, order.freebieItemId, freebieWhId, ScanType.SALE);
+                except Exception as e:
+                    print e.message
+                    raise TransactionServiceException(110,'Error in billing freebie for warehouseId ' + str(freebieWarehouseId))
+            attr = Attribute()
+            attr.orderId = orderId
+            attr.name = "freebie_tp"
+            attr.value = str(inventoryItem.unitPrice)
+            attr1 = Attribute()
+            attr1.orderId = orderId
+            attr1.name = "freebie_vendor"
+            attr1.value = str(inventoryItem.supplierId)
+            attr2 = Attribute()
+            attr2.orderId = orderId
+            attr2.name = "freebie_nlc"
+            attr2.value = str(inventoryItem.nlc)
+        if order.productCondition != ProductCondition.BAD:
+            '''
+            Reduce the reservation count for all line items of the given order.
+            '''
+            try:
+                if not inventory_client.isAlive():
+                    inventory_client = InventoryClient().get_client()
-                    for lineitem in order.lineitems:
+                for lineitem in order.lineitems:
-                        inventory_client.reduceReservationCount(lineitem.item_id, order.fulfilmentWarehouseId, sourceId, order.id, lineitem.quantity)
+                    inventory_client.reduceReservationCount(lineitem.item_id, order.fulfilmentWarehouseId, sourceId, order.id, lineitem.quantity)
-                except:
+            except:
-                    print "Unable to reduce reservation count"
+                print "Unable to reduce reservation count"
     warehouseDbConnection.commit()
     if warehouseDbConnection.open:
         warehouseDbConnection.close()
     session.commit()
         invoiceNumber = get_next_invoice_counter(ordersList[0].orderType, whStateId)
     invoiceTypeVal = 1
     if not individualInvoice:
         invoiceTypeVal = 2
-    if lineItemSize >20:
+    if lineItemSize > 1:
         invoiceTypeVal = 2
-    if lineItemSize < 20 and invoiceType =="BulkInvoice" :
+    if lineItemSize <= 1 and invoiceType =="BulkInvoice" :
         invoiceTypeVal = 2
     transactionShipSeqValues = ordersList[0].logisticsTransactionId.split('-')
     txnShipSeq = TransactionShipmentSequence.query.filter(TransactionShipmentSequence.transactionId==int(transactionShipSeqValues[0])).filter(TransactionShipmentSequence.sequence==int(transactionShipSeqValues[1])).order_by(desc(TransactionShipmentSequence.id)).first()

Subversion Repositories SmartDukaan

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