Subversion Repositories SmartDukaan

Rev

Rev 18577 | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 18577 Rev 18578
Line 274... Line 274...
274 
     - amount
 274 
     - amount
275 
     - isDigital
 275 
     - isDigital
276 
    """
 276 
    """
277 
    pass
 277 
    pass
278 
 
 278 
 
279 
  def getCreditorInfo(self, id, name):
 - 
 
280 
    """
 - 
 
281 
    Parameters:
 - 
 
282 
     - id
 - 
 
283 
     - name
 - 
 
284 
    """
 - 
 
285 
    pass
 - 
 
286 
 
 - 
 
287 
  def updateCreditorInfo(self, creditor):
 - 
 
288 
    """
 - 
 
289 
    Parameters:
 - 
 
290 
     - creditor
 - 
 
291 
    """
 - 
 
292 
    pass
 - 
 
293 
 
 - 
 
294 
  def getUserSanctionDetails(self, userId):
 - 
 
295 
    """
 - 
 
296 
    Parameters:
 - 
 
297 
     - userId
 - 
 
298 
    """
 - 
 
299 
    pass
 - 
 
300 
 
 - 
 
301 
  def getUserSanctionDetailsForCreditor(self, userId, creditorId):
 - 
 
302 
    """
 - 
 
303 
    Parameters:
 - 
 
304 
     - userId
 - 
 
305 
     - creditorId
 - 
 
306 
    """
 - 
 
307 
    pass
 - 
 
308 
 
 - 
 
309 
  def updateUserSanction(self, userSanaction):
 - 
 
310 
    """
 - 
 
311 
    Parameters:
 - 
 
312 
     - userSanaction
 - 
 
313 
    """
 - 
 
314 
    pass
 - 
 
315 
 
 - 
 
316 
  def getCreditHistoryRecordsForTransaction(self, paymentId, creditorId, creditTxnType):
 - 
 
317 
    """
 - 
 
318 
    Parameters:
 - 
 
319 
     - paymentId
 - 
 
320 
     - creditorId
 - 
 
321 
     - creditTxnType
 - 
 
322 
    """
 - 
 
323 
    pass
 - 
 
324 
 
 - 
 
325 
  def getCreditHistoryRecordsForUserAndCreditor(self, userId, creditTxnType):
 - 
 
326 
    """
 - 
 
327 
    Parameters:
 - 
 
328 
     - userId
 - 
 
329 
     - creditTxnType
 - 
 
330 
    """
 - 
 
331 
    pass
 - 
 
332 
 
 - 
 
333 
  def processCreditTransaction(self, paymentId, creditTxns):
 - 
 
334 
    """
 - 
 
335 
    Parameters:
 - 
 
336 
     - paymentId
 - 
 
337 
     - creditTxns
 - 
 
338 
    """
 - 
 
339 
    pass
 - 
 
340 
 
 - 
 
341 
  def getLoanPayableForUserToCreditor(self, userId, creditorId, dueDate):
 - 
 
342 
    """
 - 
 
343 
    Parameters:
 - 
 
344 
     - userId
 - 
 
345 
     - creditorId
 - 
 
346 
     - dueDate
 - 
 
347 
    """
 - 
 
348 
    pass
 - 
 
349 
 
 - 
 
350 
 
 279 
 
351 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
 280 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
352 
  def __init__(self, iprot, oprot=None):
 281 
  def __init__(self, iprot, oprot=None):
353 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
 282 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
354 
 
 283 
 
Line 1190... Line 1119...
1190 
      return result.success
 1119 
      return result.success
1191 
    if result.pe is not None:
 1120 
    if result.pe is not None:
1192 
      raise result.pe
 1121 
      raise result.pe
1193 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPaymentStatusAtGateway failed: unknown result");
 1122 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getPaymentStatusAtGateway failed: unknown result");
1194 
 
 1123 
 
1195 
  def getCreditorInfo(self, id, name):
 - 
 
1196 
    """
 - 
 
1197 
    Parameters:
 - 
 
1198 
     - id
 - 
 
1199 
     - name
 - 
 
1200 
    """
 - 
 
1201 
    self.send_getCreditorInfo(id, name)
 - 
 
1202 
    return self.recv_getCreditorInfo()
 - 
 
1203 
 
 - 
 
1204 
  def send_getCreditorInfo(self, id, name):
 - 
 
1205 
    self._oprot.writeMessageBegin('getCreditorInfo', TMessageType.CALL, self._seqid)
 - 
 
1206 
    args = getCreditorInfo_args()
 - 
 
1207 
    args.id = id
 - 
 
1208 
    args.name = name
 - 
 
1209 
    args.write(self._oprot)
 - 
 
1210 
    self._oprot.writeMessageEnd()
 - 
 
1211 
    self._oprot.trans.flush()
 - 
 
1212 
 
 - 
 
1213 
  def recv_getCreditorInfo(self, ):
 - 
 
1214 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
 - 
 
1215 
    if mtype == TMessageType.EXCEPTION:
 - 
 
1216 
      x = TApplicationException()
 - 
 
1217 
      x.read(self._iprot)
 - 
 
1218 
      self._iprot.readMessageEnd()
 - 
 
1219 
      raise x
 - 
 
1220 
    result = getCreditorInfo_result()
 - 
 
1221 
    result.read(self._iprot)
 - 
 
1222 
    self._iprot.readMessageEnd()
 - 
 
1223 
    if result.success is not None:
 - 
 
1224 
      return result.success
 - 
 
1225 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCreditorInfo failed: unknown result");
 - 
 
1226 
 
 - 
 
1227 
  def updateCreditorInfo(self, creditor):
 - 
 
1228 
    """
 - 
 
1229 
    Parameters:
 - 
 
1230 
     - creditor
 - 
 
1231 
    """
 - 
 
1232 
    self.send_updateCreditorInfo(creditor)
 - 
 
1233 
    return self.recv_updateCreditorInfo()
 - 
 
1234 
 
 - 
 
1235 
  def send_updateCreditorInfo(self, creditor):
 - 
 
1236 
    self._oprot.writeMessageBegin('updateCreditorInfo', TMessageType.CALL, self._seqid)
 - 
 
1237 
    args = updateCreditorInfo_args()
 - 
 
1238 
    args.creditor = creditor
 - 
 
1239 
    args.write(self._oprot)
 - 
 
1240 
    self._oprot.writeMessageEnd()
 - 
 
1241 
    self._oprot.trans.flush()
 - 
 
1242 
 
 - 
 
1243 
  def recv_updateCreditorInfo(self, ):
 - 
 
1244 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
 - 
 
1245 
    if mtype == TMessageType.EXCEPTION:
 - 
 
1246 
      x = TApplicationException()
 - 
 
1247 
      x.read(self._iprot)
 - 
 
1248 
      self._iprot.readMessageEnd()
 - 
 
1249 
      raise x
 - 
 
1250 
    result = updateCreditorInfo_result()
 - 
 
1251 
    result.read(self._iprot)
 - 
 
1252 
    self._iprot.readMessageEnd()
 - 
 
1253 
    if result.success is not None:
 - 
 
1254 
      return result.success
 - 
 
1255 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateCreditorInfo failed: unknown result");
 - 
 
1256 
 
 - 
 
1257 
  def getUserSanctionDetails(self, userId):
 - 
 
1258 
    """
 - 
 
1259 
    Parameters:
 - 
 
1260 
     - userId
 - 
 
1261 
    """
 - 
 
1262 
    self.send_getUserSanctionDetails(userId)
 - 
 
1263 
    return self.recv_getUserSanctionDetails()
 - 
 
1264 
 
 - 
 
1265 
  def send_getUserSanctionDetails(self, userId):
 - 
 
1266 
    self._oprot.writeMessageBegin('getUserSanctionDetails', TMessageType.CALL, self._seqid)
 - 
 
1267 
    args = getUserSanctionDetails_args()
 - 
 
1268 
    args.userId = userId
 - 
 
1269 
    args.write(self._oprot)
 - 
 
1270 
    self._oprot.writeMessageEnd()
 - 
 
1271 
    self._oprot.trans.flush()
 - 
 
1272 
 
 - 
 
1273 
  def recv_getUserSanctionDetails(self, ):
 - 
 
1274 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
 - 
 
1275 
    if mtype == TMessageType.EXCEPTION:
 - 
 
1276 
      x = TApplicationException()
 - 
 
1277 
      x.read(self._iprot)
 - 
 
1278 
      self._iprot.readMessageEnd()
 - 
 
1279 
      raise x
 - 
 
1280 
    result = getUserSanctionDetails_result()
 - 
 
1281 
    result.read(self._iprot)
 - 
 
1282 
    self._iprot.readMessageEnd()
 - 
 
1283 
    if result.success is not None:
 - 
 
1284 
      return result.success
 - 
 
1285 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserSanctionDetails failed: unknown result");
 - 
 
1286 
 
 - 
 
1287 
  def getUserSanctionDetailsForCreditor(self, userId, creditorId):
 - 
 
1288 
    """
 - 
 
1289 
    Parameters:
 - 
 
1290 
     - userId
 - 
 
1291 
     - creditorId
 - 
 
1292 
    """
 - 
 
1293 
    self.send_getUserSanctionDetailsForCreditor(userId, creditorId)
 - 
 
1294 
    return self.recv_getUserSanctionDetailsForCreditor()
 - 
 
1295 
 
 - 
 
1296 
  def send_getUserSanctionDetailsForCreditor(self, userId, creditorId):
 - 
 
1297 
    self._oprot.writeMessageBegin('getUserSanctionDetailsForCreditor', TMessageType.CALL, self._seqid)
 - 
 
1298 
    args = getUserSanctionDetailsForCreditor_args()
 - 
 
1299 
    args.userId = userId
 - 
 
1300 
    args.creditorId = creditorId
 - 
 
1301 
    args.write(self._oprot)
 - 
 
1302 
    self._oprot.writeMessageEnd()
 - 
 
1303 
    self._oprot.trans.flush()
 - 
 
1304 
 
 - 
 
1305 
  def recv_getUserSanctionDetailsForCreditor(self, ):
 - 
 
1306 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
 - 
 
1307 
    if mtype == TMessageType.EXCEPTION:
 - 
 
1308 
      x = TApplicationException()
 - 
 
1309 
      x.read(self._iprot)
 - 
 
1310 
      self._iprot.readMessageEnd()
 - 
 
1311 
      raise x
 - 
 
1312 
    result = getUserSanctionDetailsForCreditor_result()
 - 
 
1313 
    result.read(self._iprot)
 - 
 
1314 
    self._iprot.readMessageEnd()
 - 
 
1315 
    if result.success is not None:
 - 
 
1316 
      return result.success
 - 
 
1317 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserSanctionDetailsForCreditor failed: unknown result");
 - 
 
1318 
 
 - 
 
1319 
  def updateUserSanction(self, userSanaction):
 - 
 
1320 
    """
 - 
 
1321 
    Parameters:
 - 
 
1322 
     - userSanaction
 - 
 
1323 
    """
 - 
 
1324 
    self.send_updateUserSanction(userSanaction)
 - 
 
1325 
    return self.recv_updateUserSanction()
 - 
 
1326 
 
 - 
 
1327 
  def send_updateUserSanction(self, userSanaction):
 - 
 
