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

      - orderId
      - airwayBillNo
     """
     pass
+  def getOrdersByVendor(self, vendors, statuses):
+    """
+    Parameters:
+     - vendors
+     - statuses
+    """
+    pass
+  def createEbayOrder(self, ebayOrder):
+    """
+    Parameters:
+     - ebayOrder
+    """
+    pass
+  def getEbayOrderByOrderId(self, orderId):
+    """
+    Parameters:
+     - orderId
+    """
+    pass
+  def getEbayOrderBySalesRecNumber(self, salesRecordNumber):
+    """
+    Parameters:
+     - salesRecordNumber
+    """
+    pass
+  def getEbayOrder(self, salesRecordNumber, listingId):
+    """
+    Parameters:
+     - salesRecordNumber
+     - listingId
+    """
+    pass
+  def updateEbayOrder(self, ebayOrder):
+    """
+    Parameters:
+     - ebayOrder
+    """
+    pass
+  def ebayOrderExists(self, salesRecNumber, ebayListingId):
+    """
+    Parameters:
+     - salesRecNumber
+     - ebayListingId
+    """
+    pass
+  def updateOrderForEbay(self, order):
+    """
+    Parameters:
+     - order
+    """
+    pass
+  def splitEbayOrder(self, orderId, splitOrderQty, splitOrderItemId, usePowerShip):
+    """
+    Parameters:
+     - orderId
+     - splitOrderQty
+     - splitOrderItemId
+     - usePowerShip
+    """
+    pass
 class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
   def __init__(self, iprot, oprot=None):
     shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
     raise TApplicationException(TApplicationException.MISSING_RESULT, "updateOrderAWB failed: unknown result");
+  def getOrdersByVendor(self, vendors, statuses):
+    """
+    Parameters:
+     - vendors
+     - statuses
+    """
+    self.send_getOrdersByVendor(vendors, statuses)
+    return self.recv_getOrdersByVendor()
+  def send_getOrdersByVendor(self, vendors, statuses):
+    self._oprot.writeMessageBegin('getOrdersByVendor', TMessageType.CALL, self._seqid)
+    args = getOrdersByVendor_args()
+    args.vendors = vendors
+    args.statuses = statuses
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getOrdersByVendor(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getOrdersByVendor_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, "getOrdersByVendor failed: unknown result");
+  def createEbayOrder(self, ebayOrder):
+    """
+    Parameters:
+     - ebayOrder
+    """
+    self.send_createEbayOrder(ebayOrder)
+    self.recv_createEbayOrder()
+  def send_createEbayOrder(self, ebayOrder):
+    self._oprot.writeMessageBegin('createEbayOrder', TMessageType.CALL, self._seqid)
+    args = createEbayOrder_args()
+    args.ebayOrder = ebayOrder
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_createEbayOrder(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = createEbayOrder_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    return
+  def getEbayOrderByOrderId(self, orderId):
+    """
+    Parameters:
+     - orderId
+    """
+    self.send_getEbayOrderByOrderId(orderId)
+    return self.recv_getEbayOrderByOrderId()
+  def send_getEbayOrderByOrderId(self, orderId):
+    self._oprot.writeMessageBegin('getEbayOrderByOrderId', TMessageType.CALL, self._seqid)
+    args = getEbayOrderByOrderId_args()
+    args.orderId = orderId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getEbayOrderByOrderId(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getEbayOrderByOrderId_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayOrderByOrderId failed: unknown result");
+  def getEbayOrderBySalesRecNumber(self, salesRecordNumber):
+    """
+    Parameters:
+     - salesRecordNumber
+    """
+    self.send_getEbayOrderBySalesRecNumber(salesRecordNumber)
+    return self.recv_getEbayOrderBySalesRecNumber()
+  def send_getEbayOrderBySalesRecNumber(self, salesRecordNumber):
+    self._oprot.writeMessageBegin('getEbayOrderBySalesRecNumber', TMessageType.CALL, self._seqid)
+    args = getEbayOrderBySalesRecNumber_args()
+    args.salesRecordNumber = salesRecordNumber
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getEbayOrderBySalesRecNumber(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getEbayOrderBySalesRecNumber_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayOrderBySalesRecNumber failed: unknown result");
+  def getEbayOrder(self, salesRecordNumber, listingId):
+    """
+    Parameters:
+     - salesRecordNumber
+     - listingId
+    """
+    self.send_getEbayOrder(salesRecordNumber, listingId)
+    return self.recv_getEbayOrder()
+  def send_getEbayOrder(self, salesRecordNumber, listingId):
+    self._oprot.writeMessageBegin('getEbayOrder', TMessageType.CALL, self._seqid)
+    args = getEbayOrder_args()
+    args.salesRecordNumber = salesRecordNumber
+    args.listingId = listingId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getEbayOrder(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getEbayOrder_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getEbayOrder failed: unknown result");
+  def updateEbayOrder(self, ebayOrder):
+    """
+    Parameters:
+     - ebayOrder
+    """
+    self.send_updateEbayOrder(ebayOrder)
+    self.recv_updateEbayOrder()
+  def send_updateEbayOrder(self, ebayOrder):
+    self._oprot.writeMessageBegin('updateEbayOrder', TMessageType.CALL, self._seqid)
+    args = updateEbayOrder_args()
+    args.ebayOrder = ebayOrder
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_updateEbayOrder(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = updateEbayOrder_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    return
+  def ebayOrderExists(self, salesRecNumber, ebayListingId):
+    """
+    Parameters:
+     - salesRecNumber
+     - ebayListingId
+    """
+    self.send_ebayOrderExists(salesRecNumber, ebayListingId)
+    return self.recv_ebayOrderExists()
+  def send_ebayOrderExists(self, salesRecNumber, ebayListingId):
+    self._oprot.writeMessageBegin('ebayOrderExists', TMessageType.CALL, self._seqid)
+    args = ebayOrderExists_args()
+    args.salesRecNumber = salesRecNumber
+    args.ebayListingId = ebayListingId
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_ebayOrderExists(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = ebayOrderExists_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "ebayOrderExists failed: unknown result");
+  def updateOrderForEbay(self, order):
+    """
+    Parameters:
+     - order
+    """
+    self.send_updateOrderForEbay(order)
+    self.recv_updateOrderForEbay()
+  def send_updateOrderForEbay(self, order):
+    self._oprot.writeMessageBegin('updateOrderForEbay', TMessageType.CALL, self._seqid)
+    args = updateOrderForEbay_args()
+    args.order = order
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_updateOrderForEbay(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = updateOrderForEbay_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    return
+  def splitEbayOrder(self, orderId, splitOrderQty, splitOrderItemId, usePowerShip):
+    """
+    Parameters:
+     - orderId
+     - splitOrderQty
+     - splitOrderItemId
+     - usePowerShip
+    """
+    self.send_splitEbayOrder(orderId, splitOrderQty, splitOrderItemId, usePowerShip)
+    return self.recv_splitEbayOrder()
+  def send_splitEbayOrder(self, orderId, splitOrderQty, splitOrderItemId, usePowerShip):
+    self._oprot.writeMessageBegin('splitEbayOrder', TMessageType.CALL, self._seqid)
+    args = splitEbayOrder_args()
+    args.orderId = orderId
+    args.splitOrderQty = splitOrderQty
+    args.splitOrderItemId = splitOrderItemId
+    args.usePowerShip = usePowerShip
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_splitEbayOrder(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = splitEbayOrder_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "splitEbayOrder failed: unknown result");
 class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
   def __init__(self, handler):
     shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
     self._processMap["createTransaction"] = Processor.process_createTransaction
     self._processMap["getOrdersByAmazonOrderCode"] = Processor.process_getOrdersByAmazonOrderCode
     self._processMap["convertStoreToNormal"] = Processor.process_convertStoreToNormal
     self._processMap["updateFreebieItem"] = Processor.process_updateFreebieItem
     self._processMap["getHotspotServiceMatrices"] = Processor.process_getHotspotServiceMatrices
     self._processMap["updateOrderAWB"] = Processor.process_updateOrderAWB
+    self._processMap["getOrdersByVendor"] = Processor.process_getOrdersByVendor
+    self._processMap["createEbayOrder"] = Processor.process_createEbayOrder
+    self._processMap["getEbayOrderByOrderId"] = Processor.process_getEbayOrderByOrderId
+    self._processMap["getEbayOrderBySalesRecNumber"] = Processor.process_getEbayOrderBySalesRecNumber
+    self._processMap["getEbayOrder"] = Processor.process_getEbayOrder
+    self._processMap["updateEbayOrder"] = Processor.process_updateEbayOrder
+    self._processMap["ebayOrderExists"] = Processor.process_ebayOrderExists
+    self._processMap["updateOrderForEbay"] = Processor.process_updateOrderForEbay
+    self._processMap["splitEbayOrder"] = Processor.process_splitEbayOrder
   def process(self, iprot, oprot):
     (name, type, seqid) = iprot.readMessageBegin()
     if name not in self._processMap:
       iprot.skip(TType.STRUCT)
     oprot.writeMessageBegin("updateOrderAWB", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
+  def process_getOrdersByVendor(self, seqid, iprot, oprot):
+    args = getOrdersByVendor_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getOrdersByVendor_result()
+    try:
+      result.success = self._handler.getOrdersByVendor(args.vendors, args.statuses)
+    except TransactionServiceException, ex:
+      result.ex = ex
+    oprot.writeMessageBegin("getOrdersByVendor", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_createEbayOrder(self, seqid, iprot, oprot):
+    args = createEbayOrder_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = createEbayOrder_result()
+    self._handler.createEbayOrder(args.ebayOrder)
+    oprot.writeMessageBegin("createEbayOrder", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getEbayOrderByOrderId(self, seqid, iprot, oprot):
+    args = getEbayOrderByOrderId_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getEbayOrderByOrderId_result()
+    result.success = self._handler.getEbayOrderByOrderId(args.orderId)
+    oprot.writeMessageBegin("getEbayOrderByOrderId", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getEbayOrderBySalesRecNumber(self, seqid, iprot, oprot):
+    args = getEbayOrderBySalesRecNumber_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getEbayOrderBySalesRecNumber_result()
+    result.success = self._handler.getEbayOrderBySalesRecNumber(args.salesRecordNumber)
+    oprot.writeMessageBegin("getEbayOrderBySalesRecNumber", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getEbayOrder(self, seqid, iprot, oprot):
+    args = getEbayOrder_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getEbayOrder_result()
+    result.success = self._handler.getEbayOrder(args.salesRecordNumber, args.listingId)
+    oprot.writeMessageBegin("getEbayOrder", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_updateEbayOrder(self, seqid, iprot, oprot):
+    args = updateEbayOrder_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = updateEbayOrder_result()
+    self._handler.updateEbayOrder(args.ebayOrder)
+    oprot.writeMessageBegin("updateEbayOrder", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_ebayOrderExists(self, seqid, iprot, oprot):
+    args = ebayOrderExists_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = ebayOrderExists_result()
+    result.success = self._handler.ebayOrderExists(args.salesRecNumber, args.ebayListingId)
+    oprot.writeMessageBegin("ebayOrderExists", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_updateOrderForEbay(self, seqid, iprot, oprot):
+    args = updateOrderForEbay_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = updateOrderForEbay_result()
+    self._handler.updateOrderForEbay(args.order)
+    oprot.writeMessageBegin("updateOrderForEbay", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_splitEbayOrder(self, seqid, iprot, oprot):
+    args = splitEbayOrder_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = splitEbayOrder_result()
+    result.success = self._handler.splitEbayOrder(args.orderId, args.splitOrderQty, args.splitOrderItemId, args.usePowerShip)
+    oprot.writeMessageBegin("splitEbayOrder", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
 # HELPER FUNCTIONS AND STRUCTURES
 class createTransaction_args:
   """
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.STRUCT, 0)
       self.success.write(oprot)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getOrdersByVendor_args:
