WebSVN – SmartDukaan – Diff – /trunk/PyProj/src/shop2020/thriftpy/model/v1/order/TransactionService.py

      - invoiceNumber
      - color
     """
     pass
-  def markOrdersAsManifested(self, warehouseId, providerId, cod):
+  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
     """
     Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
-    given warehouse and were picked up by the given provider as MANIFESTED.
+    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
     Parameters:
      - warehouseId
      - providerId
      - cod
+     - orderIds
     """
     pass
-  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
+  def markOrdersAsPickedUp(self, providerId, pickupDetails):
     """
-    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
+    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
-    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
+    Raises an exception if we encounter report for an AWB number that we did not ship.
     Parameters:
-     - warehouseId
      - providerId
-     - cod
-     - orderIds
+     - pickupDetails
     """
     pass
-  def markOrdersAsPickedUp(self, providerId, pickupDetails):
+  def getOrdersNotPickedUp(self, providerId):
     """
-    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
     Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
-    Raises an exception if we encounter report for an AWB number that we did not ship.
     Parameters:
      - providerId
-     - pickupDetails
     """
     pass
   def markOrdersAsDelivered(self, providerId, deliveredOrders):
     """
      - providerId
      - deliveredOrders
     """
     pass
-  def markOrdersAsFailed(self, providerId, returnedOrders):
+  def markAsRTOrders(self, providerId, returnedOrders):
     """
-    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
+    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
     Raises an exception if we encounter report for an AWB number that we did not ship.
     Parameters:
      - providerId
      - returnedOrders
     """
     pass
+  def getRTOrders(self, providerId):
+    """
+    Returns a list of orders that were returned by courier.
+    Parameters:
+     - providerId
+    """
+    pass
   def updateNonDeliveryReason(self, providerId, undeliveredOrders):
     """
     Update the status description of orders whose AWB numbers are keys of the Map.
-    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
     Parameters:
      - providerId
      - undeliveredOrders
     """
     pass
+  def getNonDeliveredOrdersbyCourier(self, providerId):
+    """
+    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
+    Parameters:
+     - providerId
+    """
+    pass
+  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
+    """
+    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
+    Parameters:
+     - providerId
+     - local_connected_orders
+    """
+    pass
+  def getOrdersNotLocalConnected(self, providerId):
+    """
+    Returns a list of orders that were picked up or shipped but pending local connection.
+    Parameters:
+     - providerId
+    """
+    pass
+  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
+    """
+    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
+    Parameters:
+     - providerId
+     - destination_city_reached_orders
+    """
+    pass
+  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
+    """
+    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
+    Parameters:
+     - providerId
+     - first_atdl_orders
+    """
+    pass
   def getUndeliveredOrders(self, providerId, warehouseId):
     """
     Returns the list of orders whose delivery time has passed but have not been
     delivered yet for the given provider and warehouse. To get a complete list of
     undelivered orders, pass them as -1.
     pass
   def markDoasAsPickedUp(self, providerId, pickupDetails):
     """
     Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
-    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
     Parameters:
      - providerId
      - pickupDetails
     """
     pass
+  def getDoasNotPickedUp(self, providerId):
+    """
+    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
+    Parameters:
+     - providerId
+    """
+    pass
   def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
     """
     Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
-    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
     Parameters:
      - providerId
      - pickupDetails
     """
     pass
+  def getReturnOrdersNotPickedUp(self, providerId):
+    """
+    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
+    Parameters:
+     - providerId
+    """
+    pass
   def receiveReturn(self, orderId, receiveCondition):
     """
     If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
     If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
     If the order is in any other state, it returns false.
     Parameters:
      - awb
     """
     pass
-  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
+  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
     """
-    Returns the order corresponding to a logistics provider id for a given order status
+    Returns the order corresponding to a logistics provider id for a given list of order status
     Parameters:
      - logistics_provider_id
-     - order_status
+     - order_status_list
     """
     pass
   def getBilledOrdersForVendor(self, vendorId, billingDateFrom, billingDateTo):
     """
     self._iprot.readMessageEnd()
     if result.ex is not None:
       raise result.ex
     return
-  def markOrdersAsManifested(self, warehouseId, providerId, cod):
+  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
     """
     Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
-    given warehouse and were picked up by the given provider as MANIFESTED.
+    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
     Parameters:
      - warehouseId
      - providerId
      - cod
+     - orderIds
     """
-    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
+    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
-    return self.recv_markOrdersAsManifested()
+    return self.recv_markOrdersAsShippedFromWarehouse()
-  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
+  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
-    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
-    args = markOrdersAsManifested_args()
+    args = markOrdersAsShippedFromWarehouse_args()
     args.warehouseId = warehouseId
     args.providerId = providerId
     args.cod = cod
+    args.orderIds = orderIds
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_markOrdersAsManifested(self, ):
+  def recv_markOrdersAsShippedFromWarehouse(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = markOrdersAsManifested_result()
+    result = markOrdersAsShippedFromWarehouse_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
     if result.ex is not None:
       raise result.ex
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
-  def markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
+  def markOrdersAsPickedUp(self, providerId, pickupDetails):
     """
-    Depending on the third parameter, marks either all prepaid or all cod orders BILLED and marked as MANIFESTED by the
+    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
-    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
+    Raises an exception if we encounter report for an AWB number that we did not ship.
     Parameters:
-     - warehouseId
      - providerId
-     - cod
-     - orderIds
+     - pickupDetails
     """
-    self.send_markOrdersAsShippedFromWarehouse(warehouseId, providerId, cod, orderIds)
+    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
-    return self.recv_markOrdersAsShippedFromWarehouse()
+    self.recv_markOrdersAsPickedUp()
-  def send_markOrdersAsShippedFromWarehouse(self, warehouseId, providerId, cod, orderIds):
+  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
-    self._oprot.writeMessageBegin('markOrdersAsShippedFromWarehouse', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
-    args = markOrdersAsShippedFromWarehouse_args()
+    args = markOrdersAsPickedUp_args()
-    args.warehouseId = warehouseId
     args.providerId = providerId
-    args.cod = cod
-    args.orderIds = orderIds
+    args.pickupDetails = pickupDetails
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_markOrdersAsShippedFromWarehouse(self, ):
+  def recv_markOrdersAsPickedUp(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = markOrdersAsShippedFromWarehouse_result()
+    result = markOrdersAsPickedUp_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
-    if result.success is not None:
-      return result.success
     if result.ex is not None:
       raise result.ex
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsShippedFromWarehouse failed: unknown result");
+    return
-  def markOrdersAsPickedUp(self, providerId, pickupDetails):
+  def getOrdersNotPickedUp(self, providerId):
     """
-    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
     Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
-    Raises an exception if we encounter report for an AWB number that we did not ship.
     Parameters:
      - providerId
-     - pickupDetails
     """
-    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
+    self.send_getOrdersNotPickedUp(providerId)
-    return self.recv_markOrdersAsPickedUp()
+    return self.recv_getOrdersNotPickedUp()
-  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
+  def send_getOrdersNotPickedUp(self, providerId):
-    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('getOrdersNotPickedUp', TMessageType.CALL, self._seqid)
-    args = markOrdersAsPickedUp_args()
+    args = getOrdersNotPickedUp_args()
     args.providerId = providerId
-    args.pickupDetails = pickupDetails
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_markOrdersAsPickedUp(self, ):
+  def recv_getOrdersNotPickedUp(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = markOrdersAsPickedUp_result()
+    result = getOrdersNotPickedUp_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
-    if result.ex is not None:
-      raise result.ex
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotPickedUp failed: unknown result");
   def markOrdersAsDelivered(self, providerId, deliveredOrders):
     """
     Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
     the name of the receiver.
     self._iprot.readMessageEnd()
     if result.ex is not None:
       raise result.ex
     return
-  def markOrdersAsFailed(self, providerId, returnedOrders):
+  def markAsRTOrders(self, providerId, returnedOrders):
     """
-    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
+    Mark all orders with AWBs in the given map as RTO. Also sets the delivery timestamp.
     Raises an exception if we encounter report for an AWB number that we did not ship.
     Parameters:
      - providerId
      - returnedOrders
     """