1328 
    self._oprot.writeMessageBegin('updateUserSanction', TMessageType.CALL, self._seqid)
 - 
 
1329 
    args = updateUserSanction_args()
 - 
 
1330 
    args.userSanaction = userSanaction
 - 
 
1331 
    args.write(self._oprot)
 - 
 
1332 
    self._oprot.writeMessageEnd()
 - 
 
1333 
    self._oprot.trans.flush()
 - 
 
1334 
 
 - 
 
1335 
  def recv_updateUserSanction(self, ):
 - 
 
1336 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
 - 
 
1337 
    if mtype == TMessageType.EXCEPTION:
 - 
 
1338 
      x = TApplicationException()
 - 
 
1339 
      x.read(self._iprot)
 - 
 
1340 
      self._iprot.readMessageEnd()
 - 
 
1341 
      raise x
 - 
 
1342 
    result = updateUserSanction_result()
 - 
 
1343 
    result.read(self._iprot)
 - 
 
1344 
    self._iprot.readMessageEnd()
 - 
 
1345 
    if result.success is not None:
 - 
 
1346 
      return result.success
 - 
 
1347 
    if result.pe is not None:
 - 
 
1348 
      raise result.pe
 - 
 
1349 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUserSanction failed: unknown result");
 - 
 
1350 
 
 - 
 
1351 
  def getCreditHistoryRecordsForTransaction(self, paymentId, creditorId, creditTxnType):
 - 
 
1352 
    """
 - 
 
1353 
    Parameters:
 - 
 
1354 
     - paymentId
 - 
 
1355 
     - creditorId
 - 
 
1356 
     - creditTxnType
 - 
 
1357 
    """
 - 
 
1358 
    self.send_getCreditHistoryRecordsForTransaction(paymentId, creditorId, creditTxnType)
 - 
 
1359 
    return self.recv_getCreditHistoryRecordsForTransaction()
 - 
 
1360 
 
 - 
 
1361 
  def send_getCreditHistoryRecordsForTransaction(self, paymentId, creditorId, creditTxnType):
 - 
 
1362 
    self._oprot.writeMessageBegin('getCreditHistoryRecordsForTransaction', TMessageType.CALL, self._seqid)
 - 
 
1363 
    args = getCreditHistoryRecordsForTransaction_args()
 - 
 
1364 
    args.paymentId = paymentId
 - 
 
1365 
    args.creditorId = creditorId
 - 
 
1366 
    args.creditTxnType = creditTxnType
 - 
 
1367 
    args.write(self._oprot)
 - 
 
1368 
    self._oprot.writeMessageEnd()
 - 
 
1369 
    self._oprot.trans.flush()
 - 
 
1370 
 
 - 
 
1371 
  def recv_getCreditHistoryRecordsForTransaction(self, ):
 - 
 
1372 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
 - 
 
1373 
    if mtype == TMessageType.EXCEPTION:
 - 
 
1374 
      x = TApplicationException()
 - 
 
1375 
      x.read(self._iprot)
 - 
 
1376 
      self._iprot.readMessageEnd()
 - 
 
1377 
      raise x
 - 
 
1378 
    result = getCreditHistoryRecordsForTransaction_result()
 - 
 
1379 
    result.read(self._iprot)
 - 
 
1380 
    self._iprot.readMessageEnd()
 - 
 
1381 
    if result.success is not None:
 - 
 
1382 
      return result.success
 - 
 
1383 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCreditHistoryRecordsForTransaction failed: unknown result");
 - 
 
1384 
 
 - 
 
1385 
  def getCreditHistoryRecordsForUserAndCreditor(self, userId, creditTxnType):
 - 
 
1386 
    """
 - 
 
1387 
    Parameters:
 - 
 
1388 
     - userId
 - 
 
1389 
     - creditTxnType
 - 
 
1390 
    """
 - 
 
1391 
    self.send_getCreditHistoryRecordsForUserAndCreditor(userId, creditTxnType)
 - 
 
1392 
    return self.recv_getCreditHistoryRecordsForUserAndCreditor()
 - 
 
1393 
 
 - 
 
1394 
  def send_getCreditHistoryRecordsForUserAndCreditor(self, userId, creditTxnType):
 - 
 
1395 
    self._oprot.writeMessageBegin('getCreditHistoryRecordsForUserAndCreditor', TMessageType.CALL, self._seqid)
 - 
 
1396 
    args = getCreditHistoryRecordsForUserAndCreditor_args()
 - 
 
1397 
    args.userId = userId
 - 
 
1398 
    args.creditTxnType = creditTxnType
 - 
 
1399 
    args.write(self._oprot)
 - 
 
1400 
    self._oprot.writeMessageEnd()
 - 
 
1401 
    self._oprot.trans.flush()
 - 
 
1402 
 
 - 
 
1403 
  def recv_getCreditHistoryRecordsForUserAndCreditor(self, ):
 - 
 
1404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
 - 
 
1405 
    if mtype == TMessageType.EXCEPTION:
 - 
 
1406 
      x = TApplicationException()
 - 
 
1407 
      x.read(self._iprot)
 - 
 
1408 
      self._iprot.readMessageEnd()
 - 
 
1409 
      raise x
 - 
 
1410 
    result = getCreditHistoryRecordsForUserAndCreditor_result()
 - 
 
1411 
    result.read(self._iprot)
 - 
 
1412 
    self._iprot.readMessageEnd()
 - 
 
1413 
    if result.success is not None:
 - 
 
1414 
      return result.success
 - 
 
1415 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCreditHistoryRecordsForUserAndCreditor failed: unknown result");
 - 
 
1416 
 
 - 
 
1417 
  def processCreditTransaction(self, paymentId, creditTxns):
 - 
 
1418 
    """
 - 
 
1419 
    Parameters:
 - 
 
1420 
     - paymentId
 - 
 
1421 
     - creditTxns
 - 
 
1422 
    """
 - 
 
1423 
    self.send_processCreditTransaction(paymentId, creditTxns)
 - 
 
1424 
    return self.recv_processCreditTransaction()
 - 
 
1425 
 
 - 
 
1426 
  def send_processCreditTransaction(self, paymentId, creditTxns):
 - 
 
1427 
    self._oprot.writeMessageBegin('processCreditTransaction', TMessageType.CALL, self._seqid)
 - 
 
1428 
    args = processCreditTransaction_args()
 - 
 
1429 
    args.paymentId = paymentId
 - 
 
1430 
    args.creditTxns = creditTxns
 - 
 
1431 
    args.write(self._oprot)
 - 
 
1432 
    self._oprot.writeMessageEnd()
 - 
 
1433 
    self._oprot.trans.flush()
 - 
 
1434 
 
 - 
 
1435 
  def recv_processCreditTransaction(self, ):
 - 
 
1436 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
 - 
 
1437 
    if mtype == TMessageType.EXCEPTION:
 - 
 
1438 
      x = TApplicationException()
 - 
 
1439 
      x.read(self._iprot)
 - 
 
1440 
      self._iprot.readMessageEnd()
 - 
 
1441 
      raise x
 - 
 
1442 
    result = processCreditTransaction_result()
 - 
 
1443 
    result.read(self._iprot)
 - 
 
1444 
    self._iprot.readMessageEnd()
 - 
 
1445 
    if result.success is not None:
 - 
 
1446 
      return result.success
 - 
 
1447 
    if result.pe is not None:
 - 
 
1448 
      raise result.pe
 - 
 
1449 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "processCreditTransaction failed: unknown result");
 - 
 
1450 
 
 - 
 
1451 
  def getLoanPayableForUserToCreditor(self, userId, creditorId, dueDate):
 - 
 
1452 
    """
 - 
 
1453 
    Parameters:
 - 
 
1454 
     - userId
 - 
 
1455 
     - creditorId
 - 
 
1456 
     - dueDate
 - 
 
1457 
    """
 - 
 
1458 
    self.send_getLoanPayableForUserToCreditor(userId, creditorId, dueDate)
 - 
 
1459 
    return self.recv_getLoanPayableForUserToCreditor()
 - 
 
1460 
 
 - 
 
1461 
  def send_getLoanPayableForUserToCreditor(self, userId, creditorId, dueDate):
 - 
 
1462 
    self._oprot.writeMessageBegin('getLoanPayableForUserToCreditor', TMessageType.CALL, self._seqid)
 - 
 
1463 
    args = getLoanPayableForUserToCreditor_args()
 - 
 
1464 
    args.userId = userId
 - 
 
1465 
    args.creditorId = creditorId
 - 
 
1466 
    args.dueDate = dueDate
 - 
 
1467 
    args.write(self._oprot)
 - 
 
1468 
    self._oprot.writeMessageEnd()
 - 
 
1469 
    self._oprot.trans.flush()
 - 
 
1470 
 
 - 
 
1471 
  def recv_getLoanPayableForUserToCreditor(self, ):
 - 
 
1472 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
 - 
 
1473 
    if mtype == TMessageType.EXCEPTION:
 - 
 
1474 
      x = TApplicationException()
 - 
 
1475 
      x.read(self._iprot)
 - 
 
1476 
      self._iprot.readMessageEnd()
 - 
 
1477 
      raise x
 - 
 
1478 
    result = getLoanPayableForUserToCreditor_result()
 - 
 
1479 
    result.read(self._iprot)
 - 
 
1480 
    self._iprot.readMessageEnd()
 - 
 
1481 
    if result.success is not None:
 - 
 
1482 
      return result.success
 - 
 
1483 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getLoanPayableForUserToCreditor failed: unknown result");
 - 
 
1484 
 
 - 
 
1485 
 
 1124 
 
1486 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
 1125 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
1487 
  def __init__(self, handler):
 1126 
  def __init__(self, handler):
1488 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
 1127 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
1489 
    self._processMap["createPayment"] = Processor.process_createPayment
 1128 
    self._processMap["createPayment"] = Processor.process_createPayment
Line 1506... Line 1145...
1506 
    self._processMap["refundPayment"] = Processor.process_refundPayment
 1145 
    self._processMap["refundPayment"] = Processor.process_refundPayment
1507 
    self._processMap["partiallyCapturePayment"] = Processor.process_partiallyCapturePayment
 1146 
    self._processMap["partiallyCapturePayment"] = Processor.process_partiallyCapturePayment
1508 
    self._processMap["getPaymentsRequiringExtraProcessing"] = Processor.process_getPaymentsRequiringExtraProcessing
 1147 
    self._processMap["getPaymentsRequiringExtraProcessing"] = Processor.process_getPaymentsRequiringExtraProcessing
1509 
    self._processMap["markPaymentAsProcessed"] = Processor.process_markPaymentAsProcessed
 1148 
    self._processMap["markPaymentAsProcessed"] = Processor.process_markPaymentAsProcessed
1510 
    self._processMap["getPaymentStatusAtGateway"] = Processor.process_getPaymentStatusAtGateway
 1149 
    self._processMap["getPaymentStatusAtGateway"] = Processor.process_getPaymentStatusAtGateway
1511 
    self._processMap["getCreditorInfo"] = Processor.process_getCreditorInfo
 - 
 
1512 
    self._processMap["updateCreditorInfo"] = Processor.process_updateCreditorInfo
 - 
 
1513 
    self._processMap["getUserSanctionDetails"] = Processor.process_getUserSanctionDetails
 - 
 
