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

      - status
      - description
     """
     pass
-  def addBillingDetails(self, orderId, invoice_number, billed_by):
-    """
-    Add billing details such as the bill number and the biller to the Order.
-    Parameters:
-     - orderId
-     - invoice_number
-     - billed_by
-    """
-    pass
-  def addJacketNumber(self, orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType):
-    """
-    Adds jacket number and IMEI no. to the order. Doesn't update the IMEI no. if a -1 is supplied.
-    Also marks the order as billed and sets the billing timestamp.
-    Return false if it doesn't find the order with the given ID.
-    Parameters:
-     - orderId
-     - jacketNumber
-     - imeiNumber
-     - itemNumber
-     - billedBy
-     - billingType
-    """
-    pass
-  def acceptOrder(self, orderId):
-    """
-    Parameters:
-     - orderId
-    """
-    pass
-  def billOrder(self, orderId):
-    """
-    Parameters:
-     - orderId
-    """
-    pass
   def getOrdersForTransaction(self, transactionId, customerId):
     """
     Returns list of orders for given transaction Id. Also filters based on customer Id so that
     only user who owns the transaction can view its order details.
      - orderId
      - customerId
     """
     pass
+  def getAlerts(self, orderId, valid):
+    """
+    Parameters:
+     - orderId
+     - valid
+    """
+    pass
+  def setAlert(self, orderId, unset, type, comment):
+    """
+    Parameters:
+     - orderId
+     - unset
+     - type
+     - comment
+    """
+    pass
+  def getValidOrderCount(self, ):
+    """
+    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
+    """
+    pass
+  def getNoOfCustomersWithSuccessfulTransaction(self, ):
+    """
+    Returns the number of distinct customers who have done successful transactions
+    """
+    pass
+  def getValidOrdersAmountRange(self, ):
+    """
+    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
+    List contains two values, first minimum amount and second maximum amount.
+    """
+    pass
+  def getValidOrders(self, limit):
+    """
+    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
+    If limit is passed as 0, then all valid Orders are returned.
+    Parameters:
+     - limit
+    """
+    pass
   def batchOrders(self, warehouseId):
     """
     Create a batch of all the pending orders for the given warehouse.
     The returned list is orderd by created_timestamp.
     If there are no pending orders, an empty list is returned.
     Parameters:
      - orderId
     """
     pass
-  def markOrdersAsManifested(self, warehouseId, providerId):
+  def verifyOrder(self, orderId):
     """
+    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
+    timestamp. It is intended to be used for COD orders but can be harmlessly
+    used for all other orders as well.
+    Throws an exception if no such order exists.
+    Parameters:
+     - orderId
+    """
+    pass
+  def acceptOrder(self, orderId):
+    """
+    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
+    given order is not a COD order, it also captures the payment if the same has
+    not been captured.
+    Throws an exception if no such order exists.
+    Parameters:
+     - orderId
+    """
+    pass
+  def billOrder(self, orderId):
+    """
+    Parameters:
+     - orderId
+    """
+    pass
+  def addBillingDetails(self, orderId, invoice_number, billed_by):
+    """
+    Add billing details such as the bill number and the biller to the Order.
+    Should be used when the bill is issued by a 3rd party and we've to feed
+    the information into our system.
+    Parameters:
+     - orderId
+     - invoice_number
+     - billed_by
+    """
+    pass
+  def addJacketNumber(self, orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType):
+    """
+    Adds jacket number, item number and IMEI no. to the order. Doesn't update
+    the IMEI no. if a -1 is supplied.
+    Also, it generates an invoice number for the order, marks the order as
+    BILLED and sets the billing timestamp.
+    It should be used when we are billing the orders ourselves.
+    Returns false if it doesn't find the order with the given ID.
+    Parameters:
+     - orderId
+     - jacketNumber
+     - imeiNumber
+     - itemNumber
+     - billedBy
+     - billingType
+    """
+    pass
+  def markOrdersAsManifested(self, warehouseId, providerId, cod):
+    """
+    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
-    Marks all BILLED orders for a warehouse and a provider as SHIPPED_FROM_WH
+    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
     Parameters:
      - warehouseId
      - providerId
+     - cod
     """
     pass
   def markOrdersAsPickedUp(self, providerId, pickupDetails):
     """
      - providerId
      - warehouseId
     """
     pass
-  def getAlerts(self, orderId, valid):
-    """
-    Parameters:
-     - orderId
-     - valid
-    """
-    pass
-  def setAlert(self, orderId, unset, type, comment):
-    """
-    Parameters:
-     - orderId
-     - unset
-     - type
-     - comment
-    """
-    pass
-  def getValidOrderCount(self, ):
-    """
-    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
-    """
-    pass
-  def getNoOfCustomersWithSuccessfulTransaction(self, ):
-    """
-    Returns the number of distinct customers who have done successful transactions
-    """
-    pass
-  def getValidOrdersAmountRange(self, ):
-    """
-    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
-    List contains two values, first minimum amount and second maximum amount.
-    """
-    pass
-  def getValidOrders(self, limit):
-    """
-    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
-    If limit is passed as 0, then all valid Orders are returned.
-    Parameters:
-     - limit
-    """
-    pass
   def toggleDOAFlag(self, orderId):
     """
     Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
     Returns the final flag status.
     Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
       return result.success
     if result.ex != None:
       raise result.ex
     raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus failed: unknown result");
