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

     Parameters:
      - userSanaction
     """
     pass
-  def getCreditHistoryRecordsForTransaction(self, paymentId, creditorId, creditTxnType):
+  def getCreditHistoryRecordsForTransaction(self, paymentId, creditTxnType):
     """
     Parameters:
      - paymentId
-     - creditorId
      - creditTxnType
     """
     pass
-  def getCreditHistoryRecordsForUserAndCreditor(self, userId, creditTxnType):
+  def getCreditHistoryRecordsForUserAndCreditor(self, userId, creditorId, creditTxnType):
     """
     Parameters:
      - userId
+     - creditorId
      - creditTxnType
     """
     pass
-  def processCreditTransaction(self, paymentId, creditTxns):
+  def processCreditTransaction(self, paymentId, userId, creditorId, creditTxns):
     """
     Parameters:
      - paymentId
+     - userId
+     - creditorId
      - creditTxns
     """
     pass
   def getLoanPayableForUserToCreditor(self, userId, creditorId, dueDate):
      - creditorId
      - dueDate
     """
     pass
+  def getLoanHistoryRecordsForTransaction(self, paymentId, creditTxnType):
+    """
+    Parameters:
+     - paymentId
+     - creditTxnType
+    """
+    pass
+  def getLoanHistoryRecordsForUserAndCreditor(self, userId, creditorId, creditTxnType):
+    """
+    Parameters:
+     - userId
+     - creditorId
+     - creditTxnType
+    """
+    pass
+  def processLoanTransaction(self, paymentId, userId, creditorId, creditTxns):
+    """
+    Parameters:
+     - paymentId
+     - userId
+     - creditorId
+     - creditTxns
+    """
+    pass
   def getReturnOrderInfo(self, id):
     """
     Parameters:
      - id
     """
       return result.success
     if result.pe is not None:
       raise result.pe
     raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUserSanction failed: unknown result");
-  def getCreditHistoryRecordsForTransaction(self, paymentId, creditorId, creditTxnType):
+  def getCreditHistoryRecordsForTransaction(self, paymentId, creditTxnType):
     """
     Parameters:
      - paymentId
-     - creditorId
      - creditTxnType
     """
-    self.send_getCreditHistoryRecordsForTransaction(paymentId, creditorId, creditTxnType)
+    self.send_getCreditHistoryRecordsForTransaction(paymentId, creditTxnType)
     return self.recv_getCreditHistoryRecordsForTransaction()
-  def send_getCreditHistoryRecordsForTransaction(self, paymentId, creditorId, creditTxnType):
+  def send_getCreditHistoryRecordsForTransaction(self, paymentId, creditTxnType):
     self._oprot.writeMessageBegin('getCreditHistoryRecordsForTransaction', TMessageType.CALL, self._seqid)
     args = getCreditHistoryRecordsForTransaction_args()
     args.paymentId = paymentId
-    args.creditorId = creditorId
     args.creditTxnType = creditTxnType
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
     raise TApplicationException(TApplicationException.MISSING_RESULT, "getCreditHistoryRecordsForTransaction failed: unknown result");
-  def getCreditHistoryRecordsForUserAndCreditor(self, userId, creditTxnType):
+  def getCreditHistoryRecordsForUserAndCreditor(self, userId, creditorId, creditTxnType):
     """
     Parameters:
      - userId
+     - creditorId
      - creditTxnType
     """
-    self.send_getCreditHistoryRecordsForUserAndCreditor(userId, creditTxnType)
+    self.send_getCreditHistoryRecordsForUserAndCreditor(userId, creditorId, creditTxnType)
     return self.recv_getCreditHistoryRecordsForUserAndCreditor()
-  def send_getCreditHistoryRecordsForUserAndCreditor(self, userId, creditTxnType):
+  def send_getCreditHistoryRecordsForUserAndCreditor(self, userId, creditorId, creditTxnType):
     self._oprot.writeMessageBegin('getCreditHistoryRecordsForUserAndCreditor', TMessageType.CALL, self._seqid)
     args = getCreditHistoryRecordsForUserAndCreditor_args()
     args.userId = userId
+    args.creditorId = creditorId
     args.creditTxnType = creditTxnType
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
     raise TApplicationException(TApplicationException.MISSING_RESULT, "getCreditHistoryRecordsForUserAndCreditor failed: unknown result");
-  def processCreditTransaction(self, paymentId, creditTxns):
+  def processCreditTransaction(self, paymentId, userId, creditorId, creditTxns):
     """
     Parameters:
      - paymentId
+     - userId
+     - creditorId
      - creditTxns
     """
-    self.send_processCreditTransaction(paymentId, creditTxns)
+    self.send_processCreditTransaction(paymentId, userId, creditorId, creditTxns)
     return self.recv_processCreditTransaction()
-  def send_processCreditTransaction(self, paymentId, creditTxns):
+  def send_processCreditTransaction(self, paymentId, userId, creditorId, creditTxns):
     self._oprot.writeMessageBegin('processCreditTransaction', TMessageType.CALL, self._seqid)
     args = processCreditTransaction_args()
     args.paymentId = paymentId
+    args.userId = userId
+    args.creditorId = creditorId
     args.creditTxns = creditTxns
     args.write(self._oprot)
     self._oprot.writeMessageEnd()
     self._oprot.trans.flush()
     self._iprot.readMessageEnd()
     if result.success is not None:
       return result.success
     raise TApplicationException(TApplicationException.MISSING_RESULT, "getLoanPayableForUserToCreditor failed: unknown result");