1514 
    self._processMap["getUserSanctionDetailsForCreditor"] = Processor.process_getUserSanctionDetailsForCreditor
 - 
 
1515 
    self._processMap["updateUserSanction"] = Processor.process_updateUserSanction
 - 
 
1516 
    self._processMap["getCreditHistoryRecordsForTransaction"] = Processor.process_getCreditHistoryRecordsForTransaction
 - 
 
1517 
    self._processMap["getCreditHistoryRecordsForUserAndCreditor"] = Processor.process_getCreditHistoryRecordsForUserAndCreditor
 - 
 
1518 
    self._processMap["processCreditTransaction"] = Processor.process_processCreditTransaction
 - 
 
1519 
    self._processMap["getLoanPayableForUserToCreditor"] = Processor.process_getLoanPayableForUserToCreditor
 - 
 
1520 
 
 1150 
 
1521 
  def process(self, iprot, oprot):
 1151 
  def process(self, iprot, oprot):
1522 
    (name, type, seqid) = iprot.readMessageBegin()
 1152 
    (name, type, seqid) = iprot.readMessageBegin()
1523 
    if name not in self._processMap:
 1153 
    if name not in self._processMap:
1524 
      iprot.skip(TType.STRUCT)
 1154 
      iprot.skip(TType.STRUCT)
Line 1830... Line 1460...
1830 
    oprot.writeMessageBegin("getPaymentStatusAtGateway", TMessageType.REPLY, seqid)
 1460 
    oprot.writeMessageBegin("getPaymentStatusAtGateway", TMessageType.REPLY, seqid)
1831 
    result.write(oprot)
 1461 
    result.write(oprot)
1832 
    oprot.writeMessageEnd()
 1462 
    oprot.writeMessageEnd()
1833 
    oprot.trans.flush()
 1463 
    oprot.trans.flush()
1834 
 
 1464 
 
1835 
  def process_getCreditorInfo(self, seqid, iprot, oprot):
 - 
 
1836 
    args = getCreditorInfo_args()
 - 
 
1837 
    args.read(iprot)
 - 
 
1838 
    iprot.readMessageEnd()
 - 
 
1839 
    result = getCreditorInfo_result()
 - 
 
1840 
    result.success = self._handler.getCreditorInfo(args.id, args.name)
 - 
 
1841 
    oprot.writeMessageBegin("getCreditorInfo", TMessageType.REPLY, seqid)
 - 
 
1842 
    result.write(oprot)
 - 
 
1843 
    oprot.writeMessageEnd()
 - 
 
1844 
    oprot.trans.flush()
 - 
 
1845 
 
 - 
 
1846 
  def process_updateCreditorInfo(self, seqid, iprot, oprot):
 - 
 
1847 
    args = updateCreditorInfo_args()
 - 
 
1848 
    args.read(iprot)
 - 
 
1849 
    iprot.readMessageEnd()
 - 
 
1850 
    result = updateCreditorInfo_result()
 - 
 
1851 
    result.success = self._handler.updateCreditorInfo(args.creditor)
 - 
 
1852 
    oprot.writeMessageBegin("updateCreditorInfo", TMessageType.REPLY, seqid)
 - 
 
1853 
    result.write(oprot)
 - 
 
1854 
    oprot.writeMessageEnd()
 - 
 
1855 
    oprot.trans.flush()
 - 
 
1856 
 
 - 
 
1857 
  def process_getUserSanctionDetails(self, seqid, iprot, oprot):
 - 
 
1858 
    args = getUserSanctionDetails_args()
 - 
 
1859 
    args.read(iprot)
 - 
 
1860 
    iprot.readMessageEnd()
 - 
 
1861 
    result = getUserSanctionDetails_result()
 - 
 
1862 
    result.success = self._handler.getUserSanctionDetails(args.userId)
 - 
 
1863 
    oprot.writeMessageBegin("getUserSanctionDetails", TMessageType.REPLY, seqid)
 - 
 
1864 
    result.write(oprot)
 - 
 
1865 
    oprot.writeMessageEnd()
 - 
 
1866 
    oprot.trans.flush()
 - 
 
1867 
 
 - 
 
1868 
  def process_getUserSanctionDetailsForCreditor(self, seqid, iprot, oprot):
 - 
 
1869 
    args = getUserSanctionDetailsForCreditor_args()
 - 
 
1870 
    args.read(iprot)
 - 
 
1871 
    iprot.readMessageEnd()
 - 
 
1872 
    result = getUserSanctionDetailsForCreditor_result()
 - 
 
1873 
    result.success = self._handler.getUserSanctionDetailsForCreditor(args.userId, args.creditorId)
 - 
 
1874 
    oprot.writeMessageBegin("getUserSanctionDetailsForCreditor", TMessageType.REPLY, seqid)
 - 
 
1875 
    result.write(oprot)
 - 
 
1876 
    oprot.writeMessageEnd()
 - 
 
1877 
    oprot.trans.flush()
 - 
 
1878 
 
 - 
 
1879 
  def process_updateUserSanction(self, seqid, iprot, oprot):
 - 
 
1880 
    args = updateUserSanction_args()
 - 
 
1881 
    args.read(iprot)
 - 
 
1882 
    iprot.readMessageEnd()
 - 
 
1883 
    result = updateUserSanction_result()
 - 
 
1884 
    try:
 - 
 
1885 
      result.success = self._handler.updateUserSanction(args.userSanaction)
 - 
 
1886 
    except PaymentException, pe:
 - 
 
1887 
      result.pe = pe
 - 
 
1888 
    oprot.writeMessageBegin("updateUserSanction", TMessageType.REPLY, seqid)
 - 
 
1889 
    result.write(oprot)
 - 
 
1890 
    oprot.writeMessageEnd()
 - 
 
1891 
    oprot.trans.flush()
 - 
 
1892 
 
 - 
 
1893 
  def process_getCreditHistoryRecordsForTransaction(self, seqid, iprot, oprot):
 - 
 
1894 
    args = getCreditHistoryRecordsForTransaction_args()
 - 
 
1895 
    args.read(iprot)
 - 
 
1896 
    iprot.readMessageEnd()
 - 
 
1897 
    result = getCreditHistoryRecordsForTransaction_result()
 - 
 
1898 
    result.success = self._handler.getCreditHistoryRecordsForTransaction(args.paymentId, args.creditorId, args.creditTxnType)
 - 
 
1899 
    oprot.writeMessageBegin("getCreditHistoryRecordsForTransaction", TMessageType.REPLY, seqid)
 - 
 
1900 
    result.write(oprot)
 - 
 
1901 
    oprot.writeMessageEnd()
 - 
 
1902 
    oprot.trans.flush()
 - 
 
1903 
 
 - 
 
1904 
  def process_getCreditHistoryRecordsForUserAndCreditor(self, seqid, iprot, oprot):
 - 
 
1905 
    args = getCreditHistoryRecordsForUserAndCreditor_args()
 - 
 
1906 
    args.read(iprot)
 - 
 
1907 
    iprot.readMessageEnd()
 - 
 
1908 
    result = getCreditHistoryRecordsForUserAndCreditor_result()
 - 
 
1909 
    result.success = self._handler.getCreditHistoryRecordsForUserAndCreditor(args.userId, args.creditTxnType)
 - 
 
1910 
    oprot.writeMessageBegin("getCreditHistoryRecordsForUserAndCreditor", TMessageType.REPLY, seqid)
 - 
 
1911 
    result.write(oprot)
 - 
 
1912 
    oprot.writeMessageEnd()
 - 
 
1913 
    oprot.trans.flush()
 - 
 
1914 
 
 - 
 
1915 
  def process_processCreditTransaction(self, seqid, iprot, oprot):
 - 
 
1916 
    args = processCreditTransaction_args()
 - 
 
1917 
    args.read(iprot)
 - 
 
1918 
    iprot.readMessageEnd()
 - 
 
1919 
    result = processCreditTransaction_result()
 - 
 
1920 
    try:
 - 
 
1921 
      result.success = self._handler.processCreditTransaction(args.paymentId, args.creditTxns)
 - 
 
1922 
    except PaymentException, pe:
 - 
 
1923 
      result.pe = pe
 - 
 
1924 
    oprot.writeMessageBegin("processCreditTransaction", TMessageType.REPLY, seqid)
 - 
 
1925 
    result.write(oprot)
 - 
 
1926 
    oprot.writeMessageEnd()
 - 
 
1927 
    oprot.trans.flush()
 - 
 
1928 
 
 - 
 
1929 
  def process_getLoanPayableForUserToCreditor(self, seqid, iprot, oprot):
 - 
 
1930 
    args = getLoanPayableForUserToCreditor_args()
 - 
 
1931 
    args.read(iprot)
 - 
 
1932 
    iprot.readMessageEnd()
 - 
 
1933 
    result = getLoanPayableForUserToCreditor_result()
 - 
 
1934 
    result.success = self._handler.getLoanPayableForUserToCreditor(args.userId, args.creditorId, args.dueDate)
 - 
 
1935 
    oprot.writeMessageBegin("getLoanPayableForUserToCreditor", TMessageType.REPLY, seqid)
 - 
 
1936 
    result.write(oprot)
 - 
 
1937 
    oprot.writeMessageEnd()
 - 
 
1938 
    oprot.trans.flush()
 - 
 
1939 
 
 - 
 
1940 
 
 1465 
 
1941 
# HELPER FUNCTIONS AND STRUCTURES
 1466 
# HELPER FUNCTIONS AND STRUCTURES
1942 
 
 1467 
 
1943 
class createPayment_args:
 1468 
class createPayment_args:
1944 
  """
 1469 
  """
Line 5310... Line 4835...
5310 
      oprot.writeFieldEnd()
 4835 
      oprot.writeFieldEnd()
5311 
    oprot.writeFieldStop()
 4836 
    oprot.writeFieldStop()
5312 
    oprot.writeStructEnd()
 4837 
    oprot.writeStructEnd()
5313 
 
 4838 
 
5314 
  def validate(self):
 4839 
  def validate(self):
5315 
    return
 - 
 
5316 
 
 - 
 
5317 
 
 - 
 
5318 
  def __repr__(self):
 - 
 
5319 
    L = ['%s=%r' % (key, value)
 - 
 
5320 
      for key, value in self.__dict__.iteritems()]
 - 
 
5321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
5322 
 
 - 
 
5323 
  def __eq__(self, other):
 - 
 
5324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
5325 
 
 - 
 
5326 
  def __ne__(self, other):
 - 
 
5327 
    return not (self == other)
 - 
 
5328 
 
 - 
 
5329 
class getCreditorInfo_args:
 - 
 
5330 
  """
 - 
 
5331 
  Attributes:
 - 
 
5332 
   - id
 - 
 
5333 
   - name
 - 
 
5334 
  """
 - 
 
5335 
 
 - 
 
5336 
  thrift_spec = (
 - 
 
5337 
    None, # 0
 - 
 
5338 
    (1, TType.I64, 'id', None, None, ), # 1
 - 
 
5339 
    (2, TType.STRING, 'name', None, None, ), # 2
 - 
 
5340 
  )
 - 
 
5341 
 
 - 
 
5342 
  def __init__(self, id=None, name=None,):
 - 
 
5343 
    self.id = id
 - 
 
