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



#
# Autogenerated by Thrift Compiler (0.7.0)
#
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
#
 
from thrift.Thrift import *
import shop2020.thriftpy.generic.GenericService
from ttypes import *
from thrift.Thrift import TProcessor
from thrift.transport import TTransport
from thrift.protocol import TBinaryProtocol, TProtocol
try:
  from thrift.protocol import fastbinary
except:
  fastbinary = None
 

    pass
 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
    """
    Returns orders within a range of their billing dates
 
    Parameters:
     - status
     - start_billing_date
     - end_billing_date
     - warehouse_id

 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId):
    """
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
    Pass providerId and warehouseId as -1 to ignore both the parameters.
 
    Parameters:
     - fromShippingDate
     - toShippingDate
     - providerId
     - warehouseId

    pass
 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
    """
    Returns order ids for orders which can be returned
 
    Parameters:
     - customer_id
     - limit
    """
    pass
 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
    """
    Returns order ids for orders which can be cancelled
 
    Parameters:
     - customer_id
     - limit
    """
    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.
 
    Parameters:
     - transactionId
     - customerId
    """
    pass
 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
    """
    Returns list of orders for the given customer created between the given dates and having the given statuses.
    Pass and empty list to ignore filtering on statuses.
 
    Parameters:
     - customerId
     - from_date
     - to_date
     - statuses

 
  def getOrderForCustomer(self, orderId, customerId):
    """
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
 
    Parameters:
     - orderId
     - customerId
    """
    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:
     - warehouseId
    """
    pass
 
  def markOrderAsOutOfStock(self, orderId):
    """
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
 
    Parameters:
     - orderId
    """
    pass
 

    """
    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
 

    """
    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 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
    """

    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

 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
    """
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
 
    Parameters:
     - warehouseId
     - providerId
     - cod
    """

  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:
     - providerId
     - pickupDetails
    """
    pass

  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:
     - providerId
     - deliveredOrders
    """
    pass
 
  def markOrdersAsFailed(self, providerId, returnedOrders):
    """
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
    Raises an exception if we encounter report for an AWB number that we did not ship.
 
    Parameters:
     - providerId
     - returnedOrders
    """
    pass
 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
    """
    Update the status description of orders whose AWB numbers are keys of the Map.
 
    Parameters:
     - providerId
     - undeliveredOrders
    """
    pass

    """
    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.
    Returns an empty list if no such orders exist.
 
    Parameters:
     - providerId
     - warehouseId
    """
    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.
 
    Parameters:
     - orderId
    """
    pass
 

    Sends out an email to the account manager of the original courier provider used to ship the order.
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
    For any other status, it returns false.
    Throws an exception if the order with the given id couldn't be found.
 
    Parameters:
     - orderId
    """
    pass
 

    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
    	3. Returns true
    If the order is in any other status, it returns false.
    Throws an exception if the order with the given id couldn't be found.
 
    Parameters:
     - orderId
     - pickupNumber
    """
    pass
 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
    """
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
 
    Parameters:
     - providerId
     - pickupDetails
    """
    pass

    """
    If the order status is DOA_RETURN_AUTHORIZED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED and returns true.
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
    If the order is in any other state, it returns false.
    Throws an exception if the order with the given id couldn't be found.
 
    Parameters:
     - orderId
    """
    pass
 

    """
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
    If the order is in any other state, it returns false.
    Throws an exception if the order with the given id couldn't be found.
 
    Parameters:
     - orderId
     - isValid
    """
    pass

    	
    If the order is in DOA_CERT_VALID state, it does the following:
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
    	2. Creates a return order for the warehouse executive to return the DOA material.
    	3. Marks the current order as the final DOA_RESHIPPED state.
 
    Returns the id of the newly created order.
 
    Throws an exception if the order with the given id couldn't be found.
 
    Parameters:
     - orderId
    """
    pass
 

    """
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
    	1. Creates a refund request for batch processing.
    	2. Creates a return order for the warehouse executive to return the shipped material.
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
    	1. Creates a refund request for batch processing.
    	2. Cancels the reservation of the item in the warehouse.
    	3. Marks the current order as the REFUNDED final state.
 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
    	1. Cancels the reservation of the item in the warehouse.
    	2. Marks the current order as CANCELED.
    	
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
     
    Returns True if it is successful, False otherwise.
 
    Throws an exception if the order with the given id couldn't be found.
 
    Parameters:
     - orderId
     - refundedBy
     - reason
    """

 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
    """
    Get all return orders created between the from and to dates for the given warehouse.
    Ignores the warehouse if it is passed as -1.
 
    Parameters:
     - warehouseId
     - fromDate
     - toDate
    """

 
  def getReturnOrder(self, id):
    """
    Returns the ReturnOrder corresponding to the given id.
    Throws an exception if the return order with the given id couldn't be found.
 
    Parameters:
     - id
    """
    pass
 
  def processReturn(self, returnOrderId):
    """
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
 
    Parameters:
     - returnOrderId
    """
    pass
 
  def createPurchaseOrder(self, warehouseId):
    """
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
 
    Parameters:
     - warehouseId
    """
    pass
 

      self._iprot.readMessageEnd()
      raise x
    result = createTransaction_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");
 
  def getTransaction(self, id):
    """

      self._iprot.readMessageEnd()
      raise x
    result = getTransaction_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");
 
  def getTransactionsForCustomer(self, customerId, from_date, to_date, status):
    """

      self._iprot.readMessageEnd()
      raise x
    result = getTransactionsForCustomer_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");
 
  def getTransactionsForShoppingCartId(self, shoppingCartId):
    """

      self._iprot.readMessageEnd()
      raise x
    result = getTransactionsForShoppingCartId_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");
 
  def getTransactionStatus(self, transactionId):
    """

      self._iprot.readMessageEnd()
      raise x
    result = getTransactionStatus_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");
 
  def changeTransactionStatus(self, transactionId, status, description):
    """

      self._iprot.readMessageEnd()
      raise x
    result = changeTransactionStatus_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");
 
  def enqueueTransactionInfoEmail(self, transactionId):
    """

      self._iprot.readMessageEnd()
      raise x
    result = enqueueTransactionInfoEmail_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "enqueueTransactionInfoEmail failed: unknown result");
 
  def getAllOrders(self, status, from_date, to_date, warehouse_id):
    """

      self._iprot.readMessageEnd()
      raise x
    result = getAllOrders_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllOrders failed: unknown result");
 
  def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):
    """
    Returns orders within a range of their billing dates
 
    Parameters:
     - status
     - start_billing_date
     - end_billing_date
     - warehouse_id

      self._iprot.readMessageEnd()
      raise x
    result = getOrdersByBillingDate_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByBillingDate failed: unknown result");
 
  def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId):
    """
    Returns orders for a particular provider and warehouse which were shipped between the given dates.
    Pass providerId and warehouseId as -1 to ignore both the parameters.
 
    Parameters:
     - fromShippingDate
     - toShippingDate
     - providerId
     - warehouseId

      self._iprot.readMessageEnd()
      raise x
    result = getOrdersByShippingDate_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersByShippingDate failed: unknown result");
 
  def getReturnableOrdersForCustomer(self, customer_id, limit):
    """
    Returns order ids for orders which can be returned
 
    Parameters:
     - customer_id
     - limit
    """
    self.send_getReturnableOrdersForCustomer(customer_id, limit)

      self._iprot.readMessageEnd()
      raise x
    result = getReturnableOrdersForCustomer_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnableOrdersForCustomer failed: unknown result");
 
  def getCancellableOrdersForCustomer(self, customer_id, limit):
    """
    Returns order ids for orders which can be cancelled
 
    Parameters:
     - customer_id
     - limit
    """
    self.send_getCancellableOrdersForCustomer(customer_id, limit)

      self._iprot.readMessageEnd()
      raise x
    result = getCancellableOrdersForCustomer_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCancellableOrdersForCustomer failed: unknown result");
 
  def changeOrderStatus(self, orderId, status, description):
    """

      self._iprot.readMessageEnd()
      raise x
    result = changeOrderStatus_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "changeOrderStatus 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.
 
    Parameters:
     - transactionId
     - customerId
    """
    self.send_getOrdersForTransaction(transactionId, customerId)

      self._iprot.readMessageEnd()
      raise x
    result = getOrdersForTransaction_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForTransaction failed: unknown result");
 
  def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):
    """
    Returns list of orders for the given customer created between the given dates and having the given statuses.
    Pass and empty list to ignore filtering on statuses.
 
    Parameters:
     - customerId
     - from_date
     - to_date
     - statuses

      self._iprot.readMessageEnd()
      raise x
    result = getOrdersForCustomer_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrdersForCustomer failed: unknown result");
 
  def createOrder(self, order):
    """

      self._iprot.readMessageEnd()
      raise x
    result = createOrder_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrder failed: unknown result");
 
  def getOrder(self, id):
    """

      self._iprot.readMessageEnd()
      raise x
    result = getOrder_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrder failed: unknown result");
 
  def getLineItemsForOrder(self, orderId):
    """

      self._iprot.readMessageEnd()
      raise x
    result = getLineItemsForOrder_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLineItemsForOrder failed: unknown result");
 
  def getOrderForCustomer(self, orderId, customerId):
    """
    Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.
    Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.
 
    Parameters:
     - orderId
     - customerId
    """
    self.send_getOrderForCustomer(orderId, customerId)

      self._iprot.readMessageEnd()
      raise x
    result = getOrderForCustomer_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getOrderForCustomer failed: unknown result");
 
  def getAlerts(self, orderId, valid):
    """

      self._iprot.readMessageEnd()
      raise x
    result = getAlerts_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAlerts failed: unknown result");
 
  def setAlert(self, orderId, unset, type, comment):
    """

      self._iprot.readMessageEnd()
      raise x
    result = getValidOrderCount_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getValidOrderCount failed: unknown result");
 
  def getNoOfCustomersWithSuccessfulTransaction(self, ):
    """

      self._iprot.readMessageEnd()
      raise x
    result = getNoOfCustomersWithSuccessfulTransaction_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getNoOfCustomersWithSuccessfulTransaction failed: unknown result");
 
  def getValidOrdersAmountRange(self, ):
    """

      self._iprot.readMessageEnd()
      raise x
    result = getValidOrdersAmountRange_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not 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()

      self._iprot.readMessageEnd()
      raise x
    result = getValidOrders_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not 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.
 
    Parameters:
     - warehouseId
    """
    self.send_batchOrders(warehouseId)
    return self.recv_batchOrders()

      self._iprot.readMessageEnd()
      raise x
    result = batchOrders_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "batchOrders failed: unknown result");
 
  def markOrderAsOutOfStock(self, orderId):
    """
    Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.
 
    Parameters:
     - orderId
    """
    self.send_markOrderAsOutOfStock(orderId)
    return self.recv_markOrderAsOutOfStock()

      self._iprot.readMessageEnd()
      raise x
    result = markOrderAsOutOfStock_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrderAsOutOfStock failed: unknown result");
 
  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
    """
    self.send_verifyOrder(orderId)
    return self.recv_verifyOrder()

      self._iprot.readMessageEnd()
      raise x
    result = verifyOrder_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "verifyOrder failed: unknown result");
 
  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
    """
    self.send_acceptOrder(orderId)
    return self.recv_acceptOrder()

      self._iprot.readMessageEnd()
      raise x
    result = acceptOrder_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "acceptOrder failed: unknown result");
 
  def billOrder(self, orderId):
    """

      self._iprot.readMessageEnd()
      raise x
    result = billOrder_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "billOrder 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.
    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
    """

      self._iprot.readMessageEnd()
      raise x
    result = addBillingDetails_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addBillingDetails failed: unknown result");
 
  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

      self._iprot.readMessageEnd()
      raise x
    result = addJacketNumber_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addJacketNumber failed: unknown result");
 
  def markOrdersAsManifested(self, warehouseId, providerId, cod):
    """
    Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the
    given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.
 
    Parameters:
     - warehouseId
     - providerId
     - cod
    """

      self._iprot.readMessageEnd()
      raise x
    result = markOrdersAsManifested_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsManifested failed: unknown result");
 
  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:
     - providerId
     - pickupDetails
    """
    self.send_markOrdersAsPickedUp(providerId, pickupDetails)

      self._iprot.readMessageEnd()
      raise x
    result = markOrdersAsPickedUp_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markOrdersAsPickedUp failed: unknown result");
 
  def markOrdersAsDelivered(self, providerId, deliveredOrders):
    """
    Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and
    the name of the receiver.
    Raises an exception if we encounter report for an AWB number that we did not ship.
 
    Parameters:
     - providerId
     - deliveredOrders
    """
    self.send_markOrdersAsDelivered(providerId, deliveredOrders)

      self._iprot.readMessageEnd()
      raise x
    result = markOrdersAsDelivered_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ex is not None:
      raise result.ex
    return
 
  def markOrdersAsFailed(self, providerId, returnedOrders):
    """
    Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.
    Raises an exception if we encounter report for an AWB number that we did not ship.
 
    Parameters:
     - providerId
     - returnedOrders
    """
    self.send_markOrdersAsFailed(providerId, returnedOrders)

      self._iprot.readMessageEnd()
      raise x
    result = markOrdersAsFailed_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ex is not None:
      raise result.ex
    return
 
  def updateNonDeliveryReason(self, providerId, undeliveredOrders):
    """
    Update the status description of orders whose AWB numbers are keys of the Map.
 
    Parameters:
     - providerId
     - undeliveredOrders
    """
    self.send_updateNonDeliveryReason(providerId, undeliveredOrders)

      self._iprot.readMessageEnd()
      raise x
    result = updateNonDeliveryReason_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ex is not None:
      raise result.ex
    return
 
  def getUndeliveredOrders(self, providerId, warehouseId):
    """
    Returns the list of orders whose delivery time has passed but have not been
    delivered yet for the given provider and warehouse. To get a complete list of
    undelivered orders, pass them as -1.
    Returns an empty list if no such orders exist.
 
    Parameters:
     - providerId
     - warehouseId
    """
    self.send_getUndeliveredOrders(providerId, warehouseId)

      self._iprot.readMessageEnd()
      raise x
    result = getUndeliveredOrders_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    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.
    Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.
 
    Parameters:
     - orderId
    """
    self.send_toggleDOAFlag(orderId)
    return self.recv_toggleDOAFlag()

      self._iprot.readMessageEnd()
      raise x
    result = toggleDOAFlag_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "toggleDOAFlag failed: unknown result");
 
  def requestPickupNumber(self, orderId):
    """
    Sends out an email to the account manager of the original courier provider used to ship the order.
    If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.
    If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.
    For any other status, it returns false.
    Throws an exception if the order with the given id couldn't be found.
 
    Parameters:
     - orderId
    """
    self.send_requestPickupNumber(orderId)
    return self.recv_requestPickupNumber()

      self._iprot.readMessageEnd()
      raise x
    result = requestPickupNumber_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "requestPickupNumber failed: unknown result");
 
  def authorizePickup(self, orderId, pickupNumber):
    """

    	1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.
    	2. Changes order status to be DOA_PICKUP_AUTHORIZED.
    	3. Returns true
    If the order is in any other status, it returns false.
    Throws an exception if the order with the given id couldn't be found.
 
    Parameters:
     - orderId
     - pickupNumber
    """
    self.send_authorizePickup(orderId, pickupNumber)

      self._iprot.readMessageEnd()
      raise x
    result = authorizePickup_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authorizePickup failed: unknown result");
 
  def markDoasAsPickedUp(self, providerId, pickupDetails):
    """
    Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.
    Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.
 
    Parameters:
     - providerId
     - pickupDetails
    """
    self.send_markDoasAsPickedUp(providerId, pickupDetails)

      self._iprot.readMessageEnd()
      raise x
    result = markDoasAsPickedUp_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "markDoasAsPickedUp failed: unknown result");
 
  def receiveReturn(self, orderId):
    """
    If the order status is DOA_RETURN_AUTHORIZED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED and returns true.
    If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.
    If the order is in any other state, it returns false.
    Throws an exception if the order with the given id couldn't be found.
 
    Parameters:
     - orderId
    """
    self.send_receiveReturn(orderId)
    return self.recv_receiveReturn()

      self._iprot.readMessageEnd()
      raise x
    result = receiveReturn_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "receiveReturn failed: unknown result");
 
  def validateDoa(self, orderId, isValid):
    """
    Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,
    the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.
    If the order is in any other state, it returns false.
    Throws an exception if the order with the given id couldn't be found.
 
    Parameters:
     - orderId
     - isValid
    """
    self.send_validateDoa(orderId, isValid)

      self._iprot.readMessageEnd()
      raise x
    result = validateDoa_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateDoa failed: unknown result");
 
  def reshipOrder(self, orderId):
    """

    	
    If the order is in DOA_CERT_VALID state, it does the following:
    	1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.
    	2. Creates a return order for the warehouse executive to return the DOA material.
    	3. Marks the current order as the final DOA_RESHIPPED state.
 
    Returns the id of the newly created order.
 
    Throws an exception if the order with the given id couldn't be found.
 
    Parameters:
     - orderId
    """
    self.send_reshipOrder(orderId)
    return self.recv_reshipOrder()

      self._iprot.readMessageEnd()
      raise x
    result = reshipOrder_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "reshipOrder failed: unknown result");
 
  def refundOrder(self, orderId, refundedBy, reason):
    """
    If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:
    	1. Creates a refund request for batch processing.
    	2. Creates a return order for the warehouse executive to return the shipped material.
    	3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.
 
    If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
    	1. Creates a refund request for batch processing.
    	2. Cancels the reservation of the item in the warehouse.
    	3. Marks the current order as the REFUNDED final state.
 
    For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:
    	1. Cancels the reservation of the item in the warehouse.
    	2. Marks the current order as CANCELED.
    	
    In all cases, it updates the reason for cancellation or refund and the person who performed the action.
     
    Returns True if it is successful, False otherwise.
 
    Throws an exception if the order with the given id couldn't be found.
 
    Parameters:
     - orderId
     - refundedBy
     - reason
    """

      self._iprot.readMessageEnd()
      raise x
    result = refundOrder_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "refundOrder failed: unknown result");
 
  def getReturnOrders(self, warehouseId, fromDate, toDate):
    """
    Get all return orders created between the from and to dates for the given warehouse.
    Ignores the warehouse if it is passed as -1.
 
    Parameters:
     - warehouseId
     - fromDate
     - toDate
    """

      self._iprot.readMessageEnd()
      raise x
    result = getReturnOrders_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrders failed: unknown result");
 
  def getReturnOrder(self, id):
    """
    Returns the ReturnOrder corresponding to the given id.
    Throws an exception if the return order with the given id couldn't be found.
 
    Parameters:
     - id
    """
    self.send_getReturnOrder(id)
    return self.recv_getReturnOrder()

      self._iprot.readMessageEnd()
      raise x
    result = getReturnOrder_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getReturnOrder failed: unknown result");
 
  def processReturn(self, returnOrderId):
    """
    Marks the return order with the given id as processed. Raises an exception if no such return order exists.
 
    Parameters:
     - returnOrderId
    """
    self.send_processReturn(returnOrderId)
    self.recv_processReturn()

      self._iprot.readMessageEnd()
      raise x
    result = processReturn_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.ex is not None:
      raise result.ex
    return
 
  def createPurchaseOrder(self, warehouseId):
    """
    Creates a purchase order corresponding to all the pending orders of the given warehouse.
    Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.
 
    Parameters:
     - warehouseId
    """
    self.send_createPurchaseOrder(warehouseId)
    return self.recv_createPurchaseOrder()

      self._iprot.readMessageEnd()
      raise x
    result = createPurchaseOrder_result()
    result.read(self._iprot)
    self._iprot.readMessageEnd()
    if result.success is not None:
      return result.success
    if result.ex is not None:
      raise result.ex
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createPurchaseOrder failed: unknown result");
 
 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):

  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('createTransaction_args')
    if self.transaction is not None:
      oprot.writeFieldBegin('transaction', TType.STRUCT, 1)
      self.transaction.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('createTransaction_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.I64, 0)
      oprot.writeI64(self.success)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  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('getTransaction_args')
    if self.id is not None:
      oprot.writeFieldBegin('id', TType.I64, 1)
      oprot.writeI64(self.id)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('getTransaction_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  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('getTransactionsForCustomer_args')
    if self.customerId is not None:
      oprot.writeFieldBegin('customerId', TType.I64, 1)
      oprot.writeI64(self.customerId)
      oprot.writeFieldEnd()
    if self.from_date is not None:
      oprot.writeFieldBegin('from_date', TType.I64, 2)
      oprot.writeI64(self.from_date)
      oprot.writeFieldEnd()
    if self.to_date is not None:
      oprot.writeFieldBegin('to_date', TType.I64, 3)
      oprot.writeI64(self.to_date)
      oprot.writeFieldEnd()
    if self.status is not None:
      oprot.writeFieldBegin('status', TType.I32, 4)
      oprot.writeI32(self.status)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('getTransactionsForCustomer_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter20 in self.success:
        iter20.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  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('getTransactionsForShoppingCartId_args')
    if self.shoppingCartId is not None:
      oprot.writeFieldBegin('shoppingCartId', TType.I64, 1)
      oprot.writeI64(self.shoppingCartId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('getTransactionsForShoppingCartId_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter27 in self.success:
        iter27.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  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('getTransactionStatus_args')
    if self.transactionId is not None:
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
      oprot.writeI64(self.transactionId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('getTransactionStatus_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.I32, 0)
      oprot.writeI32(self.success)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  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('changeTransactionStatus_args')
    if self.transactionId is not None:
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
      oprot.writeI64(self.transactionId)
      oprot.writeFieldEnd()
    if self.status is not None:
      oprot.writeFieldBegin('status', TType.I32, 2)
      oprot.writeI32(self.status)
      oprot.writeFieldEnd()
    if self.description is not None:
      oprot.writeFieldBegin('description', TType.STRING, 3)
      oprot.writeString(self.description)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('changeTransactionStatus_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.BOOL, 0)
      oprot.writeBool(self.success)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('enqueueTransactionInfoEmail_args')
    if self.transactionId is not None:
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
      oprot.writeI64(self.transactionId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('enqueueTransactionInfoEmail_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.BOOL, 0)
      oprot.writeBool(self.success)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('getAllOrders_args')
    if self.status is not None:
      oprot.writeFieldBegin('status', TType.I32, 1)
      oprot.writeI32(self.status)
      oprot.writeFieldEnd()
    if self.from_date is not None:
      oprot.writeFieldBegin('from_date', TType.I64, 2)
      oprot.writeI64(self.from_date)
      oprot.writeFieldEnd()
    if self.to_date is not None:
      oprot.writeFieldBegin('to_date', TType.I64, 3)
      oprot.writeI64(self.to_date)
      oprot.writeFieldEnd()
    if self.warehouse_id is not None:
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
      oprot.writeI64(self.warehouse_id)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('getAllOrders_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter34 in self.success:
        iter34.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  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('getOrdersByBillingDate_args')
    if self.status is not None:
      oprot.writeFieldBegin('status', TType.I32, 1)
      oprot.writeI32(self.status)
      oprot.writeFieldEnd()
    if self.start_billing_date is not None:
      oprot.writeFieldBegin('start_billing_date', TType.I64, 2)
      oprot.writeI64(self.start_billing_date)
      oprot.writeFieldEnd()
    if self.end_billing_date is not None:
      oprot.writeFieldBegin('end_billing_date', TType.I64, 3)
      oprot.writeI64(self.end_billing_date)
      oprot.writeFieldEnd()
    if self.warehouse_id is not None:
      oprot.writeFieldBegin('warehouse_id', TType.I64, 4)
      oprot.writeI64(self.warehouse_id)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('getOrdersByBillingDate_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter41 in self.success:
        iter41.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  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('getOrdersByShippingDate_args')
    if self.fromShippingDate is not None:
      oprot.writeFieldBegin('fromShippingDate', TType.I64, 1)
      oprot.writeI64(self.fromShippingDate)
      oprot.writeFieldEnd()
    if self.toShippingDate is not None:
      oprot.writeFieldBegin('toShippingDate', TType.I64, 2)
      oprot.writeI64(self.toShippingDate)
      oprot.writeFieldEnd()
    if self.providerId is not None:
      oprot.writeFieldBegin('providerId', TType.I64, 3)
      oprot.writeI64(self.providerId)
      oprot.writeFieldEnd()
    if self.warehouseId is not None:
      oprot.writeFieldBegin('warehouseId', TType.I64, 4)
      oprot.writeI64(self.warehouseId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('getOrdersByShippingDate_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter48 in self.success:
        iter48.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  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('getReturnableOrdersForCustomer_args')
    if self.customer_id is not None:
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
      oprot.writeI64(self.customer_id)
      oprot.writeFieldEnd()
    if self.limit is not None:
      oprot.writeFieldBegin('limit', TType.I64, 2)
      oprot.writeI64(self.limit)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('getReturnableOrdersForCustomer_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.I64, len(self.success))
      for iter55 in self.success:
        oprot.writeI64(iter55)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  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('getCancellableOrdersForCustomer_args')
    if self.customer_id is not None:
      oprot.writeFieldBegin('customer_id', TType.I64, 1)
      oprot.writeI64(self.customer_id)
      oprot.writeFieldEnd()
    if self.limit is not None:
      oprot.writeFieldBegin('limit', TType.I64, 2)
      oprot.writeI64(self.limit)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('getCancellableOrdersForCustomer_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.I64, len(self.success))
      for iter62 in self.success:
        oprot.writeI64(iter62)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  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('changeOrderStatus_args')
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 1)
      oprot.writeI64(self.orderId)
      oprot.writeFieldEnd()
    if self.status is not None:
      oprot.writeFieldBegin('status', TType.I32, 2)
      oprot.writeI32(self.status)
      oprot.writeFieldEnd()
    if self.description is not None:
      oprot.writeFieldBegin('description', TType.STRING, 3)
      oprot.writeString(self.description)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('changeOrderStatus_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.BOOL, 0)
      oprot.writeBool(self.success)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.transactionId is not None:
      oprot.writeFieldBegin('transactionId', TType.I64, 1)
      oprot.writeI64(self.transactionId)
      oprot.writeFieldEnd()
    if self.customerId is not None:
      oprot.writeFieldBegin('customerId', TType.I64, 2)
      oprot.writeI64(self.customerId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter69 in self.success:
        iter69.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  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')
    if self.customerId is not None:
      oprot.writeFieldBegin('customerId', TType.I64, 1)
      oprot.writeI64(self.customerId)
      oprot.writeFieldEnd()
    if self.from_date is not None:
      oprot.writeFieldBegin('from_date', TType.I64, 2)
      oprot.writeI64(self.from_date)
      oprot.writeFieldEnd()
    if self.to_date is not None:
      oprot.writeFieldBegin('to_date', TType.I64, 3)
      oprot.writeI64(self.to_date)
      oprot.writeFieldEnd()
    if self.statuses is not None:
      oprot.writeFieldBegin('statuses', TType.LIST, 4)
      oprot.writeListBegin(TType.I32, len(self.statuses))
      for iter76 in self.statuses:
        oprot.writeI32(iter76)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter83 in self.success:
        iter83.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  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')
    if self.order is not None:
      oprot.writeFieldBegin('order', TType.STRUCT, 1)
      self.order.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.I64, 0)
      oprot.writeI64(self.success)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  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')
    if self.id is not None:
      oprot.writeFieldBegin('id', TType.I64, 1)
      oprot.writeI64(self.id)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  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')
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 1)
      oprot.writeI64(self.orderId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter90 in self.success:
        iter90.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  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')
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 1)
      oprot.writeI64(self.orderId)
      oprot.writeFieldEnd()
    if self.customerId is not None:
      oprot.writeFieldBegin('customerId', TType.I64, 2)
      oprot.writeI64(self.customerId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  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')
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 1)
      oprot.writeI64(self.orderId)
      oprot.writeFieldEnd()
    if self.valid is not None:
      oprot.writeFieldBegin('valid', TType.BOOL, 2)
      oprot.writeBool(self.valid)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter97 in self.success:
        iter97.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 1)
      oprot.writeI64(self.orderId)
      oprot.writeFieldEnd()
    if self.unset is not None:
      oprot.writeFieldBegin('unset', TType.BOOL, 2)
      oprot.writeBool(self.unset)
      oprot.writeFieldEnd()
    if self.type is not None:
      oprot.writeFieldBegin('type', TType.I64, 3)
      oprot.writeI64(self.type)
      oprot.writeFieldEnd()
    if self.comment is not None:
      oprot.writeFieldBegin('comment', TType.STRING, 4)
      oprot.writeString(self.comment)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

      return
    oprot.writeStructBegin('setAlert_result')
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

      return
    oprot.writeStructBegin('getValidOrderCount_args')
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.I64, 0)
      oprot.writeI64(self.success)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

      return
    oprot.writeStructBegin('getNoOfCustomersWithSuccessfulTransaction_args')
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.I64, 0)
      oprot.writeI64(self.success)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

      return
    oprot.writeStructBegin('getValidOrdersAmountRange_args')
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.DOUBLE, len(self.success))
      for iter104 in self.success:
        oprot.writeDouble(iter104)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.limit is not None:
      oprot.writeFieldBegin('limit', TType.I64, 1)
      oprot.writeI64(self.limit)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter111 in self.success:
        iter111.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('batchOrders_args')
    if self.warehouseId is not None:
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
      oprot.writeI64(self.warehouseId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('batchOrders_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter118 in self.success:
        iter118.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  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('markOrderAsOutOfStock_args')
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 1)
      oprot.writeI64(self.orderId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('markOrderAsOutOfStock_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.BOOL, 0)
      oprot.writeBool(self.success)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('verifyOrder_args')
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 1)
      oprot.writeI64(self.orderId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('verifyOrder_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.BOOL, 0)
      oprot.writeBool(self.success)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 1)
      oprot.writeI64(self.orderId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.BOOL, 0)
      oprot.writeBool(self.success)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 1)
      oprot.writeI64(self.orderId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.BOOL, 0)
      oprot.writeBool(self.success)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 1)
      oprot.writeI64(self.orderId)
      oprot.writeFieldEnd()
    if self.invoice_number is not None:
      oprot.writeFieldBegin('invoice_number', TType.STRING, 2)
      oprot.writeString(self.invoice_number)
      oprot.writeFieldEnd()
    if self.billed_by is not None:
      oprot.writeFieldBegin('billed_by', TType.STRING, 3)
      oprot.writeString(self.billed_by)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.BOOL, 0)
      oprot.writeBool(self.success)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 1)
      oprot.writeI64(self.orderId)
      oprot.writeFieldEnd()
    if self.jacketNumber is not None:
      oprot.writeFieldBegin('jacketNumber', TType.I64, 2)
      oprot.writeI64(self.jacketNumber)
      oprot.writeFieldEnd()
    if self.imeiNumber is not None:
      oprot.writeFieldBegin('imeiNumber', TType.I64, 3)
      oprot.writeI64(self.imeiNumber)
      oprot.writeFieldEnd()
    if self.itemNumber is not None:
      oprot.writeFieldBegin('itemNumber', TType.STRING, 4)
      oprot.writeString(self.itemNumber)
      oprot.writeFieldEnd()
    if self.billedBy is not None:
      oprot.writeFieldBegin('billedBy', TType.STRING, 5)
      oprot.writeString(self.billedBy)
      oprot.writeFieldEnd()
    if self.billingType is not None:
      oprot.writeFieldBegin('billingType', TType.I64, 6)
      oprot.writeI64(self.billingType)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.BOOL, 0)
      oprot.writeBool(self.success)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.warehouseId is not None:
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
      oprot.writeI64(self.warehouseId)
      oprot.writeFieldEnd()
    if self.providerId is not None:
      oprot.writeFieldBegin('providerId', TType.I64, 2)
      oprot.writeI64(self.providerId)
      oprot.writeFieldEnd()
    if self.cod is not None:
      oprot.writeFieldBegin('cod', TType.BOOL, 3)
      oprot.writeBool(self.cod)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.BOOL, 0)
      oprot.writeBool(self.success)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.providerId is not None:
      oprot.writeFieldBegin('providerId', TType.I64, 1)
      oprot.writeI64(self.providerId)
      oprot.writeFieldEnd()
    if self.pickupDetails is not None:
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
      for kiter126,viter127 in self.pickupDetails.items():
        oprot.writeString(kiter126)
        oprot.writeString(viter127)
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter134 in self.success:
        iter134.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  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')
    if self.providerId is not None:
      oprot.writeFieldBegin('providerId', TType.I64, 1)
      oprot.writeI64(self.providerId)
      oprot.writeFieldEnd()
    if self.deliveredOrders is not None:
      oprot.writeFieldBegin('deliveredOrders', TType.MAP, 2)
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.deliveredOrders))
      for kiter142,viter143 in self.deliveredOrders.items():
        oprot.writeString(kiter142)
        oprot.writeString(viter143)
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.providerId is not None:
      oprot.writeFieldBegin('providerId', TType.I64, 1)
      oprot.writeI64(self.providerId)
      oprot.writeFieldEnd()
    if self.returnedOrders is not None:
      oprot.writeFieldBegin('returnedOrders', TType.MAP, 2)
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.returnedOrders))
      for kiter151,viter152 in self.returnedOrders.items():
        oprot.writeString(kiter151)
        oprot.writeString(viter152)
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.providerId is not None:
      oprot.writeFieldBegin('providerId', TType.I64, 1)
      oprot.writeI64(self.providerId)
      oprot.writeFieldEnd()
    if self.undeliveredOrders is not None:
      oprot.writeFieldBegin('undeliveredOrders', TType.MAP, 2)
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.undeliveredOrders))
      for kiter160,viter161 in self.undeliveredOrders.items():
        oprot.writeString(kiter160)
        oprot.writeString(viter161)
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('updateNonDeliveryReason_result')
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.providerId is not None:
      oprot.writeFieldBegin('providerId', TType.I64, 1)
      oprot.writeI64(self.providerId)
      oprot.writeFieldEnd()
    if self.warehouseId is not None:
      oprot.writeFieldBegin('warehouseId', TType.I64, 2)
      oprot.writeI64(self.warehouseId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter168 in self.success:
        iter168.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('toggleDOAFlag_args')
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 1)
      oprot.writeI64(self.orderId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('toggleDOAFlag_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.BOOL, 0)
      oprot.writeBool(self.success)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('requestPickupNumber_args')
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 1)
      oprot.writeI64(self.orderId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('requestPickupNumber_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.BOOL, 0)
      oprot.writeBool(self.success)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('authorizePickup_args')
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 1)
      oprot.writeI64(self.orderId)
      oprot.writeFieldEnd()
    if self.pickupNumber is not None:
      oprot.writeFieldBegin('pickupNumber', TType.STRING, 2)
      oprot.writeString(self.pickupNumber)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('authorizePickup_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.BOOL, 0)
      oprot.writeBool(self.success)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('markDoasAsPickedUp_args')
    if self.providerId is not None:
      oprot.writeFieldBegin('providerId', TType.I64, 1)
      oprot.writeI64(self.providerId)
      oprot.writeFieldEnd()
    if self.pickupDetails is not None:
      oprot.writeFieldBegin('pickupDetails', TType.MAP, 2)
      oprot.writeMapBegin(TType.STRING, TType.STRING, len(self.pickupDetails))
      for kiter176,viter177 in self.pickupDetails.items():
        oprot.writeString(kiter176)
        oprot.writeString(viter177)
      oprot.writeMapEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def write(self, oprot):
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
      return
    oprot.writeStructBegin('markDoasAsPickedUp_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter184 in self.success:
        iter184.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('receiveReturn_args')
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 1)
      oprot.writeI64(self.orderId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('receiveReturn_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.BOOL, 0)
      oprot.writeBool(self.success)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('validateDoa_args')
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 1)
      oprot.writeI64(self.orderId)
      oprot.writeFieldEnd()
    if self.isValid is not None:
      oprot.writeFieldBegin('isValid', TType.BOOL, 2)
      oprot.writeBool(self.isValid)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('validateDoa_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.BOOL, 0)
      oprot.writeBool(self.success)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('reshipOrder_args')
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 1)
      oprot.writeI64(self.orderId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('reshipOrder_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.I64, 0)
      oprot.writeI64(self.success)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  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('refundOrder_args')
    if self.orderId is not None:
      oprot.writeFieldBegin('orderId', TType.I64, 1)
      oprot.writeI64(self.orderId)
      oprot.writeFieldEnd()
    if self.refundedBy is not None:
      oprot.writeFieldBegin('refundedBy', TType.STRING, 2)
      oprot.writeString(self.refundedBy)
      oprot.writeFieldEnd()
    if self.reason is not None:
      oprot.writeFieldBegin('reason', TType.STRING, 3)
      oprot.writeString(self.reason)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('refundOrder_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.BOOL, 0)
      oprot.writeBool(self.success)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('getReturnOrders_args')
    if self.warehouseId is not None:
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
      oprot.writeI64(self.warehouseId)
      oprot.writeFieldEnd()
    if self.fromDate is not None:
      oprot.writeFieldBegin('fromDate', TType.I64, 2)
      oprot.writeI64(self.fromDate)
      oprot.writeFieldEnd()
    if self.toDate is not None:
      oprot.writeFieldBegin('toDate', TType.I64, 3)
      oprot.writeI64(self.toDate)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('getReturnOrders_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.LIST, 0)
      oprot.writeListBegin(TType.STRUCT, len(self.success))
      for iter191 in self.success:
        iter191.write(oprot)
      oprot.writeListEnd()
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('getReturnOrder_args')
    if self.id is not None:
      oprot.writeFieldBegin('id', TType.I64, 1)
      oprot.writeI64(self.id)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('getReturnOrder_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
      self.success.write(oprot)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  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('processReturn_args')
    if self.returnOrderId is not None:
      oprot.writeFieldBegin('returnOrderId', TType.I64, 1)
      oprot.writeI64(self.returnOrderId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('processReturn_result')
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('createPurchaseOrder_args')
    if self.warehouseId is not None:
      oprot.writeFieldBegin('warehouseId', TType.I64, 1)
      oprot.writeI64(self.warehouseId)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  def __repr__(self):
    L = ['%s=%r' % (key, value)
      for key, value in self.__dict__.iteritems()]
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 

  def 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('createPurchaseOrder_result')
    if self.success is not None:
      oprot.writeFieldBegin('success', TType.I64, 0)
      oprot.writeI64(self.success)
      oprot.writeFieldEnd()
    if self.ex is not None:
      oprot.writeFieldBegin('ex', TType.STRUCT, 1)
      self.ex.write(oprot)
      oprot.writeFieldEnd()
    oprot.writeFieldStop()
    oprot.writeStructEnd()
 
  def validate(self):
    return
 
 
  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)
 
 

Rev 3427	Rev 3431
Line 1...	Line 1...
1	`#`	1	`#`
2	`# Autogenerated by Thrift`	2	`# Autogenerated by Thrift Compiler (0.7.0)`
3	`#`	3	`#`
4	`# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING`	4	`# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING`
5	`#`	5	`#`
6		6
7	`from thrift.Thrift import *`	7	`from thrift.Thrift import *`
8	`import shop2020.thriftpy.generic.GenericService`	8	`import shop2020.thriftpy.generic.GenericService`
9	`from ttypes import *`	9	`from ttypes import *`
10	`from thrift.Thrift import TProcessor`	10	`from thrift.Thrift import TProcessor`
11	`from thrift.transport import TTransport`	11	`from thrift.transport import TTransport`
12	`from thrift.protocol import TBinaryProtocol`	12	`from thrift.protocol import TBinaryProtocol, TProtocol`
13	`try:`	13	`try:`
14	`from thrift.protocol import fastbinary`	14	`from thrift.protocol import fastbinary`
15	`except:`	15	`except:`
16	`fastbinary = None`	16	`fastbinary = None`
17		17
Line 82...	Line 82...
82	`pass`	82	`pass`
83		83
84	`def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):`	84	`def getOrdersByBillingDate(self, status, start_billing_date, end_billing_date, warehouse_id):`
85	`"""`	85	`"""`
86	`Returns orders within a range of their billing dates`	86	`Returns orders within a range of their billing dates`
87		87
88	`Parameters:`	88	`Parameters:`
89	`- status`	89	`- status`
90	`- start_billing_date`	90	`- start_billing_date`
91	`- end_billing_date`	91	`- end_billing_date`
92	`- warehouse_id`	92	`- warehouse_id`
Line 95...	Line 95...
95		95
96	`def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId):`	96	`def getOrdersByShippingDate(self, fromShippingDate, toShippingDate, providerId, warehouseId):`
97	`"""`	97	`"""`
98	`Returns orders for a particular provider and warehouse which were shipped between the given dates.`	98	`Returns orders for a particular provider and warehouse which were shipped between the given dates.`
99	`Pass providerId and warehouseId as -1 to ignore both the parameters.`	99	`Pass providerId and warehouseId as -1 to ignore both the parameters.`
100		100
101	`Parameters:`	101	`Parameters:`
102	`- fromShippingDate`	102	`- fromShippingDate`
103	`- toShippingDate`	103	`- toShippingDate`
104	`- providerId`	104	`- providerId`
105	`- warehouseId`	105	`- warehouseId`
Line 107...	Line 107...
107	`pass`	107	`pass`
108		108
109	`def getReturnableOrdersForCustomer(self, customer_id, limit):`	109	`def getReturnableOrdersForCustomer(self, customer_id, limit):`
110	`"""`	110	`"""`
111	`Returns order ids for orders which can be returned`	111	`Returns order ids for orders which can be returned`
112		112
113	`Parameters:`	113	`Parameters:`
114	`- customer_id`	114	`- customer_id`
115	`- limit`	115	`- limit`
116	`"""`	116	`"""`
117	`pass`	117	`pass`
118		118
119	`def getCancellableOrdersForCustomer(self, customer_id, limit):`	119	`def getCancellableOrdersForCustomer(self, customer_id, limit):`
120	`"""`	120	`"""`
121	`Returns order ids for orders which can be cancelled`	121	`Returns order ids for orders which can be cancelled`
122		122
123	`Parameters:`	123	`Parameters:`
124	`- customer_id`	124	`- customer_id`
125	`- limit`	125	`- limit`
126	`"""`	126	`"""`
127	`pass`	127	`pass`
Line 137...	Line 137...
137		137
138	`def getOrdersForTransaction(self, transactionId, customerId):`	138	`def getOrdersForTransaction(self, transactionId, customerId):`
139	`"""`	139	`"""`
140	`Returns list of orders for given transaction Id. Also filters based on customer Id so that`	140	`Returns list of orders for given transaction Id. Also filters based on customer Id so that`
141	`only user who owns the transaction can view its order details.`	141	`only user who owns the transaction can view its order details.`
142		142
143	`Parameters:`	143	`Parameters:`
144	`- transactionId`	144	`- transactionId`
145	`- customerId`	145	`- customerId`
146	`"""`	146	`"""`
147	`pass`	147	`pass`
148		148
149	`def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):`	149	`def getOrdersForCustomer(self, customerId, from_date, to_date, statuses):`
150	`"""`	150	`"""`
151	`Returns list of orders for the given customer created between the given dates and having the given statuses.`	151	`Returns list of orders for the given customer created between the given dates and having the given statuses.`
152	`Pass and empty list to ignore filtering on statuses.`	152	`Pass and empty list to ignore filtering on statuses.`
153		153
154	`Parameters:`	154	`Parameters:`
155	`- customerId`	155	`- customerId`
156	`- from_date`	156	`- from_date`
157	`- to_date`	157	`- to_date`
158	`- statuses`	158	`- statuses`
Line 182...	Line 182...
182		182
183	`def getOrderForCustomer(self, orderId, customerId):`	183	`def getOrderForCustomer(self, orderId, customerId):`
184	`"""`	184	`"""`
185	`Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.`	185	`Returns an order for the order Id. Also checks if the order belongs to the customer whose Id is passed.`
186	`Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.`	186	`Throws exception if either order Id is invalid or order does not below to the customer whose Id is passed.`
187		187
188	`Parameters:`	188	`Parameters:`
189	`- orderId`	189	`- orderId`
190	`- customerId`	190	`- customerId`
191	`"""`	191	`"""`
192	`pass`	192	`pass`
Line 230...	Line 230...
230		230
231	`def getValidOrders(self, limit):`	231	`def getValidOrders(self, limit):`
232	`"""`	232	`"""`
233	`Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.`	233	`Returns list of Orders in descending order by Order creation date. List is restricted to limit Orders.`
234	`If limit is passed as 0, then all valid Orders are returned.`	234	`If limit is passed as 0, then all valid Orders are returned.`
235		235
236	`Parameters:`	236	`Parameters:`
237	`- limit`	237	`- limit`
238	`"""`	238	`"""`
239	`pass`	239	`pass`
240		240
241	`def batchOrders(self, warehouseId):`	241	`def batchOrders(self, warehouseId):`
242	`"""`	242	`"""`
243	`Create a batch of all the pending orders for the given warehouse.`	243	`Create a batch of all the pending orders for the given warehouse.`
244	`The returned list is orderd by created_timestamp.`	244	`The returned list is orderd by created_timestamp.`
245	`If there are no pending orders, an empty list is returned.`	245	`If there are no pending orders, an empty list is returned.`
246		246
247	`Parameters:`	247	`Parameters:`
248	`- warehouseId`	248	`- warehouseId`
249	`"""`	249	`"""`
250	`pass`	250	`pass`
251		251
252	`def markOrderAsOutOfStock(self, orderId):`	252	`def markOrderAsOutOfStock(self, orderId):`
253	`"""`	253	`"""`
254	`Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.`	254	`Mark the given order as out of stock. Throws an exception if the order with the given Id couldn't be found.`
255		255
256	`Parameters:`	256	`Parameters:`
257	`- orderId`	257	`- orderId`
258	`"""`	258	`"""`
259	`pass`	259	`pass`
260		260
Line 262...	Line 262...
262	`"""`	262	`"""`
263	`Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified`	263	`Marks the given order as SUBMITTED_FOR_PROCESSING and updates the verified`
264	`timestamp. It is intended to be used for COD orders but can be harmlessly`	264	`timestamp. It is intended to be used for COD orders but can be harmlessly`
265	`used for all other orders as well.`	265	`used for all other orders as well.`
266	`Throws an exception if no such order exists.`	266	`Throws an exception if no such order exists.`
267		267
268	`Parameters:`	268	`Parameters:`
269	`- orderId`	269	`- orderId`
270	`"""`	270	`"""`
271	`pass`	271	`pass`
272		272
Line 274...	Line 274...
274	`"""`	274	`"""`
275	`Marks the given order as ACCEPTED and updates the accepted timestamp. If the`	275	`Marks the given order as ACCEPTED and updates the accepted timestamp. If the`
276	`given order is not a COD order, it also captures the payment if the same has`	276	`given order is not a COD order, it also captures the payment if the same has`
277	`not been captured.`	277	`not been captured.`
278	`Throws an exception if no such order exists.`	278	`Throws an exception if no such order exists.`
279		279
280	`Parameters:`	280	`Parameters:`
281	`- orderId`	281	`- orderId`
282	`"""`	282	`"""`
283	`pass`	283	`pass`
284		284
Line 292...	Line 292...
292	`def addBillingDetails(self, orderId, invoice_number, billed_by):`	292	`def addBillingDetails(self, orderId, invoice_number, billed_by):`
293	`"""`	293	`"""`
294	`Add billing details such as the bill number and the biller to the Order.`	294	`Add billing details such as the bill number and the biller to the Order.`
295	`Should be used when the bill is issued by a 3rd party and we've to feed`	295	`Should be used when the bill is issued by a 3rd party and we've to feed`
296	`the information into our system.`	296	`the information into our system.`
297		297
298	`Parameters:`	298	`Parameters:`
299	`- orderId`	299	`- orderId`
300	`- invoice_number`	300	`- invoice_number`
301	`- billed_by`	301	`- billed_by`
302	`"""`	302	`"""`
Line 307...	Line 307...
307	`Adds jacket number, item number and IMEI no. to the order. Doesn't update`	307	`Adds jacket number, item number and IMEI no. to the order. Doesn't update`
308	`the IMEI no. if a -1 is supplied.`	308	`the IMEI no. if a -1 is supplied.`
309	`Also, it generates an invoice number for the order, marks the order as`	309	`Also, it generates an invoice number for the order, marks the order as`
310	`BILLED and sets the billing timestamp.`	310	`BILLED and sets the billing timestamp.`
311	`It should be used when we are billing the orders ourselves.`	311	`It should be used when we are billing the orders ourselves.`
312		312
313	`Returns false if it doesn't find the order with the given ID.`	313	`Returns false if it doesn't find the order with the given ID.`
314		314
315	`Parameters:`	315	`Parameters:`
316	`- orderId`	316	`- orderId`
317	`- jacketNumber`	317	`- jacketNumber`
318	`- imeiNumber`	318	`- imeiNumber`
319	`- itemNumber`	319	`- itemNumber`
Line 324...	Line 324...
324		324
325	`def markOrdersAsManifested(self, warehouseId, providerId, cod):`	325	`def markOrdersAsManifested(self, warehouseId, providerId, cod):`
326	`"""`	326	`"""`
327	`Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the`	327	`Depending on the third parameter, marks either all prepaid or all cod orders BILLED by the`
328	`given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.`	328	`given warehouse and were picked up by the given provider as SHIPPED_FROM_WH.`
329		329
330	`Parameters:`	330	`Parameters:`
331	`- warehouseId`	331	`- warehouseId`
332	`- providerId`	332	`- providerId`
333	`- cod`	333	`- cod`
334	`"""`	334	`"""`
Line 337...	Line 337...
337	`def markOrdersAsPickedUp(self, providerId, pickupDetails):`	337	`def markOrdersAsPickedUp(self, providerId, pickupDetails):`
338	`"""`	338	`"""`
339	`Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.`	339	`Marks all SHIPPED_FROM_WH orders of the previous day for a provider as SHIPPED_TO_LOGISTICS.`
340	`Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.`	340	`Returns a list of orders that were shipped from warehouse but did not appear in the pick-up report.`
341	`Raises an exception if we encounter report for an AWB number that we did not ship.`	341	`Raises an exception if we encounter report for an AWB number that we did not ship.`
342		342
343	`Parameters:`	343	`Parameters:`
344	`- providerId`	344	`- providerId`
345	`- pickupDetails`	345	`- pickupDetails`
346	`"""`	346	`"""`
347	`pass`	347	`pass`
Line 349...	Line 349...
349	`def markOrdersAsDelivered(self, providerId, deliveredOrders):`	349	`def markOrdersAsDelivered(self, providerId, deliveredOrders):`
350	`"""`	350	`"""`
351	`Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and`	351	`Marks all orders with AWBs in the given map as delivered. Also sets the delivery timestamp and`
352	`the name of the receiver.`	352	`the name of the receiver.`
353	`Raises an exception if we encounter report for an AWB number that we did not ship.`	353	`Raises an exception if we encounter report for an AWB number that we did not ship.`
354		354
355	`Parameters:`	355	`Parameters:`
356	`- providerId`	356	`- providerId`
357	`- deliveredOrders`	357	`- deliveredOrders`
358	`"""`	358	`"""`
359	`pass`	359	`pass`
360		360
361	`def markOrdersAsFailed(self, providerId, returnedOrders):`	361	`def markOrdersAsFailed(self, providerId, returnedOrders):`
362	`"""`	362	`"""`
363	`Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.`	363	`Mark all orders with AWBs in the given map as failed. Also sets the delivery timestamp.`
364	`Raises an exception if we encounter report for an AWB number that we did not ship.`	364	`Raises an exception if we encounter report for an AWB number that we did not ship.`
365		365
366	`Parameters:`	366	`Parameters:`
367	`- providerId`	367	`- providerId`
368	`- returnedOrders`	368	`- returnedOrders`
369	`"""`	369	`"""`
370	`pass`	370	`pass`
371		371
372	`def updateNonDeliveryReason(self, providerId, undeliveredOrders):`	372	`def updateNonDeliveryReason(self, providerId, undeliveredOrders):`
373	`"""`	373	`"""`
374	`Update the status description of orders whose AWB numbers are keys of the Map.`	374	`Update the status description of orders whose AWB numbers are keys of the Map.`
375		375
376	`Parameters:`	376	`Parameters:`
377	`- providerId`	377	`- providerId`
378	`- undeliveredOrders`	378	`- undeliveredOrders`
379	`"""`	379	`"""`
380	`pass`	380	`pass`
Line 383...	Line 383...
383	`"""`	383	`"""`
384	`Returns the list of orders whose delivery time has passed but have not been`	384	`Returns the list of orders whose delivery time has passed but have not been`
385	`delivered yet for the given provider and warehouse. To get a complete list of`	385	`delivered yet for the given provider and warehouse. To get a complete list of`
386	`undelivered orders, pass them as -1.`	386	`undelivered orders, pass them as -1.`
387	`Returns an empty list if no such orders exist.`	387	`Returns an empty list if no such orders exist.`
388		388
389	`Parameters:`	389	`Parameters:`
390	`- providerId`	390	`- providerId`
391	`- warehouseId`	391	`- warehouseId`
392	`"""`	392	`"""`
393	`pass`	393	`pass`
Line 395...	Line 395...
395	`def toggleDOAFlag(self, orderId):`	395	`def toggleDOAFlag(self, orderId):`
396	`"""`	396	`"""`
397	`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.`	397	`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.`
398	`Returns the final flag status.`	398	`Returns the final flag status.`
399	`Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.`	399	`Throws an exception if the order with the given id couldn't be found or if the order status is not DELVIERY_SUCCESS.`
400		400
401	`Parameters:`	401	`Parameters:`
402	`- orderId`	402	`- orderId`
403	`"""`	403	`"""`
404	`pass`	404	`pass`
405		405
Line 408...	Line 408...
408	`Sends out an email to the account manager of the original courier provider used to ship the order.`	408	`Sends out an email to the account manager of the original courier provider used to ship the order.`
409	`If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.`	409	`If the order status was DELIVERY_SUCCESS, it is changed to be DOA_PICKUP_REQUESTED.`
410	`If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.`	410	`If the order status was DOA_PICKUP_REQUESTED, it is left unchanged.`
411	`For any other status, it returns false.`	411	`For any other status, it returns false.`
412	`Throws an exception if the order with the given id couldn't be found.`	412	`Throws an exception if the order with the given id couldn't be found.`
413		413
414	`Parameters:`	414	`Parameters:`
415	`- orderId`	415	`- orderId`
416	`"""`	416	`"""`
417	`pass`	417	`pass`
418		418
Line 422...	Line 422...
422	`1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.`	422	`1. Sends out an email to the customer with the dispatch advice that he has to print as an attachment.`
423	`2. Changes order status to be DOA_PICKUP_AUTHORIZED.`	423	`2. Changes order status to be DOA_PICKUP_AUTHORIZED.`
424	`3. Returns true`	424	`3. Returns true`
425	`If the order is in any other status, it returns false.`	425	`If the order is in any other status, it returns false.`
426	`Throws an exception if the order with the given id couldn't be found.`	426	`Throws an exception if the order with the given id couldn't be found.`
427		427
428	`Parameters:`	428	`Parameters:`
429	`- orderId`	429	`- orderId`
430	`- pickupNumber`	430	`- pickupNumber`
431	`"""`	431	`"""`
432	`pass`	432	`pass`
433		433
434	`def markDoasAsPickedUp(self, providerId, pickupDetails):`	434	`def markDoasAsPickedUp(self, providerId, pickupDetails):`
435	`"""`	435	`"""`
436	`Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.`	436	`Marks all DOA_PICKUP_AUTHORIZED orders of the previous day for a provider as DOA_RETURN_IN_TRANSIT.`
437	`Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.`	437	`Returns a list of orders that were authorized for pickup but did not appear in the pick-up report.`
438		438
439	`Parameters:`	439	`Parameters:`
440	`- providerId`	440	`- providerId`
441	`- pickupDetails`	441	`- pickupDetails`
442	`"""`	442	`"""`
443	`pass`	443	`pass`
Line 446...	Line 446...
446	`"""`	446	`"""`
447	`If the order status is DOA_RETURN_AUTHORIZED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED and returns true.`	447	`If the order status is DOA_RETURN_AUTHORIZED or DOA_RETURN_IN_TRANSIT, marks the order status as DOA_RECEIVED and returns true.`
448	`If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.`	448	`If the order status is SALES_RETURN_IN_TRANSIT, marks the order status as SALES_RET_RECEIVED and returns true.`
449	`If the order is in any other state, it returns false.`	449	`If the order is in any other state, it returns false.`
450	`Throws an exception if the order with the given id couldn't be found.`	450	`Throws an exception if the order with the given id couldn't be found.`
451		451
452	`Parameters:`	452	`Parameters:`
453	`- orderId`	453	`- orderId`
454	`"""`	454	`"""`
455	`pass`	455	`pass`
456		456
Line 458...	Line 458...
458	`"""`	458	`"""`
459	`Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,`	459	`Used to validate the DOA certificate for an order in the DOA_RECEIVED state. If the certificate is valid,`
460	`the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.`	460	`the order state is changed to DOA_CERT_VALID. If the certificate is invalid, the order state is changed to DOA_CERT_INVALID.`
461	`If the order is in any other state, it returns false.`	461	`If the order is in any other state, it returns false.`
462	`Throws an exception if the order with the given id couldn't be found.`	462	`Throws an exception if the order with the given id couldn't be found.`
463		463
464	`Parameters:`	464	`Parameters:`
465	`- orderId`	465	`- orderId`
466	`- isValid`	466	`- isValid`
467	`"""`	467	`"""`
468	`pass`	468	`pass`
Line 475...	Line 475...
475		475
476	`If the order is in DOA_CERT_VALID state, it does the following:`	476	`If the order is in DOA_CERT_VALID state, it does the following:`
477	`1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.`	477	`1. Creates a new order for processing in the SUBMITTED_FOR_PROCESSING state.`
478	`2. Creates a return order for the warehouse executive to return the DOA material.`	478	`2. Creates a return order for the warehouse executive to return the DOA material.`
479	`3. Marks the current order as the final DOA_RESHIPPED state.`	479	`3. Marks the current order as the final DOA_RESHIPPED state.`
480		480
481	`Returns the id of the newly created order.`	481	`Returns the id of the newly created order.`
482		482
483	`Throws an exception if the order with the given id couldn't be found.`	483	`Throws an exception if the order with the given id couldn't be found.`
484		484
485	`Parameters:`	485	`Parameters:`
486	`- orderId`	486	`- orderId`
487	`"""`	487	`"""`
488	`pass`	488	`pass`
489		489
Line 491...	Line 491...
491	`"""`	491	`"""`
492	`If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:`	492	`If the order is in SALES_RET_RECEIVED, DOA_CERT_VALID or DOA_CERT_INVALID state, it does the following:`
493	`1. Creates a refund request for batch processing.`	493	`1. Creates a refund request for batch processing.`
494	`2. Creates a return order for the warehouse executive to return the shipped material.`	494	`2. Creates a return order for the warehouse executive to return the shipped material.`
495	`3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.`	495	`3. Marks the current order as SALES_RET_REFUNDED, DOA_VALID_REFUNDED or DOA_INVALID_REFUNDED final states.`
496		496
497	`If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:`	497	`If the order is in SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:`
498	`1. Creates a refund request for batch processing.`	498	`1. Creates a refund request for batch processing.`
499	`2. Cancels the reservation of the item in the warehouse.`	499	`2. Cancels the reservation of the item in the warehouse.`
500	`3. Marks the current order as the REFUNDED final state.`	500	`3. Marks the current order as the REFUNDED final state.`
501		501
502	`For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:`	502	`For all COD orders, if the order is in INIT, SUBMITTED_FOR_PROCESSING or INVENTORY_LOW state, it does the following:`
503	`1. Cancels the reservation of the item in the warehouse.`	503	`1. Cancels the reservation of the item in the warehouse.`
504	`2. Marks the current order as CANCELED.`	504	`2. Marks the current order as CANCELED.`
505		505
506	`In all cases, it updates the reason for cancellation or refund and the person who performed the action.`	506	`In all cases, it updates the reason for cancellation or refund and the person who performed the action.`
507		507
508	`Returns True if it is successful, False otherwise.`	508	`Returns True if it is successful, False otherwise.`
509		509
510	`Throws an exception if the order with the given id couldn't be found.`	510	`Throws an exception if the order with the given id couldn't be found.`
511		511
512	`Parameters:`	512	`Parameters:`
513	`- orderId`	513	`- orderId`
514	`- refundedBy`	514	`- refundedBy`
515	`- reason`	515	`- reason`
516	`"""`	516	`"""`
Line 518...	Line 518...
518		518
519	`def getReturnOrders(self, warehouseId, fromDate, toDate):`	519	`def getReturnOrders(self, warehouseId, fromDate, toDate):`
520	`"""`	520	`"""`
521	`Get all return orders created between the from and to dates for the given warehouse.`	521	`Get all return orders created between the from and to dates for the given warehouse.`
522	`Ignores the warehouse if it is passed as -1.`	522	`Ignores the warehouse if it is passed as -1.`
523		523
524	`Parameters:`	524	`Parameters:`
525	`- warehouseId`	525	`- warehouseId`
526	`- fromDate`	526	`- fromDate`
527	`- toDate`	527	`- toDate`
528	`"""`	528	`"""`
Line 530...	Line 530...
530		530
531	`def getReturnOrder(self, id):`	531	`def getReturnOrder(self, id):`
532	`"""`	532	`"""`
533	`Returns the ReturnOrder corresponding to the given id.`	533	`Returns the ReturnOrder corresponding to the given id.`
534	`Throws an exception if the return order with the given id couldn't be found.`	534	`Throws an exception if the return order with the given id couldn't be found.`
535		535
536	`Parameters:`	536	`Parameters:`
537	`- id`	537	`- id`
538	`"""`	538	`"""`
539	`pass`	539	`pass`
540		540
541	`def processReturn(self, returnOrderId):`	541	`def processReturn(self, returnOrderId):`
542	`"""`	542	`"""`
543	`Marks the return order with the given id as processed. Raises an exception if no such return order exists.`	543	`Marks the return order with the given id as processed. Raises an exception if no such return order exists.`
544		544
545	`Parameters:`	545	`Parameters:`
546	`- returnOrderId`	546	`- returnOrderId`
547	`"""`	547	`"""`
548	`pass`	548	`pass`
549		549
550	`def createPurchaseOrder(self, warehouseId):`	550	`def createPurchaseOrder(self, warehouseId):`
551	`"""`	551	`"""`
552	`Creates a purchase order corresponding to all the pending orders of the given warehouse.`	552	`Creates a purchase order corresponding to all the pending orders of the given warehouse.`
553	`Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.`	553	`Returns the PO no. of the newly created purchase order. Returns -1 no new purchase order had to be created.`
554		554
555	`Parameters:`	555	`Parameters:`
556	`- warehouseId`	556	`- warehouseId`
557	`"""`	557	`"""`
558	`pass`	558	`pass`
559		559
Line 586...	Line 586...
586	`self._iprot.readMessageEnd()`	586	`self._iprot.readMessageEnd()`
587	`raise x`	587	`raise x`
588	`result = createTransaction_result()`	588	`result = createTransaction_result()`
589	`result.read(self._iprot)`	589	`result.read(self._iprot)`
590	`self._iprot.readMessageEnd()`	590	`self._iprot.readMessageEnd()`
591	`if result.success != None:`	591	`if result.success is not None:`
592	`return result.success`	592	`return result.success`
593	`if result.ex != None:`	593	`if result.ex is not None:`
594	`raise result.ex`	594	`raise result.ex`
595	`raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");`	595	`raise TApplicationException(TApplicationException.MISSING_RESULT, "createTransaction failed: unknown result");`
596		596
597	`def getTransaction(self, id):`	597	`def getTransaction(self, id):`
598	`"""`	598	`"""`
Line 618...	Line 618...
618	`self._iprot.readMessageEnd()`	618	`self._iprot.readMessageEnd()`
619	`raise x`	619	`raise x`
620	`result = getTransaction_result()`	620	`result = getTransaction_result()`
621	`result.read(self._iprot)`	621	`result.read(self._iprot)`
622	`self._iprot.readMessageEnd()`	622	`self._iprot.readMessageEnd()`
623	`if result.success != None:`	623	`if result.success is not None:`
624	`return result.success`	624	`return result.success`
625	`if result.ex != None:`	625	`if result.ex is not None:`
626	`raise result.ex`	626	`raise result.ex`
627	`raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");`	627	`raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransaction failed: unknown result");`
628		628
629	`def getTransactionsForCustomer(self, customerId, from_date, to_date, status):`	629	`def getTransactionsForCustomer(self, customerId, from_date, to_date, status):`
630	`"""`	630	`"""`
Line 656...	Line 656...
656	`self._iprot.readMessageEnd()`	656	`self._iprot.readMessageEnd()`
657	`raise x`	657	`raise x`
658	`result = getTransactionsForCustomer_result()`	658	`result = getTransactionsForCustomer_result()`
659	`result.read(self._iprot)`	659	`result.read(self._iprot)`
660	`self._iprot.readMessageEnd()`	660	`self._iprot.readMessageEnd()`
661	`if result.success != None:`	661	`if result.success is not None:`
662	`return result.success`	662	`return result.success`
663	`if result.ex != None:`	663	`if result.ex is not None:`
664	`raise result.ex`	664	`raise result.ex`
665	`raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");`	665	`raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForCustomer failed: unknown result");`
666		666
667	`def getTransactionsForShoppingCartId(self, shoppingCartId):`	667	`def getTransactionsForShoppingCartId(self, shoppingCartId):`
668	`"""`	668	`"""`
Line 688...	Line 688...
688	`self._iprot.readMessageEnd()`	688	`self._iprot.readMessageEnd()`
689	`raise x`	689	`raise x`
690	`result = getTransactionsForShoppingCartId_result()`	690	`result = getTransactionsForShoppingCartId_result()`
691	`result.read(self._iprot)`	691	`result.read(self._iprot)`
692	`self._iprot.readMessageEnd()`	692	`self._iprot.readMessageEnd()`
693	`if result.success != None:`	693	`if result.success is not None:`
694	`return result.success`	694	`return result.success`
695	`if result.ex != None:`	695	`if result.ex is not None:`
696	`raise result.ex`	696	`raise result.ex`
697	`raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");`	697	`raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionsForShoppingCartId failed: unknown result");`
698		698
699	`def getTransactionStatus(self, transactionId):`	699	`def getTransactionStatus(self, transactionId):`
700	`"""`	700	`"""`
Line 720...	Line 720...
720	`self._iprot.readMessageEnd()`	720	`self._iprot.readMessageEnd()`
721	`raise x`	721	`raise x`
722	`result = getTransactionStatus_result()`	722	`result = getTransactionStatus_result()`
723	`result.read(self._iprot)`	723	`result.read(self._iprot)`
724	`self._iprot.readMessageEnd()`	724	`self._iprot.readMessageEnd()`
725	`if result.success != None:`	725	`if result.success is not None:`
726	`return result.success`	726	`return result.success`
727	`if result.ex != None:`	727	`if result.ex is not None:`
728	`raise result.ex`	728	`raise result.ex`
729	`raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");`	729	`raise TApplicationException(TApplicationException.MISSING_RESULT, "getTransactionStatus failed: unknown result");`
730		730
731	`def changeTransactionStatus(self, transactionId, status, description):`	731	`def changeTransactionStatus(self, transactionId, status, description):`
732	`"""`	732	`"""`
Line 756...	Line 756...
756	`self._iprot.readMessageEnd()`	756	`self._iprot.readMessageEnd()`
757	`raise x`	757	`raise x`
758	`result = changeTransactionStatus_result()`	758	`result = changeTransactionStatus_result()`
759	`result.read(self._iprot)`	759	`result.read(self._iprot)`
760	`self._iprot.readMessageEnd()`	760	`self._iprot.readMessageEnd()`
761	`if result.success != None:`	761	`if result.success is not None:`
762	`return result.success`	762	`return result.success`
763	`if result.ex != None:`	763	`if result.ex is not None:`
764	`raise result.ex`	764	`raise result.ex`
765	`raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");`	765	`raise TApplicationException(TApplicationException.MISSING_RESULT, "changeTransactionStatus failed: unknown result");`
766		766
767	`def enqueueTransactionInfoEmail(self, transactionId):`	767	`def enqueueTransactionInfoEmail(self, transactionId):`
768	`"""`	768	`"""`
Line 788...	Line 788...
788	`self._iprot.readMessageEnd()`	788	`self._iprot.readMessageEnd()`
789	`raise x`	789	`raise x`
790	`result = enqueueTransactionInfoEmail_result()`	790	`result = enqueueTransactionInfoEmail_result()`
791	`result.read(self._iprot)`	791	`result.read(self._iprot)`
792	`self._iprot.readMessageEnd()`	792	`self._iprot.readMessageEnd()`
793	`if result.success != None:`	793	`if result.success is not None:`
794	`return result.success`	794	`return result.success`
795	`if result.ex != None:`	795	`if result.ex is not None:`

Subversion Repositories SmartDukaan

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