-    self.send_markOrdersAsFailed(providerId, returnedOrders)
+    self.send_markAsRTOrders(providerId, returnedOrders)
-    self.recv_markOrdersAsFailed()
+    self.recv_markAsRTOrders()
-  def send_markOrdersAsFailed(self, providerId, returnedOrders):
+  def send_markAsRTOrders(self, providerId, returnedOrders):
-    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('markAsRTOrders', TMessageType.CALL, self._seqid)
-    args = markOrdersAsFailed_args()
+    args = markAsRTOrders_args()
     args.providerId = providerId
     args.returnedOrders = returnedOrders
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_markOrdersAsFailed(self, ):
+  def recv_markAsRTOrders(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = markOrdersAsFailed_result()
+    result = markAsRTOrders_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.ex is not None:
       raise result.ex
     return
+  def getRTOrders(self, providerId):
+    """
+    Returns a list of orders that were returned by courier.
+    Parameters:
+     - providerId
+    """
+    self.send_getRTOrders(providerId)
+    return self.recv_getRTOrders()
+  def send_getRTOrders(self, providerId):
+    self._oprot.writeMessageBegin('getRTOrders', TMessageType.CALL, self._seqid)
+    args = getRTOrders_args()
+    args.providerId = providerId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getRTOrders(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getRTOrders_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getRTOrders failed: unknown result");
   def updateNonDeliveryReason(self, providerId, undeliveredOrders):
     """
     Update the status description of orders whose AWB numbers are keys of the Map.
-    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
     Parameters:
      - providerId
      - undeliveredOrders
     """
     self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
-    return self.recv_updateNonDeliveryReason()
+    self.recv_updateNonDeliveryReason()
   def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
     self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
     args = updateNonDeliveryReason_args()
     args.providerId = providerId
       self._iprot.readMessageEnd()
       raise x
     result = updateNonDeliveryReason_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
+    if result.ex is not None:
+      raise result.ex
+    return
+  def getNonDeliveredOrdersbyCourier(self, providerId):
+    """
+    Returns a list of orders that were picked up or shipped four days ago but did not get delivered.
+    Parameters:
+     - providerId
+    """
+    self.send_getNonDeliveredOrdersbyCourier(providerId)
+    return self.recv_getNonDeliveredOrdersbyCourier()
+  def send_getNonDeliveredOrdersbyCourier(self, providerId):
+    self._oprot.writeMessageBegin('getNonDeliveredOrdersbyCourier', TMessageType.CALL, self._seqid)
+    args = getNonDeliveredOrdersbyCourier_args()
+    args.providerId = providerId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getNonDeliveredOrdersbyCourier(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getNonDeliveredOrdersbyCourier_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNonDeliveredOrdersbyCourier failed: unknown result");
+  def markOrdersAsLocalConnected(self, providerId, local_connected_orders):
+    """
+    Mark all orders with AWBs in the given map as local connected. Also sets the local connected timestamp.
+    Parameters:
+     - providerId
+     - local_connected_orders
+    """
+    self.send_markOrdersAsLocalConnected(providerId, local_connected_orders)
+    self.recv_markOrdersAsLocalConnected()
+  def send_markOrdersAsLocalConnected(self, providerId, local_connected_orders):
+    self._oprot.writeMessageBegin('markOrdersAsLocalConnected', TMessageType.CALL, self._seqid)
+    args = markOrdersAsLocalConnected_args()
+    args.providerId = providerId
+    args.local_connected_orders = local_connected_orders
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_markOrdersAsLocalConnected(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = markOrdersAsLocalConnected_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.ex is not None:
+      raise result.ex
+    return
+  def getOrdersNotLocalConnected(self, providerId):
+    """
+    Returns a list of orders that were picked up or shipped but pending local connection.
+    Parameters:
+     - providerId
+    """
+    self.send_getOrdersNotLocalConnected(providerId)
+    return self.recv_getOrdersNotLocalConnected()
+  def send_getOrdersNotLocalConnected(self, providerId):
+    self._oprot.writeMessageBegin('getOrdersNotLocalConnected', TMessageType.CALL, self._seqid)
+    args = getOrdersNotLocalConnected_args()
+    args.providerId = providerId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getOrdersNotLocalConnected(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getOrdersNotLocalConnected_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersNotLocalConnected failed: unknown result");
+  def markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
+    """
+    Mark all orders with AWBs in the given map as reached destination city. Also sets the reached destination timestamp.
+    Parameters:
+     - providerId
+     - destination_city_reached_orders
+    """
+    self.send_markOrdersAsDestinationCityReached(providerId, destination_city_reached_orders)
+    self.recv_markOrdersAsDestinationCityReached()
+  def send_markOrdersAsDestinationCityReached(self, providerId, destination_city_reached_orders):
+    self._oprot.writeMessageBegin('markOrdersAsDestinationCityReached', TMessageType.CALL, self._seqid)
+    args = markOrdersAsDestinationCityReached_args()
+    args.providerId = providerId
+    args.destination_city_reached_orders = destination_city_reached_orders
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_markOrdersAsDestinationCityReached(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = markOrdersAsDestinationCityReached_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
     if result.ex is not None:
       raise result.ex
+    return
+  def markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
+    """
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateNonDeliveryReason failed: unknown result");
+    Mark all orders with AWBs in the given map as first delivery attempt made. Also sets the first delivery attempted timestamp.
+    Parameters:
+     - providerId
+     - first_atdl_orders
+    """
+    self.send_markOrdersAsFirstDeliveryAttempted(providerId, first_atdl_orders)
+    self.recv_markOrdersAsFirstDeliveryAttempted()
+  def send_markOrdersAsFirstDeliveryAttempted(self, providerId, first_atdl_orders):
+    self._oprot.writeMessageBegin('markOrdersAsFirstDeliveryAttempted', TMessageType.CALL, self._seqid)
+    args = markOrdersAsFirstDeliveryAttempted_args()
+    args.providerId = providerId
+    args.first_atdl_orders = first_atdl_orders
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_markOrdersAsFirstDeliveryAttempted(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = markOrdersAsFirstDeliveryAttempted_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.ex is not None:
+      raise result.ex
+    return
   def getUndeliveredOrders(self, providerId, warehouseId):
     """
     Returns the list of orders whose delivery time has passed but have not been
     delivered yet for the given provider and warehouse. To get a complete list of
     raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
   def markDoasAsPickedUp(self, providerId, pickupDetails):
     """
     Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
-    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
     Parameters:
      - providerId
      - pickupDetails
     """
     self.send_markDoasAsPickedUp(providerId, pickupDetails)
-    return self.recv_markDoasAsPickedUp()
+    self.recv_markDoasAsPickedUp()
   def send_markDoasAsPickedUp(self, providerId, pickupDetails):
     self._oprot.writeMessageBegin('markDoasAsPickedUp', TMessageType.CALL, self._seqid)
     args = markDoasAsPickedUp_args()
     args.providerId = providerId
       self._iprot.readMessageEnd()
       raise x
     result = markDoasAsPickedUp_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
+    return
+  def getDoasNotPickedUp(self, providerId):
+    """
+    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
+    Parameters:
+     - providerId
+    """
+    self.send_getDoasNotPickedUp(providerId)
+    return self.recv_getDoasNotPickedUp()
+  def send_getDoasNotPickedUp(self, providerId):
+    self._oprot.writeMessageBegin('getDoasNotPickedUp', TMessageType.CALL, self._seqid)
+    args = getDoasNotPickedUp_args()
+    args.providerId = providerId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getDoasNotPickedUp(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getDoasNotPickedUp_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDoasNotPickedUp failed: unknown result");
   def markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
     """
     Marks all RET_PICKUP_CONFIRMED orders of the previous day for a provider as RET_RETURN_IN_TRANSIT.
-    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
     Parameters:
      - providerId
      - pickupDetails
     """
     self.send_markReturnOrdersAsPickedUp(providerId, pickupDetails)
-    return self.recv_markReturnOrdersAsPickedUp()
+    self.recv_markReturnOrdersAsPickedUp()
   def send_markReturnOrdersAsPickedUp(self, providerId, pickupDetails):
     self._oprot.writeMessageBegin('markReturnOrdersAsPickedUp', TMessageType.CALL, self._seqid)
     args = markReturnOrdersAsPickedUp_args()
     args.providerId = providerId
       self._iprot.readMessageEnd()
       raise x
     result = markReturnOrdersAsPickedUp_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
+    return
+  def getReturnOrdersNotPickedUp(self, providerId):
+    """
+    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
+    Parameters:
+     - providerId
+    """
+    self.send_getReturnOrdersNotPickedUp(providerId)
+    return self.recv_getReturnOrdersNotPickedUp()
+  def send_getReturnOrdersNotPickedUp(self, providerId):
+    self._oprot.writeMessageBegin('getReturnOrdersNotPickedUp', TMessageType.CALL, self._seqid)
+    args = getReturnOrdersNotPickedUp_args()
+    args.providerId = providerId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getReturnOrdersNotPickedUp(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getReturnOrdersNotPickedUp_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "markReturnOrdersAsPickedUp failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrdersNotPickedUp failed: unknown result");
   def receiveReturn(self, orderId, receiveCondition):
     """
     If the order status is DOA_PICKUP_CONFIRMED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED_PRESTINE and returns true.
     If the order status is RTO_IN_TRANSIT, marks the order status as RTO_RECEIVED_PRESTINE and returns true.
       return result.success
     if result.ex is not None:
       raise result.ex
     raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForAwb failed: unknown result");
-  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
+  def getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
     """
-    Returns the order corresponding to a logistics provider id for a given order status
+    Returns the order corresponding to a logistics provider id for a given list of order status
     Parameters:
      - logistics_provider_id
-     - order_status
+     - order_status_list
     """
-    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status)
+    self.send_getOrdersForProviderForStatus(logistics_provider_id, order_status_list)
     return self.recv_getOrdersForProviderForStatus()
-  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status):
+  def send_getOrdersForProviderForStatus(self, logistics_provider_id, order_status_list):
     self._oprot.writeMessageBegin('getOrdersForProviderForStatus', TMessageType.CALL, self._seqid)
     args = getOrdersForProviderForStatus_args()
     args.logistics_provider_id = logistics_provider_id
-    args.order_status = order_status
+    args.order_status_list = order_status_list
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
   def recv_getOrdersForProviderForStatus(self, ):
     self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
     self._processMap["verifyOrder"] = Processor.process_verifyOrder
     self._processMap["acceptOrder"] = Processor.process_acceptOrder
     self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
     self._processMap["addInvoiceNumber"] = Processor.process_addInvoiceNumber
-    self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
     self._processMap["markOrdersAsShippedFromWarehouse"] = Processor.process_markOrdersAsShippedFromWarehouse
     self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
+    self._processMap["getOrdersNotPickedUp"] = Processor.process_getOrdersNotPickedUp
     self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
-    self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
+    self._processMap["markAsRTOrders"] = Processor.process_markAsRTOrders
+    self._processMap["getRTOrders"] = Processor.process_getRTOrders
     self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
+    self._processMap["getNonDeliveredOrdersbyCourier"] = Processor.process_getNonDeliveredOrdersbyCourier
+    self._processMap["markOrdersAsLocalConnected"] = Processor.process_markOrdersAsLocalConnected
+    self._processMap["getOrdersNotLocalConnected"] = Processor.process_getOrdersNotLocalConnected
+    self._processMap["markOrdersAsDestinationCityReached"] = Processor.process_markOrdersAsDestinationCityReached
+    self._processMap["markOrdersAsFirstDeliveryAttempted"] = Processor.process_markOrdersAsFirstDeliveryAttempted
     self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
     self._processMap["getUndeliveredOrdersExpectedDeliveryDateNotMet"] = Processor.process_getUndeliveredOrdersExpectedDeliveryDateNotMet
     self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
     self._processMap["markOrderAsDelivered"] = Processor.process_markOrderAsDelivered
     self._processMap["markOrderDoaRequestReceived"] = Processor.process_markOrderDoaRequestReceived
     self._processMap["markOrderReturnRequestReceived"] = Processor.process_markOrderReturnRequestReceived
     self._processMap["markOrderReturnRequestAuthorized"] = Processor.process_markOrderReturnRequestAuthorized
     self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
     self._processMap["authorizePickup"] = Processor.process_authorizePickup
     self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
+    self._processMap["getDoasNotPickedUp"] = Processor.process_getDoasNotPickedUp
     self._processMap["markReturnOrdersAsPickedUp"] = Processor.process_markReturnOrdersAsPickedUp
+    self._processMap["getReturnOrdersNotPickedUp"] = Processor.process_getReturnOrdersNotPickedUp
     self._processMap["receiveReturn"] = Processor.process_receiveReturn
     self._processMap["validateDoa"] = Processor.process_validateDoa
     self._processMap["validateReturnProduct"] = Processor.process_validateReturnProduct
     self._processMap["reshipOrder"] = Processor.process_reshipOrder
     self._processMap["refundOrder"] = Processor.process_refundOrder
     oprot.writeMessageBegin("addInvoiceNumber", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
-    args = markOrdersAsManifested_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = markOrdersAsManifested_result()
-    try:
-      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
-    except TransactionServiceException, ex:
-      result.ex = ex
-    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
   def process_markOrdersAsShippedFromWarehouse(self, seqid, iprot, oprot):
     args = markOrdersAsShippedFromWarehouse_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = markOrdersAsShippedFromWarehouse_result()
     args = markOrdersAsPickedUp_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = markOrdersAsPickedUp_result()
     try:
-      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
+      self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
     except TransactionServiceException, ex:
       result.ex = ex
     oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
+  def process_getOrdersNotPickedUp(self, seqid, iprot, oprot):
+    args = getOrdersNotPickedUp_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getOrdersNotPickedUp_result()
+    result.success = self._handler.getOrdersNotPickedUp(args.providerId)
+    oprot.writeMessageBegin("getOrdersNotPickedUp", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
   def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
     args = markOrdersAsDelivered_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = markOrdersAsDelivered_result()
     oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
+  def process_markAsRTOrders(self, seqid, iprot, oprot):
-    args = markOrdersAsFailed_args()
+    args = markAsRTOrders_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = markOrdersAsFailed_result()
+    result = markAsRTOrders_result()
     try:
-      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
+      self._handler.markAsRTOrders(args.providerId, args.returnedOrders)
     except TransactionServiceException, ex:
       result.ex = ex
-    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("markAsRTOrders", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getRTOrders(self, seqid, iprot, oprot):
+    args = getRTOrders_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getRTOrders_result()
+    result.success = self._handler.getRTOrders(args.providerId)
+    oprot.writeMessageBegin("getRTOrders", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
   def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
     args = updateNonDeliveryReason_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = updateNonDeliveryReason_result()
     try:
-      result.success = self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
+      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
     except TransactionServiceException, ex:
       result.ex = ex
     oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
+  def process_getNonDeliveredOrdersbyCourier(self, seqid, iprot, oprot):
+    args = getNonDeliveredOrdersbyCourier_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getNonDeliveredOrdersbyCourier_result()
+    result.success = self._handler.getNonDeliveredOrdersbyCourier(args.providerId)
+    oprot.writeMessageBegin("getNonDeliveredOrdersbyCourier", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_markOrdersAsLocalConnected(self, seqid, iprot, oprot):
+    args = markOrdersAsLocalConnected_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = markOrdersAsLocalConnected_result()
+    try:
+      self._handler.markOrdersAsLocalConnected(args.providerId, args.local_connected_orders)
+    except TransactionServiceException, ex:
+      result.ex = ex
+    oprot.writeMessageBegin("markOrdersAsLocalConnected", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getOrdersNotLocalConnected(self, seqid, iprot, oprot):
+    args = getOrdersNotLocalConnected_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getOrdersNotLocalConnected_result()
+    result.success = self._handler.getOrdersNotLocalConnected(args.providerId)
+    oprot.writeMessageBegin("getOrdersNotLocalConnected", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_markOrdersAsDestinationCityReached(self, seqid, iprot, oprot):
+    args = markOrdersAsDestinationCityReached_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = markOrdersAsDestinationCityReached_result()
+    try:
+      self._handler.markOrdersAsDestinationCityReached(args.providerId, args.destination_city_reached_orders)
+    except TransactionServiceException, ex:
+      result.ex = ex
+    oprot.writeMessageBegin("markOrdersAsDestinationCityReached", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_markOrdersAsFirstDeliveryAttempted(self, seqid, iprot, oprot):
+    args = markOrdersAsFirstDeliveryAttempted_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = markOrdersAsFirstDeliveryAttempted_result()
+    try:
+      self._handler.markOrdersAsFirstDeliveryAttempted(args.providerId, args.first_atdl_orders)
+    except TransactionServiceException, ex:
+      result.ex = ex
+    oprot.writeMessageBegin("markOrdersAsFirstDeliveryAttempted", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
   def process_getUndeliveredOrders(self, seqid, iprot, oprot):
     args = getUndeliveredOrders_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = getUndeliveredOrders_result()
   def process_markDoasAsPickedUp(self, seqid, iprot, oprot):
     args = markDoasAsPickedUp_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = markDoasAsPickedUp_result()
-    result.success = self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
+    self._handler.markDoasAsPickedUp(args.providerId, args.pickupDetails)
     oprot.writeMessageBegin("markDoasAsPickedUp", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
+  def process_getDoasNotPickedUp(self, seqid, iprot, oprot):
+    args = getDoasNotPickedUp_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getDoasNotPickedUp_result()
+    result.success = self._handler.getDoasNotPickedUp(args.providerId)
+    oprot.writeMessageBegin("getDoasNotPickedUp", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
   def process_markReturnOrdersAsPickedUp(self, seqid, iprot, oprot):
     args = markReturnOrdersAsPickedUp_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = markReturnOrdersAsPickedUp_result()
-    result.success = self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
+    self._handler.markReturnOrdersAsPickedUp(args.providerId, args.pickupDetails)
     oprot.writeMessageBegin("markReturnOrdersAsPickedUp", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
+  def process_getReturnOrdersNotPickedUp(self, seqid, iprot, oprot):
+    args = getReturnOrdersNotPickedUp_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getReturnOrdersNotPickedUp_result()
+    result.success = self._handler.getReturnOrdersNotPickedUp(args.providerId)
+    oprot.writeMessageBegin("getReturnOrdersNotPickedUp", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
   def process_receiveReturn(self, seqid, iprot, oprot):
     args = receiveReturn_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = receiveReturn_result()
     args = getOrdersForProviderForStatus_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = getOrdersForProviderForStatus_result()
     try:
-      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status)
+      result.success = self._handler.getOrdersForProviderForStatus(args.logistics_provider_id, args.order_status_list)
     except TransactionServiceException, ex:
       result.ex = ex
     oprot.writeMessageBegin("getOrdersForProviderForStatus", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class markOrdersAsManifested_args:
+class markOrdersAsShippedFromWarehouse_args:
   """
   Attributes:
    - warehouseId
    - providerId
    - cod
+   - orderIds
   """
   thrift_spec = (
     None, # 0
     (1, TType.I64, 'warehouseId', None, None, ), # 1
     (2, TType.I64, 'providerId', None, None, ), # 2
     (3, TType.BOOL, 'cod', None, None, ), # 3
+    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
+  )
-  def __init__(self, warehouseId=None, providerId=None, cod=None,):
+  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
     self.warehouseId = warehouseId
     self.providerId = providerId
     self.cod = cod
+    self.orderIds = orderIds
   def read(self, iprot):
     if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
       fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
       return
       elif fid == 3:
         if ftype == TType.BOOL:
           self.cod = iprot.readBool();
         else:
           iprot.skip(ftype)
+      elif fid == 4:
+        if ftype == TType.LIST:
+          self.orderIds = []
+          (_etype178, _size175) = iprot.readListBegin()
+          for _i179 in xrange(_size175):
+            _elem180 = iprot.readI64();
+            self.orderIds.append(_elem180)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
     iprot.readStructEnd()
   def write(self, oprot):
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('markOrdersAsManifested_args')
+    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
     if self.warehouseId is not None:
       oprot.writeFieldBegin('warehouseId', TType.I64, 1)
       oprot.writeI64(self.warehouseId)
       oprot.writeFieldEnd()
     if self.providerId is not None:
       oprot.writeFieldEnd()
     if self.cod is not None:
       oprot.writeFieldBegin('cod', TType.BOOL, 3)
       oprot.writeBool(self.cod)
       oprot.writeFieldEnd()
+    if self.orderIds is not None:
+      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
+      oprot.writeListBegin(TType.I64, len(self.orderIds))
+      for iter181 in self.orderIds:
+        oprot.writeI64(iter181)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def validate(self):
     return
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class markOrdersAsManifested_result:
+class markOrdersAsShippedFromWarehouse_result:
   """
   Attributes:
    - success
    - ex
   """
   def write(self, oprot):
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('markOrdersAsManifested_result')
+    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.BOOL, 0)
       oprot.writeBool(self.success)
       oprot.writeFieldEnd()
     if self.ex is not None:
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class markOrdersAsShippedFromWarehouse_args:
+class markOrdersAsPickedUp_args:
   """
   Attributes:
-   - warehouseId
    - providerId
-   - cod
-   - orderIds
+   - pickupDetails
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'warehouseId', None, None, ), # 1
-    (2, TType.I64, 'providerId', None, None, ), # 2
+    (1, TType.I64, 'providerId', None, None, ), # 1
-    (3, TType.BOOL, 'cod', None, None, ), # 3
-    (4, TType.LIST, 'orderIds', (TType.I64,None), None, ), # 4
+    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
+  )
-  def __init__(self, warehouseId=None, providerId=None, cod=None, orderIds=None,):
+  def __init__(self, providerId=None, pickupDetails=None,):
-    self.warehouseId = warehouseId
     self.providerId = providerId
-    self.cod = cod
-    self.orderIds = orderIds
+    self.pickupDetails = pickupDetails
   def read(self, iprot):
     if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
       fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
       return
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.I64:
-          self.warehouseId = iprot.readI64();
-        else:
-          iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.I64:
           self.providerId = iprot.readI64();
         else:
           iprot.skip(ftype)
-      elif fid == 3:
+      elif fid == 2:
-        if ftype == TType.BOOL:
-          self.cod = iprot.readBool();
-        else:
-          iprot.skip(ftype)
-      elif fid == 4:
-        if ftype == TType.LIST:
+        if ftype == TType.MAP:
-          self.orderIds = []
+          self.pickupDetails = {}
-          (_etype178, _size175) = iprot.readListBegin()
+          (_ktype183, _vtype184, _size182 ) = iprot.readMapBegin()
-          for _i179 in xrange(_size175):
+          for _i186 in xrange(_size182):
-            _elem180 = iprot.readI64();
+            _key187 = iprot.readString();
+            _val188 = iprot.readString();
-            self.orderIds.append(_elem180)
+            self.pickupDetails[_key187] = _val188
-          iprot.readListEnd()
+          iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
   def write(self, oprot):
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_args')
+    oprot.writeStructBegin('markOrdersAsPickedUp_args')
-    if self.warehouseId is not None:
-      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
-      oprot.writeI64(self.warehouseId)
-      oprot.writeFieldEnd()
     if self.providerId is not None:
-      oprot.writeFieldBegin('providerId', TType.I64, 2)
+      oprot.writeFieldBegin('providerId', TType.I64, 1)
       oprot.writeI64(self.providerId)
       oprot.writeFieldEnd()
-    if self.cod is not None:
+    if self.pickupDetails is not None:
-      oprot.writeFieldBegin('cod', TType.BOOL, 3)
+      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
-      oprot.writeBool(self.cod)
-      oprot.writeFieldEnd()
-    if self.orderIds is not None:
-      oprot.writeFieldBegin('orderIds', TType.LIST, 4)
+      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
-      oprot.writeListBegin(TType.I64, len(self.orderIds))
+      for kiter189,viter190 in self.pickupDetails.items():
-      for iter181 in self.orderIds:
+        oprot.writeString(kiter189)
-        oprot.writeI64(iter181)
+        oprot.writeString(viter190)
-      oprot.writeListEnd()
+      oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def validate(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class markOrdersAsShippedFromWarehouse_result:
+class markOrdersAsPickedUp_result:
   """
   Attributes:
-   - success
    - ex
   """
   thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
+    None, # 0
     (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, success=None, ex=None,):
+  def __init__(self, ex=None,):
-    self.success = success
     self.ex = ex
   def read(self, iprot):
     if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
       fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
     iprot.readStructBegin()
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
-      if fid == 0:
+      if fid == 1:
-        if ftype == TType.BOOL:
-          self.success = iprot.readBool();
-        else:
-          iprot.skip(ftype)
-      elif fid == 1:
         if ftype == TType.STRUCT:
           self.ex = TransactionServiceException()
           self.ex.read(iprot)
         else:
           iprot.skip(ftype)
   def write(self, oprot):
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('markOrdersAsShippedFromWarehouse_result')
+    oprot.writeStructBegin('markOrdersAsPickedUp_result')
-    if self.success is not None:
-      oprot.writeFieldBegin('success', TType.BOOL, 0)
-      oprot.writeBool(self.success)
-      oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class markOrdersAsPickedUp_args:
+class getOrdersNotPickedUp_args:
   """
   Attributes:
    - providerId
-   - pickupDetails
   """
   thrift_spec = (
     None, # 0
     (1, TType.I64, 'providerId', None, None, ), # 1
-    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
+  )
-  def __init__(self, providerId=None, pickupDetails=None,):
+  def __init__(self, providerId=None,):
     self.providerId = providerId
-    self.pickupDetails = pickupDetails
   def read(self, iprot):
     if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
       fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
       return
       if fid == 1:
         if ftype == TType.I64:
           self.providerId = iprot.readI64();
         else:
           iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.MAP:
-          self.pickupDetails = {}
-          (_ktype183, _vtype184, _size182 ) = iprot.readMapBegin()
-          for _i186 in xrange(_size182):
-            _key187 = iprot.readString();
-            _val188 = iprot.readString();
-            self.pickupDetails[_key187] = _val188
-          iprot.readMapEnd()
-        else:
-          iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
     iprot.readStructEnd()
   def write(self, oprot):
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('markOrdersAsPickedUp_args')
+    oprot.writeStructBegin('getOrdersNotPickedUp_args')
     if self.providerId is not None:
       oprot.writeFieldBegin('providerId', TType.I64, 1)
       oprot.writeI64(self.providerId)
       oprot.writeFieldEnd()
-    if self.pickupDetails is not None:
-      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
-      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
-      for kiter189,viter190 in self.pickupDetails.items():
-        oprot.writeString(kiter189)
-        oprot.writeString(viter190)
-      oprot.writeMapEnd()
-      oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def validate(self):
     return
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class markOrdersAsPickedUp_result:
+class getOrdersNotPickedUp_result:
   """
   Attributes:
    - success
-   - ex
   """
   thrift_spec = (
     (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
-    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, success=None, ex=None,):
+  def __init__(self, success=None,):
     self.success = success
-    self.ex = ex
   def read(self, iprot):
     if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
       fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
       return
             _elem196.read(iprot)
             self.success.append(_elem196)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
-      elif fid == 1:
-        if ftype == TType.STRUCT:
-          self.ex = TransactionServiceException()
-          self.ex.read(iprot)
-        else:
-          iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
     iprot.readStructEnd()
   def write(self, oprot):
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('markOrdersAsPickedUp_result')
+    oprot.writeStructBegin('getOrdersNotPickedUp_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
       for iter197 in self.success:
         iter197.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
-    if self.ex is not None:
-      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
-      self.ex.write(oprot)
-      oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def validate(self):
     return
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class markOrdersAsFailed_args:
+class markAsRTOrders_args:
   """
   Attributes:
    - providerId
    - returnedOrders
   """
   def write(self, oprot):
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('markOrdersAsFailed_args')
+    oprot.writeStructBegin('markAsRTOrders_args')
     if self.providerId is not None:
       oprot.writeFieldBegin('providerId', TType.I64, 1)
       oprot.writeI64(self.providerId)
       oprot.writeFieldEnd()
     if self.returnedOrders is not None:
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class markOrdersAsFailed_result:
+class markAsRTOrders_result:
   """
   Attributes:
    - ex
   """
   def write(self, oprot):
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('markOrdersAsFailed_result')
+    oprot.writeStructBegin('markAsRTOrders_result')
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
+class getRTOrders_args:
+  """
+  Attributes:
+   - providerId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'providerId', None, None, ), # 1
+  )
+  def __init__(self, providerId=None,):
+    self.providerId = providerId
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.providerId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getRTOrders_args')
+    if self.providerId is not None:
+      oprot.writeFieldBegin('providerId', TType.I64, 1)
+      oprot.writeI64(self.providerId)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getRTOrders_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype219, _size216) = iprot.readListBegin()
+          for _i220 in xrange(_size216):
+            _elem221 = Order()
+            _elem221.read(iprot)
+            self.success.append(_elem221)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getRTOrders_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter222 in self.success:
+        iter222.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
 class updateNonDeliveryReason_args:
   """
   Attributes:
    - providerId
    - undeliveredOrders
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.MAP:
           self.undeliveredOrders = {}
-          (_ktype217, _vtype218, _size216 ) = iprot.readMapBegin()
+          (_ktype224, _vtype225, _size223 ) = iprot.readMapBegin()
-          for _i220 in xrange(_size216):
+          for _i227 in xrange(_size223):
-            _key221 = iprot.readString();
+            _key228 = iprot.readString();
-            _val222 = iprot.readString();
+            _val229 = iprot.readString();
-            self.undeliveredOrders[_key221] = _val222
+            self.undeliveredOrders[_key228] = _val229
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       oprot.writeI64(self.providerId)
       oprot.writeFieldEnd()
     if self.undeliveredOrders is not None:
       oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
       oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
-      for kiter223,viter224 in self.undeliveredOrders.items():
+      for kiter230,viter231 in self.undeliveredOrders.items():
-        oprot.writeString(kiter223)
+        oprot.writeString(kiter230)
-        oprot.writeString(viter224)
+        oprot.writeString(viter231)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
     return not (self == other)
 class updateNonDeliveryReason_result:
   """
   Attributes:
-   - success
    - ex
   """
   thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
+    None, # 0
     (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, success=None, ex=None,):
+  def __init__(self, ex=None,):
-    self.success = success
     self.ex = ex
   def read(self, iprot):
     if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
       fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
     iprot.readStructBegin()
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
+      if fid == 1:
+        if ftype == TType.STRUCT:
+          self.ex = TransactionServiceException()
+          self.ex.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('updateNonDeliveryReason_result')
+    if self.ex is not None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
+      self.ex.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getNonDeliveredOrdersbyCourier_args:
+  """
+  Attributes:
+   - providerId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'providerId', None, None, ), # 1
+  )
+  def __init__(self, providerId=None,):
+    self.providerId = providerId
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.providerId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_args')
+    if self.providerId is not None:
+      oprot.writeFieldBegin('providerId', TType.I64, 1)
+      oprot.writeI64(self.providerId)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getNonDeliveredOrdersbyCourier_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype228, _size225) = iprot.readListBegin()
+          (_etype235, _size232) = iprot.readListBegin()
-          for _i229 in xrange(_size225):
+          for _i236 in xrange(_size232):
-            _elem230 = Order()
+            _elem237 = Order()
-            _elem230.read(iprot)
+            _elem237.read(iprot)
-            self.success.append(_elem230)
+            self.success.append(_elem237)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getNonDeliveredOrdersbyCourier_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter238 in self.success:
+        iter238.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class markOrdersAsLocalConnected_args:
+  """
+  Attributes:
+   - providerId
+   - local_connected_orders
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'providerId', None, None, ), # 1
+    (2, TType.MAP, 'local_connected_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
+  )
+  def __init__(self, providerId=None, local_connected_orders=None,):
+    self.providerId = providerId
+    self.local_connected_orders = local_connected_orders
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.providerId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
-      elif fid == 1:
+      elif fid == 2:
+        if ftype == TType.MAP:
+          self.local_connected_orders = {}
+          (_ktype240, _vtype241, _size239 ) = iprot.readMapBegin()
+          for _i243 in xrange(_size239):
+            _key244 = iprot.readString();
+            _val245 = iprot.readString();
+            self.local_connected_orders[_key244] = _val245
+          iprot.readMapEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('markOrdersAsLocalConnected_args')
+    if self.providerId is not None:
+      oprot.writeFieldBegin('providerId', TType.I64, 1)
+      oprot.writeI64(self.providerId)
+      oprot.writeFieldEnd()
+    if self.local_connected_orders is not None:
+      oprot.writeFieldBegin('local_connected_orders', TType.MAP, 2)
+      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.local_connected_orders))
+      for kiter246,viter247 in self.local_connected_orders.items():
+        oprot.writeString(kiter246)
+        oprot.writeString(viter247)
+      oprot.writeMapEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class markOrdersAsLocalConnected_result:
+  """
+  Attributes:
+   - ex
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, ex=None,):
+    self.ex = ex
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
         if ftype == TType.STRUCT:
           self.ex = TransactionServiceException()
           self.ex.read(iprot)
         else:
           iprot.skip(ftype)
   def write(self, oprot):
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
+    oprot.writeStructBegin('markOrdersAsLocalConnected_result')
+    if self.ex is not None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
+      self.ex.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getOrdersNotLocalConnected_args:
+  """
+  Attributes:
+   - providerId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'providerId', None, None, ), # 1
+  )
+  def __init__(self, providerId=None,):
+    self.providerId = providerId
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.providerId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getOrdersNotLocalConnected_args')
+    if self.providerId is not None:
+      oprot.writeFieldBegin('providerId', TType.I64, 1)
+      oprot.writeI64(self.providerId)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getOrdersNotLocalConnected_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype251, _size248) = iprot.readListBegin()
+          for _i252 in xrange(_size248):
+            _elem253 = Order()
+            _elem253.read(iprot)
+            self.success.append(_elem253)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
-    oprot.writeStructBegin('updateNonDeliveryReason_result')
+    oprot.writeStructBegin('getOrdersNotLocalConnected_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter231 in self.success:
+      for iter254 in self.success:
-        iter231.write(oprot)
+        iter254.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class markOrdersAsDestinationCityReached_args:
+  """
+  Attributes:
+   - providerId
+   - destination_city_reached_orders
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'providerId', None, None, ), # 1
+    (2, TType.MAP, 'destination_city_reached_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
+  )
+  def __init__(self, providerId=None, destination_city_reached_orders=None,):
+    self.providerId = providerId
+    self.destination_city_reached_orders = destination_city_reached_orders
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.providerId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.MAP:
+          self.destination_city_reached_orders = {}
+          (_ktype256, _vtype257, _size255 ) = iprot.readMapBegin()
+          for _i259 in xrange(_size255):
+            _key260 = iprot.readString();
+            _val261 = iprot.readString();
+            self.destination_city_reached_orders[_key260] = _val261
+          iprot.readMapEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('markOrdersAsDestinationCityReached_args')
+    if self.providerId is not None:
+      oprot.writeFieldBegin('providerId', TType.I64, 1)
+      oprot.writeI64(self.providerId)
+      oprot.writeFieldEnd()
+    if self.destination_city_reached_orders is not None:
+      oprot.writeFieldBegin('destination_city_reached_orders', TType.MAP, 2)
+      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.destination_city_reached_orders))
+      for kiter262,viter263 in self.destination_city_reached_orders.items():
+        oprot.writeString(kiter262)
+        oprot.writeString(viter263)
+      oprot.writeMapEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class markOrdersAsDestinationCityReached_result:
+  """
+  Attributes:
+   - ex
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, ex=None,):
+    self.ex = ex
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRUCT:
+          self.ex = TransactionServiceException()
+          self.ex.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('markOrdersAsDestinationCityReached_result')
+    if self.ex is not None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
+      self.ex.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class markOrdersAsFirstDeliveryAttempted_args:
+  """
+  Attributes:
+   - providerId
+   - first_atdl_orders
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'providerId', None, None, ), # 1
+    (2, TType.MAP, 'first_atdl_orders', (TType.STRING,None,TType.STRING,None), None, ), # 2
+  )
+  def __init__(self, providerId=None, first_atdl_orders=None,):
+    self.providerId = providerId
+    self.first_atdl_orders = first_atdl_orders
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.providerId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.MAP:
+          self.first_atdl_orders = {}
+          (_ktype265, _vtype266, _size264 ) = iprot.readMapBegin()
+          for _i268 in xrange(_size264):
+            _key269 = iprot.readString();
+            _val270 = iprot.readString();
+            self.first_atdl_orders[_key269] = _val270
+          iprot.readMapEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_args')
+    if self.providerId is not None:
+      oprot.writeFieldBegin('providerId', TType.I64, 1)
+      oprot.writeI64(self.providerId)
+      oprot.writeFieldEnd()
+    if self.first_atdl_orders is not None:
+      oprot.writeFieldBegin('first_atdl_orders', TType.MAP, 2)
+      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.first_atdl_orders))
+      for kiter271,viter272 in self.first_atdl_orders.items():
+        oprot.writeString(kiter271)
+        oprot.writeString(viter272)
+      oprot.writeMapEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class markOrdersAsFirstDeliveryAttempted_result:
+  """
+  Attributes:
+   - ex
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, ex=None,):
+    self.ex = ex
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRUCT:
+          self.ex = TransactionServiceException()
+          self.ex.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('markOrdersAsFirstDeliveryAttempted_result')
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype235, _size232) = iprot.readListBegin()
+          (_etype276, _size273) = iprot.readListBegin()
-          for _i236 in xrange(_size232):
+          for _i277 in xrange(_size273):
-            _elem237 = Order()
+            _elem278 = Order()
-            _elem237.read(iprot)
+            _elem278.read(iprot)
-            self.success.append(_elem237)
+            self.success.append(_elem278)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getUndeliveredOrders_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter238 in self.success:
+      for iter279 in self.success:
-        iter238.write(oprot)
+        iter279.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype242, _size239) = iprot.readListBegin()
+          (_etype283, _size280) = iprot.readListBegin()
-          for _i243 in xrange(_size239):
+          for _i284 in xrange(_size280):
-            _elem244 = Order()
+            _elem285 = Order()
-            _elem244.read(iprot)
+            _elem285.read(iprot)
-            self.success.append(_elem244)
+            self.success.append(_elem285)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getUndeliveredOrdersExpectedDeliveryDateNotMet_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter245 in self.success:
+      for iter286 in self.success:
-        iter245.write(oprot)
+        iter286.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.MAP:
           self.pickupDetails = {}
-          (_ktype247, _vtype248, _size246 ) = iprot.readMapBegin()
+          (_ktype288, _vtype289, _size287 ) = iprot.readMapBegin()
-          for _i250 in xrange(_size246):
+          for _i291 in xrange(_size287):
-            _key251 = iprot.readString();
+            _key292 = iprot.readString();
-            _val252 = iprot.readString();
+            _val293 = iprot.readString();
-            self.pickupDetails[_key251] = _val252
+            self.pickupDetails[_key292] = _val293
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       oprot.writeI64(self.providerId)
       oprot.writeFieldEnd()
     if self.pickupDetails is not None:
       oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
       oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
-      for kiter253,viter254 in self.pickupDetails.items():
+      for kiter294,viter295 in self.pickupDetails.items():
-        oprot.writeString(kiter253)
+        oprot.writeString(kiter294)
-        oprot.writeString(viter254)
+        oprot.writeString(viter295)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __ne__(self, other):
     return not (self == other)
 class markDoasAsPickedUp_result:
+  thrift_spec = (
+  )
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('markDoasAsPickedUp_result')
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getDoasNotPickedUp_args:
+  """
+  Attributes:
+   - providerId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'providerId', None, None, ), # 1
+  )
+  def __init__(self, providerId=None,):
+    self.providerId = providerId
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.providerId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getDoasNotPickedUp_args')
+    if self.providerId is not None:
+      oprot.writeFieldBegin('providerId', TType.I64, 1)
+      oprot.writeI64(self.providerId)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getDoasNotPickedUp_result:
   """
   Attributes:
    - success
   """
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype258, _size255) = iprot.readListBegin()
+          (_etype299, _size296) = iprot.readListBegin()
-          for _i259 in xrange(_size255):
+          for _i300 in xrange(_size296):
-            _elem260 = Order()
+            _elem301 = Order()
-            _elem260.read(iprot)
+            _elem301.read(iprot)
-            self.success.append(_elem260)
+            self.success.append(_elem301)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
   def write(self, oprot):
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('markDoasAsPickedUp_result')
+    oprot.writeStructBegin('getDoasNotPickedUp_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter261 in self.success:
+      for iter302 in self.success:
-        iter261.write(oprot)
+        iter302.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.MAP:
           self.pickupDetails = {}
-          (_ktype263, _vtype264, _size262 ) = iprot.readMapBegin()
+          (_ktype304, _vtype305, _size303 ) = iprot.readMapBegin()
-          for _i266 in xrange(_size262):
+          for _i307 in xrange(_size303):
-            _key267 = iprot.readString();
+            _key308 = iprot.readString();
-            _val268 = iprot.readString();
+            _val309 = iprot.readString();
-            self.pickupDetails[_key267] = _val268
+            self.pickupDetails[_key308] = _val309
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       oprot.writeI64(self.providerId)
       oprot.writeFieldEnd()
     if self.pickupDetails is not None:
       oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
       oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
-      for kiter269,viter270 in self.pickupDetails.items():
+      for kiter310,viter311 in self.pickupDetails.items():
-        oprot.writeString(kiter269)
+        oprot.writeString(kiter310)
-        oprot.writeString(viter270)
+        oprot.writeString(viter311)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __ne__(self, other):
     return not (self == other)
 class markReturnOrdersAsPickedUp_result:
+  thrift_spec = (
+  )
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getReturnOrdersNotPickedUp_args:
+  """
+  Attributes:
+   - providerId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'providerId', None, None, ), # 1
+  )
+  def __init__(self, providerId=None,):
+    self.providerId = providerId
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.providerId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getReturnOrdersNotPickedUp_args')
+    if self.providerId is not None:
+      oprot.writeFieldBegin('providerId', TType.I64, 1)
+      oprot.writeI64(self.providerId)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getReturnOrdersNotPickedUp_result:
   """
   Attributes:
    - success
   """
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype274, _size271) = iprot.readListBegin()
+          (_etype315, _size312) = iprot.readListBegin()
-          for _i275 in xrange(_size271):
+          for _i316 in xrange(_size312):
-            _elem276 = Order()
+            _elem317 = Order()
-            _elem276.read(iprot)
+            _elem317.read(iprot)
-            self.success.append(_elem276)
+            self.success.append(_elem317)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
   def write(self, oprot):
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('markReturnOrdersAsPickedUp_result')
+    oprot.writeStructBegin('getReturnOrdersNotPickedUp_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter277 in self.success:
+      for iter318 in self.success:
-        iter277.write(oprot)
+        iter318.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype281, _size278) = iprot.readListBegin()
+          (_etype322, _size319) = iprot.readListBegin()
-          for _i282 in xrange(_size278):
+          for _i323 in xrange(_size319):
-            _elem283 = ReturnOrder()
+            _elem324 = ReturnOrder()
-            _elem283.read(iprot)
+            _elem324.read(iprot)
-            self.success.append(_elem283)
+            self.success.append(_elem324)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getReturnOrders_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter284 in self.success:
+      for iter325 in self.success:
-        iter284.write(oprot)
+        iter325.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.MAP:
           self.collectedAmountMap = {}
-          (_ktype286, _vtype287, _size285 ) = iprot.readMapBegin()
+          (_ktype327, _vtype328, _size326 ) = iprot.readMapBegin()
-          for _i289 in xrange(_size285):
+          for _i330 in xrange(_size326):
-            _key290 = iprot.readString();
+            _key331 = iprot.readString();
-            _val291 = iprot.readDouble();
+            _val332 = iprot.readDouble();
-            self.collectedAmountMap[_key290] = _val291
+            self.collectedAmountMap[_key331] = _val332
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.STRING:
       return
     oprot.writeStructBegin('reconcileCodCollection_args')
     if self.collectedAmountMap is not None:
       oprot.writeFieldBegin('collectedAmountMap', TType.MAP, 1)
       oprot.writeMapBegin(TType.STRING, TType.DOUBLE, len(self.collectedAmountMap))
-      for kiter292,viter293 in self.collectedAmountMap.items():
+      for kiter333,viter334 in self.collectedAmountMap.items():
-        oprot.writeString(kiter292)
+        oprot.writeString(kiter333)
-        oprot.writeDouble(viter293)
+        oprot.writeDouble(viter334)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     if self.xferBy is not None:
       oprot.writeFieldBegin('xferBy', TType.STRING, 2)
       oprot.writeString(self.xferBy)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.MAP:
           self.success = {}
-          (_ktype295, _vtype296, _size294 ) = iprot.readMapBegin()
+          (_ktype336, _vtype337, _size335 ) = iprot.readMapBegin()
-          for _i298 in xrange(_size294):
+          for _i339 in xrange(_size335):
-            _key299 = iprot.readString();
+            _key340 = iprot.readString();
-            _val300 = iprot.readString();
+            _val341 = iprot.readString();
-            self.success[_key299] = _val300
+            self.success[_key340] = _val341
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('reconcileCodCollection_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.MAP, 0)
       oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.success))
-      for kiter301,viter302 in self.success.items():
+      for kiter342,viter343 in self.success.items():
-        oprot.writeString(kiter301)
+        oprot.writeString(kiter342)
-        oprot.writeString(viter302)
+        oprot.writeString(viter343)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype306, _size303) = iprot.readListBegin()
+          (_etype347, _size344) = iprot.readListBegin()
-          for _i307 in xrange(_size303):
+          for _i348 in xrange(_size344):
-            _elem308 = iprot.readI64();
+            _elem349 = iprot.readI64();
-            self.success.append(_elem308)
+            self.success.append(_elem349)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getTransactionsRequiringExtraProcessing_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.I64, len(self.success))
-      for iter309 in self.success:
+      for iter350 in self.success:
-        oprot.writeI64(iter309)
+        oprot.writeI64(iter350)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.MAP:
           self.success = {}
-          (_ktype311, _vtype312, _size310 ) = iprot.readMapBegin()
+          (_ktype352, _vtype353, _size351 ) = iprot.readMapBegin()
-          for _i314 in xrange(_size310):
+          for _i355 in xrange(_size351):
-            _key315 = iprot.readI64();
+            _key356 = iprot.readI64();
-            _val316 = iprot.readI64();
+            _val357 = iprot.readI64();
-            self.success[_key315] = _val316
+            self.success[_key356] = _val357
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getItemWiseRiskyOrdersCount_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.MAP, 0)
       oprot.writeMapBegin(TType.I64, TType.I64, len(self.success))
-      for kiter317,viter318 in self.success.items():
+      for kiter358,viter359 in self.success.items():
-        oprot.writeI64(kiter317)
+        oprot.writeI64(kiter358)
-        oprot.writeI64(viter318)
+        oprot.writeI64(viter359)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.itemIds = []
-          (_etype322, _size319) = iprot.readListBegin()
+          (_etype363, _size360) = iprot.readListBegin()
-          for _i323 in xrange(_size319):
+          for _i364 in xrange(_size360):
-            _elem324 = iprot.readI64();
+            _elem365 = iprot.readI64();
-            self.itemIds.append(_elem324)
+            self.itemIds.append(_elem365)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getOrdersForItemIds_args')
     if self.itemIds is not None:
       oprot.writeFieldBegin('itemIds', TType.LIST, 1)
       oprot.writeListBegin(TType.I64, len(self.itemIds))
-      for iter325 in self.itemIds:
+      for iter366 in self.itemIds:
-        oprot.writeI64(iter325)
+        oprot.writeI64(iter366)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype329, _size326) = iprot.readListBegin()
+          (_etype370, _size367) = iprot.readListBegin()
-          for _i330 in xrange(_size326):
+          for _i371 in xrange(_size367):
-            _elem331 = Order()
+            _elem372 = Order()
-            _elem331.read(iprot)
+            _elem372.read(iprot)
-            self.success.append(_elem331)
+            self.success.append(_elem372)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getOrdersForItemIds_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter332 in self.success:
+      for iter373 in self.success:
-        iter332.write(oprot)
+        iter373.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.MAP:
           self.success = {}
-          (_ktype334, _vtype335, _size333 ) = iprot.readMapBegin()
+          (_ktype375, _vtype376, _size374 ) = iprot.readMapBegin()
-          for _i337 in xrange(_size333):
+          for _i378 in xrange(_size374):
-            _key338 = iprot.readI32();
+            _key379 = iprot.readI32();
-            _val339 = TimeoutSummary()
+            _val380 = TimeoutSummary()
-            _val339.read(iprot)
+            _val380.read(iprot)
-            self.success[_key338] = _val339
+            self.success[_key379] = _val380
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('markOrdersAsTimeout_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.MAP, 0)
       oprot.writeMapBegin(TType.I32, TType.STRUCT, len(self.success))
-      for kiter340,viter341 in self.success.items():
+      for kiter381,viter382 in self.success.items():
-        oprot.writeI32(kiter340)
+        oprot.writeI32(kiter381)
-        viter341.write(oprot)
+        viter382.write(oprot)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
 class getOrdersForProviderForStatus_args:
   """
   Attributes:
    - logistics_provider_id
-   - order_status
+   - order_status_list
   """
   thrift_spec = (
     None, # 0
     (1, TType.I64, 'logistics_provider_id', None, None, ), # 1
-    (2, TType.I32, 'order_status', None, None, ), # 2
+    (2, TType.LIST, 'order_status_list', (TType.I32,None), None, ), # 2
+  )
-  def __init__(self, logistics_provider_id=None, order_status=None,):
+  def __init__(self, logistics_provider_id=None, order_status_list=None,):
     self.logistics_provider_id = logistics_provider_id
-    self.order_status = order_status
+    self.order_status_list = order_status_list
   def read(self, iprot):
     if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
       fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
       return
         if ftype == TType.I64:
           self.logistics_provider_id = iprot.readI64();
         else:
           iprot.skip(ftype)
       elif fid == 2:
-        if ftype == TType.I32:
+        if ftype == TType.LIST:
+          self.order_status_list = []
+          (_etype386, _size383) = iprot.readListBegin()
+          for _i387 in xrange(_size383):
-          self.order_status = iprot.readI32();
+            _elem388 = iprot.readI32();
+            self.order_status_list.append(_elem388)
+          iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
     oprot.writeStructBegin('getOrdersForProviderForStatus_args')
     if self.logistics_provider_id is not None:
       oprot.writeFieldBegin('logistics_provider_id', TType.I64, 1)
       oprot.writeI64(self.logistics_provider_id)
       oprot.writeFieldEnd()
-    if self.order_status is not None:
+    if self.order_status_list is not None:
-      oprot.writeFieldBegin('order_status', TType.I32, 2)
+      oprot.writeFieldBegin('order_status_list', TType.LIST, 2)
+      oprot.writeListBegin(TType.I32, len(self.order_status_list))
-      oprot.writeI32(self.order_status)
+      for iter389 in self.order_status_list:
+        oprot.writeI32(iter389)
+      oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def validate(self):
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype345, _size342) = iprot.readListBegin()
+          (_etype393, _size390) = iprot.readListBegin()
-          for _i346 in xrange(_size342):
+          for _i394 in xrange(_size390):
-            _elem347 = Order()
+            _elem395 = Order()
-            _elem347.read(iprot)
+            _elem395.read(iprot)
-            self.success.append(_elem347)
+            self.success.append(_elem395)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getOrdersForProviderForStatus_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter348 in self.success:
+      for iter396 in self.success:
-        iter348.write(oprot)
+        iter396.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype352, _size349) = iprot.readListBegin()
+          (_etype400, _size397) = iprot.readListBegin()
-          for _i353 in xrange(_size349):
+          for _i401 in xrange(_size397):
-            _elem354 = Order()
+            _elem402 = Order()
-            _elem354.read(iprot)
+            _elem402.read(iprot)
-            self.success.append(_elem354)
+            self.success.append(_elem402)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getBilledOrdersForVendor_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter355 in self.success:
+      for iter403 in self.success:
-        iter355.write(oprot)
+        iter403.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype359, _size356) = iprot.readListBegin()
+          (_etype407, _size404) = iprot.readListBegin()
-          for _i360 in xrange(_size356):
+          for _i408 in xrange(_size404):
-            _elem361 = Order()
+            _elem409 = Order()
-            _elem361.read(iprot)
+            _elem409.read(iprot)
-            self.success.append(_elem361)
+            self.success.append(_elem409)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getSlippedSippingDateOrders_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter362 in self.success:
+      for iter410 in self.success:
-        iter362.write(oprot)
+        iter410.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype366, _size363) = iprot.readListBegin()
+          (_etype414, _size411) = iprot.readListBegin()
-          for _i367 in xrange(_size363):
+          for _i415 in xrange(_size411):
-            _elem368 = Order()
+            _elem416 = Order()
-            _elem368.read(iprot)
+            _elem416.read(iprot)
-            self.success.append(_elem368)
+            self.success.append(_elem416)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getCancelledOrders_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter369 in self.success:
+      for iter417 in self.success:
-        iter369.write(oprot)
+        iter417.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.MAP:
           self.mapAWBAndAmount = {}
-          (_ktype371, _vtype372, _size370 ) = iprot.readMapBegin()
+          (_ktype419, _vtype420, _size418 ) = iprot.readMapBegin()
-          for _i374 in xrange(_size370):
+          for _i422 in xrange(_size418):
-            _key375 = iprot.readI64();
+            _key423 = iprot.readI64();
-            _val376 = iprot.readDouble();
+            _val424 = iprot.readDouble();
-            self.mapAWBAndAmount[_key375] = _val376
+            self.mapAWBAndAmount[_key423] = _val424
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('saveBluedartSettlements_args')
     if self.mapAWBAndAmount is not None:
       oprot.writeFieldBegin('mapAWBAndAmount', TType.MAP, 1)
       oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.mapAWBAndAmount))
-      for kiter377,viter378 in self.mapAWBAndAmount.items():
+      for kiter425,viter426 in self.mapAWBAndAmount.items():
-        oprot.writeI64(kiter377)
+        oprot.writeI64(kiter425)
-        oprot.writeDouble(viter378)
+        oprot.writeDouble(viter426)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.MAP:
           self.success = {}
-          (_ktype380, _vtype381, _size379 ) = iprot.readMapBegin()
+          (_ktype428, _vtype429, _size427 ) = iprot.readMapBegin()
-          for _i383 in xrange(_size379):
+          for _i431 in xrange(_size427):
-            _key384 = iprot.readI64();
+            _key432 = iprot.readI64();
-            _val385 = iprot.readString();
+            _val433 = iprot.readString();
-            self.success[_key384] = _val385
+            self.success[_key432] = _val433
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getEBSSettlementSummaries_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.MAP, 0)
       oprot.writeMapBegin(TType.I64, TType.STRING, len(self.success))
-      for kiter386,viter387 in self.success.items():
+      for kiter434,viter435 in self.success.items():
-        oprot.writeI64(kiter386)
+        oprot.writeI64(kiter434)
-        oprot.writeString(viter387)
+        oprot.writeString(viter435)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype391, _size388) = iprot.readListBegin()
+          (_etype439, _size436) = iprot.readListBegin()
-          for _i392 in xrange(_size388):
+          for _i440 in xrange(_size436):
-            _elem393 = PaymentSettlement()
+            _elem441 = PaymentSettlement()
-            _elem393.read(iprot)
+            _elem441.read(iprot)
-            self.success.append(_elem393)
+            self.success.append(_elem441)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getSettlementsByDate_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter394 in self.success:
+      for iter442 in self.success:
-        iter394.write(oprot)
+        iter442.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.orderIds = []
-          (_etype398, _size395) = iprot.readListBegin()
+          (_etype446, _size443) = iprot.readListBegin()
-          for _i399 in xrange(_size395):
+          for _i447 in xrange(_size443):
-            _elem400 = iprot.readI64();
+            _elem448 = iprot.readI64();
-            self.orderIds.append(_elem400)
+            self.orderIds.append(_elem448)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getReshippedOrderIds_args')
     if self.orderIds is not None:
       oprot.writeFieldBegin('orderIds', TType.LIST, 1)
       oprot.writeListBegin(TType.I64, len(self.orderIds))
-      for iter401 in self.orderIds:
+      for iter449 in self.orderIds:
-        oprot.writeI64(iter401)
+        oprot.writeI64(iter449)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype405, _size402) = iprot.readListBegin()
+          (_etype453, _size450) = iprot.readListBegin()
-          for _i406 in xrange(_size402):
+          for _i454 in xrange(_size450):
-            _elem407 = iprot.readI64();
+            _elem455 = iprot.readI64();
-            self.success.append(_elem407)
+            self.success.append(_elem455)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getReshippedOrderIds_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.I64, len(self.success))
-      for iter408 in self.success:
+      for iter456 in self.success:
-        oprot.writeI64(iter408)
+        oprot.writeI64(iter456)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.MAP:
           self.itemIdQuantityMap = {}
-          (_ktype410, _vtype411, _size409 ) = iprot.readMapBegin()
+          (_ktype458, _vtype459, _size457 ) = iprot.readMapBegin()
-          for _i413 in xrange(_size409):
+          for _i461 in xrange(_size457):
-            _key414 = iprot.readI64();
+            _key462 = iprot.readI64();
-            _val415 = iprot.readI64();
+            _val463 = iprot.readI64();
-            self.itemIdQuantityMap[_key414] = _val415
+            self.itemIdQuantityMap[_key462] = _val463
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.I64:
       return
     oprot.writeStructBegin('updateOrdersAsPORaised_args')
     if self.itemIdQuantityMap is not None:
       oprot.writeFieldBegin('itemIdQuantityMap', TType.MAP, 1)
       oprot.writeMapBegin(TType.I64, TType.I64, len(self.itemIdQuantityMap))
-      for kiter416,viter417 in self.itemIdQuantityMap.items():
+      for kiter464,viter465 in self.itemIdQuantityMap.items():
-        oprot.writeI64(kiter416)
+        oprot.writeI64(kiter464)
-        oprot.writeI64(viter417)
+        oprot.writeI64(viter465)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     if self.purchaseOrderId is not None:
       oprot.writeFieldBegin('purchaseOrderId', TType.I64, 2)
       oprot.writeI64(self.purchaseOrderId)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype421, _size418) = iprot.readListBegin()
+          (_etype469, _size466) = iprot.readListBegin()
-          for _i422 in xrange(_size418):
+          for _i470 in xrange(_size466):
-            _elem423 = Order()
+            _elem471 = Order()
-            _elem423.read(iprot)
+            _elem471.read(iprot)
-            self.success.append(_elem423)
+            self.success.append(_elem471)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getOrdersWhereVendorNotPaid_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter424 in self.success:
+      for iter472 in self.success:
-        iter424.write(oprot)
+        iter472.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)

Subversion Repositories SmartDukaan

(root)/trunk/PyProj/src/shop2020/thriftpy/model/v1/order/TransactionService.py – Rev 4905 → 4910