5344 
    self.name = name
 - 
 
5345 
 
 - 
 
5346 
  def read(self, iprot):
 - 
 
5347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
5349 
      return
 - 
 
5350 
    iprot.readStructBegin()
 - 
 
5351 
    while True:
 - 
 
5352 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
5353 
      if ftype == TType.STOP:
 - 
 
5354 
        break
 - 
 
5355 
      if fid == 1:
 - 
 
5356 
        if ftype == TType.I64:
 - 
 
5357 
          self.id = iprot.readI64();
 - 
 
5358 
        else:
 - 
 
5359 
          iprot.skip(ftype)
 - 
 
5360 
      elif fid == 2:
 - 
 
5361 
        if ftype == TType.STRING:
 - 
 
5362 
          self.name = iprot.readString();
 - 
 
5363 
        else:
 - 
 
5364 
          iprot.skip(ftype)
 - 
 
5365 
      else:
 - 
 
5366 
        iprot.skip(ftype)
 - 
 
5367 
      iprot.readFieldEnd()
 - 
 
5368 
    iprot.readStructEnd()
 - 
 
5369 
 
 - 
 
5370 
  def write(self, oprot):
 - 
 
5371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
5373 
      return
 - 
 
5374 
    oprot.writeStructBegin('getCreditorInfo_args')
 - 
 
5375 
    if self.id is not None:
 - 
 
5376 
      oprot.writeFieldBegin('id', TType.I64, 1)
 - 
 
5377 
      oprot.writeI64(self.id)
 - 
 
5378 
      oprot.writeFieldEnd()
 - 
 
5379 
    if self.name is not None:
 - 
 
5380 
      oprot.writeFieldBegin('name', TType.STRING, 2)
 - 
 
5381 
      oprot.writeString(self.name)
 - 
 
5382 
      oprot.writeFieldEnd()
 - 
 
5383 
    oprot.writeFieldStop()
 - 
 
5384 
    oprot.writeStructEnd()
 - 
 
5385 
 
 - 
 
5386 
  def validate(self):
 - 
 
5387 
    return
 - 
 
5388 
 
 - 
 
5389 
 
 - 
 
5390 
  def __repr__(self):
 - 
 
5391 
    L = ['%s=%r' % (key, value)
 - 
 
5392 
      for key, value in self.__dict__.iteritems()]
 - 
 
5393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
5394 
 
 - 
 
5395 
  def __eq__(self, other):
 - 
 
5396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
5397 
 
 - 
 
5398 
  def __ne__(self, other):
 - 
 
5399 
    return not (self == other)
 - 
 
5400 
 
 - 
 
5401 
class getCreditorInfo_result:
 - 
 
5402 
  """
 - 
 
5403 
  Attributes:
 - 
 
5404 
   - success
 - 
 
5405 
  """
 - 
 
5406 
 
 - 
 
5407 
  thrift_spec = (
 - 
 
5408 
    (0, TType.STRUCT, 'success', (Creditor, Creditor.thrift_spec), None, ), # 0
 - 
 
5409 
  )
 - 
 
5410 
 
 - 
 
5411 
  def __init__(self, success=None,):
 - 
 
5412 
    self.success = success
 - 
 
5413 
 
 - 
 
5414 
  def read(self, iprot):
 - 
 
5415 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5416 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
5417 
      return
 - 
 
5418 
    iprot.readStructBegin()
 - 
 
5419 
    while True:
 - 
 
5420 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
5421 
      if ftype == TType.STOP:
 - 
 
5422 
        break
 - 
 
5423 
      if fid == 0:
 - 
 
5424 
        if ftype == TType.STRUCT:
 - 
 
5425 
          self.success = Creditor()
 - 
 
5426 
          self.success.read(iprot)
 - 
 
5427 
        else:
 - 
 
5428 
          iprot.skip(ftype)
 - 
 
5429 
      else:
 - 
 
5430 
        iprot.skip(ftype)
 - 
 
5431 
      iprot.readFieldEnd()
 - 
 
5432 
    iprot.readStructEnd()
 - 
 
5433 
 
 - 
 
5434 
  def write(self, oprot):
 - 
 
5435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
5437 
      return
 - 
 
5438 
    oprot.writeStructBegin('getCreditorInfo_result')
 - 
 
5439 
    if self.success is not None:
 - 
 
5440 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
 - 
 
5441 
      self.success.write(oprot)
 - 
 
5442 
      oprot.writeFieldEnd()
 - 
 
5443 
    oprot.writeFieldStop()
 - 
 
5444 
    oprot.writeStructEnd()
 - 
 
5445 
 
 - 
 
5446 
  def validate(self):
 - 
 
5447 
    return
 - 
 
5448 
 
 - 
 
5449 
 
 - 
 
5450 
  def __repr__(self):
 - 
 
5451 
    L = ['%s=%r' % (key, value)
 - 
 
5452 
      for key, value in self.__dict__.iteritems()]
 - 
 
5453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
5454 
 
 - 
 
5455 
  def __eq__(self, other):
 - 
 
5456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
5457 
 
 - 
 
5458 
  def __ne__(self, other):
 - 
 
5459 
    return not (self == other)
 - 
 
5460 
 
 - 
 
5461 
class updateCreditorInfo_args:
 - 
 
5462 
  """
 - 
 
5463 
  Attributes:
 - 
 
5464 
   - creditor
 - 
 
5465 
  """
 - 
 
5466 
 
 - 
 
5467 
  thrift_spec = (
 - 
 
5468 
    None, # 0
 - 
 
5469 
    (1, TType.STRUCT, 'creditor', (Creditor, Creditor.thrift_spec), None, ), # 1
 - 
 
5470 
  )
 - 
 
5471 
 
 - 
 
5472 
  def __init__(self, creditor=None,):
 - 
 
5473 
    self.creditor = creditor
 - 
 
5474 
 
 - 
 
5475 
  def read(self, iprot):
 - 
 
5476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
5478 
      return
 - 
 
5479 
    iprot.readStructBegin()
 - 
 
5480 
    while True:
 - 
 
5481 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
5482 
      if ftype == TType.STOP:
 - 
 
5483 
        break
 - 
 
5484 
      if fid == 1:
 - 
 
5485 
        if ftype == TType.STRUCT:
 - 
 
5486 
          self.creditor = Creditor()
 - 
 
5487 
          self.creditor.read(iprot)
 - 
 
5488 
        else:
 - 
 
5489 
          iprot.skip(ftype)
 - 
 
5490 
      else:
 - 
 
5491 
        iprot.skip(ftype)
 - 
 
5492 
      iprot.readFieldEnd()
 - 
 
5493 
    iprot.readStructEnd()
 - 
 
5494 
 
 - 
 
5495 
  def write(self, oprot):
 - 
 
5496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
5498 
      return
 - 
 
5499 
    oprot.writeStructBegin('updateCreditorInfo_args')
 - 
 
5500 
    if self.creditor is not None:
 - 
 
5501 
      oprot.writeFieldBegin('creditor', TType.STRUCT, 1)
 - 
 
5502 
      self.creditor.write(oprot)
 - 
 
5503 
      oprot.writeFieldEnd()
 - 
 
5504 
    oprot.writeFieldStop()
 - 
 
5505 
    oprot.writeStructEnd()
 - 
 
5506 
 
 - 
 
5507 
  def validate(self):
 - 
 
5508 
    return
 - 
 
5509 
 
 - 
 
5510 
 
 - 
 
5511 
  def __repr__(self):
 - 
 
5512 
    L = ['%s=%r' % (key, value)
 - 
 
5513 
      for key, value in self.__dict__.iteritems()]
 - 
 
5514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
5515 
 
 - 
 
5516 
  def __eq__(self, other):
 - 
 
5517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
5518 
 
 - 
 
5519 
  def __ne__(self, other):
 - 
 
5520 
    return not (self == other)
 - 
 
5521 
 
 - 
 
5522 
class updateCreditorInfo_result:
 - 
 
5523 
  """
 - 
 
5524 
  Attributes:
 - 
 
5525 
   - success
 - 
 
5526 
  """
 - 
 
5527 
 
 - 
 
5528 
  thrift_spec = (
 - 
 
5529 
    (0, TType.BOOL, 'success', None, None, ), # 0
 - 
 
5530 
  )
 - 
 
5531 
 
 - 
 
5532 
  def __init__(self, success=None,):
 - 
 
5533 
    self.success = success
 - 
 
5534 
 
 - 
 
5535 
  def read(self, iprot):
 - 
 
5536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
5538 
      return
 - 
 
5539 
    iprot.readStructBegin()
 - 
 
5540 
    while True:
 - 
 
5541 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
5542 
      if ftype == TType.STOP:
 - 
 
5543 
        break
 - 
 
5544 
      if fid == 0:
 - 
 
5545 
        if ftype == TType.BOOL:
 - 
 
5546 
          self.success = iprot.readBool();
 - 
 
5547 
        else:
 - 
 
5548 
          iprot.skip(ftype)
 - 
 
5549 
      else:
 - 
 
5550 
        iprot.skip(ftype)
 - 
 
5551 
      iprot.readFieldEnd()
 - 
 
5552 
    iprot.readStructEnd()
 - 
 
5553 
 
 - 
 
5554 
  def write(self, oprot):
 - 
 
5555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
5557 
      return
 - 
 
5558 
    oprot.writeStructBegin('updateCreditorInfo_result')
 - 
 
5559 
    if self.success is not None:
 - 
 
5560 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
 - 
 
5561 
      oprot.writeBool(self.success)
 - 
 
5562 
      oprot.writeFieldEnd()
 - 
 
5563 
    oprot.writeFieldStop()
 - 
 
5564 
    oprot.writeStructEnd()
 - 
 
5565 
 
 - 
 
5566 
  def validate(self):
 - 
 
5567 
    return
 - 
 
5568 
 
 - 
 
5569 
 
 - 
 
5570 
  def __repr__(self):
 - 
 
5571 
    L = ['%s=%r' % (key, value)
 - 
 
5572 
      for key, value in self.__dict__.iteritems()]
 - 
 
5573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
5574 
 
 - 
 
5575 
  def __eq__(self, other):
 - 
 
5576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
5577 
 
 - 
 
5578 
  def __ne__(self, other):
 - 
 
5579 
    return not (self == other)
 - 
 
5580 
 
 - 
 
5581 
class getUserSanctionDetails_args:
 - 
 
5582 
  """
 - 
 
5583 
  Attributes:
 - 
 
5584 
   - userId
 - 
 
5585 
  """
 - 
 
5586 
 
 - 
 
5587 
  thrift_spec = (
 - 
 
5588 
    None, # 0
 - 
 
5589 
    (1, TType.I64, 'userId', None, None, ), # 1
 - 
 
5590 
  )
 - 
 
5591 
 
 - 
 
5592 
  def __init__(self, userId=None,):
 - 
 
5593 
    self.userId = userId
 - 
 
5594 
 
 - 
 
5595 
  def read(self, iprot):
 - 
 
5596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
5598 
      return
 - 
 
5599 
    iprot.readStructBegin()
 - 
 
5600 
    while True:
 - 
 
5601 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
5602 
      if ftype == TType.STOP:
 - 
 
5603 
        break
 - 
 
5604 
      if fid == 1:
 - 
 