+  def getLoanHistoryRecordsForTransaction(self, paymentId, creditTxnType):
+    """
+    Parameters:
+     - paymentId
+     - creditTxnType
+    """
+    self.send_getLoanHistoryRecordsForTransaction(paymentId, creditTxnType)
+    return self.recv_getLoanHistoryRecordsForTransaction()
+  def send_getLoanHistoryRecordsForTransaction(self, paymentId, creditTxnType):
+    self._oprot.writeMessageBegin('getLoanHistoryRecordsForTransaction', TMessageType.CALL, self._seqid)
+    args = getLoanHistoryRecordsForTransaction_args()
+    args.paymentId = paymentId
+    args.creditTxnType = creditTxnType
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getLoanHistoryRecordsForTransaction(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getLoanHistoryRecordsForTransaction_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLoanHistoryRecordsForTransaction failed: unknown result");
+  def getLoanHistoryRecordsForUserAndCreditor(self, userId, creditorId, creditTxnType):
+    """
+    Parameters:
+     - userId
+     - creditorId
+     - creditTxnType
+    """
+    self.send_getLoanHistoryRecordsForUserAndCreditor(userId, creditorId, creditTxnType)
+    return self.recv_getLoanHistoryRecordsForUserAndCreditor()
+  def send_getLoanHistoryRecordsForUserAndCreditor(self, userId, creditorId, creditTxnType):
+    self._oprot.writeMessageBegin('getLoanHistoryRecordsForUserAndCreditor', TMessageType.CALL, self._seqid)
+    args = getLoanHistoryRecordsForUserAndCreditor_args()
+    args.userId = userId
+    args.creditorId = creditorId
+    args.creditTxnType = creditTxnType
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_getLoanHistoryRecordsForUserAndCreditor(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = getLoanHistoryRecordsForUserAndCreditor_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLoanHistoryRecordsForUserAndCreditor failed: unknown result");
+  def processLoanTransaction(self, paymentId, userId, creditorId, creditTxns):
+    """
+    Parameters:
+     - paymentId
+     - userId
+     - creditorId
+     - creditTxns
+    """
+    self.send_processLoanTransaction(paymentId, userId, creditorId, creditTxns)
+    return self.recv_processLoanTransaction()
+  def send_processLoanTransaction(self, paymentId, userId, creditorId, creditTxns):
+    self._oprot.writeMessageBegin('processLoanTransaction', TMessageType.CALL, self._seqid)
+    args = processLoanTransaction_args()
+    args.paymentId = paymentId
+    args.userId = userId
+    args.creditorId = creditorId
+    args.creditTxns = creditTxns
+    args.write(self._oprot)
+    self._oprot.writeMessageEnd()
+    self._oprot.trans.flush()
+  def recv_processLoanTransaction(self, ):
+    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
+    if mtype == TMessageType.EXCEPTION:
+      x = TApplicationException()
+      x.read(self._iprot)
+      self._iprot.readMessageEnd()
+      raise x
+    result = processLoanTransaction_result()
+    result.read(self._iprot)
+    self._iprot.readMessageEnd()
+    if result.success is not None:
+      return result.success
+    if result.pe is not None:
+      raise result.pe
+    raise TApplicationException(TApplicationException.MISSING_RESULT, "processLoanTransaction failed: unknown result");
   def getReturnOrderInfo(self, id):
     """
     Parameters:
      - id
     """
     self._processMap["updateUserSanction"] = Processor.process_updateUserSanction
     self._processMap["getCreditHistoryRecordsForTransaction"] = Processor.process_getCreditHistoryRecordsForTransaction
     self._processMap["getCreditHistoryRecordsForUserAndCreditor"] = Processor.process_getCreditHistoryRecordsForUserAndCreditor
     self._processMap["processCreditTransaction"] = Processor.process_processCreditTransaction
     self._processMap["getLoanPayableForUserToCreditor"] = Processor.process_getLoanPayableForUserToCreditor
+    self._processMap["getLoanHistoryRecordsForTransaction"] = Processor.process_getLoanHistoryRecordsForTransaction
+    self._processMap["getLoanHistoryRecordsForUserAndCreditor"] = Processor.process_getLoanHistoryRecordsForUserAndCreditor
+    self._processMap["processLoanTransaction"] = Processor.process_processLoanTransaction
     self._processMap["getReturnOrderInfo"] = Processor.process_getReturnOrderInfo
     self._processMap["getReturnOrderInfoList"] = Processor.process_getReturnOrderInfoList
     self._processMap["getReturnOrderInfoListAsByStatus"] = Processor.process_getReturnOrderInfoListAsByStatus
     self._processMap["updateReturnOrderInfo"] = Processor.process_updateReturnOrderInfo
     self._processMap["bulkUpdateReturnOrderInfo"] = Processor.process_bulkUpdateReturnOrderInfo
   def process_getCreditHistoryRecordsForTransaction(self, seqid, iprot, oprot):
     args = getCreditHistoryRecordsForTransaction_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = getCreditHistoryRecordsForTransaction_result()
-    result.success = self._handler.getCreditHistoryRecordsForTransaction(args.paymentId, args.creditorId, args.creditTxnType)
+    result.success = self._handler.getCreditHistoryRecordsForTransaction(args.paymentId, args.creditTxnType)
     oprot.writeMessageBegin("getCreditHistoryRecordsForTransaction", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
   def process_getCreditHistoryRecordsForUserAndCreditor(self, seqid, iprot, oprot):
     args = getCreditHistoryRecordsForUserAndCreditor_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = getCreditHistoryRecordsForUserAndCreditor_result()
-    result.success = self._handler.getCreditHistoryRecordsForUserAndCreditor(args.userId, args.creditTxnType)
+    result.success = self._handler.getCreditHistoryRecordsForUserAndCreditor(args.userId, args.creditorId, args.creditTxnType)
     oprot.writeMessageBegin("getCreditHistoryRecordsForUserAndCreditor", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
     args = processCreditTransaction_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = processCreditTransaction_result()
     try:
-      result.success = self._handler.processCreditTransaction(args.paymentId, args.creditTxns)
+      result.success = self._handler.processCreditTransaction(args.paymentId, args.userId, args.creditorId, args.creditTxns)
     except TransactionServiceException, pe:
       result.pe = pe
     oprot.writeMessageBegin("processCreditTransaction", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.writeMessageBegin("getLoanPayableForUserToCreditor", TMessageType.REPLY, seqid)
     result.write(oprot)
     oprot.writeMessageEnd()
     oprot.trans.flush()
+  def process_getLoanHistoryRecordsForTransaction(self, seqid, iprot, oprot):
+    args = getLoanHistoryRecordsForTransaction_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getLoanHistoryRecordsForTransaction_result()
+    result.success = self._handler.getLoanHistoryRecordsForTransaction(args.paymentId, args.creditTxnType)
+    oprot.writeMessageBegin("getLoanHistoryRecordsForTransaction", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_getLoanHistoryRecordsForUserAndCreditor(self, seqid, iprot, oprot):
+    args = getLoanHistoryRecordsForUserAndCreditor_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = getLoanHistoryRecordsForUserAndCreditor_result()
+    result.success = self._handler.getLoanHistoryRecordsForUserAndCreditor(args.userId, args.creditorId, args.creditTxnType)
+    oprot.writeMessageBegin("getLoanHistoryRecordsForUserAndCreditor", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
+  def process_processLoanTransaction(self, seqid, iprot, oprot):
+    args = processLoanTransaction_args()
+    args.read(iprot)
+    iprot.readMessageEnd()
+    result = processLoanTransaction_result()
+    try:
+      result.success = self._handler.processLoanTransaction(args.paymentId, args.userId, args.creditorId, args.creditTxns)
+    except TransactionServiceException, pe:
+      result.pe = pe
+    oprot.writeMessageBegin("processLoanTransaction", TMessageType.REPLY, seqid)
+    result.write(oprot)
+    oprot.writeMessageEnd()
+    oprot.trans.flush()
   def process_getReturnOrderInfo(self, seqid, iprot, oprot):
     args = getReturnOrderInfo_args()
     args.read(iprot)
     iprot.readMessageEnd()
     result = getReturnOrderInfo_result()
 class getCreditHistoryRecordsForTransaction_args:
   """
   Attributes:
    - paymentId
-   - creditorId
    - creditTxnType
   """
   thrift_spec = (
     None, # 0
     (1, TType.I64, 'paymentId', None, None, ), # 1
-    (2, TType.I64, 'creditorId', None, None, ), # 2
-    (3, TType.STRING, 'creditTxnType', None, None, ), # 3
+    (2, TType.I32, 'creditTxnType', None, None, ), # 2
+  )
-  def __init__(self, paymentId=None, creditorId=None, creditTxnType=None,):
+  def __init__(self, paymentId=None, creditTxnType=None,):
     self.paymentId = paymentId
-    self.creditorId = creditorId
     self.creditTxnType = creditTxnType
   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))
         if ftype == TType.I64:
           self.paymentId = iprot.readI64();
         else:
           iprot.skip(ftype)
       elif fid == 2:
-        if ftype == TType.I64:
+        if ftype == TType.I32:
-          self.creditorId = iprot.readI64();
-        else:
-          iprot.skip(ftype)
-      elif fid == 3:
-        if ftype == TType.STRING:
-          self.creditTxnType = iprot.readString();
+          self.creditTxnType = iprot.readI32();
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
     oprot.writeStructBegin('getCreditHistoryRecordsForTransaction_args')
     if self.paymentId is not None:
       oprot.writeFieldBegin('paymentId', TType.I64, 1)
       oprot.writeI64(self.paymentId)
       oprot.writeFieldEnd()
-    if self.creditorId is not None:
-      oprot.writeFieldBegin('creditorId', TType.I64, 2)
-      oprot.writeI64(self.creditorId)
-      oprot.writeFieldEnd()
     if self.creditTxnType is not None:
-      oprot.writeFieldBegin('creditTxnType', TType.STRING, 3)
+      oprot.writeFieldBegin('creditTxnType', TType.I32, 2)
-      oprot.writeString(self.creditTxnType)
+      oprot.writeI32(self.creditTxnType)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def validate(self):
 class getCreditHistoryRecordsForUserAndCreditor_args:
   """
   Attributes:
    - userId
+   - creditorId
    - creditTxnType
   """
   thrift_spec = (
     None, # 0
     (1, TType.I64, 'userId', None, None, ), # 1
+    (2, TType.I64, 'creditorId', None, None, ), # 2
-    (2, TType.STRING, 'creditTxnType', None, None, ), # 2
+    (3, TType.I32, 'creditTxnType', None, None, ), # 3
+  )
-  def __init__(self, userId=None, creditTxnType=None,):
+  def __init__(self, userId=None, creditorId=None, creditTxnType=None,):
     self.userId = userId
+    self.creditorId = creditorId
     self.creditTxnType = creditTxnType
   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))
         if ftype == TType.I64:
           self.userId = iprot.readI64();
         else:
           iprot.skip(ftype)
       elif fid == 2:
-        if ftype == TType.STRING:
+        if ftype == TType.I64:
+          self.creditorId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.I32:
-          self.creditTxnType = iprot.readString();
+          self.creditTxnType = iprot.readI32();
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       iprot.readFieldEnd()
     oprot.writeStructBegin('getCreditHistoryRecordsForUserAndCreditor_args')
     if self.userId is not None:
       oprot.writeFieldBegin('userId', TType.I64, 1)
       oprot.writeI64(self.userId)
       oprot.writeFieldEnd()
+    if self.creditorId is not None:
+      oprot.writeFieldBegin('creditorId', TType.I64, 2)
+      oprot.writeI64(self.creditorId)
+      oprot.writeFieldEnd()
     if self.creditTxnType is not None:
-      oprot.writeFieldBegin('creditTxnType', TType.STRING, 2)
+      oprot.writeFieldBegin('creditTxnType', TType.I32, 3)
-      oprot.writeString(self.creditTxnType)
+      oprot.writeI32(self.creditTxnType)
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
   def validate(self):
 class processCreditTransaction_args:
   """
   Attributes:
    - paymentId
+   - userId
+   - creditorId
    - creditTxns
   """
   thrift_spec = (
     None, # 0
     (1, TType.I64, 'paymentId', None, None, ), # 1
+    (2, TType.I64, 'userId', None, None, ), # 2
+    (3, TType.I64, 'creditorId', None, None, ), # 3
-    (2, TType.LIST, 'creditTxns', (TType.STRUCT,(CreditHistory, CreditHistory.thrift_spec)), None, ), # 2
+    (4, TType.LIST, 'creditTxns', (TType.STRUCT,(CreditHistory, CreditHistory.thrift_spec)), None, ), # 4
+  )
-  def __init__(self, paymentId=None, creditTxns=None,):
+  def __init__(self, paymentId=None, userId=None, creditorId=None, creditTxns=None,):
     self.paymentId = paymentId
+    self.userId = userId
+    self.creditorId = creditorId
     self.creditTxns = creditTxns
   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))
         if ftype == TType.I64:
           self.paymentId = iprot.readI64();
         else:
           iprot.skip(ftype)
       elif fid == 2:
+        if ftype == TType.I64:
+          self.userId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.I64:
+          self.creditorId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
         if ftype == TType.LIST:
           self.creditTxns = []
           (_etype1173, _size1170) = iprot.readListBegin()
           for _i1174 in xrange(_size1170):
             _elem1175 = CreditHistory()
     oprot.writeStructBegin('processCreditTransaction_args')
     if self.paymentId is not None:
       oprot.writeFieldBegin('paymentId', TType.I64, 1)
       oprot.writeI64(self.paymentId)
       oprot.writeFieldEnd()
+    if self.userId is not None:
+      oprot.writeFieldBegin('userId', TType.I64, 2)
+      oprot.writeI64(self.userId)
+      oprot.writeFieldEnd()
+    if self.creditorId is not None:
+      oprot.writeFieldBegin('creditorId', TType.I64, 3)
+      oprot.writeI64(self.creditorId)
+      oprot.writeFieldEnd()
     if self.creditTxns is not None:
-      oprot.writeFieldBegin('creditTxns', TType.LIST, 2)
+      oprot.writeFieldBegin('creditTxns', TType.LIST, 4)
       oprot.writeListBegin(TType.STRUCT, len(self.creditTxns))
       for iter1176 in self.creditTxns:
         iter1176.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
   Attributes:
    - success
   """
   thrift_spec = (
+    (0, TType.DOUBLE, '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.DOUBLE:
+          self.success = iprot.readDouble();
+        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('getLoanPayableForUserToCreditor_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.DOUBLE, 0)
+      oprot.writeDouble(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 getLoanHistoryRecordsForTransaction_args:
+  """
+  Attributes:
+   - paymentId
+   - creditTxnType
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'paymentId', None, None, ), # 1
+    (2, TType.I32, 'creditTxnType', None, None, ), # 2
+  )
+  def __init__(self, paymentId=None, creditTxnType=None,):
+    self.paymentId = paymentId
+    self.creditTxnType = creditTxnType
+  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.paymentId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I32:
+          self.creditTxnType = iprot.readI32();
+        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('getLoanHistoryRecordsForTransaction_args')
+    if self.paymentId is not None:
+      oprot.writeFieldBegin('paymentId', TType.I64, 1)
+      oprot.writeI64(self.paymentId)
+      oprot.writeFieldEnd()
+    if self.creditTxnType is not None:
+      oprot.writeFieldBegin('creditTxnType', TType.I32, 2)
+      oprot.writeI32(self.creditTxnType)
+      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 getLoanHistoryRecordsForTransaction_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
-    (0, TType.LIST, 'success', (TType.STRUCT,(CreditHistory, CreditHistory.thrift_spec)), None, ), # 0
+    (0, TType.LIST, 'success', (TType.STRUCT,(LoanHistory, LoanHistory.thrift_spec)), None, ), # 0
+  )
   def __init__(self, success=None,):
     self.success = success
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
           (_etype1180, _size1177) = iprot.readListBegin()
           for _i1181 in xrange(_size1177):