-  def addBillingDetails(self, orderId, invoice_number, billed_by):
-    """
-    Add billing details such as the bill number and the biller to the Order.
-    Parameters:
-     - orderId
-     - invoice_number
-     - billed_by
-    """
-    self.send_addBillingDetails(orderId, invoice_number, billed_by)
-    return self.recv_addBillingDetails()
-  def send_addBillingDetails(self, orderId, invoice_number, billed_by):
-    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
-    args = addBillingDetails_args()
-    args.orderId = orderId
-    args.invoice_number = invoice_number
-    args.billed_by = billed_by
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-  def recv_addBillingDetails(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = addBillingDetails_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success != None:
-      return result.success
-    if result.ex != None:
-      raise result.ex
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
-  def addJacketNumber(self, orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType):
-    """
-    Adds jacket number and IMEI no. to the order. Doesn't update the IMEI no. if a -1 is supplied.
-    Also marks the order as billed and sets the billing timestamp.
-    Return false if it doesn't find the order with the given ID.
-    Parameters:
-     - orderId
-     - jacketNumber
-     - imeiNumber
-     - itemNumber
-     - billedBy
-     - billingType
-    """
-    self.send_addJacketNumber(orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType)
-    return self.recv_addJacketNumber()
-  def send_addJacketNumber(self, orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType):
-    self._oprot.writeMessageBegin('addJacketNumber', TMessageType.CALL, self._seqid)
-    args = addJacketNumber_args()
-    args.orderId = orderId
-    args.jacketNumber = jacketNumber
-    args.imeiNumber = imeiNumber
-    args.itemNumber = itemNumber
-    args.billedBy = billedBy
-    args.billingType = billingType
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-  def recv_addJacketNumber(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = addJacketNumber_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success != None:
-      return result.success
-    if result.ex != None:
-      raise result.ex
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "addJacketNumber failed: unknown result");
-  def acceptOrder(self, orderId):
-    """
-    Parameters:
-     - orderId
-    """
-    self.send_acceptOrder(orderId)
-    return self.recv_acceptOrder()
-  def send_acceptOrder(self, orderId):
-    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
-    args = acceptOrder_args()
-    args.orderId = orderId
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-  def recv_acceptOrder(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = acceptOrder_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success != None:
-      return result.success
-    if result.ex != None:
-      raise result.ex
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
-  def billOrder(self, orderId):
-    """
-    Parameters:
-     - orderId
-    """
-    self.send_billOrder(orderId)
-    return self.recv_billOrder()
-  def send_billOrder(self, orderId):
-    self._oprot.writeMessageBegin('billOrder', TMessageType.CALL, self._seqid)
-    args = billOrder_args()
-    args.orderId = orderId
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-  def recv_billOrder(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = billOrder_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success != None:
-      return result.success
-    if result.ex != None:
-      raise result.ex
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "billOrder failed: unknown result");
   def getOrdersForTransaction(self, transactionId, customerId):
     """
     Returns list of orders for given transaction Id. Also filters based on customer Id so that
     only user who owns the transaction can view its order details.
       return result.success
     if result.ex != None:
       raise result.ex
     raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
+  def getAlerts(self, orderId, valid):
+    """
+    Parameters:
+     - orderId
+     - valid
+    """
+    self.send_getAlerts(orderId, valid)
+    return self.recv_getAlerts()
+  def send_getAlerts(self, orderId, valid):
+    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
+    args = getAlerts_args()
+    args.orderId = orderId
+    args.valid = valid
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getAlerts(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getAlerts_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
+  def setAlert(self, orderId, unset, type, comment):
+    """
+    Parameters:
+     - orderId
+     - unset
+     - type
+     - comment
+    """
+    self.send_setAlert(orderId, unset, type, comment)
+    self.recv_setAlert()
+  def send_setAlert(self, orderId, unset, type, comment):
+    self._oprot.writeMessageBegin('setAlert', TMessageType.CALL, self._seqid)
+    args = setAlert_args()
+    args.orderId = orderId
+    args.unset = unset
+    args.type = type
+    args.comment = comment
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_setAlert(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = setAlert_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    return
+  def getValidOrderCount(self, ):
+    """
+    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
+    """
+    self.send_getValidOrderCount()
+    return self.recv_getValidOrderCount()
+  def send_getValidOrderCount(self, ):
+    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
+    args = getValidOrderCount_args()
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getValidOrderCount(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getValidOrderCount_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
+  def getNoOfCustomersWithSuccessfulTransaction(self, ):
+    """
+    Returns the number of distinct customers who have done successful transactions
+    """
+    self.send_getNoOfCustomersWithSuccessfulTransaction()
+    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
+  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
+    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
+    args = getNoOfCustomersWithSuccessfulTransaction_args()
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getNoOfCustomersWithSuccessfulTransaction_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
+  def getValidOrdersAmountRange(self, ):
+    """
+    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
+    List contains two values, first minimum amount and second maximum amount.
+    """
+    self.send_getValidOrdersAmountRange()
+    return self.recv_getValidOrdersAmountRange()
+  def send_getValidOrdersAmountRange(self, ):
+    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
+    args = getValidOrdersAmountRange_args()
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getValidOrdersAmountRange(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getValidOrdersAmountRange_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
+  def getValidOrders(self, limit):
+    """
+    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
+    If limit is passed as 0, then all valid Orders are returned.
+    Parameters:
+     - limit
+    """
+    self.send_getValidOrders(limit)
+    return self.recv_getValidOrders()
+  def send_getValidOrders(self, limit):
+    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
+    args = getValidOrders_args()
+    args.limit = limit
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getValidOrders(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getValidOrders_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
   def batchOrders(self, warehouseId):
     """
     Create a batch of all the pending orders for the given warehouse.
     The returned list is orderd by created_timestamp.
     If there are no pending orders, an empty list is returned.
       return result.success
     if result.ex != None:
       raise result.ex
     raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
-  def markOrdersAsManifested(self, warehouseId, providerId):
+  def verifyOrder(self, orderId):
     """
-    Marks all BILLED orders for a warehouse and a provider as SHIPPED_FROM_WH
+    Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified
+    timestamp. It is intended to be used for COD orders but can be harmlessly
+    used for all other orders as well.
+    Throws an exception if no such order exists.
     Parameters:
-     - warehouseId
-     - providerId
+     - orderId
     """
-    self.send_markOrdersAsManifested(warehouseId, providerId)
+    self.send_verifyOrder(orderId)
-    return self.recv_markOrdersAsManifested()
+    return self.recv_verifyOrder()
-  def send_markOrdersAsManifested(self, warehouseId, providerId):
+  def send_verifyOrder(self, orderId):
-    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('verifyOrder', TMessageType.CALL, self._seqid)
-    args = markOrdersAsManifested_args()
+    args = verifyOrder_args()
-    args.warehouseId = warehouseId
-    args.providerId = providerId
+    args.orderId = orderId
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_markOrdersAsManifested(self, ):
+  def recv_verifyOrder(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 = verifyOrder_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success != None:
       return result.success
     if result.ex != None:
       raise result.ex
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
-  def markOrdersAsPickedUp(self, providerId, pickupDetails):
+  def acceptOrder(self, orderId):
     """
-    Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.
+    Marks the given order as ACCEPTED and updates the accepted timestamp. If the
-    Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.
+    given order is not a COD order, it also captures the payment if the same has
+    not been captured.
-    Raises an exception if we encounter report for an AWB number that we did not ship.
+    Throws an exception if no such order exists.
     Parameters:
-     - providerId
+     - orderId
-     - pickupDetails
     """
-    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
+    self.send_acceptOrder(orderId)
-    return self.recv_markOrdersAsPickedUp()
+    return self.recv_acceptOrder()
-  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
+  def send_acceptOrder(self, orderId):
-    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('acceptOrder', TMessageType.CALL, self._seqid)
-    args = markOrdersAsPickedUp_args()
+    args = acceptOrder_args()
-    args.providerId = providerId
+    args.orderId = orderId
-    args.pickupDetails = pickupDetails
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_markOrdersAsPickedUp(self, ):
+  def recv_acceptOrder(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 = acceptOrder_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success != None:
       return result.success
     if result.ex != None:
       raise result.ex
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
-  def markOrdersAsDelivered(self, providerId, deliveredOrders):
+  def billOrder(self, orderId):
     """
-    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
-    the name of the receiver.
-    Raises an exception if we encounter report for an AWB number that we did not ship.
     Parameters:
-     - providerId
+     - orderId
-     - deliveredOrders
     """
-    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
+    self.send_billOrder(orderId)
-    self.recv_markOrdersAsDelivered()
+    return self.recv_billOrder()
-  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
+  def send_billOrder(self, orderId):
-    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('billOrder', TMessageType.CALL, self._seqid)
-    args = markOrdersAsDelivered_args()
+    args = billOrder_args()
-    args.providerId = providerId
+    args.orderId = orderId
-    args.deliveredOrders = deliveredOrders
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_markOrdersAsDelivered(self, ):
+  def recv_billOrder(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = markOrdersAsDelivered_result()
+    result = billOrder_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
     if result.ex != None:
       raise result.ex
-    return
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "billOrder failed: unknown result");
-  def markOrdersAsFailed(self, providerId, returnedOrders):
+  def addBillingDetails(self, orderId, invoice_number, billed_by):
     """
-    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
+    Add billing details such as the bill number and the biller to the Order.
-    Raises an exception if we encounter report for an AWB number that we did not ship.
+    Should be used when the bill is issued by a 3rd party and we've to feed
+    the information into our system.
     Parameters:
-     - providerId
+     - orderId
-     - returnedOrders
+     - invoice_number
+     - billed_by
     """
-    self.send_markOrdersAsFailed(providerId, returnedOrders)
+    self.send_addBillingDetails(orderId, invoice_number, billed_by)
-    self.recv_markOrdersAsFailed()
+    return self.recv_addBillingDetails()
-  def send_markOrdersAsFailed(self, providerId, returnedOrders):
+  def send_addBillingDetails(self, orderId, invoice_number, billed_by):
-    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('addBillingDetails', TMessageType.CALL, self._seqid)
-    args = markOrdersAsFailed_args()
+    args = addBillingDetails_args()
-    args.providerId = providerId
+    args.orderId = orderId
-    args.returnedOrders = returnedOrders
+    args.invoice_number = invoice_number
+    args.billed_by = billed_by
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_markOrdersAsFailed(self, ):
+  def recv_addBillingDetails(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 = addBillingDetails_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
     if result.ex != None:
       raise result.ex
-    return
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
-  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
+  def addJacketNumber(self, orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType):
     """
+    Adds jacket number, item number and IMEI no. to the order. Doesn't update
+    the IMEI no. if a -1 is supplied.
-    Update the status description of orders whose AWB numbers are keys of the Map.
+    Also, it generates an invoice number for the order, marks the order as
+    BILLED and sets the billing timestamp.
+    It should be used when we are billing the orders ourselves.
+    Returns false if it doesn't find the order with the given ID.
     Parameters:
-     - providerId
+     - orderId
+     - jacketNumber
-     - undeliveredOrders
+     - imeiNumber
+     - itemNumber
+     - billedBy
+     - billingType
     """
-    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
+    self.send_addJacketNumber(orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType)
-    self.recv_updateNonDeliveryReason()
+    return self.recv_addJacketNumber()
-  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
+  def send_addJacketNumber(self, orderId, jacketNumber, imeiNumber, itemNumber, billedBy, billingType):
-    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('addJacketNumber', TMessageType.CALL, self._seqid)
-    args = updateNonDeliveryReason_args()
+    args = addJacketNumber_args()
-    args.providerId = providerId
+    args.orderId = orderId
+    args.jacketNumber = jacketNumber
+    args.imeiNumber = imeiNumber
-    args.undeliveredOrders = undeliveredOrders
+    args.itemNumber = itemNumber
+    args.billedBy = billedBy
+    args.billingType = billingType
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_updateNonDeliveryReason(self, ):
+  def recv_addJacketNumber(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = updateNonDeliveryReason_result()
+    result = addJacketNumber_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
+    if result.success != None:
+      return result.success
     if result.ex != None:
       raise result.ex
-    return
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "addJacketNumber failed: unknown result");
-  def getUndeliveredOrders(self, providerId, warehouseId):
+  def markOrdersAsManifested(self, warehouseId, providerId, cod):
     """
-    Returns the list of orders whose delivery time has passed but have not been
+    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
-    delivered yet for the given provider and warehouse. To get a complete list of
+    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
-    undelivered orders, pass them as -1.
-    Returns an empty list if no such orders exist.
     Parameters:
-     - providerId
      - warehouseId
+     - providerId
+     - cod
     """
-    self.send_getUndeliveredOrders(providerId, warehouseId)
+    self.send_markOrdersAsManifested(warehouseId, providerId, cod)
-    return self.recv_getUndeliveredOrders()
+    return self.recv_markOrdersAsManifested()
-  def send_getUndeliveredOrders(self, providerId, warehouseId):
+  def send_markOrdersAsManifested(self, warehouseId, providerId, cod):
-    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('markOrdersAsManifested', TMessageType.CALL, self._seqid)
-    args = getUndeliveredOrders_args()
+    args = markOrdersAsManifested_args()
-    args.providerId = providerId
     args.warehouseId = warehouseId
+    args.providerId = providerId
+    args.cod = cod
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_getUndeliveredOrders(self, ):
+  def recv_markOrdersAsManifested(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = getUndeliveredOrders_result()
+    result = markOrdersAsManifested_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success != None:
       return result.success
+    if result.ex != None:
+      raise result.ex
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
-  def getAlerts(self, orderId, valid):
+  def markOrdersAsPickedUp(self, providerId, pickupDetails):
     """
+    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:
-     - orderId
+     - providerId
-     - valid
+     - pickupDetails
     """
-    self.send_getAlerts(orderId, valid)
+    self.send_markOrdersAsPickedUp(providerId, pickupDetails)
-    return self.recv_getAlerts()
+    return self.recv_markOrdersAsPickedUp()
-  def send_getAlerts(self, orderId, valid):
+  def send_markOrdersAsPickedUp(self, providerId, pickupDetails):
-    self._oprot.writeMessageBegin('getAlerts', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('markOrdersAsPickedUp', TMessageType.CALL, self._seqid)
-    args = getAlerts_args()
+    args = markOrdersAsPickedUp_args()
-    args.orderId = orderId
+    args.providerId = providerId
-    args.valid = valid
+    args.pickupDetails = pickupDetails
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_getAlerts(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 = getAlerts_result()
+    result = markOrdersAsPickedUp_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success != None:
       return result.success
+    if result.ex != None:
+      raise result.ex
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
-  def setAlert(self, orderId, unset, type, comment):
+  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.
+    Raises an exception if we encounter report for an AWB number that we did not ship.
     Parameters:
-     - orderId
+     - providerId
-     - unset
-     - type
-     - comment
+     - deliveredOrders
     """
-    self.send_setAlert(orderId, unset, type, comment)
+    self.send_markOrdersAsDelivered(providerId, deliveredOrders)
-    self.recv_setAlert()
+    self.recv_markOrdersAsDelivered()
-  def send_setAlert(self, orderId, unset, type, comment):
+  def send_markOrdersAsDelivered(self, providerId, deliveredOrders):
-    self._oprot.writeMessageBegin('setAlert', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('markOrdersAsDelivered', TMessageType.CALL, self._seqid)
-    args = setAlert_args()
+    args = markOrdersAsDelivered_args()
-    args.orderId = orderId
+    args.providerId = providerId
-    args.unset = unset
-    args.type = type
-    args.comment = comment
+    args.deliveredOrders = deliveredOrders
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_setAlert(self, ):
+  def recv_markOrdersAsDelivered(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = setAlert_result()
+    result = markOrdersAsDelivered_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
+    if result.ex != None:
+      raise result.ex
     return
-  def getValidOrderCount(self, ):
-    """
-    Return the number of valid orders. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
-    """
-    self.send_getValidOrderCount()
-    return self.recv_getValidOrderCount()
-  def send_getValidOrderCount(self, ):
-    self._oprot.writeMessageBegin('getValidOrderCount', TMessageType.CALL, self._seqid)
-    args = getValidOrderCount_args()
-    args.write(self._oprot)
-    self._oprot.writeMessageEnd()
-    self._oprot.trans.flush()
-  def recv_getValidOrderCount(self, ):
-    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+  def markOrdersAsFailed(self, providerId, returnedOrders):
-    if mtype == TMessageType.EXCEPTION:
-      x = TApplicationException()
-      x.read(self._iprot)
-      self._iprot.readMessageEnd()
-      raise x
-    result = getValidOrderCount_result()
-    result.read(self._iprot)
-    self._iprot.readMessageEnd()
-    if result.success != None:
-      return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
-  def getNoOfCustomersWithSuccessfulTransaction(self, ):
     """
+    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
-    Returns the number of distinct customers who have done successful transactions
+    Raises an exception if we encounter report for an AWB number that we did not ship.
+    Parameters:
+     - providerId
+     - returnedOrders
     """
-    self.send_getNoOfCustomersWithSuccessfulTransaction()
+    self.send_markOrdersAsFailed(providerId, returnedOrders)
-    return self.recv_getNoOfCustomersWithSuccessfulTransaction()
+    self.recv_markOrdersAsFailed()
-  def send_getNoOfCustomersWithSuccessfulTransaction(self, ):
+  def send_markOrdersAsFailed(self, providerId, returnedOrders):
-    self._oprot.writeMessageBegin('getNoOfCustomersWithSuccessfulTransaction', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('markOrdersAsFailed', TMessageType.CALL, self._seqid)
-    args = getNoOfCustomersWithSuccessfulTransaction_args()
+    args = markOrdersAsFailed_args()
+    args.providerId = providerId
+    args.returnedOrders = returnedOrders
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_getNoOfCustomersWithSuccessfulTransaction(self, ):
+  def recv_markOrdersAsFailed(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = getNoOfCustomersWithSuccessfulTransaction_result()
+    result = markOrdersAsFailed_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
-    if result.success != None:
+    if result.ex != None:
-      return result.success
+      raise result.ex
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
+    return
-  def getValidOrdersAmountRange(self, ):
+  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
     """
-    Returns the minimum and maximum amounts of a valid order. (OrderStatus >= OrderStatus.SUBMITTED_FOR_PROCESSING)
+    Update the status description of orders whose AWB numbers are keys of the Map.
+    Parameters:
+     - providerId
-    List contains two values, first minimum amount and second maximum amount.
+     - undeliveredOrders
     """
-    self.send_getValidOrdersAmountRange()
+    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)
-    return self.recv_getValidOrdersAmountRange()
+    self.recv_updateNonDeliveryReason()
-  def send_getValidOrdersAmountRange(self, ):
+  def send_updateNonDeliveryReason(self, providerId, undeliveredOrders):
-    self._oprot.writeMessageBegin('getValidOrdersAmountRange', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('updateNonDeliveryReason', TMessageType.CALL, self._seqid)
-    args = getValidOrdersAmountRange_args()
+    args = updateNonDeliveryReason_args()
+    args.providerId = providerId
+    args.undeliveredOrders = undeliveredOrders
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_getValidOrdersAmountRange(self, ):
+  def recv_updateNonDeliveryReason(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = getValidOrdersAmountRange_result()
+    result = updateNonDeliveryReason_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
-    if result.success != None:
+    if result.ex != None:
-      return result.success
+      raise result.ex
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrdersAmountRange failed: unknown result");
+    return
-  def getValidOrders(self, limit):
+  def getUndeliveredOrders(self, providerId, warehouseId):
     """
-    Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.
+    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.
-    If limit is passed as 0, then all valid Orders are returned.
+    Returns an empty list if no such orders exist.
     Parameters:
-     - limit
+     - providerId
+     - warehouseId
     """
-    self.send_getValidOrders(limit)
+    self.send_getUndeliveredOrders(providerId, warehouseId)
-    return self.recv_getValidOrders()
+    return self.recv_getUndeliveredOrders()
-  def send_getValidOrders(self, limit):
+  def send_getUndeliveredOrders(self, providerId, warehouseId):
-    self._oprot.writeMessageBegin('getValidOrders', TMessageType.CALL, self._seqid)
+    self._oprot.writeMessageBegin('getUndeliveredOrders', TMessageType.CALL, self._seqid)
-    args = getValidOrders_args()
+    args = getUndeliveredOrders_args()
-    args.limit = limit
+    args.providerId = providerId
+    args.warehouseId = warehouseId
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
-  def recv_getValidOrders(self, ):
+  def recv_getUndeliveredOrders(self, ):
     (fname, mtype, rseqid) = self._iprot.readMessageBegin()
     if mtype == TMessageType.EXCEPTION:
       x = TApplicationException()
       x.read(self._iprot)
       self._iprot.readMessageEnd()
       raise x
-    result = getValidOrders_result()
+    result = getUndeliveredOrders_result()
     result.read(self._iprot)
     self._iprot.readMessageEnd()
     if result.success != None:
       return result.success
-    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrders failed: unknown result");
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUndeliveredOrders failed: unknown result");
   def toggleDOAFlag(self, orderId):
     """
     Toggle the DOA flag of an order. This should be used to flag an order for follow-up and unflag it when the follow-up is complete.
     Returns the final flag status.
     self._processMap["getAllOrders"] = Processor.process_getAllOrders
     self._processMap["getOrdersByBillingDate"] = Processor.process_getOrdersByBillingDate
     self._processMap["getReturnableOrdersForCustomer"] = Processor.process_getReturnableOrdersForCustomer
     self._processMap["getCancellableOrdersForCustomer"] = Processor.process_getCancellableOrdersForCustomer
     self._processMap["changeOrderStatus"] = Processor.process_changeOrderStatus
-    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
-    self._processMap["addJacketNumber"] = Processor.process_addJacketNumber
-    self._processMap["acceptOrder"] = Processor.process_acceptOrder
-    self._processMap["billOrder"] = Processor.process_billOrder
     self._processMap["getOrdersForTransaction"] = Processor.process_getOrdersForTransaction
     self._processMap["getOrdersForCustomer"] = Processor.process_getOrdersForCustomer
     self._processMap["createOrder"] = Processor.process_createOrder
     self._processMap["getOrder"] = Processor.process_getOrder
     self._processMap["getLineItemsForOrder"] = Processor.process_getLineItemsForOrder
     self._processMap["getOrderForCustomer"] = Processor.process_getOrderForCustomer
+    self._processMap["getAlerts"] = Processor.process_getAlerts
+    self._processMap["setAlert"] = Processor.process_setAlert
+    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
+    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
+    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
+    self._processMap["getValidOrders"] = Processor.process_getValidOrders
     self._processMap["batchOrders"] = Processor.process_batchOrders
     self._processMap["markOrderAsOutOfStock"] = Processor.process_markOrderAsOutOfStock
+    self._processMap["verifyOrder"] = Processor.process_verifyOrder
+    self._processMap["acceptOrder"] = Processor.process_acceptOrder
+    self._processMap["billOrder"] = Processor.process_billOrder
+    self._processMap["addBillingDetails"] = Processor.process_addBillingDetails
+    self._processMap["addJacketNumber"] = Processor.process_addJacketNumber
     self._processMap["markOrdersAsManifested"] = Processor.process_markOrdersAsManifested
     self._processMap["markOrdersAsPickedUp"] = Processor.process_markOrdersAsPickedUp
     self._processMap["markOrdersAsDelivered"] = Processor.process_markOrdersAsDelivered
     self._processMap["markOrdersAsFailed"] = Processor.process_markOrdersAsFailed
     self._processMap["updateNonDeliveryReason"] = Processor.process_updateNonDeliveryReason
     self._processMap["getUndeliveredOrders"] = Processor.process_getUndeliveredOrders
-    self._processMap["getAlerts"] = Processor.process_getAlerts
-    self._processMap["setAlert"] = Processor.process_setAlert
-    self._processMap["getValidOrderCount"] = Processor.process_getValidOrderCount
-    self._processMap["getNoOfCustomersWithSuccessfulTransaction"] = Processor.process_getNoOfCustomersWithSuccessfulTransaction
-    self._processMap["getValidOrdersAmountRange"] = Processor.process_getValidOrdersAmountRange
-    self._processMap["getValidOrders"] = Processor.process_getValidOrders
     self._processMap["toggleDOAFlag"] = Processor.process_toggleDOAFlag
     self._processMap["requestPickupNumber"] = Processor.process_requestPickupNumber
     self._processMap["authorizePickup"] = Processor.process_authorizePickup
     self._processMap["markDoasAsPickedUp"] = Processor.process_markDoasAsPickedUp
     self._processMap["receiveReturn"] = Processor.process_receiveReturn
     oprot.writeMessageBegin("changeOrderStatus", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_addBillingDetails(self, seqid, iprot, oprot):
-    args = addBillingDetails_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = addBillingDetails_result()
-    try:
-      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.billed_by)
-    except TransactionServiceException, ex:
-      result.ex = ex
-    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-  def process_addJacketNumber(self, seqid, iprot, oprot):
-    args = addJacketNumber_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = addJacketNumber_result()
-    try:
-      result.success = self._handler.addJacketNumber(args.orderId, args.jacketNumber, args.imeiNumber, args.itemNumber, args.billedBy, args.billingType)
-    except TransactionServiceException, ex:
-      result.ex = ex
-    oprot.writeMessageBegin("addJacketNumber", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-  def process_acceptOrder(self, seqid, iprot, oprot):
-    args = acceptOrder_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = acceptOrder_result()
-    try:
-      result.success = self._handler.acceptOrder(args.orderId)
-    except TransactionServiceException, ex:
-      result.ex = ex
-    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
-  def process_billOrder(self, seqid, iprot, oprot):
-    args = billOrder_args()
-    args.read(iprot)
-    iprot.readMessageEnd()
-    result = billOrder_result()
-    try:
-      result.success = self._handler.billOrder(args.orderId)
-    except TransactionServiceException, ex:
-      result.ex = ex
-    oprot.writeMessageBegin("billOrder", TMessageType.REPLY, seqid)
-    result.write(oprot)
-    oprot.writeMessageEnd()
-    oprot.trans.flush()
   def process_getOrdersForTransaction(self, seqid, iprot, oprot):
     args = getOrdersForTransaction_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = getOrdersForTransaction_result()
     oprot.writeMessageBegin("getOrderForCustomer", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
+  def process_getAlerts(self, seqid, iprot, oprot):
+    args = getAlerts_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getAlerts_result()
+    result.success = self._handler.getAlerts(args.orderId, args.valid)
+    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_setAlert(self, seqid, iprot, oprot):
+    args = setAlert_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = setAlert_result()
+    self._handler.setAlert(args.orderId, args.unset, args.type, args.comment)
+    oprot.writeMessageBegin("setAlert", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getValidOrderCount(self, seqid, iprot, oprot):
+    args = getValidOrderCount_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getValidOrderCount_result()
+    result.success = self._handler.getValidOrderCount()
+    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
+    args = getNoOfCustomersWithSuccessfulTransaction_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getNoOfCustomersWithSuccessfulTransaction_result()
+    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
+    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
+    args = getValidOrdersAmountRange_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getValidOrdersAmountRange_result()
+    result.success = self._handler.getValidOrdersAmountRange()
+    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getValidOrders(self, seqid, iprot, oprot):
+    args = getValidOrders_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getValidOrders_result()
+    result.success = self._handler.getValidOrders(args.limit)
+    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
   def process_batchOrders(self, seqid, iprot, oprot):
     args = batchOrders_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = batchOrders_result()
     oprot.writeMessageBegin("markOrderAsOutOfStock", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
+  def process_verifyOrder(self, seqid, iprot, oprot):
-    args = markOrdersAsManifested_args()
+    args = verifyOrder_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = markOrdersAsManifested_result()
+    result = verifyOrder_result()
     try:
-      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId)
+      result.success = self._handler.verifyOrder(args.orderId)
     except TransactionServiceException, ex:
       result.ex = ex
-    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("verifyOrder", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
+  def process_acceptOrder(self, seqid, iprot, oprot):
-    args = markOrdersAsPickedUp_args()
+    args = acceptOrder_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = markOrdersAsPickedUp_result()
+    result = acceptOrder_result()
     try:
-      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
+      result.success = self._handler.acceptOrder(args.orderId)
     except TransactionServiceException, ex:
       result.ex = ex
-    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("acceptOrder", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
+  def process_billOrder(self, seqid, iprot, oprot):
-    args = markOrdersAsDelivered_args()
+    args = billOrder_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = markOrdersAsDelivered_result()
+    result = billOrder_result()
     try:
-      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
+      result.success = self._handler.billOrder(args.orderId)
     except TransactionServiceException, ex:
       result.ex = ex
-    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("billOrder", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
+  def process_addBillingDetails(self, seqid, iprot, oprot):
-    args = markOrdersAsFailed_args()
+    args = addBillingDetails_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = markOrdersAsFailed_result()
+    result = addBillingDetails_result()
     try:
-      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
+      result.success = self._handler.addBillingDetails(args.orderId, args.invoice_number, args.billed_by)
     except TransactionServiceException, ex:
       result.ex = ex
-    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("addBillingDetails", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
+  def process_addJacketNumber(self, seqid, iprot, oprot):
-    args = updateNonDeliveryReason_args()
+    args = addJacketNumber_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = updateNonDeliveryReason_result()
+    result = addJacketNumber_result()
     try:
-      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
+      result.success = self._handler.addJacketNumber(args.orderId, args.jacketNumber, args.imeiNumber, args.itemNumber, args.billedBy, args.billingType)
     except TransactionServiceException, ex:
       result.ex = ex
-    oprot.writeMessageBegin("updateNonDeliveryReason", 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()
-    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
-    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("addJacketNumber", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_getAlerts(self, seqid, iprot, oprot):
+  def process_markOrdersAsManifested(self, seqid, iprot, oprot):
-    args = getAlerts_args()
+    args = markOrdersAsManifested_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = getAlerts_result()
+    result = markOrdersAsManifested_result()
+    try:
-    result.success = self._handler.getAlerts(args.orderId, args.valid)
+      result.success = self._handler.markOrdersAsManifested(args.warehouseId, args.providerId, args.cod)
+    except TransactionServiceException, ex:
+      result.ex = ex
-    oprot.writeMessageBegin("getAlerts", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("markOrdersAsManifested", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_setAlert(self, seqid, iprot, oprot):
+  def process_markOrdersAsPickedUp(self, seqid, iprot, oprot):
-    args = setAlert_args()
+    args = markOrdersAsPickedUp_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = setAlert_result()
+    result = markOrdersAsPickedUp_result()
+    try:
-    self._handler.setAlert(args.orderId, args.unset, args.type, args.comment)
+      result.success = self._handler.markOrdersAsPickedUp(args.providerId, args.pickupDetails)
+    except TransactionServiceException, ex:
+      result.ex = ex
-    oprot.writeMessageBegin("setAlert", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("markOrdersAsPickedUp", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_getValidOrderCount(self, seqid, iprot, oprot):
+  def process_markOrdersAsDelivered(self, seqid, iprot, oprot):
-    args = getValidOrderCount_args()
+    args = markOrdersAsDelivered_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = getValidOrderCount_result()
+    result = markOrdersAsDelivered_result()
+    try:
+      self._handler.markOrdersAsDelivered(args.providerId, args.deliveredOrders)
-    result.success = self._handler.getValidOrderCount()
+    except TransactionServiceException, ex:
+      result.ex = ex
-    oprot.writeMessageBegin("getValidOrderCount", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("markOrdersAsDelivered", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_getNoOfCustomersWithSuccessfulTransaction(self, seqid, iprot, oprot):
+  def process_markOrdersAsFailed(self, seqid, iprot, oprot):
-    args = getNoOfCustomersWithSuccessfulTransaction_args()
+    args = markOrdersAsFailed_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = getNoOfCustomersWithSuccessfulTransaction_result()
+    result = markOrdersAsFailed_result()
+    try:
-    result.success = self._handler.getNoOfCustomersWithSuccessfulTransaction()
+      self._handler.markOrdersAsFailed(args.providerId, args.returnedOrders)
+    except TransactionServiceException, ex:
+      result.ex = ex
-    oprot.writeMessageBegin("getNoOfCustomersWithSuccessfulTransaction", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("markOrdersAsFailed", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_getValidOrdersAmountRange(self, seqid, iprot, oprot):
+  def process_updateNonDeliveryReason(self, seqid, iprot, oprot):
-    args = getValidOrdersAmountRange_args()
+    args = updateNonDeliveryReason_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = getValidOrdersAmountRange_result()
+    result = updateNonDeliveryReason_result()
+    try:
-    result.success = self._handler.getValidOrdersAmountRange()
+      self._handler.updateNonDeliveryReason(args.providerId, args.undeliveredOrders)
+    except TransactionServiceException, ex:
+      result.ex = ex
-    oprot.writeMessageBegin("getValidOrdersAmountRange", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("updateNonDeliveryReason", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
-  def process_getValidOrders(self, seqid, iprot, oprot):
+  def process_getUndeliveredOrders(self, seqid, iprot, oprot):
-    args = getValidOrders_args()
+    args = getUndeliveredOrders_args()
     args.read(iprot)
     iprot.readMessageEnd()
-    result = getValidOrders_result()
+    result = getUndeliveredOrders_result()
-    result.success = self._handler.getValidOrders(args.limit)
+    result.success = self._handler.getUndeliveredOrders(args.providerId, args.warehouseId)
-    oprot.writeMessageBegin("getValidOrders", TMessageType.REPLY, seqid)
+    oprot.writeMessageBegin("getUndeliveredOrders", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
   def process_toggleDOAFlag(self, seqid, iprot, oprot):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class addBillingDetails_args:
+class getOrdersForTransaction_args:
   """
   Attributes:
-   - orderId
+   - transactionId
-   - invoice_number
-   - billed_by
+   - customerId
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'orderId', None, None, ), # 1
+    (1, TType.I64, 'transactionId', None, None, ), # 1
-    (2, TType.STRING, 'invoice_number', None, None, ), # 2
+    (2, TType.I64, 'customerId', None, None, ), # 2
-    (3, TType.STRING, 'billed_by', None, None, ), # 3
+  )
-  def __init__(self, orderId=None, invoice_number=None, billed_by=None,):
+  def __init__(self, transactionId=None, customerId=None,):
-    self.orderId = orderId
+    self.transactionId = transactionId
-    self.invoice_number = invoice_number
-    self.billed_by = billed_by
+    self.customerId = customerId
   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.orderId = iprot.readI64();
+          self.transactionId = iprot.readI64();
         else:
           iprot.skip(ftype)
       elif fid == 2:
-        if ftype == TType.STRING:
+        if ftype == TType.I64:
-          self.invoice_number = iprot.readString();
-        else:
-          iprot.skip(ftype)
-      elif fid == 3:
-        if ftype == TType.STRING:
-          self.billed_by = iprot.readString();
+          self.customerId = iprot.readI64();
         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('addBillingDetails_args')
+    oprot.writeStructBegin('getOrdersForTransaction_args')
-    if self.orderId != None:
+    if self.transactionId != None:
-      oprot.writeFieldBegin('orderId', TType.I64, 1)
+      oprot.writeFieldBegin('transactionId', TType.I64, 1)
-      oprot.writeI64(self.orderId)
+      oprot.writeI64(self.transactionId)
-      oprot.writeFieldEnd()
-    if self.invoice_number != None:
-      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
-      oprot.writeString(self.invoice_number)
       oprot.writeFieldEnd()
-    if self.billed_by != None:
+    if self.customerId != None:
-      oprot.writeFieldBegin('billed_by', TType.STRING, 3)
+      oprot.writeFieldBegin('customerId', TType.I64, 2)
-      oprot.writeString(self.billed_by)
+      oprot.writeI64(self.customerId)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class addBillingDetails_result:
+class getOrdersForTransaction_result:
   """
   Attributes:
    - success
    - ex
   """
   thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
+    (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,):
     self.success = success
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 0:
-        if ftype == TType.BOOL:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype59, _size56) = iprot.readListBegin()
+          for _i60 in xrange(_size56):
+            _elem61 = Order()
+            _elem61.read(iprot)
-          self.success = iprot.readBool();
+            self.success.append(_elem61)
+          iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
           self.ex = TransactionServiceException()
   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('addBillingDetails_result')
+    oprot.writeStructBegin('getOrdersForTransaction_result')
     if self.success != None:
-      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
-      oprot.writeBool(self.success)
+      for iter62 in self.success:
+        iter62.write(oprot)
+      oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex != None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       oprot.writeFieldEnd()
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class addJacketNumber_args:
+class getOrdersForCustomer_args:
   """
   Attributes:
-   - orderId
+   - customerId
-   - jacketNumber
-   - imeiNumber
+   - from_date
-   - itemNumber
+   - to_date
-   - billedBy
+   - statuses
-   - billingType
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'orderId', None, None, ), # 1
+    (1, TType.I64, 'customerId', None, None, ), # 1
-    (2, TType.I64, 'jacketNumber', None, None, ), # 2
+    (2, TType.I64, 'from_date', None, None, ), # 2
-    (3, TType.I64, 'imeiNumber', None, None, ), # 3
+    (3, TType.I64, 'to_date', None, None, ), # 3
-    (4, TType.STRING, 'itemNumber', None, None, ), # 4
+    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
-    (5, TType.STRING, 'billedBy', None, None, ), # 5
-    (6, TType.I64, 'billingType', None, None, ), # 6
+  )
-  def __init__(self, orderId=None, jacketNumber=None, imeiNumber=None, itemNumber=None, billedBy=None, billingType=None,):
+  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
-    self.orderId = orderId
+    self.customerId = customerId
-    self.jacketNumber = jacketNumber
-    self.imeiNumber = imeiNumber
+    self.from_date = from_date
-    self.itemNumber = itemNumber
+    self.to_date = to_date
-    self.billedBy = billedBy
+    self.statuses = statuses
-    self.billingType = billingType
   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.orderId = iprot.readI64();
+          self.customerId = iprot.readI64();
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.I64:
-          self.jacketNumber = iprot.readI64();
+          self.from_date = iprot.readI64();
         else:
           iprot.skip(ftype)
       elif fid == 3:
         if ftype == TType.I64:
-          self.imeiNumber = iprot.readI64();
+          self.to_date = iprot.readI64();
         else:
           iprot.skip(ftype)
       elif fid == 4:
-        if ftype == TType.STRING:
+        if ftype == TType.LIST:
-          self.itemNumber = iprot.readString();
+          self.statuses = []
-        else:
-          iprot.skip(ftype)
+          (_etype66, _size63) = iprot.readListBegin()
-      elif fid == 5:
-        if ftype == TType.STRING:
+          for _i67 in xrange(_size63):
-          self.billedBy = iprot.readString();
+            _elem68 = iprot.readI32();
-        else:
+            self.statuses.append(_elem68)
-          iprot.skip(ftype)
+          iprot.readListEnd()
-      elif fid == 6:
-        if ftype == TType.I64:
-          self.billingType = iprot.readI64();
         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('addJacketNumber_args')
+    oprot.writeStructBegin('getOrdersForCustomer_args')
-    if self.orderId != None:
+    if self.customerId != None:
-      oprot.writeFieldBegin('orderId', TType.I64, 1)
+      oprot.writeFieldBegin('customerId', TType.I64, 1)
-      oprot.writeI64(self.orderId)
+      oprot.writeI64(self.customerId)
-      oprot.writeFieldEnd()
-    if self.jacketNumber != None:
-      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
-      oprot.writeI64(self.jacketNumber)
-      oprot.writeFieldEnd()
-    if self.imeiNumber != None:
-      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
-      oprot.writeI64(self.imeiNumber)
       oprot.writeFieldEnd()
-    if self.itemNumber != None:
+    if self.from_date != None:
-      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
+      oprot.writeFieldBegin('from_date', TType.I64, 2)
-      oprot.writeString(self.itemNumber)
+      oprot.writeI64(self.from_date)
       oprot.writeFieldEnd()
-    if self.billedBy != None:
+    if self.to_date != None:
-      oprot.writeFieldBegin('billedBy', TType.STRING, 5)
+      oprot.writeFieldBegin('to_date', TType.I64, 3)
-      oprot.writeString(self.billedBy)
+      oprot.writeI64(self.to_date)
       oprot.writeFieldEnd()
-    if self.billingType != None:
+    if self.statuses != None:
-      oprot.writeFieldBegin('billingType', TType.I64, 6)
+      oprot.writeFieldBegin('statuses', TType.LIST, 4)
+      oprot.writeListBegin(TType.I32, len(self.statuses))
+      for iter69 in self.statuses:
-      oprot.writeI64(self.billingType)
+        oprot.writeI32(iter69)
+      oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class addJacketNumber_result:
+class getOrdersForCustomer_result:
   """
   Attributes:
    - success
    - ex
   """
   thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
+    (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,):
     self.success = success
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 0:
-        if ftype == TType.BOOL:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype73, _size70) = iprot.readListBegin()
+          for _i74 in xrange(_size70):
+            _elem75 = Order()
+            _elem75.read(iprot)
-          self.success = iprot.readBool();
+            self.success.append(_elem75)
+          iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
           self.ex = TransactionServiceException()
   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('addJacketNumber_result')
+    oprot.writeStructBegin('getOrdersForCustomer_result')
     if self.success != None:
-      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
-      oprot.writeBool(self.success)
+      for iter76 in self.success:
+        iter76.write(oprot)
+      oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex != None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       oprot.writeFieldEnd()
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class acceptOrder_args:
+class createOrder_args:
   """
   Attributes:
-   - orderId
+   - order
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'orderId', None, None, ), # 1
+    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
+  )
-  def __init__(self, orderId=None,):
+  def __init__(self, order=None,):
-    self.orderId = orderId
+    self.order = order
   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
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
-        if ftype == TType.I64:
+        if ftype == TType.STRUCT:
-          self.orderId = iprot.readI64();
+          self.order = Order()
+          self.order.read(iprot)
         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('acceptOrder_args')
+    oprot.writeStructBegin('createOrder_args')
-    if self.orderId != None:
+    if self.order != None:
-      oprot.writeFieldBegin('orderId', TType.I64, 1)
+      oprot.writeFieldBegin('order', TType.STRUCT, 1)
-      oprot.writeI64(self.orderId)
+      self.order.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class acceptOrder_result:
+class createOrder_result:
   """
   Attributes:
    - success
    - ex
   """
   thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
+    (0, TType.I64, 'success', None, None, ), # 0
     (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
   def __init__(self, success=None, ex=None,):
     self.success = success
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 0:
-        if ftype == TType.BOOL:
+        if ftype == TType.I64:
-          self.success = iprot.readBool();
+          self.success = iprot.readI64();
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
           self.ex = TransactionServiceException()
   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('acceptOrder_result')
+    oprot.writeStructBegin('createOrder_result')
     if self.success != None:
-      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeFieldBegin('success', TType.I64, 0)
-      oprot.writeBool(self.success)
+      oprot.writeI64(self.success)
       oprot.writeFieldEnd()
     if self.ex != None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       oprot.writeFieldEnd()
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class billOrder_args:
+class getOrder_args:
   """
   Attributes:
-   - orderId
+   - id
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'orderId', None, None, ), # 1
+    (1, TType.I64, 'id', None, None, ), # 1
+  )
-  def __init__(self, orderId=None,):
+  def __init__(self, id=None,):
-    self.orderId = orderId
+    self.id = id
   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.orderId = iprot.readI64();
+          self.id = iprot.readI64();
         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('billOrder_args')
+    oprot.writeStructBegin('getOrder_args')
-    if self.orderId != None:
+    if self.id != None:
-      oprot.writeFieldBegin('orderId', TType.I64, 1)
+      oprot.writeFieldBegin('id', TType.I64, 1)
-      oprot.writeI64(self.orderId)
+      oprot.writeI64(self.id)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class billOrder_result:
+class getOrder_result:
   """
   Attributes:
    - success
    - ex
   """
   thrift_spec = (
-    (0, TType.BOOL, 'success', None, None, ), # 0
+    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
     (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
   def __init__(self, success=None, ex=None,):
     self.success = success
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 0:
-        if ftype == TType.BOOL:
+        if ftype == TType.STRUCT:
-          self.success = iprot.readBool();
+          self.success = Order()
+          self.success.read(iprot)
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
           self.ex = TransactionServiceException()
   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('billOrder_result')
+    oprot.writeStructBegin('getOrder_result')
     if self.success != None:
-      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeFieldBegin('success', TType.STRUCT, 0)
-      oprot.writeBool(self.success)
+      self.success.write(oprot)
       oprot.writeFieldEnd()
     if self.ex != None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       oprot.writeFieldEnd()
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getOrdersForTransaction_args:
+class getLineItemsForOrder_args:
   """
   Attributes:
-   - transactionId
-   - customerId
+   - orderId
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'transactionId', None, None, ), # 1
-    (2, TType.I64, 'customerId', None, None, ), # 2
+    (1, TType.I64, 'orderId', None, None, ), # 1
+  )
-  def __init__(self, transactionId=None, customerId=None,):
+  def __init__(self, orderId=None,):
-    self.transactionId = transactionId
-    self.customerId = customerId
+    self.orderId = orderId
   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.transactionId = iprot.readI64();
-        else:
-          iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.I64:
-          self.customerId = iprot.readI64();
+          self.orderId = iprot.readI64();
         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('getOrdersForTransaction_args')
+    oprot.writeStructBegin('getLineItemsForOrder_args')
-    if self.transactionId != None:
-      oprot.writeFieldBegin('transactionId', TType.I64, 1)
-      oprot.writeI64(self.transactionId)
-      oprot.writeFieldEnd()
-    if self.customerId != None:
+    if self.orderId != None:
-      oprot.writeFieldBegin('customerId', TType.I64, 2)
+      oprot.writeFieldBegin('orderId', TType.I64, 1)
-      oprot.writeI64(self.customerId)
+      oprot.writeI64(self.orderId)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getOrdersForTransaction_result:
+class getLineItemsForOrder_result:
   """
   Attributes:
    - success
    - ex
   """
   thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
+    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
     (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
   def __init__(self, success=None, ex=None,):
     self.success = success
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype59, _size56) = iprot.readListBegin()
+          (_etype80, _size77) = iprot.readListBegin()
-          for _i60 in xrange(_size56):
+          for _i81 in xrange(_size77):
-            _elem61 = Order()
+            _elem82 = LineItem()
-            _elem61.read(iprot)
+            _elem82.read(iprot)
-            self.success.append(_elem61)
+            self.success.append(_elem82)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
   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('getOrdersForTransaction_result')
+    oprot.writeStructBegin('getLineItemsForOrder_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter62 in self.success:
+      for iter83 in self.success:
-        iter62.write(oprot)
+        iter83.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex != None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getOrdersForCustomer_args:
+class getOrderForCustomer_args:
   """
   Attributes:
+   - orderId
    - customerId
-   - from_date
-   - to_date
-   - statuses
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'customerId', None, None, ), # 1
+    (1, TType.I64, 'orderId', None, None, ), # 1
-    (2, TType.I64, 'from_date', None, None, ), # 2
+    (2, TType.I64, 'customerId', None, None, ), # 2
-    (3, TType.I64, 'to_date', None, None, ), # 3
-    (4, TType.LIST, 'statuses', (TType.I32,None), None, ), # 4
+  )
-  def __init__(self, customerId=None, from_date=None, to_date=None, statuses=None,):
+  def __init__(self, orderId=None, customerId=None,):
+    self.orderId = orderId
     self.customerId = customerId
-    self.from_date = from_date
-    self.to_date = to_date
-    self.statuses = statuses
   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.customerId = iprot.readI64();
+          self.orderId = iprot.readI64();
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.I64:
-          self.from_date = iprot.readI64();
-        else:
-          iprot.skip(ftype)
-      elif fid == 3:
-        if ftype == TType.I64:
-          self.to_date = iprot.readI64();
+          self.customerId = iprot.readI64();
-        else:
-          iprot.skip(ftype)
-      elif fid == 4:
-        if ftype == TType.LIST:
-          self.statuses = []
-          (_etype66, _size63) = iprot.readListBegin()
-          for _i67 in xrange(_size63):
-            _elem68 = iprot.readI32();
-            self.statuses.append(_elem68)
-          iprot.readListEnd()
         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('getOrdersForCustomer_args')
+    oprot.writeStructBegin('getOrderForCustomer_args')
+    if self.orderId != None:
+      oprot.writeFieldBegin('orderId', TType.I64, 1)
+      oprot.writeI64(self.orderId)
+      oprot.writeFieldEnd()
     if self.customerId != None:
-      oprot.writeFieldBegin('customerId', TType.I64, 1)
+      oprot.writeFieldBegin('customerId', TType.I64, 2)
       oprot.writeI64(self.customerId)
       oprot.writeFieldEnd()
-    if self.from_date != None:
-      oprot.writeFieldBegin('from_date', TType.I64, 2)
-      oprot.writeI64(self.from_date)
-      oprot.writeFieldEnd()
-    if self.to_date != None:
-      oprot.writeFieldBegin('to_date', TType.I64, 3)
-      oprot.writeI64(self.to_date)
-      oprot.writeFieldEnd()
-    if self.statuses != None:
-      oprot.writeFieldBegin('statuses', TType.LIST, 4)
-      oprot.writeListBegin(TType.I32, len(self.statuses))
-      for iter69 in self.statuses:
-        oprot.writeI32(iter69)
-      oprot.writeListEnd()
-      oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     L = ['%s=%r' % (key, value)
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getOrdersForCustomer_result:
+class getOrderForCustomer_result:
   """
   Attributes:
    - success
    - ex
   """
   thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
+    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
     (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
   def __init__(self, success=None, ex=None,):
     self.success = success
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 0:
-        if ftype == TType.LIST:
+        if ftype == TType.STRUCT:
-          self.success = []
+          self.success = Order()
-          (_etype73, _size70) = iprot.readListBegin()
-          for _i74 in xrange(_size70):
-            _elem75 = Order()
-            _elem75.read(iprot)
-            self.success.append(_elem75)
+          self.success.read(iprot)
-          iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
           self.ex = TransactionServiceException()
   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('getOrdersForCustomer_result')
+    oprot.writeStructBegin('getOrderForCustomer_result')
     if self.success != None:
-      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeFieldBegin('success', TType.STRUCT, 0)
-      oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter76 in self.success:
-        iter76.write(oprot)
+      self.success.write(oprot)
-      oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex != None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       oprot.writeFieldEnd()
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class createOrder_args:
+class getAlerts_args:
   """
   Attributes:
-   - order
+   - orderId
+   - valid
   """
   thrift_spec = (
     None, # 0
-    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
+    (1, TType.I64, 'orderId', None, None, ), # 1
+    (2, TType.BOOL, 'valid', None, None, ), # 2
+  )
-  def __init__(self, order=None,):
+  def __init__(self, orderId=None, valid=None,):
-    self.order = order
+    self.orderId = orderId
+    self.valid = valid
   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
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 1:
-        if ftype == TType.STRUCT:
+        if ftype == TType.I64:
-          self.order = Order()
+          self.orderId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.BOOL:
-          self.order.read(iprot)
+          self.valid = iprot.readBool();
         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('createOrder_args')
+    oprot.writeStructBegin('getAlerts_args')
-    if self.order != None:
+    if self.orderId != None:
-      oprot.writeFieldBegin('order', TType.STRUCT, 1)
+      oprot.writeFieldBegin('orderId', TType.I64, 1)
+      oprot.writeI64(self.orderId)
-      self.order.write(oprot)
+      oprot.writeFieldEnd()
+    if self.valid != None:
+      oprot.writeFieldBegin('valid', TType.BOOL, 2)
+      oprot.writeBool(self.valid)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class createOrder_result:
+class getAlerts_result:
   """
   Attributes:
    - success
-   - ex
   """
   thrift_spec = (
-    (0, TType.I64, 'success', None, None, ), # 0
-    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
+  )
-  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
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 0:
-        if ftype == TType.I64:
+        if ftype == TType.LIST:
-          self.success = iprot.readI64();
+          self.success = []
-        else:
+          (_etype87, _size84) = iprot.readListBegin()
-          iprot.skip(ftype)
+          for _i88 in xrange(_size84):
-      elif fid == 1:
+            _elem89 = Alert()
-        if ftype == TType.STRUCT:
+            _elem89.read(iprot)
-          self.ex = TransactionServiceException()
+            self.success.append(_elem89)
-          self.ex.read(iprot)
+          iprot.readListEnd()
         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('createOrder_result')
+    oprot.writeStructBegin('getAlerts_result')
     if self.success != None:
-      oprot.writeFieldBegin('success', TType.I64, 0)
+      oprot.writeFieldBegin('success', TType.LIST, 0)
-      oprot.writeI64(self.success)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
-      oprot.writeFieldEnd()
+      for iter90 in self.success:
-    if self.ex != None:
+        iter90.write(oprot)
-      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
-      self.ex.write(oprot)
+      oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getOrder_args:
+class setAlert_args:
   """
   Attributes:
+   - orderId
+   - unset
-   - id
+   - type
+   - comment
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'id', None, None, ), # 1
+    (1, TType.I64, 'orderId', None, None, ), # 1
+    (2, TType.BOOL, 'unset', None, None, ), # 2
+    (3, TType.I64, 'type', None, None, ), # 3
+    (4, TType.STRING, 'comment', None, None, ), # 4
+  )
+  def __init__(self, orderId=None, unset=None, type=None, comment=None,):
-  def __init__(self, id=None,):
+    self.orderId = orderId
+    self.unset = unset
-    self.id = id
+    self.type = type
+    self.comment = comment
   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.orderId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.BOOL:
+          self.unset = iprot.readBool();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.I64:
-          self.id = iprot.readI64();
+          self.type = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
+        if ftype == TType.STRING:
+          self.comment = iprot.readString();
         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('getOrder_args')
+    oprot.writeStructBegin('setAlert_args')
+    if self.orderId != None:
+      oprot.writeFieldBegin('orderId', TType.I64, 1)
+      oprot.writeI64(self.orderId)
+      oprot.writeFieldEnd()
+    if self.unset != None:
+      oprot.writeFieldBegin('unset', TType.BOOL, 2)
+      oprot.writeBool(self.unset)
+      oprot.writeFieldEnd()
-    if self.id != None:
+    if self.type != None:
-      oprot.writeFieldBegin('id', TType.I64, 1)
+      oprot.writeFieldBegin('type', TType.I64, 3)
-      oprot.writeI64(self.id)
+      oprot.writeI64(self.type)
+      oprot.writeFieldEnd()
+    if self.comment != None:
+      oprot.writeFieldBegin('comment', TType.STRING, 4)
+      oprot.writeString(self.comment)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getOrder_result:
+class setAlert_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('setAlert_result')
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 getValidOrderCount_args:
+  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('getValidOrderCount_args')
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 getValidOrderCount_result:
   """
   Attributes:
    - success
-   - ex
   """
   thrift_spec = (
-    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
+    (0, TType.I64, 'success', None, 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
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 0:
-        if ftype == TType.STRUCT:
+        if ftype == TType.I64:
-          self.success = Order()
+          self.success = iprot.readI64();
-          self.success.read(iprot)
-        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()
   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('getOrder_result')
+    oprot.writeStructBegin('getValidOrderCount_result')
     if self.success != None:
-      oprot.writeFieldBegin('success', TType.STRUCT, 0)
+      oprot.writeFieldBegin('success', TType.I64, 0)
-      self.success.write(oprot)
-      oprot.writeFieldEnd()
+      oprot.writeI64(self.success)
-    if self.ex != None:
-      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
-      self.ex.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getLineItemsForOrder_args:
+class getNoOfCustomersWithSuccessfulTransaction_args:
+  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('getNoOfCustomersWithSuccessfulTransaction_args')
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 getNoOfCustomersWithSuccessfulTransaction_result:
   """
   Attributes:
-   - orderId
+   - success
   """
   thrift_spec = (
-    None, # 0
-    (1, TType.I64, 'orderId', None, None, ), # 1
+    (0, TType.I64, 'success', None, None, ), # 0
+  )
-  def __init__(self, orderId=None,):
+  def __init__(self, success=None,):
-    self.orderId = orderId
+    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 == 1:
+      if fid == 0:
         if ftype == TType.I64:
-          self.orderId = iprot.readI64();
+          self.success = iprot.readI64();
         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('getLineItemsForOrder_args')
+    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_result')
-    if self.orderId != None:
+    if self.success != None:
-      oprot.writeFieldBegin('orderId', TType.I64, 1)
+      oprot.writeFieldBegin('success', TType.I64, 0)
-      oprot.writeI64(self.orderId)
+      oprot.writeI64(self.success)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
+class getValidOrdersAmountRange_args:
+  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('getValidOrdersAmountRange_args')
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  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 getLineItemsForOrder_result:
+class getValidOrdersAmountRange_result:
   """
   Attributes:
    - success
-   - ex
   """
   thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(LineItem, LineItem.thrift_spec)), None, ), # 0
+    (0, TType.LIST, 'success', (TType.DOUBLE,None), 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
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype80, _size77) = iprot.readListBegin()
+          (_etype94, _size91) = iprot.readListBegin()
-          for _i81 in xrange(_size77):
+          for _i95 in xrange(_size91):
-            _elem82 = LineItem()
+            _elem96 = iprot.readDouble();
-            _elem82.read(iprot)
-            self.success.append(_elem82)
+            self.success.append(_elem96)
           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('getLineItemsForOrder_result')
+    oprot.writeStructBegin('getValidOrdersAmountRange_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
-      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      oprot.writeListBegin(TType.DOUBLE, len(self.success))
-      for iter83 in self.success:
+      for iter97 in self.success:
-        iter83.write(oprot)
+        oprot.writeDouble(iter97)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
-    if self.ex != None:
-      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
-      self.ex.write(oprot)
-      oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     L = ['%s=%r' % (key, value)
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getOrderForCustomer_args:
+class getValidOrders_args:
   """
   Attributes:
-   - orderId
+   - limit
-   - customerId
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'orderId', None, None, ), # 1
+    (1, TType.I64, 'limit', None, None, ), # 1
-    (2, TType.I64, 'customerId', None, None, ), # 2
+  )
-  def __init__(self, orderId=None, customerId=None,):
+  def __init__(self, limit=None,):
-    self.orderId = orderId
+    self.limit = limit
-    self.customerId = customerId
   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.orderId = iprot.readI64();
+          self.limit = iprot.readI64();
-        else:
-          iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.I64:
-          self.customerId = iprot.readI64();
         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('getOrderForCustomer_args')
+    oprot.writeStructBegin('getValidOrders_args')
-    if self.orderId != None:
+    if self.limit != None:
-      oprot.writeFieldBegin('orderId', TType.I64, 1)
+      oprot.writeFieldBegin('limit', TType.I64, 1)
-      oprot.writeI64(self.orderId)
+      oprot.writeI64(self.limit)
-      oprot.writeFieldEnd()
-    if self.customerId != None:
-      oprot.writeFieldBegin('customerId', TType.I64, 2)
-      oprot.writeI64(self.customerId)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getOrderForCustomer_result:
+class getValidOrders_result:
   """
   Attributes:
    - success
-   - ex
   """
   thrift_spec = (
-    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
+    (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
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 0:
-        if ftype == TType.STRUCT:
+        if ftype == TType.LIST:
-          self.success = Order()
+          self.success = []
-          self.success.read(iprot)
+          (_etype101, _size98) = iprot.readListBegin()
-        else:
-          iprot.skip(ftype)
+          for _i102 in xrange(_size98):
-      elif fid == 1:
+            _elem103 = Order()
-        if ftype == TType.STRUCT:
+            _elem103.read(iprot)
-          self.ex = TransactionServiceException()
+            self.success.append(_elem103)
-          self.ex.read(iprot)
+          iprot.readListEnd()
         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('getOrderForCustomer_result')
+    oprot.writeStructBegin('getValidOrders_result')
     if self.success != None:
-      oprot.writeFieldBegin('success', TType.STRUCT, 0)
+      oprot.writeFieldBegin('success', TType.LIST, 0)
-      self.success.write(oprot)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
-      oprot.writeFieldEnd()
+      for iter104 in self.success:
-    if self.ex != None:
+        iter104.write(oprot)
-      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
-      self.ex.write(oprot)
+      oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype87, _size84) = iprot.readListBegin()
+          (_etype108, _size105) = iprot.readListBegin()
-          for _i88 in xrange(_size84):
+          for _i109 in xrange(_size105):
-            _elem89 = Order()
+            _elem110 = Order()
-            _elem89.read(iprot)
+            _elem110.read(iprot)
-            self.success.append(_elem89)
+            self.success.append(_elem110)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('batchOrders_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter90 in self.success:
+      for iter111 in self.success:
-        iter90.write(oprot)
+        iter111.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex != None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class markOrdersAsManifested_args:
+class verifyOrder_args:
   """
   Attributes:
-   - warehouseId
-   - providerId
+   - orderId
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'warehouseId', None, None, ), # 1
-    (2, TType.I64, 'providerId', None, None, ), # 2
+    (1, TType.I64, 'orderId', None, None, ), # 1
+  )
-  def __init__(self, warehouseId=None, providerId=None,):
+  def __init__(self, orderId=None,):
-    self.warehouseId = warehouseId
-    self.providerId = providerId
+    self.orderId = orderId
   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();
+          self.orderId = iprot.readI64();
         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('markOrdersAsManifested_args')
+    oprot.writeStructBegin('verifyOrder_args')
-    if self.warehouseId != None:
-      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
-      oprot.writeI64(self.warehouseId)
-      oprot.writeFieldEnd()
-    if self.providerId != None:
+    if self.orderId != None:
-      oprot.writeFieldBegin('providerId', TType.I64, 2)
+      oprot.writeFieldBegin('orderId', TType.I64, 1)
-      oprot.writeI64(self.providerId)
+      oprot.writeI64(self.orderId)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class markOrdersAsManifested_result:
+class verifyOrder_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('verifyOrder_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.BOOL, 0)
       oprot.writeBool(self.success)
       oprot.writeFieldEnd()
     if self.ex != None:
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class markOrdersAsPickedUp_args:
+class acceptOrder_args:
   """
   Attributes:
-   - providerId
+   - orderId
-   - pickupDetails
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'providerId', None, None, ), # 1
+    (1, TType.I64, 'orderId', 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, orderId=None,):
-    self.providerId = providerId
+    self.orderId = orderId
-    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.providerId = iprot.readI64();
+          self.orderId = iprot.readI64();
-        else:
-          iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.MAP:
-          self.pickupDetails = {}
-          (_ktype92, _vtype93, _size91 ) = iprot.readMapBegin()
-          for _i95 in xrange(_size91):
-            _key96 = iprot.readString();
-            _val97 = iprot.readString();
-            self.pickupDetails[_key96] = _val97
-          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('markOrdersAsPickedUp_args')
+    oprot.writeStructBegin('acceptOrder_args')
-    if self.providerId != None:
+    if self.orderId != None:
-      oprot.writeFieldBegin('providerId', TType.I64, 1)
+      oprot.writeFieldBegin('orderId', TType.I64, 1)
-      oprot.writeI64(self.providerId)
+      oprot.writeI64(self.orderId)
-      oprot.writeFieldEnd()
-    if self.pickupDetails != None:
-      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
-      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
-      for kiter98,viter99 in self.pickupDetails.items():
-        oprot.writeString(kiter98)
-        oprot.writeString(viter99)
-      oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class markOrdersAsPickedUp_result:
+class acceptOrder_result:
   """
   Attributes:
    - success
    - ex
   """
   thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
+    (0, TType.BOOL, 'success', None, None, ), # 0
     (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
   def __init__(self, success=None, ex=None,):
     self.success = success
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 0:
-        if ftype == TType.LIST:
+        if ftype == TType.BOOL:
-          self.success = []
-          (_etype103, _size100) = iprot.readListBegin()
-          for _i104 in xrange(_size100):
-            _elem105 = Order()
-            _elem105.read(iprot)
-            self.success.append(_elem105)
+          self.success = iprot.readBool();
-          iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
           self.ex = TransactionServiceException()
   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('acceptOrder_result')
     if self.success != None:
-      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
-      oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter106 in self.success:
+      oprot.writeBool(self.success)
-        iter106.write(oprot)
-      oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex != None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       oprot.writeFieldEnd()
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class markOrdersAsDelivered_args:
+class billOrder_args:
   """
   Attributes:
-   - providerId
+   - orderId
-   - deliveredOrders
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'providerId', None, None, ), # 1
+    (1, TType.I64, 'orderId', None, None, ), # 1
-    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
+  )
-  def __init__(self, providerId=None, deliveredOrders=None,):
+  def __init__(self, orderId=None,):
-    self.providerId = providerId
+    self.orderId = orderId
-    self.deliveredOrders = deliveredOrders
   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.providerId = iprot.readI64();
+          self.orderId = iprot.readI64();
-        else:
-          iprot.skip(ftype)
-      elif fid == 2:
-        if ftype == TType.MAP:
-          self.deliveredOrders = {}
-          (_ktype108, _vtype109, _size107 ) = iprot.readMapBegin()
-          for _i111 in xrange(_size107):
-            _key112 = iprot.readString();
-            _val113 = iprot.readString();
-            self.deliveredOrders[_key112] = _val113
-          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('markOrdersAsDelivered_args')
+    oprot.writeStructBegin('billOrder_args')
-    if self.providerId != None:
+    if self.orderId != None:
-      oprot.writeFieldBegin('providerId', TType.I64, 1)
+      oprot.writeFieldBegin('orderId', TType.I64, 1)
-      oprot.writeI64(self.providerId)
+      oprot.writeI64(self.orderId)
-      oprot.writeFieldEnd()
-    if self.deliveredOrders != None:
-      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
-      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
-      for kiter114,viter115 in self.deliveredOrders.items():
-        oprot.writeString(kiter114)
-        oprot.writeString(viter115)
-      oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class markOrdersAsDelivered_result:
+class billOrder_result:
   """
   Attributes:
+   - success
    - ex
   """
   thrift_spec = (
-    None, # 0
+    (0, TType.BOOL, 'success', None, None, ), # 0
     (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, ex=None,):
+  def __init__(self, success=None, 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 fid == 0:
+        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('markOrdersAsDelivered_result')
+    oprot.writeStructBegin('billOrder_result')
+    if self.success != None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(self.success)
+      oprot.writeFieldEnd()
     if self.ex != 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 markOrdersAsFailed_args:
+class addBillingDetails_args:
   """
   Attributes:
-   - providerId
+   - orderId
-   - returnedOrders
+   - invoice_number
+   - billed_by
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'providerId', None, None, ), # 1
+    (1, TType.I64, 'orderId', None, None, ), # 1
-    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
+    (2, TType.STRING, 'invoice_number', None, None, ), # 2
+    (3, TType.STRING, 'billed_by', None, None, ), # 3
+  )
-  def __init__(self, providerId=None, returnedOrders=None,):
+  def __init__(self, orderId=None, invoice_number=None, billed_by=None,):
-    self.providerId = providerId
+    self.orderId = orderId
-    self.returnedOrders = returnedOrders
+    self.invoice_number = invoice_number
+    self.billed_by = billed_by
   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.providerId = iprot.readI64();
+          self.orderId = iprot.readI64();
         else:
           iprot.skip(ftype)
       elif fid == 2:
-        if ftype == TType.MAP:
+        if ftype == TType.STRING:
-          self.returnedOrders = {}
-          (_ktype117, _vtype118, _size116 ) = iprot.readMapBegin()
+          self.invoice_number = iprot.readString();
-          for _i120 in xrange(_size116):
+        else:
-            _key121 = iprot.readString();
+          iprot.skip(ftype)
-            _val122 = iprot.readString();
+      elif fid == 3:
-            self.returnedOrders[_key121] = _val122
+        if ftype == TType.STRING:
-          iprot.readMapEnd()
+          self.billed_by = iprot.readString();
         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('markOrdersAsFailed_args')
+    oprot.writeStructBegin('addBillingDetails_args')
-    if self.providerId != None:
+    if self.orderId != None:
-      oprot.writeFieldBegin('providerId', TType.I64, 1)
+      oprot.writeFieldBegin('orderId', TType.I64, 1)
-      oprot.writeI64(self.providerId)
+      oprot.writeI64(self.orderId)
       oprot.writeFieldEnd()
-    if self.returnedOrders != None:
+    if self.invoice_number != None:
-      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
+      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
-      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
+      oprot.writeString(self.invoice_number)
-      for kiter123,viter124 in self.returnedOrders.items():
+      oprot.writeFieldEnd()
-        oprot.writeString(kiter123)
+    if self.billed_by != None:
-        oprot.writeString(viter124)
+      oprot.writeFieldBegin('billed_by', TType.STRING, 3)
-      oprot.writeMapEnd()
+      oprot.writeString(self.billed_by)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class markOrdersAsFailed_result:
+class addBillingDetails_result:
   """
   Attributes:
+   - success
    - ex
   """
   thrift_spec = (
-    None, # 0
+    (0, TType.BOOL, 'success', None, None, ), # 0
     (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, ex=None,):
+  def __init__(self, success=None, 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 fid == 0:
+        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('markOrdersAsFailed_result')
+    oprot.writeStructBegin('addBillingDetails_result')
+    if self.success != None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(self.success)
+      oprot.writeFieldEnd()
     if self.ex != 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 updateNonDeliveryReason_args:
+class addJacketNumber_args:
   """
   Attributes:
-   - providerId
+   - orderId
+   - jacketNumber
+   - imeiNumber
-   - undeliveredOrders
+   - itemNumber
+   - billedBy
+   - billingType
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'providerId', None, None, ), # 1
+    (1, TType.I64, 'orderId', None, None, ), # 1
-    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
+    (2, TType.I64, 'jacketNumber', None, None, ), # 2
+    (3, TType.I64, 'imeiNumber', None, None, ), # 3
+    (4, TType.STRING, 'itemNumber', None, None, ), # 4
+    (5, TType.STRING, 'billedBy', None, None, ), # 5
+    (6, TType.I64, 'billingType', None, None, ), # 6
+  )
-  def __init__(self, providerId=None, undeliveredOrders=None,):
+  def __init__(self, orderId=None, jacketNumber=None, imeiNumber=None, itemNumber=None, billedBy=None, billingType=None,):
-    self.providerId = providerId
+    self.orderId = orderId
+    self.jacketNumber = jacketNumber
-    self.undeliveredOrders = undeliveredOrders
+    self.imeiNumber = imeiNumber
+    self.itemNumber = itemNumber
+    self.billedBy = billedBy
+    self.billingType = billingType
   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.providerId = iprot.readI64();
+          self.orderId = iprot.readI64();
         else:
           iprot.skip(ftype)
       elif fid == 2:
-        if ftype == TType.MAP:
+        if ftype == TType.I64:
-          self.undeliveredOrders = {}
+          self.jacketNumber = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.I64:
-          (_ktype126, _vtype127, _size125 ) = iprot.readMapBegin()
+          self.imeiNumber = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
-          for _i129 in xrange(_size125):
+        if ftype == TType.STRING:
-            _key130 = iprot.readString();
+          self.itemNumber = iprot.readString();
+        else:
-            _val131 = iprot.readString();
+          iprot.skip(ftype)
+      elif fid == 5:
+        if ftype == TType.STRING:
-            self.undeliveredOrders[_key130] = _val131
+          self.billedBy = iprot.readString();
+        else:
-          iprot.readMapEnd()
+          iprot.skip(ftype)
+      elif fid == 6:
+        if ftype == TType.I64:
+          self.billingType = iprot.readI64();
         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('updateNonDeliveryReason_args')
+    oprot.writeStructBegin('addJacketNumber_args')
-    if self.providerId != None:
+    if self.orderId != None:
-      oprot.writeFieldBegin('providerId', TType.I64, 1)
+      oprot.writeFieldBegin('orderId', TType.I64, 1)
-      oprot.writeI64(self.providerId)
+      oprot.writeI64(self.orderId)
       oprot.writeFieldEnd()
-    if self.undeliveredOrders != None:
+    if self.jacketNumber != None:
-      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
+      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
+      oprot.writeI64(self.jacketNumber)
+      oprot.writeFieldEnd()
+    if self.imeiNumber != None:
-      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
+      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
+      oprot.writeI64(self.imeiNumber)
+      oprot.writeFieldEnd()
+    if self.itemNumber != None:
-      for kiter132,viter133 in self.undeliveredOrders.items():
+      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
-        oprot.writeString(kiter132)
+      oprot.writeString(self.itemNumber)
+      oprot.writeFieldEnd()
+    if self.billedBy != None:
+      oprot.writeFieldBegin('billedBy', TType.STRING, 5)
-        oprot.writeString(viter133)
+      oprot.writeString(self.billedBy)
-      oprot.writeMapEnd()
+      oprot.writeFieldEnd()
+    if self.billingType != None:
+      oprot.writeFieldBegin('billingType', TType.I64, 6)
+      oprot.writeI64(self.billingType)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class updateNonDeliveryReason_result:
+class addJacketNumber_result:
   """
   Attributes:
+   - success
    - ex
   """
   thrift_spec = (
-    None, # 0
+    (0, TType.BOOL, 'success', None, None, ), # 0
     (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, ex=None,):
+  def __init__(self, success=None, 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 fid == 0:
+        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('updateNonDeliveryReason_result')
+    oprot.writeStructBegin('addJacketNumber_result')
+    if self.success != None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(self.success)
+      oprot.writeFieldEnd()
     if self.ex != 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 getUndeliveredOrders_args:
+class markOrdersAsManifested_args:
   """
   Attributes:
-   - providerId
    - warehouseId
+   - providerId
+   - cod
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'providerId', None, None, ), # 1
+    (1, TType.I64, 'warehouseId', None, None, ), # 1
-    (2, TType.I64, 'warehouseId', None, None, ), # 2
+    (2, TType.I64, 'providerId', None, None, ), # 2
+    (3, TType.BOOL, 'cod', None, None, ), # 3
+  )
-  def __init__(self, providerId=None, warehouseId=None,):
+  def __init__(self, warehouseId=None, providerId=None, cod=None,):
-    self.providerId = providerId
     self.warehouseId = warehouseId
+    self.providerId = providerId
+    self.cod = cod
   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.providerId = iprot.readI64();
+          self.warehouseId = iprot.readI64();
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.I64:
-          self.warehouseId = iprot.readI64();
+          self.providerId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.BOOL:
+          self.cod = iprot.readBool();
         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('getUndeliveredOrders_args')
+    oprot.writeStructBegin('markOrdersAsManifested_args')
+    if self.warehouseId != None:
+      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
+      oprot.writeI64(self.warehouseId)
+      oprot.writeFieldEnd()
     if self.providerId != None:
-      oprot.writeFieldBegin('providerId', TType.I64, 1)
+      oprot.writeFieldBegin('providerId', TType.I64, 2)
       oprot.writeI64(self.providerId)
       oprot.writeFieldEnd()
-    if self.warehouseId != None:
+    if self.cod != None:
-      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
+      oprot.writeFieldBegin('cod', TType.BOOL, 3)
-      oprot.writeI64(self.warehouseId)
+      oprot.writeBool(self.cod)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getUndeliveredOrders_result:
+class markOrdersAsManifested_result:
   """
   Attributes:
    - success
+   - ex
   """
   thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
-    (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,):
+  def __init__(self, success=None, 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))
       return
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
       if fid == 0:
-        if ftype == TType.LIST:
+        if ftype == TType.BOOL:
-          self.success = []
+          self.success = iprot.readBool();
-          (_etype137, _size134) = iprot.readListBegin()
+        else:
-          for _i138 in xrange(_size134):
+          iprot.skip(ftype)
-            _elem139 = Order()
+      elif fid == 1:
-            _elem139.read(iprot)
+        if ftype == TType.STRUCT:
-            self.success.append(_elem139)
+          self.ex = TransactionServiceException()
-          iprot.readListEnd()
+          self.ex.read(iprot)
         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('getUndeliveredOrders_result')
+    oprot.writeStructBegin('markOrdersAsManifested_result')
     if self.success != None:
-      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
-      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      oprot.writeBool(self.success)
-      for iter140 in self.success:
+      oprot.writeFieldEnd()
-        iter140.write(oprot)
+    if self.ex != None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
-      oprot.writeListEnd()
+      self.ex.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getAlerts_args:
+class markOrdersAsPickedUp_args:
   """
   Attributes:
-   - orderId
+   - providerId
-   - valid
+   - pickupDetails
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'orderId', None, None, ), # 1
+    (1, TType.I64, 'providerId', None, None, ), # 1
-    (2, TType.BOOL, 'valid', None, None, ), # 2
+    (2, TType.MAP, 'pickupDetails', (TType.STRING,None,TType.STRING,None), None, ), # 2
+  )
-  def __init__(self, orderId=None, valid=None,):
+  def __init__(self, providerId=None, pickupDetails=None,):
-    self.orderId = orderId
+    self.providerId = providerId
-    self.valid = valid
+    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.orderId = iprot.readI64();
+          self.providerId = iprot.readI64();
         else:
           iprot.skip(ftype)
       elif fid == 2:
-        if ftype == TType.BOOL:
+        if ftype == TType.MAP:
+          self.pickupDetails = {}
+          (_ktype113, _vtype114, _size112 ) = iprot.readMapBegin()
+          for _i116 in xrange(_size112):
+            _key117 = iprot.readString();
-          self.valid = iprot.readBool();
+            _val118 = iprot.readString();
+            self.pickupDetails[_key117] = _val118
+          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('getAlerts_args')
+    oprot.writeStructBegin('markOrdersAsPickedUp_args')
-    if self.orderId != None:
+    if self.providerId != None:
-      oprot.writeFieldBegin('orderId', TType.I64, 1)
+      oprot.writeFieldBegin('providerId', TType.I64, 1)
-      oprot.writeI64(self.orderId)
+      oprot.writeI64(self.providerId)
       oprot.writeFieldEnd()
-    if self.valid != None:
+    if self.pickupDetails != None:
-      oprot.writeFieldBegin('valid', TType.BOOL, 2)
+      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
+      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
+      for kiter119,viter120 in self.pickupDetails.items():
-      oprot.writeBool(self.valid)
+        oprot.writeString(kiter119)
+        oprot.writeString(viter120)
+      oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getAlerts_result:
+class markOrdersAsPickedUp_result:
   """
   Attributes:
    - success
+   - ex
   """
   thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(Alert, Alert.thrift_spec)), None, ), # 0
+    (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,):
+  def __init__(self, success=None, 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))
       return
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype144, _size141) = iprot.readListBegin()
+          (_etype124, _size121) = iprot.readListBegin()
-          for _i145 in xrange(_size141):
+          for _i125 in xrange(_size121):
-            _elem146 = Alert()
+            _elem126 = Order()
-            _elem146.read(iprot)
+            _elem126.read(iprot)
-            self.success.append(_elem146)
+            self.success.append(_elem126)
           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('getAlerts_result')
+    oprot.writeStructBegin('markOrdersAsPickedUp_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter147 in self.success:
+      for iter127 in self.success:
-        iter147.write(oprot)
+        iter127.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
+    if self.ex != None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
+      self.ex.write(oprot)
+      oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     L = ['%s=%r' % (key, value)
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class setAlert_args:
+class markOrdersAsDelivered_args:
   """
   Attributes:
-   - orderId
+   - providerId
-   - unset
-   - type
-   - comment
+   - deliveredOrders
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'orderId', None, None, ), # 1
+    (1, TType.I64, 'providerId', None, None, ), # 1
-    (2, TType.BOOL, 'unset', None, None, ), # 2
-    (3, TType.I64, 'type', None, None, ), # 3
-    (4, TType.STRING, 'comment', None, None, ), # 4
+    (2, TType.MAP, 'deliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
+  )
-  def __init__(self, orderId=None, unset=None, type=None, comment=None,):
+  def __init__(self, providerId=None, deliveredOrders=None,):
-    self.orderId = orderId
+    self.providerId = providerId
-    self.unset = unset
-    self.type = type
-    self.comment = comment
+    self.deliveredOrders = deliveredOrders
   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.orderId = iprot.readI64();
+          self.providerId = iprot.readI64();
         else:
           iprot.skip(ftype)
       elif fid == 2:
-        if ftype == TType.BOOL:
+        if ftype == TType.MAP:
-          self.unset = iprot.readBool();
+          self.deliveredOrders = {}
-        else:
-          iprot.skip(ftype)
+          (_ktype129, _vtype130, _size128 ) = iprot.readMapBegin()
-      elif fid == 3:
-        if ftype == TType.I64:
+          for _i132 in xrange(_size128):
-          self.type = iprot.readI64();
+            _key133 = iprot.readString();
-        else:
-          iprot.skip(ftype)
+            _val134 = iprot.readString();
-      elif fid == 4:
-        if ftype == TType.STRING:
+            self.deliveredOrders[_key133] = _val134
-          self.comment = iprot.readString();
+          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('setAlert_args')
+    oprot.writeStructBegin('markOrdersAsDelivered_args')
-    if self.orderId != None:
+    if self.providerId != None:
-      oprot.writeFieldBegin('orderId', TType.I64, 1)
+      oprot.writeFieldBegin('providerId', TType.I64, 1)
-      oprot.writeI64(self.orderId)
+      oprot.writeI64(self.providerId)
-      oprot.writeFieldEnd()
-    if self.unset != None:
-      oprot.writeFieldBegin('unset', TType.BOOL, 2)
-      oprot.writeBool(self.unset)
-      oprot.writeFieldEnd()
-    if self.type != None:
-      oprot.writeFieldBegin('type', TType.I64, 3)
-      oprot.writeI64(self.type)
       oprot.writeFieldEnd()
-    if self.comment != None:
+    if self.deliveredOrders != None:
-      oprot.writeFieldBegin('comment', TType.STRING, 4)
+      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
+      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
+      for kiter135,viter136 in self.deliveredOrders.items():
+        oprot.writeString(kiter135)
-      oprot.writeString(self.comment)
+        oprot.writeString(viter136)
+      oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class setAlert_result:
+class markOrdersAsDelivered_result:
+  """
+  Attributes:
+   - ex
+  """
   thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
-  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('setAlert_result')
-    oprot.writeFieldStop()
-    oprot.writeStructEnd()
-  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):
+  def __init__(self, ex=None,):
-    return not (self == other)
-class getValidOrderCount_args:
-  thrift_spec = (
+    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('getValidOrderCount_args')
+    oprot.writeStructBegin('markOrdersAsDelivered_result')
+    if self.ex != None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
+      self.ex.write(oprot)
+      oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     L = ['%s=%r' % (key, value)
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getValidOrderCount_result:
+class markOrdersAsFailed_args:
   """
   Attributes:
-   - success
+   - providerId
+   - returnedOrders
   """
   thrift_spec = (
+    None, # 0
-    (0, TType.I64, 'success', None, None, ), # 0
+    (1, TType.I64, 'providerId', None, None, ), # 1
+    (2, TType.MAP, 'returnedOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
+  )
-  def __init__(self, success=None,):
+  def __init__(self, providerId=None, returnedOrders=None,):
-    self.success = success
+    self.providerId = providerId
+    self.returnedOrders = returnedOrders
   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 fid == 1:
         if ftype == TType.I64:
-          self.success = iprot.readI64();
+          self.providerId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.MAP:
+          self.returnedOrders = {}
+          (_ktype138, _vtype139, _size137 ) = iprot.readMapBegin()
+          for _i141 in xrange(_size137):
+            _key142 = iprot.readString();
+            _val143 = iprot.readString();
+            self.returnedOrders[_key142] = _val143
+          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('getValidOrderCount_result')
+    oprot.writeStructBegin('markOrdersAsFailed_args')
-    if self.success != None:
+    if self.providerId != None:
-      oprot.writeFieldBegin('success', TType.I64, 0)
+      oprot.writeFieldBegin('providerId', TType.I64, 1)
-      oprot.writeI64(self.success)
+      oprot.writeI64(self.providerId)
+      oprot.writeFieldEnd()
+    if self.returnedOrders != None:
+      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
+      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
+      for kiter144,viter145 in self.returnedOrders.items():
+        oprot.writeString(kiter144)
+        oprot.writeString(viter145)
+      oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getNoOfCustomersWithSuccessfulTransaction_args:
+class markOrdersAsFailed_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('getNoOfCustomersWithSuccessfulTransaction_args')
+    oprot.writeStructBegin('markOrdersAsFailed_result')
+    if self.ex != None:
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
+      self.ex.write(oprot)
+      oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     L = ['%s=%r' % (key, value)
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getNoOfCustomersWithSuccessfulTransaction_result:
+class updateNonDeliveryReason_args:
   """
   Attributes:
-   - success
+   - providerId
+   - undeliveredOrders
   """
   thrift_spec = (
+    None, # 0
-    (0, TType.I64, 'success', None, None, ), # 0
+    (1, TType.I64, 'providerId', None, None, ), # 1
+    (2, TType.MAP, 'undeliveredOrders', (TType.STRING,None,TType.STRING,None), None, ), # 2
+  )
-  def __init__(self, success=None,):
+  def __init__(self, providerId=None, undeliveredOrders=None,):
-    self.success = success
+    self.providerId = providerId
+    self.undeliveredOrders = undeliveredOrders
   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 fid == 1:
         if ftype == TType.I64:
-          self.success = iprot.readI64();
+          self.providerId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.MAP:
+          self.undeliveredOrders = {}
+          (_ktype147, _vtype148, _size146 ) = iprot.readMapBegin()
+          for _i150 in xrange(_size146):
+            _key151 = iprot.readString();
+            _val152 = iprot.readString();
+            self.undeliveredOrders[_key151] = _val152
+          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('getNoOfCustomersWithSuccessfulTransaction_result')
+    oprot.writeStructBegin('updateNonDeliveryReason_args')
-    if self.success != None:
+    if self.providerId != None:
-      oprot.writeFieldBegin('success', TType.I64, 0)
+      oprot.writeFieldBegin('providerId', TType.I64, 1)
-      oprot.writeI64(self.success)
+      oprot.writeI64(self.providerId)
+      oprot.writeFieldEnd()
+    if self.undeliveredOrders != None:
+      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
+      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
+      for kiter153,viter154 in self.undeliveredOrders.items():
+        oprot.writeString(kiter153)
+        oprot.writeString(viter154)
+      oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getValidOrdersAmountRange_args:
-  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('getValidOrdersAmountRange_args')
-    oprot.writeFieldStop()
-    oprot.writeStructEnd()
-  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 getValidOrdersAmountRange_result:
+class updateNonDeliveryReason_result:
   """
   Attributes:
-   - success
+   - ex
   """
   thrift_spec = (
+    None, # 0
-    (0, TType.LIST, 'success', (TType.DOUBLE,None), None, ), # 0
+    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
-  def __init__(self, success=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))
       return
     iprot.readStructBegin()
     while True:
       (fname, ftype, fid) = iprot.readFieldBegin()
       if ftype == TType.STOP:
         break
-      if fid == 0:
+      if fid == 1:
-        if ftype == TType.LIST:
+        if ftype == TType.STRUCT:
-          self.success = []
-          (_etype151, _size148) = iprot.readListBegin()
-          for _i152 in xrange(_size148):
-            _elem153 = iprot.readDouble();
-            self.success.append(_elem153)
+          self.ex = TransactionServiceException()
-          iprot.readListEnd()
+          self.ex.read(iprot)
         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('getValidOrdersAmountRange_result')
+    oprot.writeStructBegin('updateNonDeliveryReason_result')
-    if self.success != None:
+    if self.ex != None:
-      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
-      oprot.writeListBegin(TType.DOUBLE, len(self.success))
-      for iter154 in self.success:
-        oprot.writeDouble(iter154)
-      oprot.writeListEnd()
+      self.ex.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getValidOrders_args:
+class getUndeliveredOrders_args:
   """
   Attributes:
-   - limit
+   - providerId
+   - warehouseId
   """
   thrift_spec = (
     None, # 0
-    (1, TType.I64, 'limit', None, None, ), # 1
+    (1, TType.I64, 'providerId', None, None, ), # 1
+    (2, TType.I64, 'warehouseId', None, None, ), # 2
+  )
-  def __init__(self, limit=None,):
+  def __init__(self, providerId=None, warehouseId=None,):
-    self.limit = limit
+    self.providerId = providerId
+    self.warehouseId = warehouseId
   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.limit = iprot.readI64();
+          self.providerId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I64:
+          self.warehouseId = iprot.readI64();
         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('getValidOrders_args')
+    oprot.writeStructBegin('getUndeliveredOrders_args')
-    if self.limit != None:
+    if self.providerId != None:
-      oprot.writeFieldBegin('limit', TType.I64, 1)
+      oprot.writeFieldBegin('providerId', TType.I64, 1)
-      oprot.writeI64(self.limit)
+      oprot.writeI64(self.providerId)
+      oprot.writeFieldEnd()
+    if self.warehouseId != None:
+      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
+      oprot.writeI64(self.warehouseId)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def __repr__(self):
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
-class getValidOrders_result:
+class getUndeliveredOrders_result:
   """
   Attributes:
    - success
   """
   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('getValidOrders_result')
+    oprot.writeStructBegin('getUndeliveredOrders_result')
     if self.success != None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
       for iter161 in self.success:
         iter161.write(oprot)

Subversion Repositories SmartDukaan

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