5605 
        if ftype == TType.I64:
 - 
 
5606 
          self.userId = iprot.readI64();
 - 
 
5607 
        else:
 - 
 
5608 
          iprot.skip(ftype)
 - 
 
5609 
      else:
 - 
 
5610 
        iprot.skip(ftype)
 - 
 
5611 
      iprot.readFieldEnd()
 - 
 
5612 
    iprot.readStructEnd()
 - 
 
5613 
 
 - 
 
5614 
  def write(self, oprot):
 - 
 
5615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
5617 
      return
 - 
 
5618 
    oprot.writeStructBegin('getUserSanctionDetails_args')
 - 
 
5619 
    if self.userId is not None:
 - 
 
5620 
      oprot.writeFieldBegin('userId', TType.I64, 1)
 - 
 
5621 
      oprot.writeI64(self.userId)
 - 
 
5622 
      oprot.writeFieldEnd()
 - 
 
5623 
    oprot.writeFieldStop()
 - 
 
5624 
    oprot.writeStructEnd()
 - 
 
5625 
 
 - 
 
5626 
  def validate(self):
 - 
 
5627 
    return
 - 
 
5628 
 
 - 
 
5629 
 
 - 
 
5630 
  def __repr__(self):
 - 
 
5631 
    L = ['%s=%r' % (key, value)
 - 
 
5632 
      for key, value in self.__dict__.iteritems()]
 - 
 
5633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
5634 
 
 - 
 
5635 
  def __eq__(self, other):
 - 
 
5636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
5637 
 
 - 
 
5638 
  def __ne__(self, other):
 - 
 
5639 
    return not (self == other)
 - 
 
5640 
 
 - 
 
5641 
class getUserSanctionDetails_result:
 - 
 
5642 
  """
 - 
 
5643 
  Attributes:
 - 
 
5644 
   - success
 - 
 
5645 
  """
 - 
 
5646 
 
 - 
 
5647 
  thrift_spec = (
 - 
 
5648 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserSanction, UserSanction.thrift_spec)), None, ), # 0
 - 
 
5649 
  )
 - 
 
5650 
 
 - 
 
5651 
  def __init__(self, success=None,):
 - 
 
5652 
    self.success = success
 - 
 
5653 
 
 - 
 
5654 
  def read(self, iprot):
 - 
 
5655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
5657 
      return
 - 
 
5658 
    iprot.readStructBegin()
 - 
 
5659 
    while True:
 - 
 
5660 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
5661 
      if ftype == TType.STOP:
 - 
 
5662 
        break
 - 
 
5663 
      if fid == 0:
 - 
 
5664 
        if ftype == TType.LIST:
 - 
 
5665 
          self.success = []
 - 
 
5666 
          (_etype87, _size84) = iprot.readListBegin()
 - 
 
5667 
          for _i88 in xrange(_size84):
 - 
 
5668 
            _elem89 = UserSanction()
 - 
 
5669 
            _elem89.read(iprot)
 - 
 
5670 
            self.success.append(_elem89)
 - 
 
5671 
          iprot.readListEnd()
 - 
 
5672 
        else:
 - 
 
5673 
          iprot.skip(ftype)
 - 
 
5674 
      else:
 - 
 
5675 
        iprot.skip(ftype)
 - 
 
5676 
      iprot.readFieldEnd()
 - 
 
5677 
    iprot.readStructEnd()
 - 
 
5678 
 
 - 
 
5679 
  def write(self, oprot):
 - 
 
5680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
5682 
      return
 - 
 
5683 
    oprot.writeStructBegin('getUserSanctionDetails_result')
 - 
 
5684 
    if self.success is not None:
 - 
 
5685 
      oprot.writeFieldBegin('success', TType.LIST, 0)
 - 
 
5686 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
 - 
 
5687 
      for iter90 in self.success:
 - 
 
5688 
        iter90.write(oprot)
 - 
 
5689 
      oprot.writeListEnd()
 - 
 
5690 
      oprot.writeFieldEnd()
 - 
 
5691 
    oprot.writeFieldStop()
 - 
 
5692 
    oprot.writeStructEnd()
 - 
 
5693 
 
 - 
 
5694 
  def validate(self):
 - 
 
5695 
    return
 - 
 
5696 
 
 - 
 
5697 
 
 - 
 
5698 
  def __repr__(self):
 - 
 
5699 
    L = ['%s=%r' % (key, value)
 - 
 
5700 
      for key, value in self.__dict__.iteritems()]
 - 
 
5701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
5702 
 
 - 
 
5703 
  def __eq__(self, other):
 - 
 
5704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
5705 
 
 - 
 
5706 
  def __ne__(self, other):
 - 
 
5707 
    return not (self == other)
 - 
 
5708 
 
 - 
 
5709 
class getUserSanctionDetailsForCreditor_args:
 - 
 
5710 
  """
 - 
 
5711 
  Attributes:
 - 
 
5712 
   - userId
 - 
 
5713 
   - creditorId
 - 
 
5714 
  """
 - 
 
5715 
 
 - 
 
5716 
  thrift_spec = None
 - 
 
5717 
  def __init__(self, userId=None, creditorId=None,):
 - 
 
5718 
    self.userId = userId
 - 
 
5719 
    self.creditorId = creditorId
 - 
 
5720 
 
 - 
 
5721 
  def read(self, iprot):
 - 
 
5722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
5724 
      return
 - 
 
5725 
    iprot.readStructBegin()
 - 
 
5726 
    while True:
 - 
 
5727 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
5728 
      if ftype == TType.STOP:
 - 
 
5729 
        break
 - 
 
5730 
      if fid == 1:
 - 
 
5731 
        if ftype == TType.I64:
 - 
 
5732 
          self.userId = iprot.readI64();
 - 
 
5733 
        else:
 - 
 
5734 
          iprot.skip(ftype)
 - 
 
5735 
      elif fid == -1:
 - 
 
5736 
        if ftype == TType.I64:
 - 
 
5737 
          self.creditorId = iprot.readI64();
 - 
 
5738 
        else:
 - 
 
5739 
          iprot.skip(ftype)
 - 
 
5740 
      else:
 - 
 
5741 
        iprot.skip(ftype)
 - 
 
5742 
      iprot.readFieldEnd()
 - 
 
5743 
    iprot.readStructEnd()
 - 
 
5744 
 
 - 
 
5745 
  def write(self, oprot):
 - 
 
5746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
5748 
      return
 - 
 
5749 
    oprot.writeStructBegin('getUserSanctionDetailsForCreditor_args')
 - 
 
5750 
    if self.creditorId is not None:
 - 
 
5751 
      oprot.writeFieldBegin('creditorId', TType.I64, -1)
 - 
 
5752 
      oprot.writeI64(self.creditorId)
 - 
 
5753 
      oprot.writeFieldEnd()
 - 
 
5754 
    if self.userId is not None:
 - 
 
5755 
      oprot.writeFieldBegin('userId', TType.I64, 1)
 - 
 
5756 
      oprot.writeI64(self.userId)
 - 
 
5757 
      oprot.writeFieldEnd()
 - 
 
5758 
    oprot.writeFieldStop()
 - 
 
5759 
    oprot.writeStructEnd()
 - 
 
5760 
 
 - 
 
5761 
  def validate(self):
 - 
 
5762 
    return
 - 
 
5763 
 
 - 
 
5764 
 
 - 
 
5765 
  def __repr__(self):
 - 
 
5766 
    L = ['%s=%r' % (key, value)
 - 
 
5767 
      for key, value in self.__dict__.iteritems()]
 - 
 
5768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
5769 
 
 - 
 
5770 
  def __eq__(self, other):
 - 
 
5771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
5772 
 
 - 
 
5773 
  def __ne__(self, other):
 - 
 
5774 
    return not (self == other)
 - 
 
5775 
 
 - 
 
5776 
class getUserSanctionDetailsForCreditor_result:
 - 
 
5777 
  """
 - 
 
5778 
  Attributes:
 - 
 
5779 
   - success
 - 
 
5780 
  """
 - 
 
5781 
 
 - 
 
5782 
  thrift_spec = (
 - 
 
5783 
    (0, TType.STRUCT, 'success', (UserSanction, UserSanction.thrift_spec), None, ), # 0
 - 
 
5784 
  )
 - 
 
5785 
 
 - 
 
5786 
  def __init__(self, success=None,):
 - 
 
5787 
    self.success = success
 - 
 
5788 
 
 - 
 
5789 
  def read(self, iprot):
 - 
 
5790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
5792 
      return
 - 
 
5793 
    iprot.readStructBegin()
 - 
 
5794 
    while True:
 - 
 
5795 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
5796 
      if ftype == TType.STOP:
 - 
 
5797 
        break
 - 
 
5798 
      if fid == 0:
 - 
 
5799 
        if ftype == TType.STRUCT:
 - 
 
5800 
          self.success = UserSanction()
 - 
 
5801 
          self.success.read(iprot)
 - 
 
5802 
        else:
 - 
 
5803 
          iprot.skip(ftype)
 - 
 
5804 
      else:
 - 
 
5805 
        iprot.skip(ftype)
 - 
 
5806 
      iprot.readFieldEnd()
 - 
 
5807 
    iprot.readStructEnd()
 - 
 
5808 
 
 - 
 
5809 
  def write(self, oprot):
 - 
 
5810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
5812 
      return
 - 
 
5813 
    oprot.writeStructBegin('getUserSanctionDetailsForCreditor_result')
 - 
 
5814 
    if self.success is not None:
 - 
 
5815 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
 - 
 
5816 
      self.success.write(oprot)
 - 
 
5817 
      oprot.writeFieldEnd()
 - 
 
5818 
    oprot.writeFieldStop()
 - 
 
5819 
    oprot.writeStructEnd()
 - 
 
5820 
 
 - 
 
5821 
  def validate(self):
 - 
 
5822 
    return
 - 
 
5823 
 
 - 
 
5824 
 
 - 
 
5825 
  def __repr__(self):
 - 
 
5826 
    L = ['%s=%r' % (key, value)
 - 
 
5827 
      for key, value in self.__dict__.iteritems()]
 - 
 
5828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
5829 
 
 - 
 
5830 
  def __eq__(self, other):
 - 
 
5831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
5832 
 
 - 
 
5833 
  def __ne__(self, other):
 - 
 
5834 
    return not (self == other)
 - 
 
5835 
 
 - 
 
5836 
class updateUserSanction_args:
 - 
 
5837 
  """
 - 
 
5838 
  Attributes:
 - 
 
5839 
   - userSanaction
 - 
 
5840 
  """
 - 
 
5841 
 
 - 
 
5842 
  thrift_spec = (
 - 
 
5843 
    None, # 0
 - 
 
5844 
    (1, TType.STRUCT, 'userSanaction', (UserSanction, UserSanction.thrift_spec), None, ), # 1
 - 
 
5845 
  )
 - 
 
5846 
 
 - 
 
5847 
  def __init__(self, userSanaction=None,):
 - 
 
5848 
    self.userSanaction = userSanaction
 - 
 
5849 
 
 - 
 
5850 
  def read(self, iprot):
 - 
 
5851 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5852 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
5853 
      return
 - 
 
5854 
    iprot.readStructBegin()
 - 
 
5855 
    while True:
 - 
 