+  """
+  Attributes:
+   - vendors
+   - statuses
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.LIST, 'vendors', (TType.I64,None), None, ), # 1
+    (2, TType.LIST, 'statuses', (TType.I32,None), None, ), # 2
+  )
+  def __init__(self, vendors=None, statuses=None,):
+    self.vendors = vendors
+    self.statuses = statuses
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.LIST:
+          self.vendors = []
+          (_etype877, _size874) = iprot.readListBegin()
+          for _i878 in xrange(_size874):
+            _elem879 = iprot.readI64();
+            self.vendors.append(_elem879)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.LIST:
+          self.statuses = []
+          (_etype883, _size880) = iprot.readListBegin()
+          for _i884 in xrange(_size880):
+            _elem885 = iprot.readI32();
+            self.statuses.append(_elem885)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getOrdersByVendor_args')
+    if self.vendors is not None:
+      oprot.writeFieldBegin('vendors', TType.LIST, 1)
+      oprot.writeListBegin(TType.I64, len(self.vendors))
+      for iter886 in self.vendors:
+        oprot.writeI64(iter886)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    if self.statuses is not None:
+      oprot.writeFieldBegin('statuses', TType.LIST, 2)
+      oprot.writeListBegin(TType.I32, len(self.statuses))
+      for iter887 in self.statuses:
+        oprot.writeI32(iter887)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getOrdersByVendor_result:
+  """
+  Attributes:
+   - success
+   - ex
+  """
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(Order, Order.thrift_spec)), None, ), # 0
+    (1, TType.STRUCT, 'ex', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, ex=None,):
+    self.success = success
+    self.ex = ex
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype891, _size888) = iprot.readListBegin()
+          for _i892 in xrange(_size888):
+            _elem893 = Order()
+            _elem893.read(iprot)
+            self.success.append(_elem893)
+          iprot.readListEnd()
+        else:
+          iprot.skip(ftype)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.ex = TransactionServiceException()
+          self.ex.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getOrdersByVendor_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter894 in self.success:
+        iter894.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 __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class createEbayOrder_args:
+  """
+  Attributes:
+   - ebayOrder
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'ebayOrder', (EbayOrder, EbayOrder.thrift_spec), None, ), # 1
+  )
+  def __init__(self, ebayOrder=None,):
+    self.ebayOrder = ebayOrder
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRUCT:
+          self.ebayOrder = EbayOrder()
+          self.ebayOrder.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('createEbayOrder_args')
+    if self.ebayOrder is not None:
+      oprot.writeFieldBegin('ebayOrder', TType.STRUCT, 1)
+      self.ebayOrder.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class createEbayOrder_result:
+  thrift_spec = (
+  )
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('createEbayOrder_result')
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getEbayOrderByOrderId_args:
+  """
+  Attributes:
+   - orderId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'orderId', None, None, ), # 1
+  )
+  def __init__(self, orderId=None,):
+    self.orderId = orderId
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.orderId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getEbayOrderByOrderId_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 __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getEbayOrderByOrderId_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.STRUCT, 'success', (EbayOrder, EbayOrder.thrift_spec), None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.STRUCT:
+          self.success = EbayOrder()
+          self.success.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getEbayOrderByOrderId_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.STRUCT, 0)
+      self.success.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getEbayOrderBySalesRecNumber_args:
+  """
+  Attributes:
+   - salesRecordNumber
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'salesRecordNumber', None, None, ), # 1
+  )
+  def __init__(self, salesRecordNumber=None,):
+    self.salesRecordNumber = salesRecordNumber
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.salesRecordNumber = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getEbayOrderBySalesRecNumber_args')
+    if self.salesRecordNumber is not None:
+      oprot.writeFieldBegin('salesRecordNumber', TType.I64, 1)
+      oprot.writeI64(self.salesRecordNumber)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getEbayOrderBySalesRecNumber_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.STRUCT, 'success', (EbayOrder, EbayOrder.thrift_spec), None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.STRUCT:
+          self.success = EbayOrder()
+          self.success.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getEbayOrderBySalesRecNumber_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.STRUCT, 0)
+      self.success.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getEbayOrder_args:
+  """
+  Attributes:
+   - salesRecordNumber
+   - listingId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'salesRecordNumber', None, None, ), # 1
+    (2, TType.STRING, 'listingId', None, None, ), # 2
+  )
+  def __init__(self, salesRecordNumber=None, listingId=None,):
+    self.salesRecordNumber = salesRecordNumber
+    self.listingId = listingId
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.salesRecordNumber = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRING:
+          self.listingId = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getEbayOrder_args')
+    if self.salesRecordNumber is not None:
+      oprot.writeFieldBegin('salesRecordNumber', TType.I64, 1)
+      oprot.writeI64(self.salesRecordNumber)
+      oprot.writeFieldEnd()
+    if self.listingId is not None:
+      oprot.writeFieldBegin('listingId', TType.STRING, 2)
+      oprot.writeString(self.listingId)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class getEbayOrder_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.STRUCT, 'success', (EbayOrder, EbayOrder.thrift_spec), None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.STRUCT:
+          self.success = EbayOrder()
+          self.success.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('getEbayOrder_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.STRUCT, 0)
+      self.success.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class updateEbayOrder_args:
+  """
+  Attributes:
+   - ebayOrder
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'ebayOrder', (EbayOrder, EbayOrder.thrift_spec), None, ), # 1
+  )
+  def __init__(self, ebayOrder=None,):
+    self.ebayOrder = ebayOrder
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRUCT:
+          self.ebayOrder = EbayOrder()
+          self.ebayOrder.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('updateEbayOrder_args')
+    if self.ebayOrder is not None:
+      oprot.writeFieldBegin('ebayOrder', TType.STRUCT, 1)
+      self.ebayOrder.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class updateEbayOrder_result:
+  thrift_spec = (
+  )
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('updateEbayOrder_result')
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class ebayOrderExists_args:
+  """
+  Attributes:
+   - salesRecNumber
+   - ebayListingId
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'salesRecNumber', None, None, ), # 1
+    (2, TType.STRING, 'ebayListingId', None, None, ), # 2
+  )
+  def __init__(self, salesRecNumber=None, ebayListingId=None,):
+    self.salesRecNumber = salesRecNumber
+    self.ebayListingId = ebayListingId
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.salesRecNumber = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.STRING:
+          self.ebayListingId = iprot.readString();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('ebayOrderExists_args')
+    if self.salesRecNumber is not None:
+      oprot.writeFieldBegin('salesRecNumber', TType.I64, 1)
+      oprot.writeI64(self.salesRecNumber)
+      oprot.writeFieldEnd()
+    if self.ebayListingId is not None:
+      oprot.writeFieldBegin('ebayListingId', TType.STRING, 2)
+      oprot.writeString(self.ebayListingId)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class ebayOrderExists_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.BOOL:
+          self.success = iprot.readBool();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('ebayOrderExists_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(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))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class updateOrderForEbay_args:
+  """
+  Attributes:
+   - order
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.STRUCT, 'order', (Order, Order.thrift_spec), None, ), # 1
+  )
+  def __init__(self, order=None,):
+    self.order = order
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.STRUCT:
+          self.order = Order()
+          self.order.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('updateOrderForEbay_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 __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class updateOrderForEbay_result:
+  thrift_spec = (
+  )
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('updateOrderForEbay_result')
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class splitEbayOrder_args:
+  """
+  Attributes:
+   - orderId
+   - splitOrderQty
+   - splitOrderItemId
+   - usePowerShip
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'orderId', None, None, ), # 1
+    (2, TType.I64, 'splitOrderQty', None, None, ), # 2
+    (3, TType.I64, 'splitOrderItemId', None, None, ), # 3
+    (4, TType.BOOL, 'usePowerShip', None, None, ), # 4
+  )
+  def __init__(self, orderId=None, splitOrderQty=None, splitOrderItemId=None, usePowerShip=None,):
+    self.orderId = orderId
+    self.splitOrderQty = splitOrderQty
+    self.splitOrderItemId = splitOrderItemId
+    self.usePowerShip = usePowerShip
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 1:
+        if ftype == TType.I64:
+          self.orderId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I64:
+          self.splitOrderQty = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.I64:
+          self.splitOrderItemId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
+        if ftype == TType.BOOL:
+          self.usePowerShip = iprot.readBool();
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('splitEbayOrder_args')
+    if self.orderId is not None:
+      oprot.writeFieldBegin('orderId', TType.I64, 1)
+      oprot.writeI64(self.orderId)
+      oprot.writeFieldEnd()
+    if self.splitOrderQty is not None:
+      oprot.writeFieldBegin('splitOrderQty', TType.I64, 2)
+      oprot.writeI64(self.splitOrderQty)
+      oprot.writeFieldEnd()
+    if self.splitOrderItemId is not None:
+      oprot.writeFieldBegin('splitOrderItemId', TType.I64, 3)
+      oprot.writeI64(self.splitOrderItemId)
+      oprot.writeFieldEnd()
+    if self.usePowerShip is not None:
+      oprot.writeFieldBegin('usePowerShip', TType.BOOL, 4)
+      oprot.writeBool(self.usePowerShip)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class splitEbayOrder_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.STRUCT, 'success', (Order, Order.thrift_spec), None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.STRUCT:
+          self.success = Order()
+          self.success.read(iprot)
+        else:
+          iprot.skip(ftype)
+      else:
+        iprot.skip(ftype)
+      iprot.readFieldEnd()
+    iprot.readStructEnd()
+  def write(self, oprot):
+    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
+      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
+      return
+    oprot.writeStructBegin('splitEbayOrder_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.STRUCT, 0)
+      self.success.write(oprot)
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
     oprot.writeStructEnd()
   def validate(self):
     return

Subversion Repositories SmartDukaan

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