-            _elem1182 = CreditHistory()
+            _elem1182 = LoanHistory()
             _elem1182.read(iprot)
             self.success.append(_elem1182)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
   def write(self, oprot):
     if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
       oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
       return
-    oprot.writeStructBegin('getLoanPayableForUserToCreditor_result')
+    oprot.writeStructBegin('getLoanHistoryRecordsForTransaction_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
       for iter1183 in self.success:
         iter1183.write(oprot)
     return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
   def __ne__(self, other):
     return not (self == other)
+class getLoanHistoryRecordsForUserAndCreditor_args:
+  """
+  Attributes:
+   - userId
+   - creditorId
+   - creditTxnType
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'userId', None, None, ), # 1
+    (2, TType.I64, 'creditorId', None, None, ), # 2
+    (3, TType.I32, 'creditTxnType', None, None, ), # 3
+  )
+  def __init__(self, userId=None, creditorId=None, creditTxnType=None,):
+    self.userId = userId
+    self.creditorId = creditorId
+    self.creditTxnType = creditTxnType
+  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.userId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I64:
+          self.creditorId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.I32:
+          self.creditTxnType = iprot.readI32();
+        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('getLoanHistoryRecordsForUserAndCreditor_args')
+    if self.userId is not None:
+      oprot.writeFieldBegin('userId', TType.I64, 1)
+      oprot.writeI64(self.userId)
+      oprot.writeFieldEnd()
+    if self.creditorId is not None:
+      oprot.writeFieldBegin('creditorId', TType.I64, 2)
+      oprot.writeI64(self.creditorId)
+      oprot.writeFieldEnd()
+    if self.creditTxnType is not None:
+      oprot.writeFieldBegin('creditTxnType', TType.I32, 3)
+      oprot.writeI32(self.creditTxnType)
+      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 getLoanHistoryRecordsForUserAndCreditor_result:
+  """
+  Attributes:
+   - success
+  """
+  thrift_spec = (
+    (0, TType.LIST, 'success', (TType.STRUCT,(LoanHistory, LoanHistory.thrift_spec)), None, ), # 0
+  )
+  def __init__(self, success=None,):
+    self.success = success
+  def read(self, iprot):
+    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
+      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
+      return
+    iprot.readStructBegin()
+    while True:
+      (fname, ftype, fid) = iprot.readFieldBegin()
+      if ftype == TType.STOP:
+        break
+      if fid == 0:
+        if ftype == TType.LIST:
+          self.success = []
+          (_etype1187, _size1184) = iprot.readListBegin()
+          for _i1188 in xrange(_size1184):
+            _elem1189 = LoanHistory()
+            _elem1189.read(iprot)
+            self.success.append(_elem1189)
+          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('getLoanHistoryRecordsForUserAndCreditor_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.LIST, 0)
+      oprot.writeListBegin(TType.STRUCT, len(self.success))
+      for iter1190 in self.success:
+        iter1190.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class processLoanTransaction_args:
+  """
+  Attributes:
+   - paymentId
+   - userId
+   - creditorId
+   - creditTxns
+  """
+  thrift_spec = (
+    None, # 0
+    (1, TType.I64, 'paymentId', None, None, ), # 1
+    (2, TType.I64, 'userId', None, None, ), # 2
+    (3, TType.I64, 'creditorId', None, None, ), # 3
+    (4, TType.LIST, 'creditTxns', (TType.STRUCT,(LoanHistory, LoanHistory.thrift_spec)), None, ), # 4
+  )
+  def __init__(self, paymentId=None, userId=None, creditorId=None, creditTxns=None,):
+    self.paymentId = paymentId
+    self.userId = userId
+    self.creditorId = creditorId
+    self.creditTxns = creditTxns
+  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.paymentId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 2:
+        if ftype == TType.I64:
+          self.userId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 3:
+        if ftype == TType.I64:
+          self.creditorId = iprot.readI64();
+        else:
+          iprot.skip(ftype)
+      elif fid == 4:
+        if ftype == TType.LIST:
+          self.creditTxns = []
+          (_etype1194, _size1191) = iprot.readListBegin()
+          for _i1195 in xrange(_size1191):
+            _elem1196 = LoanHistory()
+            _elem1196.read(iprot)
+            self.creditTxns.append(_elem1196)
+          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('processLoanTransaction_args')
+    if self.paymentId is not None:
+      oprot.writeFieldBegin('paymentId', TType.I64, 1)
+      oprot.writeI64(self.paymentId)
+      oprot.writeFieldEnd()
+    if self.userId is not None:
+      oprot.writeFieldBegin('userId', TType.I64, 2)
+      oprot.writeI64(self.userId)
+      oprot.writeFieldEnd()
+    if self.creditorId is not None:
+      oprot.writeFieldBegin('creditorId', TType.I64, 3)
+      oprot.writeI64(self.creditorId)
+      oprot.writeFieldEnd()
+    if self.creditTxns is not None:
+      oprot.writeFieldBegin('creditTxns', TType.LIST, 4)
+      oprot.writeListBegin(TType.STRUCT, len(self.creditTxns))
+      for iter1197 in self.creditTxns:
+        iter1197.write(oprot)
+      oprot.writeListEnd()
+      oprot.writeFieldEnd()
+    oprot.writeFieldStop()
+    oprot.writeStructEnd()
+  def validate(self):
+    return
+  def __repr__(self):
+    L = ['%s=%r' % (key, value)
+      for key, value in self.__dict__.iteritems()]
+    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
+  def __eq__(self, other):
+    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
+  def __ne__(self, other):
+    return not (self == other)
+class processLoanTransaction_result:
+  """
+  Attributes:
+   - success
+   - pe
+  """
+  thrift_spec = (
+    (0, TType.BOOL, 'success', None, None, ), # 0
+    (1, TType.STRUCT, 'pe', (TransactionServiceException, TransactionServiceException.thrift_spec), None, ), # 1
+  )
+  def __init__(self, success=None, pe=None,):
+    self.success = success
+    self.pe = pe
+  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)
+      elif fid == 1:
+        if ftype == TType.STRUCT:
+          self.pe = TransactionServiceException()
+          self.pe.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('processLoanTransaction_result')
+    if self.success is not None:
+      oprot.writeFieldBegin('success', TType.BOOL, 0)
+      oprot.writeBool(self.success)
+      oprot.writeFieldEnd()
+    if self.pe is not None:
+      oprot.writeFieldBegin('pe', TType.STRUCT, 1)
+      self.pe.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 getReturnOrderInfo_args:
   """
   Attributes:
    - id
   """
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.order_ids = []
-          (_etype1187, _size1184) = iprot.readListBegin()
+          (_etype1201, _size1198) = iprot.readListBegin()
-          for _i1188 in xrange(_size1184):
+          for _i1202 in xrange(_size1198):
-            _elem1189 = iprot.readI64();
+            _elem1203 = iprot.readI64();
-            self.order_ids.append(_elem1189)
+            self.order_ids.append(_elem1203)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getReturnOrderInfoList_args')
     if self.order_ids is not None:
       oprot.writeFieldBegin('order_ids', TType.LIST, 1)
       oprot.writeListBegin(TType.I64, len(self.order_ids))
-      for iter1190 in self.order_ids:
+      for iter1204 in self.order_ids:
-        oprot.writeI64(iter1190)
+        oprot.writeI64(iter1204)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.MAP:
           self.success = {}
-          (_ktype1192, _vtype1193, _size1191 ) = iprot.readMapBegin()
+          (_ktype1206, _vtype1207, _size1205 ) = iprot.readMapBegin()
-          for _i1195 in xrange(_size1191):
+          for _i1209 in xrange(_size1205):
-            _key1196 = iprot.readI64();
+            _key1210 = iprot.readI64();
-            _val1197 = []
+            _val1211 = []
-            (_etype1201, _size1198) = iprot.readListBegin()
+            (_etype1215, _size1212) = iprot.readListBegin()
-            for _i1202 in xrange(_size1198):
+            for _i1216 in xrange(_size1212):
-              _elem1203 = ReturnOrderInfo()
+              _elem1217 = ReturnOrderInfo()
-              _elem1203.read(iprot)
+              _elem1217.read(iprot)
-              _val1197.append(_elem1203)
+              _val1211.append(_elem1217)
             iprot.readListEnd()
-            self.success[_key1196] = _val1197
+            self.success[_key1210] = _val1211
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getReturnOrderInfoList_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.MAP, 0)
       oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
-      for kiter1204,viter1205 in self.success.items():
+      for kiter1218,viter1219 in self.success.items():
-        oprot.writeI64(kiter1204)
+        oprot.writeI64(kiter1218)
-        oprot.writeListBegin(TType.STRUCT, len(viter1205))
+        oprot.writeListBegin(TType.STRUCT, len(viter1219))
-        for iter1206 in viter1205:
+        for iter1220 in viter1219:
-          iter1206.write(oprot)
+          iter1220.write(oprot)
         oprot.writeListEnd()
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.order_ids = []
-          (_etype1210, _size1207) = iprot.readListBegin()
+          (_etype1224, _size1221) = iprot.readListBegin()
-          for _i1211 in xrange(_size1207):
+          for _i1225 in xrange(_size1221):
-            _elem1212 = iprot.readI64();
+            _elem1226 = iprot.readI64();
-            self.order_ids.append(_elem1212)
+            self.order_ids.append(_elem1226)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.LIST:
           self.statuses = []
-          (_etype1216, _size1213) = iprot.readListBegin()
+          (_etype1230, _size1227) = iprot.readListBegin()
-          for _i1217 in xrange(_size1213):
+          for _i1231 in xrange(_size1227):
-            _elem1218 = iprot.readString();
+            _elem1232 = iprot.readString();
-            self.statuses.append(_elem1218)
+            self.statuses.append(_elem1232)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getReturnOrderInfoListAsByStatus_args')
     if self.order_ids is not None:
       oprot.writeFieldBegin('order_ids', TType.LIST, 1)
       oprot.writeListBegin(TType.I64, len(self.order_ids))
-      for iter1219 in self.order_ids:
+      for iter1233 in self.order_ids:
-        oprot.writeI64(iter1219)
+        oprot.writeI64(iter1233)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.statuses is not None:
       oprot.writeFieldBegin('statuses', TType.LIST, 2)
       oprot.writeListBegin(TType.STRING, len(self.statuses))
-      for iter1220 in self.statuses:
+      for iter1234 in self.statuses:
-        oprot.writeString(iter1220)
+        oprot.writeString(iter1234)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.MAP:
           self.success = {}
-          (_ktype1222, _vtype1223, _size1221 ) = iprot.readMapBegin()
+          (_ktype1236, _vtype1237, _size1235 ) = iprot.readMapBegin()
-          for _i1225 in xrange(_size1221):
+          for _i1239 in xrange(_size1235):
-            _key1226 = iprot.readI64();
+            _key1240 = iprot.readI64();
-            _val1227 = []
+            _val1241 = []
-            (_etype1231, _size1228) = iprot.readListBegin()
+            (_etype1245, _size1242) = iprot.readListBegin()
-            for _i1232 in xrange(_size1228):
+            for _i1246 in xrange(_size1242):
-              _elem1233 = ReturnOrderInfo()
+              _elem1247 = ReturnOrderInfo()
-              _elem1233.read(iprot)
+              _elem1247.read(iprot)
-              _val1227.append(_elem1233)
+              _val1241.append(_elem1247)
             iprot.readListEnd()
-            self.success[_key1226] = _val1227
+            self.success[_key1240] = _val1241
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getReturnOrderInfoListAsByStatus_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.MAP, 0)
       oprot.writeMapBegin(TType.I64, TType.LIST, len(self.success))
-      for kiter1234,viter1235 in self.success.items():
+      for kiter1248,viter1249 in self.success.items():
-        oprot.writeI64(kiter1234)
+        oprot.writeI64(kiter1248)
-        oprot.writeListBegin(TType.STRUCT, len(viter1235))
+        oprot.writeListBegin(TType.STRUCT, len(viter1249))
-        for iter1236 in viter1235:
+        for iter1250 in viter1249:
-          iter1236.write(oprot)
+          iter1250.write(oprot)
         oprot.writeListEnd()
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.MAP:
           self.orderReturnInfosMap = {}
-          (_ktype1238, _vtype1239, _size1237 ) = iprot.readMapBegin()
+          (_ktype1252, _vtype1253, _size1251 ) = iprot.readMapBegin()
-          for _i1241 in xrange(_size1237):
+          for _i1255 in xrange(_size1251):
-            _key1242 = iprot.readI64();
+            _key1256 = iprot.readI64();
-            _val1243 = []
+            _val1257 = []
-            (_etype1247, _size1244) = iprot.readListBegin()
+            (_etype1261, _size1258) = iprot.readListBegin()
-            for _i1248 in xrange(_size1244):
+            for _i1262 in xrange(_size1258):
-              _elem1249 = ReturnOrderInfo()
+              _elem1263 = ReturnOrderInfo()
-              _elem1249.read(iprot)
+              _elem1263.read(iprot)
-              _val1243.append(_elem1249)
+              _val1257.append(_elem1263)
             iprot.readListEnd()
-            self.orderReturnInfosMap[_key1242] = _val1243
+            self.orderReturnInfosMap[_key1256] = _val1257
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('bulkUpdateReturnOrderInfo_args')
     if self.orderReturnInfosMap is not None:
       oprot.writeFieldBegin('orderReturnInfosMap', TType.MAP, 1)
       oprot.writeMapBegin(TType.I64, TType.LIST, len(self.orderReturnInfosMap))
-      for kiter1250,viter1251 in self.orderReturnInfosMap.items():
+      for kiter1264,viter1265 in self.orderReturnInfosMap.items():
-        oprot.writeI64(kiter1250)
+        oprot.writeI64(kiter1264)
-        oprot.writeListBegin(TType.STRUCT, len(viter1251))
+        oprot.writeListBegin(TType.STRUCT, len(viter1265))
-        for iter1252 in viter1251:
+        for iter1266 in viter1265:
-          iter1252.write(oprot)
+          iter1266.write(oprot)
         oprot.writeListEnd()
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.MAP:
           self.success = {}
-          (_ktype1254, _vtype1255, _size1253 ) = iprot.readMapBegin()
+          (_ktype1268, _vtype1269, _size1267 ) = iprot.readMapBegin()
-          for _i1257 in xrange(_size1253):
+          for _i1271 in xrange(_size1267):
-            _key1258 = iprot.readI64();
+            _key1272 = iprot.readI64();
-            _val1259 = iprot.readBool();
+            _val1273 = iprot.readBool();
-            self.success[_key1258] = _val1259
+            self.success[_key1272] = _val1273
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('bulkUpdateReturnOrderInfo_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.MAP, 0)
       oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.success))
-      for kiter1260,viter1261 in self.success.items():
+      for kiter1274,viter1275 in self.success.items():
-        oprot.writeI64(kiter1260)
+        oprot.writeI64(kiter1274)
-        oprot.writeBool(viter1261)
+        oprot.writeBool(viter1275)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype1265, _size1262) = iprot.readListBegin()
+          (_etype1279, _size1276) = iprot.readListBegin()
-          for _i1266 in xrange(_size1262):
+          for _i1280 in xrange(_size1276):
-            _elem1267 = ReturnOrderInfo()
+            _elem1281 = ReturnOrderInfo()
-            _elem1267.read(iprot)
+            _elem1281.read(iprot)
-            self.success.append(_elem1267)
+            self.success.append(_elem1281)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       return
     oprot.writeStructBegin('getReturnOrdersAsPerWarehouseId_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter1268 in self.success:
+      for iter1282 in self.success:
-        iter1268.write(oprot)
+        iter1282.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype1272, _size1269) = iprot.readListBegin()
+          (_etype1286, _size1283) = iprot.readListBegin()
-          for _i1273 in xrange(_size1269):
+          for _i1287 in xrange(_size1283):
-            _elem1274 = ReturnOrderInfo()
+            _elem1288 = ReturnOrderInfo()
-            _elem1274.read(iprot)
+            _elem1288.read(iprot)
-            self.success.append(_elem1274)
+            self.success.append(_elem1288)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getReturnOrdersForReturnTransaction_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter1275 in self.success:
+      for iter1289 in self.success:
-        iter1275.write(oprot)
+        iter1289.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
         else:
           iprot.skip(ftype)
       elif fid == 3:
         if ftype == TType.LIST:
           self.returnOrderIds = []
-          (_etype1279, _size1276) = iprot.readListBegin()
+          (_etype1293, _size1290) = iprot.readListBegin()
-          for _i1280 in xrange(_size1276):
+          for _i1294 in xrange(_size1290):
-            _elem1281 = iprot.readI64();
+            _elem1295 = iprot.readI64();
-            self.returnOrderIds.append(_elem1281)
+            self.returnOrderIds.append(_elem1295)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       oprot.writeI32(self.status)
       oprot.writeFieldEnd()
     if self.returnOrderIds is not None:
       oprot.writeFieldBegin('returnOrderIds', TType.LIST, 3)
       oprot.writeListBegin(TType.I64, len(self.returnOrderIds))
-      for iter1282 in self.returnOrderIds:
+      for iter1296 in self.returnOrderIds:
-        oprot.writeI64(iter1282)
+        oprot.writeI64(iter1296)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.returnOrderIds = []
-          (_etype1286, _size1283) = iprot.readListBegin()
+          (_etype1300, _size1297) = iprot.readListBegin()
-          for _i1287 in xrange(_size1283):
+          for _i1301 in xrange(_size1297):
-            _elem1288 = iprot.readI64();
+            _elem1302 = iprot.readI64();
-            self.returnOrderIds.append(_elem1288)
+            self.returnOrderIds.append(_elem1302)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.I64:
       return
     oprot.writeStructBegin('createReturnPickupRequest_args')
     if self.returnOrderIds is not None:
       oprot.writeFieldBegin('returnOrderIds', TType.LIST, 1)
       oprot.writeListBegin(TType.I64, len(self.returnOrderIds))
-      for iter1289 in self.returnOrderIds:
+      for iter1303 in self.returnOrderIds:
-        oprot.writeI64(iter1289)
+        oprot.writeI64(iter1303)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.providerId is not None:
       oprot.writeFieldBegin('providerId', TType.I64, 2)
       oprot.writeI64(self.providerId)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype1293, _size1290) = iprot.readListBegin()
+          (_etype1307, _size1304) = iprot.readListBegin()
-          for _i1294 in xrange(_size1290):
+          for _i1308 in xrange(_size1304):
-            _elem1295 = ReturnOrderInfo()
+            _elem1309 = ReturnOrderInfo()
-            _elem1295.read(iprot)
+            _elem1309.read(iprot)
-            self.success.append(_elem1295)
+            self.success.append(_elem1309)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getAllReturnOrdersForReturnPickupRequest_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter1296 in self.success:
+      for iter1310 in self.success:
-        iter1296.write(oprot)
+        iter1310.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.MAP:
           self.returnOrdersMap = {}
-          (_ktype1298, _vtype1299, _size1297 ) = iprot.readMapBegin()
+          (_ktype1312, _vtype1313, _size1311 ) = iprot.readMapBegin()
-          for _i1301 in xrange(_size1297):
+          for _i1315 in xrange(_size1311):
-            _key1302 = iprot.readI64();
+            _key1316 = iprot.readI64();
-            _val1303 = {}
+            _val1317 = {}
-            (_ktype1305, _vtype1306, _size1304 ) = iprot.readMapBegin()
+            (_ktype1319, _vtype1320, _size1318 ) = iprot.readMapBegin()
-            for _i1308 in xrange(_size1304):
+            for _i1322 in xrange(_size1318):
-              _key1309 = iprot.readString();
+              _key1323 = iprot.readString();
-              _val1310 = iprot.readString();
+              _val1324 = iprot.readString();
-              _val1303[_key1309] = _val1310
+              _val1317[_key1323] = _val1324
             iprot.readMapEnd()
-            self.returnOrdersMap[_key1302] = _val1303
+            self.returnOrdersMap[_key1316] = _val1317
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.I64:
       return
     oprot.writeStructBegin('receiveReturnPickup_args')
     if self.returnOrdersMap is not None:
       oprot.writeFieldBegin('returnOrdersMap', TType.MAP, 1)
       oprot.writeMapBegin(TType.I64, TType.MAP, len(self.returnOrdersMap))
-      for kiter1311,viter1312 in self.returnOrdersMap.items():
+      for kiter1325,viter1326 in self.returnOrdersMap.items():
-        oprot.writeI64(kiter1311)
+        oprot.writeI64(kiter1325)
-        oprot.writeMapBegin(TType.STRING, TType.STRING, len(viter1312))
+        oprot.writeMapBegin(TType.STRING, TType.STRING, len(viter1326))
-        for kiter1313,viter1314 in viter1312.items():
+        for kiter1327,viter1328 in viter1326.items():
-          oprot.writeString(kiter1313)
+          oprot.writeString(kiter1327)
-          oprot.writeString(viter1314)
+          oprot.writeString(viter1328)
         oprot.writeMapEnd()
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     if self.id is not None:
       oprot.writeFieldBegin('id', TType.I64, 2)
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.MAP:
           self.returnOrdersMap = {}
-          (_ktype1316, _vtype1317, _size1315 ) = iprot.readMapBegin()
+          (_ktype1330, _vtype1331, _size1329 ) = iprot.readMapBegin()
-          for _i1319 in xrange(_size1315):
+          for _i1333 in xrange(_size1329):
-            _key1320 = iprot.readI64();
+            _key1334 = iprot.readI64();
-            _val1321 = iprot.readBool();
+            _val1335 = iprot.readBool();
-            self.returnOrdersMap[_key1320] = _val1321
+            self.returnOrdersMap[_key1334] = _val1335
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       oprot.writeI64(self.returnPickupId)
       oprot.writeFieldEnd()
     if self.returnOrdersMap is not None:
       oprot.writeFieldBegin('returnOrdersMap', TType.MAP, 2)
       oprot.writeMapBegin(TType.I64, TType.BOOL, len(self.returnOrdersMap))
-      for kiter1322,viter1323 in self.returnOrdersMap.items():
+      for kiter1336,viter1337 in self.returnOrdersMap.items():
-        oprot.writeI64(kiter1322)
+        oprot.writeI64(kiter1336)
-        oprot.writeBool(viter1323)
+        oprot.writeBool(viter1337)
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.MAP:
           self.returnOrdersMap = {}
-          (_ktype1325, _vtype1326, _size1324 ) = iprot.readMapBegin()
+          (_ktype1339, _vtype1340, _size1338 ) = iprot.readMapBegin()
-          for _i1328 in xrange(_size1324):
+          for _i1342 in xrange(_size1338):
-            _key1329 = iprot.readI64();
+            _key1343 = iprot.readI64();
-            _val1330 = {}
+            _val1344 = {}
-            (_ktype1332, _vtype1333, _size1331 ) = iprot.readMapBegin()
+            (_ktype1346, _vtype1347, _size1345 ) = iprot.readMapBegin()
-            for _i1335 in xrange(_size1331):
+            for _i1349 in xrange(_size1345):
-              _key1336 = iprot.readString();
+              _key1350 = iprot.readString();
-              _val1337 = iprot.readString();
+              _val1351 = iprot.readString();
-              _val1330[_key1336] = _val1337
+              _val1344[_key1350] = _val1351
             iprot.readMapEnd()
-            self.returnOrdersMap[_key1329] = _val1330
+            self.returnOrdersMap[_key1343] = _val1344
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       else:
         iprot.skip(ftype)
       oprot.writeI64(self.returnPickupId)
       oprot.writeFieldEnd()
     if self.returnOrdersMap is not None:
       oprot.writeFieldBegin('returnOrdersMap', TType.MAP, 2)
       oprot.writeMapBegin(TType.I64, TType.MAP, len(self.returnOrdersMap))
-      for kiter1338,viter1339 in self.returnOrdersMap.items():
+      for kiter1352,viter1353 in self.returnOrdersMap.items():
-        oprot.writeI64(kiter1338)
+        oprot.writeI64(kiter1352)
-        oprot.writeMapBegin(TType.STRING, TType.STRING, len(viter1339))
+        oprot.writeMapBegin(TType.STRING, TType.STRING, len(viter1353))
-        for kiter1340,viter1341 in viter1339.items():
+        for kiter1354,viter1355 in viter1353.items():
-          oprot.writeString(kiter1340)
+          oprot.writeString(kiter1354)
-          oprot.writeString(viter1341)
+          oprot.writeString(viter1355)
         oprot.writeMapEnd()
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     oprot.writeFieldStop()
     oprot.writeStructEnd()
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.MAP:
           self.refundOrdersMap = {}
-          (_ktype1343, _vtype1344, _size1342 ) = iprot.readMapBegin()
+          (_ktype1357, _vtype1358, _size1356 ) = iprot.readMapBegin()
-          for _i1346 in xrange(_size1342):
+          for _i1360 in xrange(_size1356):
-            _key1347 = iprot.readI64();
+            _key1361 = iprot.readI64();
-            _val1348 = {}
+            _val1362 = {}
-            (_ktype1350, _vtype1351, _size1349 ) = iprot.readMapBegin()
+            (_ktype1364, _vtype1365, _size1363 ) = iprot.readMapBegin()
-            for _i1353 in xrange(_size1349):
+            for _i1367 in xrange(_size1363):
-              _key1354 = iprot.readString();
+              _key1368 = iprot.readString();
-              _val1355 = iprot.readString();
+              _val1369 = iprot.readString();
-              _val1348[_key1354] = _val1355
+              _val1362[_key1368] = _val1369
             iprot.readMapEnd()
-            self.refundOrdersMap[_key1347] = _val1348
+            self.refundOrdersMap[_key1361] = _val1362
           iprot.readMapEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.I64:
       return
     oprot.writeStructBegin('refundReturnTransactionPayment_args')
     if self.refundOrdersMap is not None:
       oprot.writeFieldBegin('refundOrdersMap', TType.MAP, 1)
       oprot.writeMapBegin(TType.I64, TType.MAP, len(self.refundOrdersMap))
-      for kiter1356,viter1357 in self.refundOrdersMap.items():
+      for kiter1370,viter1371 in self.refundOrdersMap.items():
-        oprot.writeI64(kiter1356)
+        oprot.writeI64(kiter1370)
-        oprot.writeMapBegin(TType.STRING, TType.STRING, len(viter1357))
+        oprot.writeMapBegin(TType.STRING, TType.STRING, len(viter1371))
-        for kiter1358,viter1359 in viter1357.items():
+        for kiter1372,viter1373 in viter1371.items():
-          oprot.writeString(kiter1358)
+          oprot.writeString(kiter1372)
-          oprot.writeString(viter1359)
+          oprot.writeString(viter1373)
         oprot.writeMapEnd()
       oprot.writeMapEnd()
       oprot.writeFieldEnd()
     if self.returntransactionId is not None:
       oprot.writeFieldBegin('returntransactionId', TType.I64, 2)
       if ftype == TType.STOP:
         break
       if fid == 1:
         if ftype == TType.LIST:
           self.statusList = []
-          (_etype1363, _size1360) = iprot.readListBegin()
+          (_etype1377, _size1374) = iprot.readListBegin()
-          for _i1364 in xrange(_size1360):
+          for _i1378 in xrange(_size1374):
-            _elem1365 = iprot.readI32();
+            _elem1379 = iprot.readI32();
-            self.statusList.append(_elem1365)
+            self.statusList.append(_elem1379)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 2:
         if ftype == TType.STRING:
       return
     oprot.writeStructBegin('getReturnTransactionsForCustomer_args')
     if self.statusList is not None:
       oprot.writeFieldBegin('statusList', TType.LIST, 1)
       oprot.writeListBegin(TType.I32, len(self.statusList))
-      for iter1366 in self.statusList:
+      for iter1380 in self.statusList:
-        oprot.writeI32(iter1366)
+        oprot.writeI32(iter1380)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.customerMobile is not None:
       oprot.writeFieldBegin('customerMobile', TType.STRING, 2)
       oprot.writeString(self.customerMobile)
       if ftype == TType.STOP:
         break
       if fid == 0:
         if ftype == TType.LIST:
           self.success = []
-          (_etype1370, _size1367) = iprot.readListBegin()
+          (_etype1384, _size1381) = iprot.readListBegin()
-          for _i1371 in xrange(_size1367):
+          for _i1385 in xrange(_size1381):
-            _elem1372 = ReturnTransaction()
+            _elem1386 = ReturnTransaction()
-            _elem1372.read(iprot)
+            _elem1386.read(iprot)
-            self.success.append(_elem1372)
+            self.success.append(_elem1386)
           iprot.readListEnd()
         else:
           iprot.skip(ftype)
       elif fid == 1:
         if ftype == TType.STRUCT:
       return
     oprot.writeStructBegin('getReturnTransactionsForCustomer_result')
     if self.success is not None:
       oprot.writeFieldBegin('success', TType.LIST, 0)
       oprot.writeListBegin(TType.STRUCT, len(self.success))
-      for iter1373 in self.success:
+      for iter1387 in self.success:
-        iter1373.write(oprot)
+        iter1387.write(oprot)
       oprot.writeListEnd()
       oprot.writeFieldEnd()
     if self.ex is not None:
       oprot.writeFieldBegin('ex', TType.STRUCT, 1)
       self.ex.write(oprot)

Subversion Repositories SmartDukaan

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