5856 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
5857 
      if ftype == TType.STOP:
 - 
 
5858 
        break
 - 
 
5859 
      if fid == 1:
 - 
 
5860 
        if ftype == TType.STRUCT:
 - 
 
5861 
          self.userSanaction = UserSanction()
 - 
 
5862 
          self.userSanaction.read(iprot)
 - 
 
5863 
        else:
 - 
 
5864 
          iprot.skip(ftype)
 - 
 
5865 
      else:
 - 
 
5866 
        iprot.skip(ftype)
 - 
 
5867 
      iprot.readFieldEnd()
 - 
 
5868 
    iprot.readStructEnd()
 - 
 
5869 
 
 - 
 
5870 
  def write(self, oprot):
 - 
 
5871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
5873 
      return
 - 
 
5874 
    oprot.writeStructBegin('updateUserSanction_args')
 - 
 
5875 
    if self.userSanaction is not None:
 - 
 
5876 
      oprot.writeFieldBegin('userSanaction', TType.STRUCT, 1)
 - 
 
5877 
      self.userSanaction.write(oprot)
 - 
 
5878 
      oprot.writeFieldEnd()
 - 
 
5879 
    oprot.writeFieldStop()
 - 
 
5880 
    oprot.writeStructEnd()
 - 
 
5881 
 
 - 
 
5882 
  def validate(self):
 - 
 
5883 
    return
 - 
 
5884 
 
 - 
 
5885 
 
 - 
 
5886 
  def __repr__(self):
 - 
 
5887 
    L = ['%s=%r' % (key, value)
 - 
 
5888 
      for key, value in self.__dict__.iteritems()]
 - 
 
5889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
5890 
 
 - 
 
5891 
  def __eq__(self, other):
 - 
 
5892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
5893 
 
 - 
 
5894 
  def __ne__(self, other):
 - 
 
5895 
    return not (self == other)
 - 
 
5896 
 
 - 
 
5897 
class updateUserSanction_result:
 - 
 
5898 
  """
 - 
 
5899 
  Attributes:
 - 
 
5900 
   - success
 - 
 
5901 
   - pe
 - 
 
5902 
  """
 - 
 
5903 
 
 - 
 
5904 
  thrift_spec = (
 - 
 
5905 
    (0, TType.BOOL, 'success', None, None, ), # 0
 - 
 
5906 
    (1, TType.STRUCT, 'pe', (PaymentException, PaymentException.thrift_spec), None, ), # 1
 - 
 
5907 
  )
 - 
 
5908 
 
 - 
 
5909 
  def __init__(self, success=None, pe=None,):
 - 
 
5910 
    self.success = success
 - 
 
5911 
    self.pe = pe
 - 
 
5912 
 
 - 
 
5913 
  def read(self, iprot):
 - 
 
5914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
5916 
      return
 - 
 
5917 
    iprot.readStructBegin()
 - 
 
5918 
    while True:
 - 
 
5919 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
5920 
      if ftype == TType.STOP:
 - 
 
5921 
        break
 - 
 
5922 
      if fid == 0:
 - 
 
5923 
        if ftype == TType.BOOL:
 - 
 
5924 
          self.success = iprot.readBool();
 - 
 
5925 
        else:
 - 
 
5926 
          iprot.skip(ftype)
 - 
 
5927 
      elif fid == 1:
 - 
 
5928 
        if ftype == TType.STRUCT:
 - 
 
5929 
          self.pe = PaymentException()
 - 
 
5930 
          self.pe.read(iprot)
 - 
 
5931 
        else:
 - 
 
5932 
          iprot.skip(ftype)
 - 
 
5933 
      else:
 - 
 
5934 
        iprot.skip(ftype)
 - 
 
5935 
      iprot.readFieldEnd()
 - 
 
5936 
    iprot.readStructEnd()
 - 
 
5937 
 
 - 
 
5938 
  def write(self, oprot):
 - 
 
5939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
5941 
      return
 - 
 
5942 
    oprot.writeStructBegin('updateUserSanction_result')
 - 
 
5943 
    if self.success is not None:
 - 
 
5944 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
 - 
 
5945 
      oprot.writeBool(self.success)
 - 
 
5946 
      oprot.writeFieldEnd()
 - 
 
5947 
    if self.pe is not None:
 - 
 
5948 
      oprot.writeFieldBegin('pe', TType.STRUCT, 1)
 - 
 
5949 
      self.pe.write(oprot)
 - 
 
5950 
      oprot.writeFieldEnd()
 - 
 
5951 
    oprot.writeFieldStop()
 - 
 
5952 
    oprot.writeStructEnd()
 - 
 
5953 
 
 - 
 
5954 
  def validate(self):
 - 
 
5955 
    return
 - 
 
5956 
 
 - 
 
5957 
 
 - 
 
5958 
  def __repr__(self):
 - 
 
5959 
    L = ['%s=%r' % (key, value)
 - 
 
5960 
      for key, value in self.__dict__.iteritems()]
 - 
 
5961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
5962 
 
 - 
 
5963 
  def __eq__(self, other):
 - 
 
5964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
5965 
 
 - 
 
5966 
  def __ne__(self, other):
 - 
 
5967 
    return not (self == other)
 - 
 
5968 
 
 - 
 
5969 
class getCreditHistoryRecordsForTransaction_args:
 - 
 
5970 
  """
 - 
 
5971 
  Attributes:
 - 
 
5972 
   - paymentId
 - 
 
5973 
   - creditorId
 - 
 
5974 
   - creditTxnType
 - 
 
5975 
  """
 - 
 
5976 
 
 - 
 
5977 
  thrift_spec = (
 - 
 
5978 
    None, # 0
 - 
 
5979 
    (1, TType.I64, 'paymentId', None, None, ), # 1
 - 
 
5980 
    (2, TType.I64, 'creditorId', None, None, ), # 2
 - 
 
5981 
    (3, TType.STRING, 'creditTxnType', None, None, ), # 3
 - 
 
5982 
  )
 - 
 
5983 
 
 - 
 
5984 
  def __init__(self, paymentId=None, creditorId=None, creditTxnType=None,):
 - 
 
5985 
    self.paymentId = paymentId
 - 
 
5986 
    self.creditorId = creditorId
 - 
 
5987 
    self.creditTxnType = creditTxnType
 - 
 
5988 
 
 - 
 
5989 
  def read(self, iprot):
 - 
 
5990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
5991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
5992 
      return
 - 
 
5993 
    iprot.readStructBegin()
 - 
 
5994 
    while True:
 - 
 
5995 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
5996 
      if ftype == TType.STOP:
 - 
 
5997 
        break
 - 
 
5998 
      if fid == 1:
 - 
 
5999 
        if ftype == TType.I64:
 - 
 
6000 
          self.paymentId = iprot.readI64();
 - 
 
6001 
        else:
 - 
 
6002 
          iprot.skip(ftype)
 - 
 
6003 
      elif fid == 2:
 - 
 
6004 
        if ftype == TType.I64:
 - 
 
6005 
          self.creditorId = iprot.readI64();
 - 
 
6006 
        else:
 - 
 
6007 
          iprot.skip(ftype)
 - 
 
6008 
      elif fid == 3:
 - 
 
6009 
        if ftype == TType.STRING:
 - 
 
6010 
          self.creditTxnType = iprot.readString();
 - 
 
6011 
        else:
 - 
 
6012 
          iprot.skip(ftype)
 - 
 
6013 
      else:
 - 
 
6014 
        iprot.skip(ftype)
 - 
 
6015 
      iprot.readFieldEnd()
 - 
 
6016 
    iprot.readStructEnd()
 - 
 
6017 
 
 - 
 
6018 
  def write(self, oprot):
 - 
 
6019 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
6020 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
6021 
      return
 - 
 
6022 
    oprot.writeStructBegin('getCreditHistoryRecordsForTransaction_args')
 - 
 
6023 
    if self.paymentId is not None:
 - 
 
6024 
      oprot.writeFieldBegin('paymentId', TType.I64, 1)
 - 
 
6025 
      oprot.writeI64(self.paymentId)
 - 
 
6026 
      oprot.writeFieldEnd()
 - 
 
6027 
    if self.creditorId is not None:
 - 
 
6028 
      oprot.writeFieldBegin('creditorId', TType.I64, 2)
 - 
 
6029 
      oprot.writeI64(self.creditorId)
 - 
 
6030 
      oprot.writeFieldEnd()
 - 
 
6031 
    if self.creditTxnType is not None:
 - 
 
6032 
      oprot.writeFieldBegin('creditTxnType', TType.STRING, 3)
 - 
 
6033 
      oprot.writeString(self.creditTxnType)
 - 
 
6034 
      oprot.writeFieldEnd()
 - 
 
6035 
    oprot.writeFieldStop()
 - 
 
6036 
    oprot.writeStructEnd()
 - 
 
6037 
 
 - 
 
6038 
  def validate(self):
 - 
 
6039 
    return
 - 
 
6040 
 
 - 
 
6041 
 
 - 
 
6042 
  def __repr__(self):
 - 
 
6043 
    L = ['%s=%r' % (key, value)
 - 
 
6044 
      for key, value in self.__dict__.iteritems()]
 - 
 
6045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
6046 
 
 - 
 
6047 
  def __eq__(self, other):
 - 
 
6048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
6049 
 
 - 
 
6050 
  def __ne__(self, other):
 - 
 
6051 
    return not (self == other)
 - 
 
6052 
 
 - 
 
6053 
class getCreditHistoryRecordsForTransaction_result:
 - 
 
6054 
  """
 - 
 
6055 
  Attributes:
 - 
 
6056 
   - success
 - 
 
6057 
  """
 - 
 
6058 
 
 - 
 
6059 
  thrift_spec = (
 - 
 
6060 
    (0, TType.LIST, 'success', (TType.STRUCT,(CreditHistory, CreditHistory.thrift_spec)), None, ), # 0
 - 
 
6061 
  )
 - 
 
6062 
 
 - 
 
6063 
  def __init__(self, success=None,):
 - 
 
6064 
    self.success = success
 - 
 
6065 
 
 - 
 
6066 
  def read(self, iprot):
 - 
 
6067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
6068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
6069 
      return
 - 
 
6070 
    iprot.readStructBegin()
 - 
 
6071 
    while True:
 - 
 
6072 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
6073 
      if ftype == TType.STOP:
 - 
 
6074 
        break
 - 
 
6075 
      if fid == 0:
 - 
 
6076 
        if ftype == TType.LIST:
 - 
 
6077 
          self.success = []
 - 
 
6078 
          (_etype94, _size91) = iprot.readListBegin()
 - 
 
6079 
          for _i95 in xrange(_size91):
 - 
 
6080 
            _elem96 = CreditHistory()
 - 
 
6081 
            _elem96.read(iprot)
 - 
 
6082 
            self.success.append(_elem96)
 - 
 
6083 
          iprot.readListEnd()
 - 
 
6084 
        else:
 - 
 
6085 
          iprot.skip(ftype)
 - 
 
6086 
      else:
 - 
 
6087 
        iprot.skip(ftype)
 - 
 
6088 
      iprot.readFieldEnd()
 - 
 
6089 
    iprot.readStructEnd()
 - 
 
6090 
 
 - 
 
6091 
  def write(self, oprot):
 - 
 
6092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
6093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
6094 
      return
 - 
 
6095 
    oprot.writeStructBegin('getCreditHistoryRecordsForTransaction_result')
 - 
 
6096 
    if self.success is not None:
 - 
 
6097 
      oprot.writeFieldBegin('success', TType.LIST, 0)
 - 
 
6098 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
 - 
 
6099 
      for iter97 in self.success:
 - 
 
6100 
        iter97.write(oprot)
 - 
 
6101 
      oprot.writeListEnd()
 - 
 
6102 
      oprot.writeFieldEnd()
 - 
 
6103 
    oprot.writeFieldStop()
 - 
 
6104 
    oprot.writeStructEnd()
 - 
 
6105 
 
 - 
 
6106 
  def validate(self):
 - 
 
6107 
    return
 - 
 
6108 
 
 - 
 
6109 
 
 - 
 
6110 
  def __repr__(self):
 - 
 
6111 
    L = ['%s=%r' % (key, value)
 - 
 
6112 
      for key, value in self.__dict__.iteritems()]
 - 
 
6113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
6114 
 
 - 
 
6115 
  def __eq__(self, other):
 - 
 
6116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
6117 
 
 - 
 
6118 
  def __ne__(self, other):
 - 
 
6119 
    return not (self == other)
 - 
 
6120 
 
 - 
 
6121 
class getCreditHistoryRecordsForUserAndCreditor_args:
 - 
 
6122 
  """
 - 
 
6123 
  Attributes:
 - 
 
6124 
   - userId
 - 
 
6125 
   - creditTxnType
 - 
 
6126 
  """
 - 
 
6127 
 
 - 
 
6128 
  thrift_spec = (
 - 
 
6129 
    None, # 0
 - 
 
6130 
    (1, TType.I64, 'userId', None, None, ), # 1
 - 
 
6131 
    (2, TType.STRING, 'creditTxnType', None, None, ), # 2
 - 
 
6132 
  )
 - 
 
6133 
 
 - 
 
6134 
  def __init__(self, userId=None, creditTxnType=None,):
 - 
 
6135 
    self.userId = userId
 - 
 
6136 
    self.creditTxnType = creditTxnType
 - 
 
6137 
 
 - 
 
6138 
  def read(self, iprot):
 - 
 
6139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
6140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
6141 
      return
 - 
 
6142 
    iprot.readStructBegin()
 - 
 
6143 
    while True:
 - 
 
6144 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
6145 
      if ftype == TType.STOP:
 - 
 
6146 
        break
 - 
 
6147 
      if fid == 1:
 - 
 
6148 
        if ftype == TType.I64:
 - 
 
6149 
          self.userId = iprot.readI64();
 - 
 
6150 
        else:
 - 
 
6151 
          iprot.skip(ftype)
 - 
 
6152 
      elif fid == 2:
 - 
 
6153 
        if ftype == TType.STRING:
 - 
 
6154 
          self.creditTxnType = iprot.readString();
 - 
 
6155 
        else:
 - 
 
6156 
          iprot.skip(ftype)
 - 
 
6157 
      else:
 - 
 
6158 
        iprot.skip(ftype)
 - 
 
6159 
      iprot.readFieldEnd()
 - 
 
6160 
    iprot.readStructEnd()
 - 
 
6161 
 
 - 
 
6162 
  def write(self, oprot):
 - 
 
6163 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
6164 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
6165 
      return
 - 
 
6166 
    oprot.writeStructBegin('getCreditHistoryRecordsForUserAndCreditor_args')
 - 
 
6167 
    if self.userId is not None:
 - 
 
6168 
      oprot.writeFieldBegin('userId', TType.I64, 1)
 - 
 
6169 
      oprot.writeI64(self.userId)
 - 
 
6170 
      oprot.writeFieldEnd()
 - 
 
6171 
    if self.creditTxnType is not None:
 - 
 
6172 
      oprot.writeFieldBegin('creditTxnType', TType.STRING, 2)
 - 
 
6173 
      oprot.writeString(self.creditTxnType)
 - 
 
6174 
      oprot.writeFieldEnd()
 - 
 
6175 
    oprot.writeFieldStop()
 - 
 
6176 
    oprot.writeStructEnd()
 - 
 
6177 
 
 - 
 
6178 
  def validate(self):
 - 
 
6179 
    return
 - 
 
6180 
 
 - 
 
6181 
 
 - 
 
6182 
  def __repr__(self):
 - 
 
6183 
    L = ['%s=%r' % (key, value)
 - 
 
6184 
      for key, value in self.__dict__.iteritems()]
 - 
 
6185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
6186 
 
 - 
 
6187 
  def __eq__(self, other):
 - 
 
6188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
6189 
 
 - 
 
6190 
  def __ne__(self, other):
 - 
 
6191 
    return not (self == other)
 - 
 
6192 
 
 - 
 
6193 
class getCreditHistoryRecordsForUserAndCreditor_result:
 - 
 
6194 
  """
 - 
 
6195 
  Attributes:
 - 
 
6196 
   - success
 - 
 
6197 
  """
 - 
 
6198 
 
 - 
 
6199 
  thrift_spec = (
 - 
 
6200 
    (0, TType.LIST, 'success', (TType.STRUCT,(CreditHistory, CreditHistory.thrift_spec)), None, ), # 0
 - 
 
6201 
  )
 - 
 
6202 
 
 - 
 
6203 
  def __init__(self, success=None,):
 - 
 
6204 
    self.success = success
 - 
 
6205 
 
 - 
 
6206 
  def read(self, iprot):
 - 
 
6207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
6208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
6209 
      return
 - 
 
6210 
    iprot.readStructBegin()
 - 
 
6211 
    while True:
 - 
 
6212 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
6213 
      if ftype == TType.STOP:
 - 
 
6214 
        break
 - 
 
6215 
      if fid == 0:
 - 
 
6216 
        if ftype == TType.LIST:
 - 
 
6217 
          self.success = []
 - 
 
6218 
          (_etype101, _size98) = iprot.readListBegin()
 - 
 
6219 
          for _i102 in xrange(_size98):
 - 
 
6220 
            _elem103 = CreditHistory()
 - 
 
6221 
            _elem103.read(iprot)
 - 
 
6222 
            self.success.append(_elem103)
 - 
 
6223 
          iprot.readListEnd()
 - 
 
6224 
        else:
 - 
 
6225 
          iprot.skip(ftype)
 - 
 
6226 
      else:
 - 
 
6227 
        iprot.skip(ftype)
 - 
 
6228 
      iprot.readFieldEnd()
 - 
 
6229 
    iprot.readStructEnd()
 - 
 
6230 
 
 - 
 
6231 
  def write(self, oprot):
 - 
 
6232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
6233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
6234 
      return
 - 
 
6235 
    oprot.writeStructBegin('getCreditHistoryRecordsForUserAndCreditor_result')
 - 
 
6236 
    if self.success is not None:
 - 
 
6237 
      oprot.writeFieldBegin('success', TType.LIST, 0)
 - 
 
6238 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
 - 
 
6239 
      for iter104 in self.success:
 - 
 
6240 
        iter104.write(oprot)
 - 
 
6241 
      oprot.writeListEnd()
 - 
 
6242 
      oprot.writeFieldEnd()
 - 
 
6243 
    oprot.writeFieldStop()
 - 
 
6244 
    oprot.writeStructEnd()
 - 
 
6245 
 
 - 
 
6246 
  def validate(self):
 - 
 
6247 
    return
 - 
 
6248 
 
 - 
 
6249 
 
 - 
 
6250 
  def __repr__(self):
 - 
 
6251 
    L = ['%s=%r' % (key, value)
 - 
 
6252 
      for key, value in self.__dict__.iteritems()]
 - 
 
6253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
6254 
 
 - 
 
6255 
  def __eq__(self, other):
 - 
 
6256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
6257 
 
 - 
 
6258 
  def __ne__(self, other):
 - 
 
6259 
    return not (self == other)
 - 
 
6260 
 
 - 
 
6261 
class processCreditTransaction_args:
 - 
 
6262 
  """
 - 
 
6263 
  Attributes:
 - 
 
6264 
   - paymentId
 - 
 
6265 
   - creditTxns
 - 
 
6266 
  """
 - 
 
6267 
 
 - 
 
6268 
  thrift_spec = (
 - 
 
6269 
    None, # 0
 - 
 
6270 
    (1, TType.I64, 'paymentId', None, None, ), # 1
 - 
 
6271 
    (2, TType.LIST, 'creditTxns', (TType.STRUCT,(CreditHistory, CreditHistory.thrift_spec)), None, ), # 2
 - 
 
6272 
  )
 - 
 
6273 
 
 - 
 
6274 
  def __init__(self, paymentId=None, creditTxns=None,):
 - 
 
6275 
    self.paymentId = paymentId
 - 
 
6276 
    self.creditTxns = creditTxns
 - 
 
6277 
 
 - 
 
6278 
  def read(self, iprot):
 - 
 
6279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
6280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
6281 
      return
 - 
 
6282 
    iprot.readStructBegin()
 - 
 
6283 
    while True:
 - 
 
6284 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
6285 
      if ftype == TType.STOP:
 - 
 
6286 
        break
 - 
 
6287 
      if fid == 1:
 - 
 
6288 
        if ftype == TType.I64:
 - 
 
6289 
          self.paymentId = iprot.readI64();
 - 
 
6290 
        else:
 - 
 
6291 
          iprot.skip(ftype)
 - 
 
6292 
      elif fid == 2:
 - 
 
6293 
        if ftype == TType.LIST:
 - 
 
6294 
          self.creditTxns = []
 - 
 
6295 
          (_etype108, _size105) = iprot.readListBegin()
 - 
 
6296 
          for _i109 in xrange(_size105):
 - 
 
6297 
            _elem110 = CreditHistory()
 - 
 
6298 
            _elem110.read(iprot)
 - 
 
6299 
            self.creditTxns.append(_elem110)
 - 
 
6300 
          iprot.readListEnd()
 - 
 
6301 
        else:
 - 
 
6302 
          iprot.skip(ftype)
 - 
 
6303 
      else:
 - 
 
6304 
        iprot.skip(ftype)
 - 
 
6305 
      iprot.readFieldEnd()
 - 
 
6306 
    iprot.readStructEnd()
 - 
 
6307 
 
 - 
 
6308 
  def write(self, oprot):
 - 
 
6309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
6310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
6311 
      return
 - 
 
6312 
    oprot.writeStructBegin('processCreditTransaction_args')
 - 
 
6313 
    if self.paymentId is not None:
 - 
 
6314 
      oprot.writeFieldBegin('paymentId', TType.I64, 1)
 - 
 
6315 
      oprot.writeI64(self.paymentId)
 - 
 
6316 
      oprot.writeFieldEnd()
 - 
 
6317 
    if self.creditTxns is not None:
 - 
 
6318 
      oprot.writeFieldBegin('creditTxns', TType.LIST, 2)
 - 
 
6319 
      oprot.writeListBegin(TType.STRUCT, len(self.creditTxns))
 - 
 
6320 
      for iter111 in self.creditTxns:
 - 
 
6321 
        iter111.write(oprot)
 - 
 
6322 
      oprot.writeListEnd()
 - 
 
6323 
      oprot.writeFieldEnd()
 - 
 
6324 
    oprot.writeFieldStop()
 - 
 
6325 
    oprot.writeStructEnd()
 - 
 
6326 
 
 - 
 
6327 
  def validate(self):
 - 
 
6328 
    return
 - 
 
6329 
 
 - 
 
6330 
 
 - 
 
6331 
  def __repr__(self):
 - 
 
6332 
    L = ['%s=%r' % (key, value)
 - 
 
6333 
      for key, value in self.__dict__.iteritems()]
 - 
 
6334 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
6335 
 
 - 
 
6336 
  def __eq__(self, other):
 - 
 
6337 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
6338 
 
 - 
 
6339 
  def __ne__(self, other):
 - 
 
6340 
    return not (self == other)
 - 
 
6341 
 
 - 
 
6342 
class processCreditTransaction_result:
 - 
 
6343 
  """
 - 
 
6344 
  Attributes:
 - 
 
6345 
   - success
 - 
 
6346 
   - pe
 - 
 
6347 
  """
 - 
 
6348 
 
 - 
 
6349 
  thrift_spec = (
 - 
 
6350 
    (0, TType.BOOL, 'success', None, None, ), # 0
 - 
 
6351 
    (1, TType.STRUCT, 'pe', (PaymentException, PaymentException.thrift_spec), None, ), # 1
 - 
 
6352 
  )
 - 
 
6353 
 
 - 
 
6354 
  def __init__(self, success=None, pe=None,):
 - 
 
6355 
    self.success = success
 - 
 
6356 
    self.pe = pe
 - 
 
6357 
 
 - 
 
6358 
  def read(self, iprot):
 - 
 
6359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
6360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
6361 
      return
 - 
 
6362 
    iprot.readStructBegin()
 - 
 
6363 
    while True:
 - 
 
6364 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
6365 
      if ftype == TType.STOP:
 - 
 
6366 
        break
 - 
 
6367 
      if fid == 0:
 - 
 
6368 
        if ftype == TType.BOOL:
 - 
 
6369 
          self.success = iprot.readBool();
 - 
 
6370 
        else:
 - 
 
6371 
          iprot.skip(ftype)
 - 
 
6372 
      elif fid == 1:
 - 
 
6373 
        if ftype == TType.STRUCT:
 - 
 
6374 
          self.pe = PaymentException()
 - 
 
6375 
          self.pe.read(iprot)
 - 
 
6376 
        else:
 - 
 
6377 
          iprot.skip(ftype)
 - 
 
6378 
      else:
 - 
 
6379 
        iprot.skip(ftype)
 - 
 
6380 
      iprot.readFieldEnd()
 - 
 
6381 
    iprot.readStructEnd()
 - 
 
6382 
 
 - 
 
6383 
  def write(self, oprot):
 - 
 
6384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
6385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
6386 
      return
 - 
 
6387 
    oprot.writeStructBegin('processCreditTransaction_result')
 - 
 
6388 
    if self.success is not None:
 - 
 
6389 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
 - 
 
6390 
      oprot.writeBool(self.success)
 - 
 
6391 
      oprot.writeFieldEnd()
 - 
 
6392 
    if self.pe is not None:
 - 
 
6393 
      oprot.writeFieldBegin('pe', TType.STRUCT, 1)
 - 
 
6394 
      self.pe.write(oprot)
 - 
 
6395 
      oprot.writeFieldEnd()
 - 
 
6396 
    oprot.writeFieldStop()
 - 
 
6397 
    oprot.writeStructEnd()
 - 
 
6398 
 
 - 
 
6399 
  def validate(self):
 - 
 
6400 
    return
 - 
 
6401 
 
 - 
 
6402 
 
 - 
 
6403 
  def __repr__(self):
 - 
 
6404 
    L = ['%s=%r' % (key, value)
 - 
 
6405 
      for key, value in self.__dict__.iteritems()]
 - 
 
6406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
6407 
 
 - 
 
6408 
  def __eq__(self, other):
 - 
 
6409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
6410 
 
 - 
 
6411 
  def __ne__(self, other):
 - 
 
6412 
    return not (self == other)
 - 
 
6413 
 
 - 
 
6414 
class getLoanPayableForUserToCreditor_args:
 - 
 
6415 
  """
 - 
 
6416 
  Attributes:
 - 
 
6417 
   - userId
 - 
 
6418 
   - creditorId
 - 
 
6419 
   - dueDate
 - 
 
6420 
  """
 - 
 
6421 
 
 - 
 
6422 
  thrift_spec = (
 - 
 
6423 
    None, # 0
 - 
 
6424 
    (1, TType.I64, 'userId', None, None, ), # 1
 - 
 
6425 
    (2, TType.I64, 'creditorId', None, None, ), # 2
 - 
 
6426 
    (3, TType.I64, 'dueDate', None, None, ), # 3
 - 
 
6427 
  )
 - 
 
6428 
 
 - 
 
6429 
  def __init__(self, userId=None, creditorId=None, dueDate=None,):
 - 
 
6430 
    self.userId = userId
 - 
 
6431 
    self.creditorId = creditorId
 - 
 
6432 
    self.dueDate = dueDate
 - 
 
6433 
 
 - 
 
6434 
  def read(self, iprot):
 - 
 
6435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
6436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
6437 
      return
 - 
 
6438 
    iprot.readStructBegin()
 - 
 
6439 
    while True:
 - 
 
6440 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
6441 
      if ftype == TType.STOP:
 - 
 
6442 
        break
 - 
 
6443 
      if fid == 1:
 - 
 
6444 
        if ftype == TType.I64:
 - 
 
6445 
          self.userId = iprot.readI64();
 - 
 
6446 
        else:
 - 
 
6447 
          iprot.skip(ftype)
 - 
 
6448 
      elif fid == 2:
 - 
 
6449 
        if ftype == TType.I64:
 - 
 
6450 
          self.creditorId = iprot.readI64();
 - 
 
6451 
        else:
 - 
 
6452 
          iprot.skip(ftype)
 - 
 
6453 
      elif fid == 3:
 - 
 
6454 
        if ftype == TType.I64:
 - 
 
6455 
          self.dueDate = iprot.readI64();
 - 
 
6456 
        else:
 - 
 
6457 
          iprot.skip(ftype)
 - 
 
6458 
      else:
 - 
 
6459 
        iprot.skip(ftype)
 - 
 
6460 
      iprot.readFieldEnd()
 - 
 
6461 
    iprot.readStructEnd()
 - 
 
6462 
 
 - 
 
6463 
  def write(self, oprot):
 - 
 
6464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
6465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
6466 
      return
 - 
 
6467 
    oprot.writeStructBegin('getLoanPayableForUserToCreditor_args')
 - 
 
6468 
    if self.userId is not None:
 - 
 
6469 
      oprot.writeFieldBegin('userId', TType.I64, 1)
 - 
 
6470 
      oprot.writeI64(self.userId)
 - 
 
6471 
      oprot.writeFieldEnd()
 - 
 
6472 
    if self.creditorId is not None:
 - 
 
6473 
      oprot.writeFieldBegin('creditorId', TType.I64, 2)
 - 
 
6474 
      oprot.writeI64(self.creditorId)
 - 
 
6475 
      oprot.writeFieldEnd()
 - 
 
6476 
    if self.dueDate is not None:
 - 
 
6477 
      oprot.writeFieldBegin('dueDate', TType.I64, 3)
 - 
 
6478 
      oprot.writeI64(self.dueDate)
 - 
 
6479 
      oprot.writeFieldEnd()
 - 
 
6480 
    oprot.writeFieldStop()
 - 
 
6481 
    oprot.writeStructEnd()
 - 
 
6482 
 
 - 
 
6483 
  def validate(self):
 - 
 
6484 
    return
 - 
 
6485 
 
 - 
 
6486 
 
 - 
 
6487 
  def __repr__(self):
 - 
 
6488 
    L = ['%s=%r' % (key, value)
 - 
 
6489 
      for key, value in self.__dict__.iteritems()]
 - 
 
6490 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
 - 
 
6491 
 
 - 
 
6492 
  def __eq__(self, other):
 - 
 
6493 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
 - 
 
6494 
 
 - 
 
6495 
  def __ne__(self, other):
 - 
 
6496 
    return not (self == other)
 - 
 
6497 
 
 - 
 
6498 
class getLoanPayableForUserToCreditor_result:
 - 
 
6499 
  """
 - 
 
6500 
  Attributes:
 - 
 
6501 
   - success
 - 
 
6502 
  """
 - 
 
6503 
 
 - 
 
6504 
  thrift_spec = (
 - 
 
6505 
    (0, TType.LIST, 'success', (TType.STRUCT,(CreditHistory, CreditHistory.thrift_spec)), None, ), # 0
 - 
 
6506 
  )
 - 
 
6507 
 
 - 
 
6508 
  def __init__(self, success=None,):
 - 
 
6509 
    self.success = success
 - 
 
6510 
 
 - 
 
6511 
  def read(self, iprot):
 - 
 
6512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
 - 
 
6513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
 - 
 
6514 
      return
 - 
 
6515 
    iprot.readStructBegin()
 - 
 
6516 
    while True:
 - 
 
6517 
      (fname, ftype, fid) = iprot.readFieldBegin()
 - 
 
6518 
      if ftype == TType.STOP:
 - 
 
6519 
        break
 - 
 
6520 
      if fid == 0:
 - 
 
6521 
        if ftype == TType.LIST:
 - 
 
6522 
          self.success = []
 - 
 
6523 
          (_etype115, _size112) = iprot.readListBegin()
 - 
 
6524 
          for _i116 in xrange(_size112):
 - 
 
6525 
            _elem117 = CreditHistory()
 - 
 
6526 
            _elem117.read(iprot)
 - 
 
6527 
            self.success.append(_elem117)
 - 
 
6528 
          iprot.readListEnd()
 - 
 
6529 
        else:
 - 
 
6530 
          iprot.skip(ftype)
 - 
 
6531 
      else:
 - 
 
6532 
        iprot.skip(ftype)
 - 
 
6533 
      iprot.readFieldEnd()
 - 
 
6534 
    iprot.readStructEnd()
 - 
 
6535 
 
 - 
 
6536 
  def write(self, oprot):
 - 
 
6537 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
 - 
 
6538 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
 - 
 
6539 
      return
 - 
 
6540 
    oprot.writeStructBegin('getLoanPayableForUserToCreditor_result')
 - 
 
6541 
    if self.success is not None:
 - 
 
6542 
      oprot.writeFieldBegin('success', TType.LIST, 0)
 - 
 
6543 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
 - 
 
6544 
      for iter118 in self.success:
 - 
 
6545 
        iter118.write(oprot)
 - 
 
6546 
      oprot.writeListEnd()
 - 
 
6547 
      oprot.writeFieldEnd()
 - 
 
6548 
    oprot.writeFieldStop()
 - 
 
6549 
    oprot.writeStructEnd()
 - 
 
6550 
 
 - 
 
6551 
  def validate(self):
 - 
 
6552 
    return
 4840 
    return
6553 
 
 4841 
 
6554 
 
 4842 
 
6555 
  def __repr__(self):
 4843 
  def __repr__(self):
6556 
    L = ['%s=%r' % (key, value)
 4844 
    L = ['%s=%r' % (key, value)