Subversion Repositories SmartDukaan

Rev

Rev 1976 | Rev 2035 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
94 ashish 1 
#
2 
# Autogenerated by Thrift
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
from ttypes import *
9 
from thrift.Thrift import TProcessor
10 
from thrift.transport import TTransport
11 
from thrift.protocol import TBinaryProtocol
12 
try:
13 
  from thrift.protocol import fastbinary
14 
except:
15 
  fastbinary = None
16 
 
17 
 
18 
class Iface:
19 
  """
20 
  service
21 
  """
765 rajveer 22 
  def closeSession(self, ):
23 
    """
24 
    For closing the open session in sqlalchemy
25 
    """
26 
    pass
27 
 
559 chandransh 28 
  def createAnonymousUser(self, jsessionId):
94 ashish 29 
    """
30 
    Parameters:
559 chandransh 31 
     - jsessionId
94 ashish 32 
    """
33 
    pass
34 
 
559 chandransh 35 
  def getUserById(self, userId):
94 ashish 36 
    """
37 
    Parameters:
38 
     - userId
39 
    """
40 
    pass
41 
 
1491 vikas 42 
  def getUserByEmail(self, email):
43 
    """
44 
    Parameters:
45 
     - email
46 
    """
47 
    pass
48 
 
559 chandransh 49 
  def createUser(self, user):
94 ashish 50 
    """
51 
    Parameters:
559 chandransh 52 
     - user
94 ashish 53 
    """
54 
    pass
55 
 
559 chandransh 56 
  def updateUser(self, user):
94 ashish 57 
    """
58 
    Parameters:
559 chandransh 59 
     - user
94 ashish 60 
    """
61 
    pass
62 
 
559 chandransh 63 
  def deleteUser(self, userId):
94 ashish 64 
    """
65 
    Parameters:
66 
     - userId
67 
    """
68 
    pass
69 
 
559 chandransh 70 
  def getUserState(self, userId):
94 ashish 71 
    """
72 
    Parameters:
73 
     - userId
74 
    """
75 
    pass
76 
 
559 chandransh 77 
  def authenticateUser(self, email, password):
94 ashish 78 
    """
79 
    Parameters:
80 
     - email
81 
     - password
82 
    """
83 
    pass
84 
 
85 
  def userExists(self, email):
86 
    """
87 
    Parameters:
88 
     - email
89 
    """
90 
    pass
91 
 
567 rajveer 92 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 93 
    """
94 
    Parameters:
95 
     - userId
96 
     - address
513 rajveer 97 
     - setDefault
94 ashish 98 
    """
99 
    pass
100 
 
101 
  def removeAddressForUser(self, userid, addressId):
102 
    """
103 
    Parameters:
104 
     - userid
105 
     - addressId
106 
    """
107 
    pass
108 
 
109 
  def setUserAsLoggedIn(self, userId, timestamp):
110 
    """
111 
    Parameters:
112 
     - userId
113 
     - timestamp
114 
    """
115 
    pass
116 
 
117 
  def setUserAsLoggedOut(self, userid, timestamp):
118 
    """
119 
    Parameters:
120 
     - userid
121 
     - timestamp
122 
    """
123 
    pass
124 
 
504 rajveer 125 
  def setDefaultAddress(self, userid, addressId):
126 
    """
127 
    Parameters:
128 
     - userid
129 
     - addressId
130 
    """
131 
    pass
132 
 
594 rajveer 133 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 134 
    """
135 
    Parameters:
136 
     - userid
594 rajveer 137 
     - oldPassword
138 
     - newPassword
94 ashish 139 
    """
140 
    pass
141 
 
884 rajveer 142 
  def forgotPassword(self, email, newPassword):
581 rajveer 143 
    """
144 
    Parameters:
145 
     - email
884 rajveer 146 
     - newPassword
581 rajveer 147 
    """
148 
    pass
149 
 
594 rajveer 150 
  def getAllAddressesForUser(self, userId):
151 
    """
152 
    Parameters:
153 
     - userId
154 
    """
155 
    pass
156 
 
1894 vikas 157 
  def getAddressById(self, addressId):
158 
    """
159 
    Parameters:
160 
     - addressId
161 
    """
162 
    pass
163 
 
594 rajveer 164 
  def getDefaultAddressId(self, userId):
165 
    """
166 
    Parameters:
167 
     - userId
168 
    """
169 
    pass
170 
 
785 rajveer 171 
  def getDefaultPincode(self, userId):
172 
    """
173 
    Parameters:
174 
     - userId
175 
    """
176 
    pass
177 
 
1274 varun.gupt 178 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
179 
    """
180 
    Parameters:
181 
     - userId
182 
     - replyTo
183 
     - communicationType
184 
     - orderId
185 
     - airwaybillNo
186 
     - productName
187 
     - subject
188 
     - message
189 
    """
190 
    pass
191 
 
1590 varun.gupt 192 
  def getUserCommunicationById(self, id):
193 
    """
194 
    Parameters:
195 
     - id
196 
    """
197 
    pass
198 
 
199 
  def getUserCommunicationByUser(self, userId):
200 
    """
201 
    Parameters:
202 
     - userId
203 
    """
204 
    pass
205 
 
206 
  def getAllUserCommunications(self, ):
207 
    pass
208 
 
1859 vikas 209 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 210 
    """
211 
    Parameters:
212 
     - name
1859 vikas 213 
     - addedOn
1845 vikas 214 
    """
215 
    pass
216 
 
1899 vikas 217 
  def getAllMasterAffiliates(self, ):
218 
    pass
219 
 
1845 vikas 220 
  def getMasterAffiliateById(self, id):
221 
    """
222 
    Parameters:
223 
     - id
224 
    """
225 
    pass
226 
 
227 
  def getMasterAffiliateByName(self, name):
228 
    """
229 
    Parameters:
230 
     - name
231 
    """
232 
    pass
233 
 
1859 vikas 234 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 235 
    """
236 
    Parameters:
237 
     - name
238 
     - url
239 
     - masterAffiliateId
1859 vikas 240 
     - addedOn
1845 vikas 241 
    """
242 
    pass
243 
 
244 
  def getAffiliateById(self, id):
245 
    """
246 
    Parameters:
247 
     - id
248 
    """
249 
    pass
250 
 
251 
  def getAffiliateByName(self, name):
252 
    """
253 
    Parameters:
254 
     - name
255 
    """
256 
    pass
257 
 
1996 vikas 258 
  def getTrackerById(self, id):
1845 vikas 259 
    """
260 
    Parameters:
261 
     - id
262 
    """
263 
    pass
264 
 
1996 vikas 265 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 266 
    """
267 
    Parameters:
1996 vikas 268 
     - id
1845 vikas 269 
    """
270 
    pass
271 
 
1996 vikas 272 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 273 
    """
274 
    Parameters:
275 
     - affiliateId
276 
     - userId
277 
     - event
278 
     - url
279 
     - data
1859 vikas 280 
     - addedOn
1845 vikas 281 
    """
282 
    pass
283 
 
284 
  def getTrackLogById(self, id):
285 
    """
286 
    Parameters:
287 
     - id
288 
    """
289 
    pass
290 
 
1996 vikas 291 
  def getTrackLogsByAffiliate(self, affiliateId):
1845 vikas 292 
    """
293 
    Parameters:
1996 vikas 294 
     - affiliateId
1845 vikas 295 
    """
296 
    pass
297 
 
298 
  def getTrackLogsByUser(self, userId):
299 
    """
300 
    Parameters:
301 
     - userId
302 
    """
303 
    pass
304 
 
1996 vikas 305 
  def getTrackLogs(self, userId, event, url):
1845 vikas 306 
    """
307 
    Parameters:
308 
     - userId
309 
     - event
310 
     - url
311 
    """
312 
    pass
313 
 
559 chandransh 314 
  def createCart(self, userId):
94 ashish 315 
    """
316 
    Parameters:
559 chandransh 317 
     - userId
94 ashish 318 
    """
319 
    pass
320 
 
559 chandransh 321 
  def getCurrentCart(self, userId):
94 ashish 322 
    """
323 
    Parameters:
559 chandransh 324 
     - userId
94 ashish 325 
    """
326 
    pass
327 
 
559 chandransh 328 
  def getCart(self, cartId):
94 ashish 329 
    """
330 
    Parameters:
559 chandransh 331 
     - cartId
94 ashish 332 
    """
333 
    pass
334 
 
559 chandransh 335 
  def getCartsForUser(self, userId, status):
94 ashish 336 
    """
337 
    Parameters:
559 chandransh 338 
     - userId
339 
     - status
94 ashish 340 
    """
341 
    pass
342 
 
559 chandransh 343 
  def getCartsByStatus(self, status):
94 ashish 344 
    """
345 
    Parameters:
559 chandransh 346 
     - status
94 ashish 347 
    """
348 
    pass
349 
 
559 chandransh 350 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 351 
    """
352 
    Parameters:
559 chandransh 353 
     - from_time
354 
     - to_time
355 
     - status
94 ashish 356 
    """
357 
    pass
358 
 
559 chandransh 359 
  def changeCartStatus(self, cartId, status):
130 ashish 360 
    """
361 
    Parameters:
559 chandransh 362 
     - cartId
363 
     - status
130 ashish 364 
    """
365 
    pass
94 ashish 366 
 
559 chandransh 367 
  def addItemToCart(self, cartId, itemId, quantity):
130 ashish 368 
    """
369 
    Parameters:
559 chandransh 370 
     - cartId
371 
     - itemId
372 
     - quantity
130 ashish 373 
    """
374 
    pass
375 
 
559 chandransh 376 
  def deleteItemFromCart(self, cartId, itemId):
377 
    """
378 
    Parameters:
379 
     - cartId
380 
     - itemId
381 
    """
382 
    pass
130 ashish 383 
 
559 chandransh 384 
  def changeQuantity(self, cartId, itemId, quantity):
385 
    """
386 
    Parameters:
387 
     - cartId
388 
     - itemId
389 
     - quantity
390 
    """
391 
    pass
392 
 
393 
  def changeItemStatus(self, cartId, itemId, status):
394 
    """
395 
    Parameters:
396 
     - cartId
397 
     - itemId
398 
     - status
399 
    """
400 
    pass
401 
 
402 
  def addAddressToCart(self, cartId, addressId):
403 
    """
404 
    Parameters:
405 
     - cartId
406 
     - addressId
407 
    """
408 
    pass
409 
 
1976 varun.gupt 410 
  def applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
411 
    """
412 
    Parameters:
413 
     - cartId
414 
     - couponCode
415 
     - totalPrice
416 
     - discountedPrice
417 
    """
418 
    pass
419 
 
420 
  def removeCoupon(self, cartId):
421 
    """
422 
    Parameters:
423 
     - cartId
424 
    """
425 
    pass
426 
 
690 chandransh 427 
  def createOrders(self, cartId):
559 chandransh 428 
    """
690 chandransh 429 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
430 
 
559 chandransh 431 
    Parameters:
432 
     - cartId
433 
    """
434 
    pass
435 
 
436 
  def validateCart(self, cartId):
437 
    """
690 chandransh 438 
    Validates that:
439 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 440 
    2. All of the lines in the cart are active items.
690 chandransh 441 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 442 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 443 
 
559 chandransh 444 
    Parameters:
445 
     - cartId
446 
    """
447 
    pass
448 
 
690 chandransh 449 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 450 
    """
690 chandransh 451 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
452 
 
575 chandransh 453 
    Parameters:
690 chandransh 454 
     - fromCartId
455 
     - toCartId
456 
    """
457 
    pass
458 
 
459 
  def checkOut(self, cartId):
460 
    """
461 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
462 
 
463 
    Parameters:
575 chandransh 464 
     - cartId
465 
    """
466 
    pass
467 
 
690 chandransh 468 
  def resetCart(self, cartId, items):
559 chandransh 469 
    """
690 chandransh 470 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
471 
    This methods removes the specified quantiry of the specified item from the cart.
472 
 
559 chandransh 473 
    Parameters:
690 chandransh 474 
     - cartId
475 
     - items
559 chandransh 476 
    """
477 
    pass
478 
 
772 rajveer 479 
  def getMyResearch(self, userId):
559 chandransh 480 
    """
772 rajveer 481 
    Widgets
482 
 
559 chandransh 483 
    Parameters:
772 rajveer 484 
     - userId
559 chandransh 485 
    """
486 
    pass
487 
 
772 rajveer 488 
  def updateMyResearch(self, userId, itemId):
559 chandransh 489 
    """
490 
    Parameters:
772 rajveer 491 
     - userId
492 
     - itemId
559 chandransh 493 
    """
494 
    pass
495 
 
772 rajveer 496 
  def deleteItemFromMyResearch(self, userId, itemId):
559 chandransh 497 
    """
498 
    Parameters:
772 rajveer 499 
     - userId
500 
     - itemId
559 chandransh 501 
    """
502 
    pass
503 
 
772 rajveer 504 
  def updateBrowseHistory(self, userId, itemId):
559 chandransh 505 
    """
506 
    Parameters:
772 rajveer 507 
     - userId
508 
     - itemId
559 chandransh 509 
    """
510 
    pass
511 
 
772 rajveer 512 
  def getBrowseHistory(self, userId):
559 chandransh 513 
    """
514 
    Parameters:
515 
     - userId
516 
    """
517 
    pass
518 
 
772 rajveer 519 
  def mergeBrowseHistory(self, fromUserId, toUserId):
559 chandransh 520 
    """
521 
    Parameters:
772 rajveer 522 
     - fromUserId
523 
     - toUserId
559 chandransh 524 
    """
525 
    pass
526 
 
1596 ankur.sing 527 
  def getUserCount(self, userType):
528 
    """
529 
    Returns number of registered users.
530 
    If userType = null, then it returns count of all users, including anonymous
531 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
532 
    If userType = UserType.USER, then it returns count of non-anonymous users only
533 
 
534 
    Parameters:
535 
     - userType
536 
    """
537 
    pass
559 chandransh 538 
 
1891 ankur.sing 539 
  def getAllUsers(self, userType, startDate, endDate):
1673 ankur.sing 540 
    """
1891 ankur.sing 541 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
542 
    If any of startDate or endDate is -1, then that filter is ignored.
543 
    If userType is null, then returns all the users, irrespective of anonymous flag
1673 ankur.sing 544 
 
1891 ankur.sing 545 
 
1673 ankur.sing 546 
    Parameters:
547 
     - userType
1891 ankur.sing 548 
     - startDate
549 
     - endDate
1673 ankur.sing 550 
    """
551 
    pass
1596 ankur.sing 552 
 
1673 ankur.sing 553 
 
94 ashish 554 
class Client(Iface):
555 
  """
556 
  service
557 
  """
558 
  def __init__(self, iprot, oprot=None):
559 
    self._iprot = self._oprot = iprot
560 
    if oprot != None:
561 
      self._oprot = oprot
562 
    self._seqid = 0
563 
 
765 rajveer 564 
  def closeSession(self, ):
565 
    """
566 
    For closing the open session in sqlalchemy
567 
    """
568 
    self.send_closeSession()
569 
    self.recv_closeSession()
570 
 
571 
  def send_closeSession(self, ):
572 
    self._oprot.writeMessageBegin('closeSession', TMessageType.CALL, self._seqid)
573 
    args = closeSession_args()
574 
    args.write(self._oprot)
575 
    self._oprot.writeMessageEnd()
576 
    self._oprot.trans.flush()
577 
 
578 
  def recv_closeSession(self, ):
579 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
580 
    if mtype == TMessageType.EXCEPTION:
581 
      x = TApplicationException()
582 
      x.read(self._iprot)
583 
      self._iprot.readMessageEnd()
584 
      raise x
585 
    result = closeSession_result()
586 
    result.read(self._iprot)
587 
    self._iprot.readMessageEnd()
588 
    return
589 
 
559 chandransh 590 
  def createAnonymousUser(self, jsessionId):
94 ashish 591 
    """
592 
    Parameters:
559 chandransh 593 
     - jsessionId
94 ashish 594 
    """
559 chandransh 595 
    self.send_createAnonymousUser(jsessionId)
596 
    return self.recv_createAnonymousUser()
94 ashish 597 
 
559 chandransh 598 
  def send_createAnonymousUser(self, jsessionId):
599 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
600 
    args = createAnonymousUser_args()
601 
    args.jsessionId = jsessionId
94 ashish 602 
    args.write(self._oprot)
603 
    self._oprot.writeMessageEnd()
604 
    self._oprot.trans.flush()
605 
 
559 chandransh 606 
  def recv_createAnonymousUser(self, ):
94 ashish 607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
608 
    if mtype == TMessageType.EXCEPTION:
609 
      x = TApplicationException()
610 
      x.read(self._iprot)
611 
      self._iprot.readMessageEnd()
612 
      raise x
559 chandransh 613 
    result = createAnonymousUser_result()
94 ashish 614 
    result.read(self._iprot)
615 
    self._iprot.readMessageEnd()
616 
    if result.success != None:
617 
      return result.success
559 chandransh 618 
    if result.ucex != None:
619 
      raise result.ucex
620 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 621 
 
559 chandransh 622 
  def getUserById(self, userId):
94 ashish 623 
    """
624 
    Parameters:
625 
     - userId
626 
    """
559 chandransh 627 
    self.send_getUserById(userId)
628 
    return self.recv_getUserById()
94 ashish 629 
 
559 chandransh 630 
  def send_getUserById(self, userId):
631 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
632 
    args = getUserById_args()
94 ashish 633 
    args.userId = userId
634 
    args.write(self._oprot)
635 
    self._oprot.writeMessageEnd()
636 
    self._oprot.trans.flush()
637 
 
559 chandransh 638 
  def recv_getUserById(self, ):
94 ashish 639 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
640 
    if mtype == TMessageType.EXCEPTION:
641 
      x = TApplicationException()
642 
      x.read(self._iprot)
643 
      self._iprot.readMessageEnd()
644 
      raise x
559 chandransh 645 
    result = getUserById_result()
94 ashish 646 
    result.read(self._iprot)
647 
    self._iprot.readMessageEnd()
648 
    if result.success != None:
649 
      return result.success
559 chandransh 650 
    if result.ucex != None:
651 
      raise result.ucex
652 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 653 
 
1491 vikas 654 
  def getUserByEmail(self, email):
655 
    """
656 
    Parameters:
657 
     - email
658 
    """
659 
    self.send_getUserByEmail(email)
660 
    return self.recv_getUserByEmail()
661 
 
662 
  def send_getUserByEmail(self, email):
663 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
664 
    args = getUserByEmail_args()
665 
    args.email = email
666 
    args.write(self._oprot)
667 
    self._oprot.writeMessageEnd()
668 
    self._oprot.trans.flush()
669 
 
670 
  def recv_getUserByEmail(self, ):
671 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
672 
    if mtype == TMessageType.EXCEPTION:
673 
      x = TApplicationException()
674 
      x.read(self._iprot)
675 
      self._iprot.readMessageEnd()
676 
      raise x
677 
    result = getUserByEmail_result()
678 
    result.read(self._iprot)
679 
    self._iprot.readMessageEnd()
680 
    if result.success != None:
681 
      return result.success
682 
    if result.ucex != None:
683 
      raise result.ucex
684 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
685 
 
559 chandransh 686 
  def createUser(self, user):
94 ashish 687 
    """
688 
    Parameters:
559 chandransh 689 
     - user
94 ashish 690 
    """
559 chandransh 691 
    self.send_createUser(user)
692 
    return self.recv_createUser()
94 ashish 693 
 
559 chandransh 694 
  def send_createUser(self, user):
695 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
696 
    args = createUser_args()
697 
    args.user = user
94 ashish 698 
    args.write(self._oprot)
699 
    self._oprot.writeMessageEnd()
700 
    self._oprot.trans.flush()
701 
 
559 chandransh 702 
  def recv_createUser(self, ):
94 ashish 703 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
704 
    if mtype == TMessageType.EXCEPTION:
705 
      x = TApplicationException()
706 
      x.read(self._iprot)
707 
      self._iprot.readMessageEnd()
708 
      raise x
559 chandransh 709 
    result = createUser_result()
94 ashish 710 
    result.read(self._iprot)
711 
    self._iprot.readMessageEnd()
712 
    if result.success != None:
713 
      return result.success
559 chandransh 714 
    if result.ucex != None:
715 
      raise result.ucex
716 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 717 
 
559 chandransh 718 
  def updateUser(self, user):
94 ashish 719 
    """
720 
    Parameters:
559 chandransh 721 
     - user
94 ashish 722 
    """
559 chandransh 723 
    self.send_updateUser(user)
724 
    return self.recv_updateUser()
94 ashish 725 
 
559 chandransh 726 
  def send_updateUser(self, user):
727 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
728 
    args = updateUser_args()
729 
    args.user = user
94 ashish 730 
    args.write(self._oprot)
731 
    self._oprot.writeMessageEnd()
732 
    self._oprot.trans.flush()
733 
 
559 chandransh 734 
  def recv_updateUser(self, ):
94 ashish 735 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
736 
    if mtype == TMessageType.EXCEPTION:
737 
      x = TApplicationException()
738 
      x.read(self._iprot)
739 
      self._iprot.readMessageEnd()
740 
      raise x
559 chandransh 741 
    result = updateUser_result()
94 ashish 742 
    result.read(self._iprot)
743 
    self._iprot.readMessageEnd()
744 
    if result.success != None:
745 
      return result.success
559 chandransh 746 
    if result.ucex != None:
747 
      raise result.ucex
748 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 749 
 
559 chandransh 750 
  def deleteUser(self, userId):
94 ashish 751 
    """
752 
    Parameters:
753 
     - userId
754 
    """
559 chandransh 755 
    self.send_deleteUser(userId)
756 
    return self.recv_deleteUser()
94 ashish 757 
 
559 chandransh 758 
  def send_deleteUser(self, userId):
759 
    self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
760 
    args = deleteUser_args()
94 ashish 761 
    args.userId = userId
762 
    args.write(self._oprot)
763 
    self._oprot.writeMessageEnd()
764 
    self._oprot.trans.flush()
765 
 
559 chandransh 766 
  def recv_deleteUser(self, ):
94 ashish 767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
768 
    if mtype == TMessageType.EXCEPTION:
769 
      x = TApplicationException()
770 
      x.read(self._iprot)
771 
      self._iprot.readMessageEnd()
772 
      raise x
559 chandransh 773 
    result = deleteUser_result()
94 ashish 774 
    result.read(self._iprot)
775 
    self._iprot.readMessageEnd()
776 
    if result.success != None:
777 
      return result.success
559 chandransh 778 
    if result.ucex != None:
779 
      raise result.ucex
780 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
94 ashish 781 
 
559 chandransh 782 
  def getUserState(self, userId):
94 ashish 783 
    """
784 
    Parameters:
785 
     - userId
786 
    """
559 chandransh 787 
    self.send_getUserState(userId)
788 
    return self.recv_getUserState()
94 ashish 789 
 
559 chandransh 790 
  def send_getUserState(self, userId):
791 
    self._oprot.writeMessageBegin('getUserState', TMessageType.CALL, self._seqid)
792 
    args = getUserState_args()
94 ashish 793 
    args.userId = userId
794 
    args.write(self._oprot)
795 
    self._oprot.writeMessageEnd()
796 
    self._oprot.trans.flush()
797 
 
559 chandransh 798 
  def recv_getUserState(self, ):
94 ashish 799 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
800 
    if mtype == TMessageType.EXCEPTION:
801 
      x = TApplicationException()
802 
      x.read(self._iprot)
803 
      self._iprot.readMessageEnd()
804 
      raise x
559 chandransh 805 
    result = getUserState_result()
94 ashish 806 
    result.read(self._iprot)
807 
    self._iprot.readMessageEnd()
808 
    if result.success != None:
809 
      return result.success
559 chandransh 810 
    if result.ucex != None:
811 
      raise result.ucex
812 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserState failed: unknown result");
94 ashish 813 
 
559 chandransh 814 
  def authenticateUser(self, email, password):
94 ashish 815 
    """
816 
    Parameters:
817 
     - email
818 
     - password
819 
    """
559 chandransh 820 
    self.send_authenticateUser(email, password)
122 ashish 821 
    return self.recv_authenticateUser()
822 
 
559 chandransh 823 
  def send_authenticateUser(self, email, password):
122 ashish 824 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
825 
    args = authenticateUser_args()
559 chandransh 826 
    args.email = email
122 ashish 827 
    args.password = password
828 
    args.write(self._oprot)
829 
    self._oprot.writeMessageEnd()
830 
    self._oprot.trans.flush()
831 
 
832 
  def recv_authenticateUser(self, ):
833 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
834 
    if mtype == TMessageType.EXCEPTION:
835 
      x = TApplicationException()
836 
      x.read(self._iprot)
837 
      self._iprot.readMessageEnd()
838 
      raise x
839 
    result = authenticateUser_result()
840 
    result.read(self._iprot)
841 
    self._iprot.readMessageEnd()
842 
    if result.success != None:
843 
      return result.success
559 chandransh 844 
    if result.auex != None:
845 
      raise result.auex
122 ashish 846 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
847 
 
94 ashish 848 
  def userExists(self, email):
849 
    """
850 
    Parameters:
851 
     - email
852 
    """
853 
    self.send_userExists(email)
854 
    return self.recv_userExists()
855 
 
856 
  def send_userExists(self, email):
857 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
858 
    args = userExists_args()
859 
    args.email = email
860 
    args.write(self._oprot)
861 
    self._oprot.writeMessageEnd()
862 
    self._oprot.trans.flush()
863 
 
864 
  def recv_userExists(self, ):
865 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
866 
    if mtype == TMessageType.EXCEPTION:
867 
      x = TApplicationException()
868 
      x.read(self._iprot)
869 
      self._iprot.readMessageEnd()
870 
      raise x
871 
    result = userExists_result()
872 
    result.read(self._iprot)
873 
    self._iprot.readMessageEnd()
874 
    if result.success != None:
875 
      return result.success
876 
    if result.ucx != None:
877 
      raise result.ucx
878 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
879 
 
567 rajveer 880 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 881 
    """
882 
    Parameters:
883 
     - userId
884 
     - address
513 rajveer 885 
     - setDefault
94 ashish 886 
    """
567 rajveer 887 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 888 
    return self.recv_addAddressForUser()
889 
 
567 rajveer 890 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 891 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
892 
    args = addAddressForUser_args()
559 chandransh 893 
    args.userId = userId
94 ashish 894 
    args.address = address
513 rajveer 895 
    args.setDefault = setDefault
94 ashish 896 
    args.write(self._oprot)
897 
    self._oprot.writeMessageEnd()
898 
    self._oprot.trans.flush()
899 
 
900 
  def recv_addAddressForUser(self, ):
901 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
902 
    if mtype == TMessageType.EXCEPTION:
903 
      x = TApplicationException()
904 
      x.read(self._iprot)
905 
      self._iprot.readMessageEnd()
906 
      raise x
907 
    result = addAddressForUser_result()
908 
    result.read(self._iprot)
909 
    self._iprot.readMessageEnd()
910 
    if result.success != None:
911 
      return result.success
912 
    if result.ucx != None:
913 
      raise result.ucx
914 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
915 
 
916 
  def removeAddressForUser(self, userid, addressId):
917 
    """
918 
    Parameters:
919 
     - userid
920 
     - addressId
921 
    """
922 
    self.send_removeAddressForUser(userid, addressId)
923 
    return self.recv_removeAddressForUser()
924 
 
925 
  def send_removeAddressForUser(self, userid, addressId):
926 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
927 
    args = removeAddressForUser_args()
928 
    args.userid = userid
929 
    args.addressId = addressId
930 
    args.write(self._oprot)
931 
    self._oprot.writeMessageEnd()
932 
    self._oprot.trans.flush()
933 
 
934 
  def recv_removeAddressForUser(self, ):
935 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
936 
    if mtype == TMessageType.EXCEPTION:
937 
      x = TApplicationException()
938 
      x.read(self._iprot)
939 
      self._iprot.readMessageEnd()
940 
      raise x
941 
    result = removeAddressForUser_result()
942 
    result.read(self._iprot)
943 
    self._iprot.readMessageEnd()
944 
    if result.success != None:
945 
      return result.success
946 
    if result.ucx != None:
947 
      raise result.ucx
948 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
949 
 
950 
  def setUserAsLoggedIn(self, userId, timestamp):
951 
    """
952 
    Parameters:
953 
     - userId
954 
     - timestamp
955 
    """
956 
    self.send_setUserAsLoggedIn(userId, timestamp)
957 
    return self.recv_setUserAsLoggedIn()
958 
 
959 
  def send_setUserAsLoggedIn(self, userId, timestamp):
960 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
961 
    args = setUserAsLoggedIn_args()
962 
    args.userId = userId
963 
    args.timestamp = timestamp
964 
    args.write(self._oprot)
965 
    self._oprot.writeMessageEnd()
966 
    self._oprot.trans.flush()
967 
 
968 
  def recv_setUserAsLoggedIn(self, ):
969 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
970 
    if mtype == TMessageType.EXCEPTION:
971 
      x = TApplicationException()
972 
      x.read(self._iprot)
973 
      self._iprot.readMessageEnd()
974 
      raise x
975 
    result = setUserAsLoggedIn_result()
976 
    result.read(self._iprot)
977 
    self._iprot.readMessageEnd()
978 
    if result.success != None:
979 
      return result.success
980 
    if result.ucx != None:
981 
      raise result.ucx
982 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
983 
 
984 
  def setUserAsLoggedOut(self, userid, timestamp):
985 
    """
986 
    Parameters:
987 
     - userid
988 
     - timestamp
989 
    """
990 
    self.send_setUserAsLoggedOut(userid, timestamp)
991 
    return self.recv_setUserAsLoggedOut()
992 
 
993 
  def send_setUserAsLoggedOut(self, userid, timestamp):
994 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
995 
    args = setUserAsLoggedOut_args()
996 
    args.userid = userid
997 
    args.timestamp = timestamp
998 
    args.write(self._oprot)
999 
    self._oprot.writeMessageEnd()
1000 
    self._oprot.trans.flush()
1001 
 
1002 
  def recv_setUserAsLoggedOut(self, ):
1003 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1004 
    if mtype == TMessageType.EXCEPTION:
1005 
      x = TApplicationException()
1006 
      x.read(self._iprot)
1007 
      self._iprot.readMessageEnd()
1008 
      raise x
1009 
    result = setUserAsLoggedOut_result()
1010 
    result.read(self._iprot)
1011 
    self._iprot.readMessageEnd()
1012 
    if result.success != None:
1013 
      return result.success
1014 
    if result.ucx != None:
1015 
      raise result.ucx
1016 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1017 
 
504 rajveer 1018 
  def setDefaultAddress(self, userid, addressId):
1019 
    """
1020 
    Parameters:
1021 
     - userid
1022 
     - addressId
1023 
    """
1024 
    self.send_setDefaultAddress(userid, addressId)
1025 
    return self.recv_setDefaultAddress()
1026 
 
1027 
  def send_setDefaultAddress(self, userid, addressId):
1028 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1029 
    args = setDefaultAddress_args()
1030 
    args.userid = userid
1031 
    args.addressId = addressId
1032 
    args.write(self._oprot)
1033 
    self._oprot.writeMessageEnd()
1034 
    self._oprot.trans.flush()
1035 
 
1036 
  def recv_setDefaultAddress(self, ):
1037 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1038 
    if mtype == TMessageType.EXCEPTION:
1039 
      x = TApplicationException()
1040 
      x.read(self._iprot)
1041 
      self._iprot.readMessageEnd()
1042 
      raise x
1043 
    result = setDefaultAddress_result()
1044 
    result.read(self._iprot)
1045 
    self._iprot.readMessageEnd()
1046 
    if result.success != None:
1047 
      return result.success
1048 
    if result.ucx != None:
1049 
      raise result.ucx
1050 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1051 
 
594 rajveer 1052 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1053 
    """
1054 
    Parameters:
1055 
     - userid
594 rajveer 1056 
     - oldPassword
1057 
     - newPassword
94 ashish 1058 
    """
594 rajveer 1059 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1060 
    return self.recv_updatePassword()
1061 
 
594 rajveer 1062 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1063 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1064 
    args = updatePassword_args()
1065 
    args.userid = userid
594 rajveer 1066 
    args.oldPassword = oldPassword
1067 
    args.newPassword = newPassword
94 ashish 1068 
    args.write(self._oprot)
1069 
    self._oprot.writeMessageEnd()
1070 
    self._oprot.trans.flush()
1071 
 
1072 
  def recv_updatePassword(self, ):
1073 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1074 
    if mtype == TMessageType.EXCEPTION:
1075 
      x = TApplicationException()
1076 
      x.read(self._iprot)
1077 
      self._iprot.readMessageEnd()
1078 
      raise x
1079 
    result = updatePassword_result()
1080 
    result.read(self._iprot)
1081 
    self._iprot.readMessageEnd()
1082 
    if result.success != None:
1083 
      return result.success
1084 
    if result.ucx != None:
1085 
      raise result.ucx
1086 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1087 
 
884 rajveer 1088 
  def forgotPassword(self, email, newPassword):
581 rajveer 1089 
    """
1090 
    Parameters:
1091 
     - email
884 rajveer 1092 
     - newPassword
581 rajveer 1093 
    """
884 rajveer 1094 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1095 
    return self.recv_forgotPassword()
1096 
 
884 rajveer 1097 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1098 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1099 
    args = forgotPassword_args()
1100 
    args.email = email
884 rajveer 1101 
    args.newPassword = newPassword
581 rajveer 1102 
    args.write(self._oprot)
1103 
    self._oprot.writeMessageEnd()
1104 
    self._oprot.trans.flush()
1105 
 
1106 
  def recv_forgotPassword(self, ):
1107 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1108 
    if mtype == TMessageType.EXCEPTION:
1109 
      x = TApplicationException()
1110 
      x.read(self._iprot)
1111 
      self._iprot.readMessageEnd()
1112 
      raise x
1113 
    result = forgotPassword_result()
1114 
    result.read(self._iprot)
1115 
    self._iprot.readMessageEnd()
1116 
    if result.success != None:
1117 
      return result.success
1118 
    if result.ucx != None:
1119 
      raise result.ucx
1120 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1121 
 
594 rajveer 1122 
  def getAllAddressesForUser(self, userId):
1123 
    """
1124 
    Parameters:
1125 
     - userId
1126 
    """
1127 
    self.send_getAllAddressesForUser(userId)
1128 
    return self.recv_getAllAddressesForUser()
1129 
 
1130 
  def send_getAllAddressesForUser(self, userId):
1131 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1132 
    args = getAllAddressesForUser_args()
1133 
    args.userId = userId
1134 
    args.write(self._oprot)
1135 
    self._oprot.writeMessageEnd()
1136 
    self._oprot.trans.flush()
1137 
 
1138 
  def recv_getAllAddressesForUser(self, ):
1139 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1140 
    if mtype == TMessageType.EXCEPTION:
1141 
      x = TApplicationException()
1142 
      x.read(self._iprot)
1143 
      self._iprot.readMessageEnd()
1144 
      raise x
1145 
    result = getAllAddressesForUser_result()
1146 
    result.read(self._iprot)
1147 
    self._iprot.readMessageEnd()
1148 
    if result.success != None:
1149 
      return result.success
1150 
    if result.ucx != None:
1151 
      raise result.ucx
1152 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1153 
 
1894 vikas 1154 
  def getAddressById(self, addressId):
1155 
    """
1156 
    Parameters:
1157 
     - addressId
1158 
    """
1159 
    self.send_getAddressById(addressId)
1160 
    return self.recv_getAddressById()
1161 
 
1162 
  def send_getAddressById(self, addressId):
1163 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1164 
    args = getAddressById_args()
1165 
    args.addressId = addressId
1166 
    args.write(self._oprot)
1167 
    self._oprot.writeMessageEnd()
1168 
    self._oprot.trans.flush()
1169 
 
1170 
  def recv_getAddressById(self, ):
1171 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1172 
    if mtype == TMessageType.EXCEPTION:
1173 
      x = TApplicationException()
1174 
      x.read(self._iprot)
1175 
      self._iprot.readMessageEnd()
1176 
      raise x
1177 
    result = getAddressById_result()
1178 
    result.read(self._iprot)
1179 
    self._iprot.readMessageEnd()
1180 
    if result.success != None:
1181 
      return result.success
1182 
    if result.ucx != None:
1183 
      raise result.ucx
1184 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1185 
 
594 rajveer 1186 
  def getDefaultAddressId(self, userId):
1187 
    """
1188 
    Parameters:
1189 
     - userId
1190 
    """
1191 
    self.send_getDefaultAddressId(userId)
1192 
    return self.recv_getDefaultAddressId()
1193 
 
1194 
  def send_getDefaultAddressId(self, userId):
1195 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1196 
    args = getDefaultAddressId_args()
1197 
    args.userId = userId
1198 
    args.write(self._oprot)
1199 
    self._oprot.writeMessageEnd()
1200 
    self._oprot.trans.flush()
1201 
 
1202 
  def recv_getDefaultAddressId(self, ):
1203 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1204 
    if mtype == TMessageType.EXCEPTION:
1205 
      x = TApplicationException()
1206 
      x.read(self._iprot)
1207 
      self._iprot.readMessageEnd()
1208 
      raise x
1209 
    result = getDefaultAddressId_result()
1210 
    result.read(self._iprot)
1211 
    self._iprot.readMessageEnd()
1212 
    if result.success != None:
1213 
      return result.success
1214 
    if result.ucx != None:
1215 
      raise result.ucx
1216 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1217 
 
785 rajveer 1218 
  def getDefaultPincode(self, userId):
1219 
    """
1220 
    Parameters:
1221 
     - userId
1222 
    """
1223 
    self.send_getDefaultPincode(userId)
1224 
    return self.recv_getDefaultPincode()
1225 
 
1226 
  def send_getDefaultPincode(self, userId):
1227 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1228 
    args = getDefaultPincode_args()
1229 
    args.userId = userId
1230 
    args.write(self._oprot)
1231 
    self._oprot.writeMessageEnd()
1232 
    self._oprot.trans.flush()
1233 
 
1234 
  def recv_getDefaultPincode(self, ):
1235 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1236 
    if mtype == TMessageType.EXCEPTION:
1237 
      x = TApplicationException()
1238 
      x.read(self._iprot)
1239 
      self._iprot.readMessageEnd()
1240 
      raise x
1241 
    result = getDefaultPincode_result()
1242 
    result.read(self._iprot)
1243 
    self._iprot.readMessageEnd()
1244 
    if result.success != None:
1245 
      return result.success
1246 
    if result.ucx != None:
1247 
      raise result.ucx
1248 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1249 
 
1274 varun.gupt 1250 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1251 
    """
1252 
    Parameters:
1253 
     - userId
1254 
     - replyTo
1255 
     - communicationType
1256 
     - orderId
1257 
     - airwaybillNo
1258 
     - productName
1259 
     - subject
1260 
     - message
1261 
    """
1262 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1263 
    return self.recv_saveUserCommunication()
1264 
 
1265 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1266 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1267 
    args = saveUserCommunication_args()
1268 
    args.userId = userId
1269 
    args.replyTo = replyTo
1270 
    args.communicationType = communicationType
1271 
    args.orderId = orderId
1272 
    args.airwaybillNo = airwaybillNo
1273 
    args.productName = productName
1274 
    args.subject = subject
1275 
    args.message = message
1276 
    args.write(self._oprot)
1277 
    self._oprot.writeMessageEnd()
1278 
    self._oprot.trans.flush()
1279 
 
1280 
  def recv_saveUserCommunication(self, ):
1281 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1282 
    if mtype == TMessageType.EXCEPTION:
1283 
      x = TApplicationException()
1284 
      x.read(self._iprot)
1285 
      self._iprot.readMessageEnd()
1286 
      raise x
1287 
    result = saveUserCommunication_result()
1288 
    result.read(self._iprot)
1289 
    self._iprot.readMessageEnd()
1290 
    if result.success != None:
1291 
      return result.success
1292 
    if result.ucx != None:
1293 
      raise result.ucx
1294 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1295 
 
1590 varun.gupt 1296 
  def getUserCommunicationById(self, id):
1297 
    """
1298 
    Parameters:
1299 
     - id
1300 
    """
1301 
    self.send_getUserCommunicationById(id)
1302 
    return self.recv_getUserCommunicationById()
1303 
 
1304 
  def send_getUserCommunicationById(self, id):
1305 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1306 
    args = getUserCommunicationById_args()
1307 
    args.id = id
1308 
    args.write(self._oprot)
1309 
    self._oprot.writeMessageEnd()
1310 
    self._oprot.trans.flush()
1311 
 
1312 
  def recv_getUserCommunicationById(self, ):
1313 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1314 
    if mtype == TMessageType.EXCEPTION:
1315 
      x = TApplicationException()
1316 
      x.read(self._iprot)
1317 
      self._iprot.readMessageEnd()
1318 
      raise x
1319 
    result = getUserCommunicationById_result()
1320 
    result.read(self._iprot)
1321 
    self._iprot.readMessageEnd()
1322 
    if result.success != None:
1323 
      return result.success
1324 
    if result.ucx != None:
1325 
      raise result.ucx
1326 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1327 
 
1328 
  def getUserCommunicationByUser(self, userId):
1329 
    """
1330 
    Parameters:
1331 
     - userId
1332 
    """
1333 
    self.send_getUserCommunicationByUser(userId)
1334 
    return self.recv_getUserCommunicationByUser()
1335 
 
1336 
  def send_getUserCommunicationByUser(self, userId):
1337 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1338 
    args = getUserCommunicationByUser_args()
1339 
    args.userId = userId
1340 
    args.write(self._oprot)
1341 
    self._oprot.writeMessageEnd()
1342 
    self._oprot.trans.flush()
1343 
 
1344 
  def recv_getUserCommunicationByUser(self, ):
1345 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1346 
    if mtype == TMessageType.EXCEPTION:
1347 
      x = TApplicationException()
1348 
      x.read(self._iprot)
1349 
      self._iprot.readMessageEnd()
1350 
      raise x
1351 
    result = getUserCommunicationByUser_result()
1352 
    result.read(self._iprot)
1353 
    self._iprot.readMessageEnd()
1354 
    if result.success != None:
1355 
      return result.success
1356 
    if result.ucx != None:
1357 
      raise result.ucx
1358 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1359 
 
1360 
  def getAllUserCommunications(self, ):
1361 
    self.send_getAllUserCommunications()
1362 
    return self.recv_getAllUserCommunications()
1363 
 
1364 
  def send_getAllUserCommunications(self, ):
1365 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1366 
    args = getAllUserCommunications_args()
1367 
    args.write(self._oprot)
1368 
    self._oprot.writeMessageEnd()
1369 
    self._oprot.trans.flush()
1370 
 
1371 
  def recv_getAllUserCommunications(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 = getAllUserCommunications_result()
1379 
    result.read(self._iprot)
1380 
    self._iprot.readMessageEnd()
1381 
    if result.success != None:
1382 
      return result.success
1383 
    if result.ucx != None:
1384 
      raise result.ucx
1385 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1386 
 
1859 vikas 1387 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1388 
    """
1389 
    Parameters:
1390 
     - name
1859 vikas 1391 
     - addedOn
1845 vikas 1392 
    """
1859 vikas 1393 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1394 
    return self.recv_createMasterAffiliate()
1395 
 
1859 vikas 1396 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1397 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1398 
    args = createMasterAffiliate_args()
1399 
    args.name = name
1859 vikas 1400 
    args.addedOn = addedOn
1845 vikas 1401 
    args.write(self._oprot)
1402 
    self._oprot.writeMessageEnd()
1403 
    self._oprot.trans.flush()
1404 
 
1405 
  def recv_createMasterAffiliate(self, ):
1406 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1407 
    if mtype == TMessageType.EXCEPTION:
1408 
      x = TApplicationException()
1409 
      x.read(self._iprot)
1410 
      self._iprot.readMessageEnd()
1411 
      raise x
1412 
    result = createMasterAffiliate_result()
1413 
    result.read(self._iprot)
1414 
    self._iprot.readMessageEnd()
1415 
    if result.success != None:
1416 
      return result.success
1417 
    if result.utx != None:
1418 
      raise result.utx
1419 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1420 
 
1899 vikas 1421 
  def getAllMasterAffiliates(self, ):
1422 
    self.send_getAllMasterAffiliates()
1423 
    return self.recv_getAllMasterAffiliates()
1424 
 
1425 
  def send_getAllMasterAffiliates(self, ):
1426 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1427 
    args = getAllMasterAffiliates_args()
1428 
    args.write(self._oprot)
1429 
    self._oprot.writeMessageEnd()
1430 
    self._oprot.trans.flush()
1431 
 
1432 
  def recv_getAllMasterAffiliates(self, ):
1433 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1434 
    if mtype == TMessageType.EXCEPTION:
1435 
      x = TApplicationException()
1436 
      x.read(self._iprot)
1437 
      self._iprot.readMessageEnd()
1438 
      raise x
1439 
    result = getAllMasterAffiliates_result()
1440 
    result.read(self._iprot)
1441 
    self._iprot.readMessageEnd()
1442 
    if result.success != None:
1443 
      return result.success
1444 
    if result.utx != None:
1445 
      raise result.utx
1446 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1447 
 
1845 vikas 1448 
  def getMasterAffiliateById(self, id):
1449 
    """
1450 
    Parameters:
1451 
     - id
1452 
    """
1453 
    self.send_getMasterAffiliateById(id)
1454 
    return self.recv_getMasterAffiliateById()
1455 
 
1456 
  def send_getMasterAffiliateById(self, id):
1457 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1458 
    args = getMasterAffiliateById_args()
1459 
    args.id = id
1460 
    args.write(self._oprot)
1461 
    self._oprot.writeMessageEnd()
1462 
    self._oprot.trans.flush()
1463 
 
1464 
  def recv_getMasterAffiliateById(self, ):
1465 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1466 
    if mtype == TMessageType.EXCEPTION:
1467 
      x = TApplicationException()
1468 
      x.read(self._iprot)
1469 
      self._iprot.readMessageEnd()
1470 
      raise x
1471 
    result = getMasterAffiliateById_result()
1472 
    result.read(self._iprot)
1473 
    self._iprot.readMessageEnd()
1474 
    if result.success != None:
1475 
      return result.success
1476 
    if result.utx != None:
1477 
      raise result.utx
1478 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1479 
 
1480 
  def getMasterAffiliateByName(self, name):
1481 
    """
1482 
    Parameters:
1483 
     - name
1484 
    """
1485 
    self.send_getMasterAffiliateByName(name)
1486 
    return self.recv_getMasterAffiliateByName()
1487 
 
1488 
  def send_getMasterAffiliateByName(self, name):
1489 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1490 
    args = getMasterAffiliateByName_args()
1491 
    args.name = name
1492 
    args.write(self._oprot)
1493 
    self._oprot.writeMessageEnd()
1494 
    self._oprot.trans.flush()
1495 
 
1496 
  def recv_getMasterAffiliateByName(self, ):
1497 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1498 
    if mtype == TMessageType.EXCEPTION:
1499 
      x = TApplicationException()
1500 
      x.read(self._iprot)
1501 
      self._iprot.readMessageEnd()
1502 
      raise x
1503 
    result = getMasterAffiliateByName_result()
1504 
    result.read(self._iprot)
1505 
    self._iprot.readMessageEnd()
1506 
    if result.success != None:
1507 
      return result.success
1508 
    if result.utx != None:
1509 
      raise result.utx
1510 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1511 
 
1859 vikas 1512 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1513 
    """
1514 
    Parameters:
1515 
     - name
1516 
     - url
1517 
     - masterAffiliateId
1859 vikas 1518 
     - addedOn
1845 vikas 1519 
    """
1859 vikas 1520 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1521 
    return self.recv_createAffiliate()
1522 
 
1859 vikas 1523 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1524 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1525 
    args = createAffiliate_args()
1526 
    args.name = name
1527 
    args.url = url
1528 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1529 
    args.addedOn = addedOn
1845 vikas 1530 
    args.write(self._oprot)
1531 
    self._oprot.writeMessageEnd()
1532 
    self._oprot.trans.flush()
1533 
 
1534 
  def recv_createAffiliate(self, ):
1535 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1536 
    if mtype == TMessageType.EXCEPTION:
1537 
      x = TApplicationException()
1538 
      x.read(self._iprot)
1539 
      self._iprot.readMessageEnd()
1540 
      raise x
1541 
    result = createAffiliate_result()
1542 
    result.read(self._iprot)
1543 
    self._iprot.readMessageEnd()
1544 
    if result.success != None:
1545 
      return result.success
1546 
    if result.utx != None:
1547 
      raise result.utx
1548 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1549 
 
1550 
  def getAffiliateById(self, id):
1551 
    """
1552 
    Parameters:
1553 
     - id
1554 
    """
1555 
    self.send_getAffiliateById(id)
1556 
    return self.recv_getAffiliateById()
1557 
 
1558 
  def send_getAffiliateById(self, id):
1559 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1560 
    args = getAffiliateById_args()
1561 
    args.id = id
1562 
    args.write(self._oprot)
1563 
    self._oprot.writeMessageEnd()
1564 
    self._oprot.trans.flush()
1565 
 
1566 
  def recv_getAffiliateById(self, ):
1567 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1568 
    if mtype == TMessageType.EXCEPTION:
1569 
      x = TApplicationException()
1570 
      x.read(self._iprot)
1571 
      self._iprot.readMessageEnd()
1572 
      raise x
1573 
    result = getAffiliateById_result()
1574 
    result.read(self._iprot)
1575 
    self._iprot.readMessageEnd()
1576 
    if result.success != None:
1577 
      return result.success
1578 
    if result.utx != None:
1579 
      raise result.utx
1580 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1581 
 
1582 
  def getAffiliateByName(self, name):
1583 
    """
1584 
    Parameters:
1585 
     - name
1586 
    """
1587 
    self.send_getAffiliateByName(name)
1588 
    return self.recv_getAffiliateByName()
1589 
 
1590 
  def send_getAffiliateByName(self, name):
1591 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1592 
    args = getAffiliateByName_args()
1593 
    args.name = name
1594 
    args.write(self._oprot)
1595 
    self._oprot.writeMessageEnd()
1596 
    self._oprot.trans.flush()
1597 
 
1598 
  def recv_getAffiliateByName(self, ):
1599 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1600 
    if mtype == TMessageType.EXCEPTION:
1601 
      x = TApplicationException()
1602 
      x.read(self._iprot)
1603 
      self._iprot.readMessageEnd()
1604 
      raise x
1605 
    result = getAffiliateByName_result()
1606 
    result.read(self._iprot)
1607 
    self._iprot.readMessageEnd()
1608 
    if result.success != None:
1609 
      return result.success
1610 
    if result.utx != None:
1611 
      raise result.utx
1612 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1613 
 
1996 vikas 1614 
  def getTrackerById(self, id):
1845 vikas 1615 
    """
1616 
    Parameters:
1617 
     - id
1618 
    """
1996 vikas 1619 
    self.send_getTrackerById(id)
1845 vikas 1620 
    return self.recv_getTrackerById()
1621 
 
1996 vikas 1622 
  def send_getTrackerById(self, id):
1845 vikas 1623 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1624 
    args = getTrackerById_args()
1996 vikas 1625 
    args.id = id
1845 vikas 1626 
    args.write(self._oprot)
1627 
    self._oprot.writeMessageEnd()
1628 
    self._oprot.trans.flush()
1629 
 
1630 
  def recv_getTrackerById(self, ):
1631 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1632 
    if mtype == TMessageType.EXCEPTION:
1633 
      x = TApplicationException()
1634 
      x.read(self._iprot)
1635 
      self._iprot.readMessageEnd()
1636 
      raise x
1637 
    result = getTrackerById_result()
1638 
    result.read(self._iprot)
1639 
    self._iprot.readMessageEnd()
1640 
    if result.success != None:
1641 
      return result.success
1642 
    if result.utx != None:
1643 
      raise result.utx
1644 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1645 
 
1996 vikas 1646 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1647 
    """
1648 
    Parameters:
1996 vikas 1649 
     - id
1845 vikas 1650 
    """
1996 vikas 1651 
    self.send_getAffiliatesByMasterAffiliate(id)
1652 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1653 
 
1996 vikas 1654 
  def send_getAffiliatesByMasterAffiliate(self, id):
1655 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1656 
    args = getAffiliatesByMasterAffiliate_args()
1657 
    args.id = id
1845 vikas 1658 
    args.write(self._oprot)
1659 
    self._oprot.writeMessageEnd()
1660 
    self._oprot.trans.flush()
1661 
 
1996 vikas 1662 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1663 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1664 
    if mtype == TMessageType.EXCEPTION:
1665 
      x = TApplicationException()
1666 
      x.read(self._iprot)
1667 
      self._iprot.readMessageEnd()
1668 
      raise x
1996 vikas 1669 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1670 
    result.read(self._iprot)
1671 
    self._iprot.readMessageEnd()
1672 
    if result.success != None:
1673 
      return result.success
1674 
    if result.utx != None:
1675 
      raise result.utx
1996 vikas 1676 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1677 
 
1996 vikas 1678 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1679 
    """
1680 
    Parameters:
1996 vikas 1681 
     - affiliateId
1845 vikas 1682 
     - userId
1683 
     - event
1684 
     - url
1685 
     - data
1859 vikas 1686 
     - addedOn
1845 vikas 1687 
    """
1996 vikas 1688 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1689 
    return self.recv_addTrackLog()
1690 
 
1996 vikas 1691 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1692 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1693 
    args = addTrackLog_args()
1996 vikas 1694 
    args.affiliateId = affiliateId
1845 vikas 1695 
    args.userId = userId
1696 
    args.event = event
1697 
    args.url = url
1698 
    args.data = data
1859 vikas 1699 
    args.addedOn = addedOn
1845 vikas 1700 
    args.write(self._oprot)
1701 
    self._oprot.writeMessageEnd()
1702 
    self._oprot.trans.flush()
1703 
 
1704 
  def recv_addTrackLog(self, ):
1705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1706 
    if mtype == TMessageType.EXCEPTION:
1707 
      x = TApplicationException()
1708 
      x.read(self._iprot)
1709 
      self._iprot.readMessageEnd()
1710 
      raise x
1711 
    result = addTrackLog_result()
1712 
    result.read(self._iprot)
1713 
    self._iprot.readMessageEnd()
1714 
    if result.success != None:
1715 
      return result.success
1716 
    if result.utx != None:
1717 
      raise result.utx
1718 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1719 
 
1720 
  def getTrackLogById(self, id):
1721 
    """
1722 
    Parameters:
1723 
     - id
1724 
    """
1725 
    self.send_getTrackLogById(id)
1726 
    return self.recv_getTrackLogById()
1727 
 
1728 
  def send_getTrackLogById(self, id):
1729 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1730 
    args = getTrackLogById_args()
1731 
    args.id = id
1732 
    args.write(self._oprot)
1733 
    self._oprot.writeMessageEnd()
1734 
    self._oprot.trans.flush()
1735 
 
1736 
  def recv_getTrackLogById(self, ):
1737 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1738 
    if mtype == TMessageType.EXCEPTION:
1739 
      x = TApplicationException()
1740 
      x.read(self._iprot)
1741 
      self._iprot.readMessageEnd()
1742 
      raise x
1743 
    result = getTrackLogById_result()
1744 
    result.read(self._iprot)
1745 
    self._iprot.readMessageEnd()
1746 
    if result.success != None:
1747 
      return result.success
1748 
    if result.utx != None:
1749 
      raise result.utx
1750 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1751 
 
1996 vikas 1752 
  def getTrackLogsByAffiliate(self, affiliateId):
1845 vikas 1753 
    """
1754 
    Parameters:
1996 vikas 1755 
     - affiliateId
1845 vikas 1756 
    """
1996 vikas 1757 
    self.send_getTrackLogsByAffiliate(affiliateId)
1758 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 1759 
 
1996 vikas 1760 
  def send_getTrackLogsByAffiliate(self, affiliateId):
1761 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
1762 
    args = getTrackLogsByAffiliate_args()
1763 
    args.affiliateId = affiliateId
1845 vikas 1764 
    args.write(self._oprot)
1765 
    self._oprot.writeMessageEnd()
1766 
    self._oprot.trans.flush()
1767 
 
1996 vikas 1768 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 1769 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1770 
    if mtype == TMessageType.EXCEPTION:
1771 
      x = TApplicationException()
1772 
      x.read(self._iprot)
1773 
      self._iprot.readMessageEnd()
1774 
      raise x
1996 vikas 1775 
    result = getTrackLogsByAffiliate_result()
1845 vikas 1776 
    result.read(self._iprot)
1777 
    self._iprot.readMessageEnd()
1778 
    if result.success != None:
1779 
      return result.success
1780 
    if result.utx != None:
1781 
      raise result.utx
1996 vikas 1782 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 1783 
 
1784 
  def getTrackLogsByUser(self, userId):
1785 
    """
1786 
    Parameters:
1787 
     - userId
1788 
    """
1789 
    self.send_getTrackLogsByUser(userId)
1790 
    return self.recv_getTrackLogsByUser()
1791 
 
1792 
  def send_getTrackLogsByUser(self, userId):
1793 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
1794 
    args = getTrackLogsByUser_args()
1795 
    args.userId = userId
1796 
    args.write(self._oprot)
1797 
    self._oprot.writeMessageEnd()
1798 
    self._oprot.trans.flush()
1799 
 
1800 
  def recv_getTrackLogsByUser(self, ):
1801 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1802 
    if mtype == TMessageType.EXCEPTION:
1803 
      x = TApplicationException()
1804 
      x.read(self._iprot)
1805 
      self._iprot.readMessageEnd()
1806 
      raise x
1807 
    result = getTrackLogsByUser_result()
1808 
    result.read(self._iprot)
1809 
    self._iprot.readMessageEnd()
1810 
    if result.success != None:
1811 
      return result.success
1812 
    if result.utx != None:
1813 
      raise result.utx
1814 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
1815 
 
1996 vikas 1816 
  def getTrackLogs(self, userId, event, url):
1845 vikas 1817 
    """
1818 
    Parameters:
1819 
     - userId
1820 
     - event
1821 
     - url
1822 
    """
1996 vikas 1823 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 1824 
    return self.recv_getTrackLogs()
1825 
 
1996 vikas 1826 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 1827 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
1828 
    args = getTrackLogs_args()
1829 
    args.userId = userId
1830 
    args.event = event
1831 
    args.url = url
1832 
    args.write(self._oprot)
1833 
    self._oprot.writeMessageEnd()
1834 
    self._oprot.trans.flush()
1835 
 
1836 
  def recv_getTrackLogs(self, ):
1837 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1838 
    if mtype == TMessageType.EXCEPTION:
1839 
      x = TApplicationException()
1840 
      x.read(self._iprot)
1841 
      self._iprot.readMessageEnd()
1842 
      raise x
1843 
    result = getTrackLogs_result()
1844 
    result.read(self._iprot)
1845 
    self._iprot.readMessageEnd()
1846 
    if result.success != None:
1847 
      return result.success
1848 
    if result.utx != None:
1849 
      raise result.utx
1850 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
1851 
 
559 chandransh 1852 
  def createCart(self, userId):
94 ashish 1853 
    """
1854 
    Parameters:
559 chandransh 1855 
     - userId
94 ashish 1856 
    """
559 chandransh 1857 
    self.send_createCart(userId)
1858 
    return self.recv_createCart()
94 ashish 1859 
 
559 chandransh 1860 
  def send_createCart(self, userId):
1861 
    self._oprot.writeMessageBegin('createCart', TMessageType.CALL, self._seqid)
1862 
    args = createCart_args()
1863 
    args.userId = userId
94 ashish 1864 
    args.write(self._oprot)
1865 
    self._oprot.writeMessageEnd()
1866 
    self._oprot.trans.flush()
1867 
 
559 chandransh 1868 
  def recv_createCart(self, ):
94 ashish 1869 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1870 
    if mtype == TMessageType.EXCEPTION:
1871 
      x = TApplicationException()
1872 
      x.read(self._iprot)
1873 
      self._iprot.readMessageEnd()
1874 
      raise x
559 chandransh 1875 
    result = createCart_result()
94 ashish 1876 
    result.read(self._iprot)
1877 
    self._iprot.readMessageEnd()
1878 
    if result.success != None:
1879 
      return result.success
559 chandransh 1880 
    if result.scx != None:
1881 
      raise result.scx
1882 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createCart failed: unknown result");
94 ashish 1883 
 
559 chandransh 1884 
  def getCurrentCart(self, userId):
94 ashish 1885 
    """
1886 
    Parameters:
559 chandransh 1887 
     - userId
94 ashish 1888 
    """
559 chandransh 1889 
    self.send_getCurrentCart(userId)
1890 
    return self.recv_getCurrentCart()
94 ashish 1891 
 
559 chandransh 1892 
  def send_getCurrentCart(self, userId):
1893 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
1894 
    args = getCurrentCart_args()
1895 
    args.userId = userId
94 ashish 1896 
    args.write(self._oprot)
1897 
    self._oprot.writeMessageEnd()
1898 
    self._oprot.trans.flush()
1899 
 
559 chandransh 1900 
  def recv_getCurrentCart(self, ):
94 ashish 1901 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1902 
    if mtype == TMessageType.EXCEPTION:
1903 
      x = TApplicationException()
1904 
      x.read(self._iprot)
1905 
      self._iprot.readMessageEnd()
1906 
      raise x
559 chandransh 1907 
    result = getCurrentCart_result()
94 ashish 1908 
    result.read(self._iprot)
1909 
    self._iprot.readMessageEnd()
1910 
    if result.success != None:
1911 
      return result.success
559 chandransh 1912 
    if result.scx != None:
1913 
      raise result.scx
1914 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 1915 
 
559 chandransh 1916 
  def getCart(self, cartId):
94 ashish 1917 
    """
1918 
    Parameters:
559 chandransh 1919 
     - cartId
94 ashish 1920 
    """
559 chandransh 1921 
    self.send_getCart(cartId)
1922 
    return self.recv_getCart()
94 ashish 1923 
 
559 chandransh 1924 
  def send_getCart(self, cartId):
1925 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
1926 
    args = getCart_args()
1927 
    args.cartId = cartId
94 ashish 1928 
    args.write(self._oprot)
1929 
    self._oprot.writeMessageEnd()
1930 
    self._oprot.trans.flush()
1931 
 
559 chandransh 1932 
  def recv_getCart(self, ):
94 ashish 1933 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1934 
    if mtype == TMessageType.EXCEPTION:
1935 
      x = TApplicationException()
1936 
      x.read(self._iprot)
1937 
      self._iprot.readMessageEnd()
1938 
      raise x
559 chandransh 1939 
    result = getCart_result()
94 ashish 1940 
    result.read(self._iprot)
1941 
    self._iprot.readMessageEnd()
1942 
    if result.success != None:
1943 
      return result.success
559 chandransh 1944 
    if result.scx != None:
1945 
      raise result.scx
1946 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 1947 
 
559 chandransh 1948 
  def getCartsForUser(self, userId, status):
94 ashish 1949 
    """
1950 
    Parameters:
559 chandransh 1951 
     - userId
1952 
     - status
94 ashish 1953 
    """
559 chandransh 1954 
    self.send_getCartsForUser(userId, status)
1955 
    return self.recv_getCartsForUser()
94 ashish 1956 
 
559 chandransh 1957 
  def send_getCartsForUser(self, userId, status):
1958 
    self._oprot.writeMessageBegin('getCartsForUser', TMessageType.CALL, self._seqid)
1959 
    args = getCartsForUser_args()
1960 
    args.userId = userId
1961 
    args.status = status
94 ashish 1962 
    args.write(self._oprot)
1963 
    self._oprot.writeMessageEnd()
1964 
    self._oprot.trans.flush()
1965 
 
559 chandransh 1966 
  def recv_getCartsForUser(self, ):
94 ashish 1967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1968 
    if mtype == TMessageType.EXCEPTION:
1969 
      x = TApplicationException()
1970 
      x.read(self._iprot)
1971 
      self._iprot.readMessageEnd()
1972 
      raise x
559 chandransh 1973 
    result = getCartsForUser_result()
94 ashish 1974 
    result.read(self._iprot)
1975 
    self._iprot.readMessageEnd()
1976 
    if result.success != None:
1977 
      return result.success
559 chandransh 1978 
    if result.scx != None:
1979 
      raise result.scx
1980 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsForUser failed: unknown result");
94 ashish 1981 
 
559 chandransh 1982 
  def getCartsByStatus(self, status):
94 ashish 1983 
    """
1984 
    Parameters:
559 chandransh 1985 
     - status
94 ashish 1986 
    """
559 chandransh 1987 
    self.send_getCartsByStatus(status)
1988 
    return self.recv_getCartsByStatus()
94 ashish 1989 
 
559 chandransh 1990 
  def send_getCartsByStatus(self, status):
1991 
    self._oprot.writeMessageBegin('getCartsByStatus', TMessageType.CALL, self._seqid)
1992 
    args = getCartsByStatus_args()
1993 
    args.status = status
94 ashish 1994 
    args.write(self._oprot)
1995 
    self._oprot.writeMessageEnd()
1996 
    self._oprot.trans.flush()
1997 
 
559 chandransh 1998 
  def recv_getCartsByStatus(self, ):
94 ashish 1999 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2000 
    if mtype == TMessageType.EXCEPTION:
2001 
      x = TApplicationException()
2002 
      x.read(self._iprot)
2003 
      self._iprot.readMessageEnd()
2004 
      raise x
559 chandransh 2005 
    result = getCartsByStatus_result()
94 ashish 2006 
    result.read(self._iprot)
2007 
    self._iprot.readMessageEnd()
2008 
    if result.success != None:
2009 
      return result.success
559 chandransh 2010 
    if result.scx != None:
2011 
      raise result.scx
2012 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByStatus failed: unknown result");
94 ashish 2013 
 
559 chandransh 2014 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2015 
    """
2016 
    Parameters:
559 chandransh 2017 
     - from_time
2018 
     - to_time
2019 
     - status
94 ashish 2020 
    """
559 chandransh 2021 
    self.send_getCartsByTime(from_time, to_time, status)
2022 
    return self.recv_getCartsByTime()
94 ashish 2023 
 
559 chandransh 2024 
  def send_getCartsByTime(self, from_time, to_time, status):
2025 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2026 
    args = getCartsByTime_args()
2027 
    args.from_time = from_time
2028 
    args.to_time = to_time
2029 
    args.status = status
94 ashish 2030 
    args.write(self._oprot)
2031 
    self._oprot.writeMessageEnd()
2032 
    self._oprot.trans.flush()
2033 
 
559 chandransh 2034 
  def recv_getCartsByTime(self, ):
94 ashish 2035 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2036 
    if mtype == TMessageType.EXCEPTION:
2037 
      x = TApplicationException()
2038 
      x.read(self._iprot)
2039 
      self._iprot.readMessageEnd()
2040 
      raise x
559 chandransh 2041 
    result = getCartsByTime_result()
94 ashish 2042 
    result.read(self._iprot)
2043 
    self._iprot.readMessageEnd()
2044 
    if result.success != None:
2045 
      return result.success
559 chandransh 2046 
    if result.scx != None:
2047 
      raise result.scx
2048 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2049 
 
559 chandransh 2050 
  def changeCartStatus(self, cartId, status):
130 ashish 2051 
    """
2052 
    Parameters:
559 chandransh 2053 
     - cartId
2054 
     - status
130 ashish 2055 
    """
559 chandransh 2056 
    self.send_changeCartStatus(cartId, status)
2057 
    self.recv_changeCartStatus()
94 ashish 2058 
 
559 chandransh 2059 
  def send_changeCartStatus(self, cartId, status):
2060 
    self._oprot.writeMessageBegin('changeCartStatus', TMessageType.CALL, self._seqid)
2061 
    args = changeCartStatus_args()
2062 
    args.cartId = cartId
2063 
    args.status = status
130 ashish 2064 
    args.write(self._oprot)
2065 
    self._oprot.writeMessageEnd()
2066 
    self._oprot.trans.flush()
2067 
 
559 chandransh 2068 
  def recv_changeCartStatus(self, ):
130 ashish 2069 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2070 
    if mtype == TMessageType.EXCEPTION:
2071 
      x = TApplicationException()
2072 
      x.read(self._iprot)
2073 
      self._iprot.readMessageEnd()
2074 
      raise x
559 chandransh 2075 
    result = changeCartStatus_result()
130 ashish 2076 
    result.read(self._iprot)
2077 
    self._iprot.readMessageEnd()
559 chandransh 2078 
    if result.scx != None:
2079 
      raise result.scx
2080 
    return
2081 
 
2082 
  def addItemToCart(self, cartId, itemId, quantity):
2083 
    """
2084 
    Parameters:
2085 
     - cartId
2086 
     - itemId
2087 
     - quantity
2088 
    """
2089 
    self.send_addItemToCart(cartId, itemId, quantity)
2090 
    self.recv_addItemToCart()
2091 
 
2092 
  def send_addItemToCart(self, cartId, itemId, quantity):
2093 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2094 
    args = addItemToCart_args()
2095 
    args.cartId = cartId
2096 
    args.itemId = itemId
2097 
    args.quantity = quantity
2098 
    args.write(self._oprot)
2099 
    self._oprot.writeMessageEnd()
2100 
    self._oprot.trans.flush()
2101 
 
2102 
  def recv_addItemToCart(self, ):
2103 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2104 
    if mtype == TMessageType.EXCEPTION:
2105 
      x = TApplicationException()
2106 
      x.read(self._iprot)
2107 
      self._iprot.readMessageEnd()
2108 
      raise x
2109 
    result = addItemToCart_result()
2110 
    result.read(self._iprot)
2111 
    self._iprot.readMessageEnd()
2112 
    if result.scx != None:
2113 
      raise result.scx
2114 
    return
2115 
 
2116 
  def deleteItemFromCart(self, cartId, itemId):
2117 
    """
2118 
    Parameters:
2119 
     - cartId
2120 
     - itemId
2121 
    """
2122 
    self.send_deleteItemFromCart(cartId, itemId)
2123 
    self.recv_deleteItemFromCart()
2124 
 
2125 
  def send_deleteItemFromCart(self, cartId, itemId):
2126 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2127 
    args = deleteItemFromCart_args()
2128 
    args.cartId = cartId
2129 
    args.itemId = itemId
2130 
    args.write(self._oprot)
2131 
    self._oprot.writeMessageEnd()
2132 
    self._oprot.trans.flush()
2133 
 
2134 
  def recv_deleteItemFromCart(self, ):
2135 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2136 
    if mtype == TMessageType.EXCEPTION:
2137 
      x = TApplicationException()
2138 
      x.read(self._iprot)
2139 
      self._iprot.readMessageEnd()
2140 
      raise x
2141 
    result = deleteItemFromCart_result()
2142 
    result.read(self._iprot)
2143 
    self._iprot.readMessageEnd()
2144 
    if result.scx != None:
2145 
      raise result.scx
2146 
    return
2147 
 
2148 
  def changeQuantity(self, cartId, itemId, quantity):
2149 
    """
2150 
    Parameters:
2151 
     - cartId
2152 
     - itemId
2153 
     - quantity
2154 
    """
2155 
    self.send_changeQuantity(cartId, itemId, quantity)
2156 
    self.recv_changeQuantity()
2157 
 
2158 
  def send_changeQuantity(self, cartId, itemId, quantity):
2159 
    self._oprot.writeMessageBegin('changeQuantity', TMessageType.CALL, self._seqid)
2160 
    args = changeQuantity_args()
2161 
    args.cartId = cartId
2162 
    args.itemId = itemId
2163 
    args.quantity = quantity
2164 
    args.write(self._oprot)
2165 
    self._oprot.writeMessageEnd()
2166 
    self._oprot.trans.flush()
2167 
 
2168 
  def recv_changeQuantity(self, ):
2169 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2170 
    if mtype == TMessageType.EXCEPTION:
2171 
      x = TApplicationException()
2172 
      x.read(self._iprot)
2173 
      self._iprot.readMessageEnd()
2174 
      raise x
2175 
    result = changeQuantity_result()
2176 
    result.read(self._iprot)
2177 
    self._iprot.readMessageEnd()
2178 
    if result.scx != None:
2179 
      raise result.scx
2180 
    return
2181 
 
2182 
  def changeItemStatus(self, cartId, itemId, status):
2183 
    """
2184 
    Parameters:
2185 
     - cartId
2186 
     - itemId
2187 
     - status
2188 
    """
2189 
    self.send_changeItemStatus(cartId, itemId, status)
2190 
    self.recv_changeItemStatus()
2191 
 
2192 
  def send_changeItemStatus(self, cartId, itemId, status):
2193 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
2194 
    args = changeItemStatus_args()
2195 
    args.cartId = cartId
2196 
    args.itemId = itemId
2197 
    args.status = status
2198 
    args.write(self._oprot)
2199 
    self._oprot.writeMessageEnd()
2200 
    self._oprot.trans.flush()
2201 
 
2202 
  def recv_changeItemStatus(self, ):
2203 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2204 
    if mtype == TMessageType.EXCEPTION:
2205 
      x = TApplicationException()
2206 
      x.read(self._iprot)
2207 
      self._iprot.readMessageEnd()
2208 
      raise x
2209 
    result = changeItemStatus_result()
2210 
    result.read(self._iprot)
2211 
    self._iprot.readMessageEnd()
2212 
    if result.scx != None:
2213 
      raise result.scx
2214 
    return
2215 
 
2216 
  def addAddressToCart(self, cartId, addressId):
2217 
    """
2218 
    Parameters:
2219 
     - cartId
2220 
     - addressId
2221 
    """
2222 
    self.send_addAddressToCart(cartId, addressId)
2223 
    self.recv_addAddressToCart()
2224 
 
2225 
  def send_addAddressToCart(self, cartId, addressId):
2226 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2227 
    args = addAddressToCart_args()
2228 
    args.cartId = cartId
2229 
    args.addressId = addressId
2230 
    args.write(self._oprot)
2231 
    self._oprot.writeMessageEnd()
2232 
    self._oprot.trans.flush()
2233 
 
2234 
  def recv_addAddressToCart(self, ):
2235 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2236 
    if mtype == TMessageType.EXCEPTION:
2237 
      x = TApplicationException()
2238 
      x.read(self._iprot)
2239 
      self._iprot.readMessageEnd()
2240 
      raise x
2241 
    result = addAddressToCart_result()
2242 
    result.read(self._iprot)
2243 
    self._iprot.readMessageEnd()
575 chandransh 2244 
    if result.scx != None:
2245 
      raise result.scx
559 chandransh 2246 
    return
2247 
 
1976 varun.gupt 2248 
  def applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
2249 
    """
2250 
    Parameters:
2251 
     - cartId
2252 
     - couponCode
2253 
     - totalPrice
2254 
     - discountedPrice
2255 
    """
2256 
    self.send_applyCouponToCart(cartId, couponCode, totalPrice, discountedPrice)
2257 
    self.recv_applyCouponToCart()
2258 
 
2259 
  def send_applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
2260 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2261 
    args = applyCouponToCart_args()
2262 
    args.cartId = cartId
2263 
    args.couponCode = couponCode
2264 
    args.totalPrice = totalPrice
2265 
    args.discountedPrice = discountedPrice
2266 
    args.write(self._oprot)
2267 
    self._oprot.writeMessageEnd()
2268 
    self._oprot.trans.flush()
2269 
 
2270 
  def recv_applyCouponToCart(self, ):
2271 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2272 
    if mtype == TMessageType.EXCEPTION:
2273 
      x = TApplicationException()
2274 
      x.read(self._iprot)
2275 
      self._iprot.readMessageEnd()
2276 
      raise x
2277 
    result = applyCouponToCart_result()
2278 
    result.read(self._iprot)
2279 
    self._iprot.readMessageEnd()
2280 
    if result.scx != None:
2281 
      raise result.scx
2282 
    return
2283 
 
2284 
  def removeCoupon(self, cartId):
2285 
    """
2286 
    Parameters:
2287 
     - cartId
2288 
    """
2289 
    self.send_removeCoupon(cartId)
2290 
    self.recv_removeCoupon()
2291 
 
2292 
  def send_removeCoupon(self, cartId):
2293 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2294 
    args = removeCoupon_args()
2295 
    args.cartId = cartId
2296 
    args.write(self._oprot)
2297 
    self._oprot.writeMessageEnd()
2298 
    self._oprot.trans.flush()
2299 
 
2300 
  def recv_removeCoupon(self, ):
2301 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2302 
    if mtype == TMessageType.EXCEPTION:
2303 
      x = TApplicationException()
2304 
      x.read(self._iprot)
2305 
      self._iprot.readMessageEnd()
2306 
      raise x
2307 
    result = removeCoupon_result()
2308 
    result.read(self._iprot)
2309 
    self._iprot.readMessageEnd()
2310 
    if result.scx != None:
2311 
      raise result.scx
2312 
    return
2313 
 
690 chandransh 2314 
  def createOrders(self, cartId):
559 chandransh 2315 
    """
690 chandransh 2316 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
2317 
 
559 chandransh 2318 
    Parameters:
2319 
     - cartId
2320 
    """
690 chandransh 2321 
    self.send_createOrders(cartId)
2322 
    return self.recv_createOrders()
559 chandransh 2323 
 
690 chandransh 2324 
  def send_createOrders(self, cartId):
2325 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2326 
    args = createOrders_args()
559 chandransh 2327 
    args.cartId = cartId
2328 
    args.write(self._oprot)
2329 
    self._oprot.writeMessageEnd()
2330 
    self._oprot.trans.flush()
2331 
 
690 chandransh 2332 
  def recv_createOrders(self, ):
559 chandransh 2333 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2334 
    if mtype == TMessageType.EXCEPTION:
2335 
      x = TApplicationException()
2336 
      x.read(self._iprot)
2337 
      self._iprot.readMessageEnd()
2338 
      raise x
690 chandransh 2339 
    result = createOrders_result()
559 chandransh 2340 
    result.read(self._iprot)
2341 
    self._iprot.readMessageEnd()
130 ashish 2342 
    if result.success != None:
2343 
      return result.success
559 chandransh 2344 
    if result.scx != None:
2345 
      raise result.scx
690 chandransh 2346 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2347 
 
559 chandransh 2348 
  def validateCart(self, cartId):
130 ashish 2349 
    """
690 chandransh 2350 
    Validates that:
2351 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2352 
    2. All of the lines in the cart are active items.
690 chandransh 2353 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2354 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 2355 
 
130 ashish 2356 
    Parameters:
559 chandransh 2357 
     - cartId
130 ashish 2358 
    """
559 chandransh 2359 
    self.send_validateCart(cartId)
2360 
    return self.recv_validateCart()
130 ashish 2361 
 
559 chandransh 2362 
  def send_validateCart(self, cartId):
2363 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2364 
    args = validateCart_args()
2365 
    args.cartId = cartId
130 ashish 2366 
    args.write(self._oprot)
2367 
    self._oprot.writeMessageEnd()
2368 
    self._oprot.trans.flush()
2369 
 
559 chandransh 2370 
  def recv_validateCart(self, ):
130 ashish 2371 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2372 
    if mtype == TMessageType.EXCEPTION:
2373 
      x = TApplicationException()
2374 
      x.read(self._iprot)
2375 
      self._iprot.readMessageEnd()
2376 
      raise x
559 chandransh 2377 
    result = validateCart_result()
130 ashish 2378 
    result.read(self._iprot)
2379 
    self._iprot.readMessageEnd()
2380 
    if result.success != None:
2381 
      return result.success
575 chandransh 2382 
    if result.scex != None:
2383 
      raise result.scex
559 chandransh 2384 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2385 
 
690 chandransh 2386 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2387 
    """
690 chandransh 2388 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
2389 
 
575 chandransh 2390 
    Parameters:
690 chandransh 2391 
     - fromCartId
2392 
     - toCartId
2393 
    """
2394 
    self.send_mergeCart(fromCartId, toCartId)
2395 
    self.recv_mergeCart()
2396 
 
2397 
  def send_mergeCart(self, fromCartId, toCartId):
2398 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2399 
    args = mergeCart_args()
2400 
    args.fromCartId = fromCartId
2401 
    args.toCartId = toCartId
2402 
    args.write(self._oprot)
2403 
    self._oprot.writeMessageEnd()
2404 
    self._oprot.trans.flush()
2405 
 
2406 
  def recv_mergeCart(self, ):
2407 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2408 
    if mtype == TMessageType.EXCEPTION:
2409 
      x = TApplicationException()
2410 
      x.read(self._iprot)
2411 
      self._iprot.readMessageEnd()
2412 
      raise x
2413 
    result = mergeCart_result()
2414 
    result.read(self._iprot)
2415 
    self._iprot.readMessageEnd()
2416 
    return
2417 
 
2418 
  def checkOut(self, cartId):
2419 
    """
2420 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
2421 
 
2422 
    Parameters:
575 chandransh 2423 
     - cartId
2424 
    """
690 chandransh 2425 
    self.send_checkOut(cartId)
2426 
    return self.recv_checkOut()
575 chandransh 2427 
 
690 chandransh 2428 
  def send_checkOut(self, cartId):
2429 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2430 
    args = checkOut_args()
575 chandransh 2431 
    args.cartId = cartId
2432 
    args.write(self._oprot)
2433 
    self._oprot.writeMessageEnd()
2434 
    self._oprot.trans.flush()
2435 
 
690 chandransh 2436 
  def recv_checkOut(self, ):
575 chandransh 2437 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2438 
    if mtype == TMessageType.EXCEPTION:
2439 
      x = TApplicationException()
2440 
      x.read(self._iprot)
2441 
      self._iprot.readMessageEnd()
2442 
      raise x
690 chandransh 2443 
    result = checkOut_result()
575 chandransh 2444 
    result.read(self._iprot)
2445 
    self._iprot.readMessageEnd()
2446 
    if result.success != None:
2447 
      return result.success
2448 
    if result.scex != None:
2449 
      raise result.scex
690 chandransh 2450 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2451 
 
690 chandransh 2452 
  def resetCart(self, cartId, items):
559 chandransh 2453 
    """
690 chandransh 2454 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2455 
    This methods removes the specified quantiry of the specified item from the cart.
2456 
 
559 chandransh 2457 
    Parameters:
690 chandransh 2458 
     - cartId
2459 
     - items
559 chandransh 2460 
    """
690 chandransh 2461 
    self.send_resetCart(cartId, items)
2462 
    return self.recv_resetCart()
130 ashish 2463 
 
690 chandransh 2464 
  def send_resetCart(self, cartId, items):
2465 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2466 
    args = resetCart_args()
2467 
    args.cartId = cartId
2468 
    args.items = items
559 chandransh 2469 
    args.write(self._oprot)
2470 
    self._oprot.writeMessageEnd()
2471 
    self._oprot.trans.flush()
2472 
 
690 chandransh 2473 
  def recv_resetCart(self, ):
559 chandransh 2474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2475 
    if mtype == TMessageType.EXCEPTION:
2476 
      x = TApplicationException()
2477 
      x.read(self._iprot)
2478 
      self._iprot.readMessageEnd()
2479 
      raise x
690 chandransh 2480 
    result = resetCart_result()
559 chandransh 2481 
    result.read(self._iprot)
2482 
    self._iprot.readMessageEnd()
690 chandransh 2483 
    if result.success != None:
2484 
      return result.success
2485 
    if result.scex != None:
2486 
      raise result.scex
2487 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2488 
 
772 rajveer 2489 
  def getMyResearch(self, userId):
559 chandransh 2490 
    """
772 rajveer 2491 
    Widgets
2492 
 
559 chandransh 2493 
    Parameters:
2494 
     - userId
2495 
    """
772 rajveer 2496 
    self.send_getMyResearch(userId)
559 chandransh 2497 
    return self.recv_getMyResearch()
2498 
 
772 rajveer 2499 
  def send_getMyResearch(self, userId):
559 chandransh 2500 
    self._oprot.writeMessageBegin('getMyResearch', TMessageType.CALL, self._seqid)
2501 
    args = getMyResearch_args()
772 rajveer 2502 
    args.userId = userId
559 chandransh 2503 
    args.write(self._oprot)
2504 
    self._oprot.writeMessageEnd()
2505 
    self._oprot.trans.flush()
2506 
 
2507 
  def recv_getMyResearch(self, ):
2508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2509 
    if mtype == TMessageType.EXCEPTION:
2510 
      x = TApplicationException()
2511 
      x.read(self._iprot)
2512 
      self._iprot.readMessageEnd()
2513 
      raise x
2514 
    result = getMyResearch_result()
2515 
    result.read(self._iprot)
2516 
    self._iprot.readMessageEnd()
2517 
    if result.success != None:
2518 
      return result.success
2519 
    if result.scx != None:
2520 
      raise result.scx
2521 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearch failed: unknown result");
2522 
 
772 rajveer 2523 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2524 
    """
2525 
    Parameters:
772 rajveer 2526 
     - userId
2527 
     - itemId
559 chandransh 2528 
    """
772 rajveer 2529 
    self.send_updateMyResearch(userId, itemId)
559 chandransh 2530 
    return self.recv_updateMyResearch()
2531 
 
772 rajveer 2532 
  def send_updateMyResearch(self, userId, itemId):
559 chandransh 2533 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2534 
    args = updateMyResearch_args()
772 rajveer 2535 
    args.userId = userId
2536 
    args.itemId = itemId
559 chandransh 2537 
    args.write(self._oprot)
2538 
    self._oprot.writeMessageEnd()
2539 
    self._oprot.trans.flush()
2540 
 
2541 
  def recv_updateMyResearch(self, ):
2542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2543 
    if mtype == TMessageType.EXCEPTION:
2544 
      x = TApplicationException()
2545 
      x.read(self._iprot)
2546 
      self._iprot.readMessageEnd()
2547 
      raise x
2548 
    result = updateMyResearch_result()
2549 
    result.read(self._iprot)
2550 
    self._iprot.readMessageEnd()
2551 
    if result.success != None:
2552 
      return result.success
2553 
    if result.scx != None:
2554 
      raise result.scx
2555 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
2556 
 
772 rajveer 2557 
  def deleteItemFromMyResearch(self, userId, itemId):
559 chandransh 2558 
    """
2559 
    Parameters:
772 rajveer 2560 
     - userId
2561 
     - itemId
559 chandransh 2562 
    """
772 rajveer 2563 
    self.send_deleteItemFromMyResearch(userId, itemId)
559 chandransh 2564 
    self.recv_deleteItemFromMyResearch()
2565 
 
772 rajveer 2566 
  def send_deleteItemFromMyResearch(self, userId, itemId):
559 chandransh 2567 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2568 
    args = deleteItemFromMyResearch_args()
772 rajveer 2569 
    args.userId = userId
2570 
    args.itemId = itemId
559 chandransh 2571 
    args.write(self._oprot)
2572 
    self._oprot.writeMessageEnd()
2573 
    self._oprot.trans.flush()
2574 
 
2575 
  def recv_deleteItemFromMyResearch(self, ):
2576 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2577 
    if mtype == TMessageType.EXCEPTION:
2578 
      x = TApplicationException()
2579 
      x.read(self._iprot)
2580 
      self._iprot.readMessageEnd()
2581 
      raise x
2582 
    result = deleteItemFromMyResearch_result()
2583 
    result.read(self._iprot)
2584 
    self._iprot.readMessageEnd()
2585 
    if result.scx != None:
2586 
      raise result.scx
2587 
    return
2588 
 
772 rajveer 2589 
  def updateBrowseHistory(self, userId, itemId):
559 chandransh 2590 
    """
2591 
    Parameters:
772 rajveer 2592 
     - userId
2593 
     - itemId
559 chandransh 2594 
    """
772 rajveer 2595 
    self.send_updateBrowseHistory(userId, itemId)
2596 
    self.recv_updateBrowseHistory()
559 chandransh 2597 
 
772 rajveer 2598 
  def send_updateBrowseHistory(self, userId, itemId):
2599 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2600 
    args = updateBrowseHistory_args()
2601 
    args.userId = userId
2602 
    args.itemId = itemId
559 chandransh 2603 
    args.write(self._oprot)
2604 
    self._oprot.writeMessageEnd()
2605 
    self._oprot.trans.flush()
2606 
 
772 rajveer 2607 
  def recv_updateBrowseHistory(self, ):
559 chandransh 2608 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2609 
    if mtype == TMessageType.EXCEPTION:
2610 
      x = TApplicationException()
2611 
      x.read(self._iprot)
2612 
      self._iprot.readMessageEnd()
2613 
      raise x
772 rajveer 2614 
    result = updateBrowseHistory_result()
559 chandransh 2615 
    result.read(self._iprot)
2616 
    self._iprot.readMessageEnd()
2617 
    return
2618 
 
772 rajveer 2619 
  def getBrowseHistory(self, userId):
559 chandransh 2620 
    """
2621 
    Parameters:
772 rajveer 2622 
     - userId
559 chandransh 2623 
    """
772 rajveer 2624 
    self.send_getBrowseHistory(userId)
2625 
    return self.recv_getBrowseHistory()
559 chandransh 2626 
 
772 rajveer 2627 
  def send_getBrowseHistory(self, userId):
2628 
    self._oprot.writeMessageBegin('getBrowseHistory', TMessageType.CALL, self._seqid)
2629 
    args = getBrowseHistory_args()
2630 
    args.userId = userId
559 chandransh 2631 
    args.write(self._oprot)
2632 
    self._oprot.writeMessageEnd()
2633 
    self._oprot.trans.flush()
2634 
 
772 rajveer 2635 
  def recv_getBrowseHistory(self, ):
559 chandransh 2636 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2637 
    if mtype == TMessageType.EXCEPTION:
2638 
      x = TApplicationException()
2639 
      x.read(self._iprot)
2640 
      self._iprot.readMessageEnd()
2641 
      raise x
772 rajveer 2642 
    result = getBrowseHistory_result()
559 chandransh 2643 
    result.read(self._iprot)
2644 
    self._iprot.readMessageEnd()
2645 
    if result.success != None:
2646 
      return result.success
2647 
    if result.scx != None:
2648 
      raise result.scx
772 rajveer 2649 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistory failed: unknown result");
559 chandransh 2650 
 
772 rajveer 2651 
  def mergeBrowseHistory(self, fromUserId, toUserId):
559 chandransh 2652 
    """
2653 
    Parameters:
772 rajveer 2654 
     - fromUserId
2655 
     - toUserId
559 chandransh 2656 
    """
772 rajveer 2657 
    self.send_mergeBrowseHistory(fromUserId, toUserId)
2658 
    self.recv_mergeBrowseHistory()
559 chandransh 2659 
 
772 rajveer 2660 
  def send_mergeBrowseHistory(self, fromUserId, toUserId):
2661 
    self._oprot.writeMessageBegin('mergeBrowseHistory', TMessageType.CALL, self._seqid)
2662 
    args = mergeBrowseHistory_args()
2663 
    args.fromUserId = fromUserId
2664 
    args.toUserId = toUserId
559 chandransh 2665 
    args.write(self._oprot)
2666 
    self._oprot.writeMessageEnd()
2667 
    self._oprot.trans.flush()
2668 
 
772 rajveer 2669 
  def recv_mergeBrowseHistory(self, ):
559 chandransh 2670 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2671 
    if mtype == TMessageType.EXCEPTION:
2672 
      x = TApplicationException()
2673 
      x.read(self._iprot)
2674 
      self._iprot.readMessageEnd()
2675 
      raise x
772 rajveer 2676 
    result = mergeBrowseHistory_result()
559 chandransh 2677 
    result.read(self._iprot)
2678 
    self._iprot.readMessageEnd()
2679 
    return
2680 
 
1596 ankur.sing 2681 
  def getUserCount(self, userType):
2682 
    """
2683 
    Returns number of registered users.
2684 
    If userType = null, then it returns count of all users, including anonymous
2685 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2686 
    If userType = UserType.USER, then it returns count of non-anonymous users only
2687 
 
2688 
    Parameters:
2689 
     - userType
2690 
    """
2691 
    self.send_getUserCount(userType)
2692 
    return self.recv_getUserCount()
559 chandransh 2693 
 
1596 ankur.sing 2694 
  def send_getUserCount(self, userType):
2695 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2696 
    args = getUserCount_args()
2697 
    args.userType = userType
2698 
    args.write(self._oprot)
2699 
    self._oprot.writeMessageEnd()
2700 
    self._oprot.trans.flush()
2701 
 
2702 
  def recv_getUserCount(self, ):
2703 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2704 
    if mtype == TMessageType.EXCEPTION:
2705 
      x = TApplicationException()
2706 
      x.read(self._iprot)
2707 
      self._iprot.readMessageEnd()
2708 
      raise x
2709 
    result = getUserCount_result()
2710 
    result.read(self._iprot)
2711 
    self._iprot.readMessageEnd()
2712 
    if result.success != None:
2713 
      return result.success
2714 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
2715 
 
1891 ankur.sing 2716 
  def getAllUsers(self, userType, startDate, endDate):
1673 ankur.sing 2717 
    """
1891 ankur.sing 2718 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2719 
    If any of startDate or endDate is -1, then that filter is ignored.
2720 
    If userType is null, then returns all the users, irrespective of anonymous flag
1673 ankur.sing 2721 
 
1891 ankur.sing 2722 
 
1673 ankur.sing 2723 
    Parameters:
2724 
     - userType
1891 ankur.sing 2725 
     - startDate
2726 
     - endDate
1673 ankur.sing 2727 
    """
1891 ankur.sing 2728 
    self.send_getAllUsers(userType, startDate, endDate)
1673 ankur.sing 2729 
    return self.recv_getAllUsers()
1596 ankur.sing 2730 
 
1891 ankur.sing 2731 
  def send_getAllUsers(self, userType, startDate, endDate):
1673 ankur.sing 2732 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2733 
    args = getAllUsers_args()
2734 
    args.userType = userType
1891 ankur.sing 2735 
    args.startDate = startDate
2736 
    args.endDate = endDate
1673 ankur.sing 2737 
    args.write(self._oprot)
2738 
    self._oprot.writeMessageEnd()
2739 
    self._oprot.trans.flush()
2740 
 
2741 
  def recv_getAllUsers(self, ):
2742 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2743 
    if mtype == TMessageType.EXCEPTION:
2744 
      x = TApplicationException()
2745 
      x.read(self._iprot)
2746 
      self._iprot.readMessageEnd()
2747 
      raise x
2748 
    result = getAllUsers_result()
2749 
    result.read(self._iprot)
2750 
    self._iprot.readMessageEnd()
2751 
    if result.success != None:
2752 
      return result.success
2753 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
2754 
 
2755 
 
94 ashish 2756 
class Processor(Iface, TProcessor):
2757 
  def __init__(self, handler):
2758 
    self._handler = handler
2759 
    self._processMap = {}
765 rajveer 2760 
    self._processMap["closeSession"] = Processor.process_closeSession
559 chandransh 2761 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
2762 
    self._processMap["getUserById"] = Processor.process_getUserById
1491 vikas 2763 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
559 chandransh 2764 
    self._processMap["createUser"] = Processor.process_createUser
2765 
    self._processMap["updateUser"] = Processor.process_updateUser
2766 
    self._processMap["deleteUser"] = Processor.process_deleteUser
2767 
    self._processMap["getUserState"] = Processor.process_getUserState
122 ashish 2768 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 2769 
    self._processMap["userExists"] = Processor.process_userExists
2770 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
2771 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
2772 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
2773 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 2774 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 2775 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 2776 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 2777 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 2778 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 2779 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 2780 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 2781 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 2782 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
2783 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
2784 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
1845 vikas 2785 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 2786 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 2787 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
2788 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
2789 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
2790 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
2791 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 2792 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 2793 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
2794 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
2795 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 2796 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 2797 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
2798 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 2799 
    self._processMap["createCart"] = Processor.process_createCart
2800 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
2801 
    self._processMap["getCart"] = Processor.process_getCart
2802 
    self._processMap["getCartsForUser"] = Processor.process_getCartsForUser
2803 
    self._processMap["getCartsByStatus"] = Processor.process_getCartsByStatus
2804 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
2805 
    self._processMap["changeCartStatus"] = Processor.process_changeCartStatus
2806 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
2807 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
2808 
    self._processMap["changeQuantity"] = Processor.process_changeQuantity
2809 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
2810 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
1976 varun.gupt 2811 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
2812 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
690 chandransh 2813 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 2814 
    self._processMap["validateCart"] = Processor.process_validateCart
2815 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 2816 
    self._processMap["checkOut"] = Processor.process_checkOut
2817 
    self._processMap["resetCart"] = Processor.process_resetCart
559 chandransh 2818 
    self._processMap["getMyResearch"] = Processor.process_getMyResearch
2819 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
2820 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
2821 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
2822 
    self._processMap["getBrowseHistory"] = Processor.process_getBrowseHistory
772 rajveer 2823 
    self._processMap["mergeBrowseHistory"] = Processor.process_mergeBrowseHistory
1596 ankur.sing 2824 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 2825 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
94 ashish 2826 
 
2827 
  def process(self, iprot, oprot):
2828 
    (name, type, seqid) = iprot.readMessageBegin()
2829 
    if name not in self._processMap:
2830 
      iprot.skip(TType.STRUCT)
2831 
      iprot.readMessageEnd()
2832 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
2833 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
2834 
      x.write(oprot)
2835 
      oprot.writeMessageEnd()
2836 
      oprot.trans.flush()
2837 
      return
2838 
    else:
2839 
      self._processMap[name](self, seqid, iprot, oprot)
2840 
    return True
2841 
 
765 rajveer 2842 
  def process_closeSession(self, seqid, iprot, oprot):
2843 
    args = closeSession_args()
2844 
    args.read(iprot)
2845 
    iprot.readMessageEnd()
2846 
    result = closeSession_result()
2847 
    self._handler.closeSession()
2848 
    oprot.writeMessageBegin("closeSession", TMessageType.REPLY, seqid)
2849 
    result.write(oprot)
2850 
    oprot.writeMessageEnd()
2851 
    oprot.trans.flush()
2852 
 
559 chandransh 2853 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
2854 
    args = createAnonymousUser_args()
94 ashish 2855 
    args.read(iprot)
2856 
    iprot.readMessageEnd()
559 chandransh 2857 
    result = createAnonymousUser_result()
94 ashish 2858 
    try:
559 chandransh 2859 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
2860 
    except UserContextException, ucex:
2861 
      result.ucex = ucex
2862 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 2863 
    result.write(oprot)
2864 
    oprot.writeMessageEnd()
2865 
    oprot.trans.flush()
2866 
 
559 chandransh 2867 
  def process_getUserById(self, seqid, iprot, oprot):
2868 
    args = getUserById_args()
94 ashish 2869 
    args.read(iprot)
2870 
    iprot.readMessageEnd()
559 chandransh 2871 
    result = getUserById_result()
94 ashish 2872 
    try:
559 chandransh 2873 
      result.success = self._handler.getUserById(args.userId)
2874 
    except UserContextException, ucex:
2875 
      result.ucex = ucex
2876 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 2877 
    result.write(oprot)
2878 
    oprot.writeMessageEnd()
2879 
    oprot.trans.flush()
2880 
 
1491 vikas 2881 
  def process_getUserByEmail(self, seqid, iprot, oprot):
2882 
    args = getUserByEmail_args()
2883 
    args.read(iprot)
2884 
    iprot.readMessageEnd()
2885 
    result = getUserByEmail_result()
2886 
    try:
2887 
      result.success = self._handler.getUserByEmail(args.email)
2888 
    except UserContextException, ucex:
2889 
      result.ucex = ucex
2890 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
2891 
    result.write(oprot)
2892 
    oprot.writeMessageEnd()
2893 
    oprot.trans.flush()
2894 
 
559 chandransh 2895 
  def process_createUser(self, seqid, iprot, oprot):
2896 
    args = createUser_args()
94 ashish 2897 
    args.read(iprot)
2898 
    iprot.readMessageEnd()
559 chandransh 2899 
    result = createUser_result()
94 ashish 2900 
    try:
559 chandransh 2901 
      result.success = self._handler.createUser(args.user)
2902 
    except UserContextException, ucex:
2903 
      result.ucex = ucex
2904 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 2905 
    result.write(oprot)
2906 
    oprot.writeMessageEnd()
2907 
    oprot.trans.flush()
2908 
 
559 chandransh 2909 
  def process_updateUser(self, seqid, iprot, oprot):
2910 
    args = updateUser_args()
94 ashish 2911 
    args.read(iprot)
2912 
    iprot.readMessageEnd()
559 chandransh 2913 
    result = updateUser_result()
94 ashish 2914 
    try:
559 chandransh 2915 
      result.success = self._handler.updateUser(args.user)
2916 
    except UserContextException, ucex:
2917 
      result.ucex = ucex
2918 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 2919 
    result.write(oprot)
2920 
    oprot.writeMessageEnd()
2921 
    oprot.trans.flush()
2922 
 
559 chandransh 2923 
  def process_deleteUser(self, seqid, iprot, oprot):
2924 
    args = deleteUser_args()
94 ashish 2925 
    args.read(iprot)
2926 
    iprot.readMessageEnd()
559 chandransh 2927 
    result = deleteUser_result()
94 ashish 2928 
    try:
559 chandransh 2929 
      result.success = self._handler.deleteUser(args.userId)
2930 
    except UserContextException, ucex:
2931 
      result.ucex = ucex
2932 
    oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
94 ashish 2933 
    result.write(oprot)
2934 
    oprot.writeMessageEnd()
2935 
    oprot.trans.flush()
2936 
 
559 chandransh 2937 
  def process_getUserState(self, seqid, iprot, oprot):
2938 
    args = getUserState_args()
94 ashish 2939 
    args.read(iprot)
2940 
    iprot.readMessageEnd()
559 chandransh 2941 
    result = getUserState_result()
94 ashish 2942 
    try:
559 chandransh 2943 
      result.success = self._handler.getUserState(args.userId)
2944 
    except UserContextException, ucex:
2945 
      result.ucex = ucex
2946 
    oprot.writeMessageBegin("getUserState", TMessageType.REPLY, seqid)
94 ashish 2947 
    result.write(oprot)
2948 
    oprot.writeMessageEnd()
2949 
    oprot.trans.flush()
2950 
 
122 ashish 2951 
  def process_authenticateUser(self, seqid, iprot, oprot):
2952 
    args = authenticateUser_args()
2953 
    args.read(iprot)
2954 
    iprot.readMessageEnd()
2955 
    result = authenticateUser_result()
2956 
    try:
559 chandransh 2957 
      result.success = self._handler.authenticateUser(args.email, args.password)
2958 
    except AuthenticationException, auex:
2959 
      result.auex = auex
122 ashish 2960 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
2961 
    result.write(oprot)
2962 
    oprot.writeMessageEnd()
2963 
    oprot.trans.flush()
2964 
 
94 ashish 2965 
  def process_userExists(self, seqid, iprot, oprot):
2966 
    args = userExists_args()
2967 
    args.read(iprot)
2968 
    iprot.readMessageEnd()
2969 
    result = userExists_result()
2970 
    try:
2971 
      result.success = self._handler.userExists(args.email)
2972 
    except UserContextException, ucx:
2973 
      result.ucx = ucx
2974 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
2975 
    result.write(oprot)
2976 
    oprot.writeMessageEnd()
2977 
    oprot.trans.flush()
2978 
 
2979 
  def process_addAddressForUser(self, seqid, iprot, oprot):
2980 
    args = addAddressForUser_args()
2981 
    args.read(iprot)
2982 
    iprot.readMessageEnd()
2983 
    result = addAddressForUser_result()
2984 
    try:
567 rajveer 2985 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 2986 
    except UserContextException, ucx:
2987 
      result.ucx = ucx
2988 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
2989 
    result.write(oprot)
2990 
    oprot.writeMessageEnd()
2991 
    oprot.trans.flush()
2992 
 
2993 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
2994 
    args = removeAddressForUser_args()
2995 
    args.read(iprot)
2996 
    iprot.readMessageEnd()
2997 
    result = removeAddressForUser_result()
2998 
    try:
2999 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
3000 
    except UserContextException, ucx:
3001 
      result.ucx = ucx
3002 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
3003 
    result.write(oprot)
3004 
    oprot.writeMessageEnd()
3005 
    oprot.trans.flush()
3006 
 
3007 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
3008 
    args = setUserAsLoggedIn_args()
3009 
    args.read(iprot)
3010 
    iprot.readMessageEnd()
3011 
    result = setUserAsLoggedIn_result()
3012 
    try:
3013 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
3014 
    except UserContextException, ucx:
3015 
      result.ucx = ucx
3016 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
3017 
    result.write(oprot)
3018 
    oprot.writeMessageEnd()
3019 
    oprot.trans.flush()
3020 
 
3021 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
3022 
    args = setUserAsLoggedOut_args()
3023 
    args.read(iprot)
3024 
    iprot.readMessageEnd()
3025 
    result = setUserAsLoggedOut_result()
3026 
    try:
3027 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
3028 
    except UserContextException, ucx:
3029 
      result.ucx = ucx
3030 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
3031 
    result.write(oprot)
3032 
    oprot.writeMessageEnd()
3033 
    oprot.trans.flush()
3034 
 
504 rajveer 3035 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
3036 
    args = setDefaultAddress_args()
3037 
    args.read(iprot)
3038 
    iprot.readMessageEnd()
3039 
    result = setDefaultAddress_result()
3040 
    try:
3041 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
3042 
    except UserContextException, ucx:
3043 
      result.ucx = ucx
3044 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
3045 
    result.write(oprot)
3046 
    oprot.writeMessageEnd()
3047 
    oprot.trans.flush()
3048 
 
94 ashish 3049 
  def process_updatePassword(self, seqid, iprot, oprot):
3050 
    args = updatePassword_args()
3051 
    args.read(iprot)
3052 
    iprot.readMessageEnd()
3053 
    result = updatePassword_result()
3054 
    try:
594 rajveer 3055 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 3056 
    except UserContextException, ucx:
3057 
      result.ucx = ucx
3058 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
3059 
    result.write(oprot)
3060 
    oprot.writeMessageEnd()
3061 
    oprot.trans.flush()
3062 
 
581 rajveer 3063 
  def process_forgotPassword(self, seqid, iprot, oprot):
3064 
    args = forgotPassword_args()
3065 
    args.read(iprot)
3066 
    iprot.readMessageEnd()
3067 
    result = forgotPassword_result()
3068 
    try:
884 rajveer 3069 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 3070 
    except UserContextException, ucx:
3071 
      result.ucx = ucx
3072 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
3073 
    result.write(oprot)
3074 
    oprot.writeMessageEnd()
3075 
    oprot.trans.flush()
3076 
 
594 rajveer 3077 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
3078 
    args = getAllAddressesForUser_args()
3079 
    args.read(iprot)
3080 
    iprot.readMessageEnd()
3081 
    result = getAllAddressesForUser_result()
3082 
    try:
3083 
      result.success = self._handler.getAllAddressesForUser(args.userId)
3084 
    except UserContextException, ucx:
3085 
      result.ucx = ucx
3086 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
3087 
    result.write(oprot)
3088 
    oprot.writeMessageEnd()
3089 
    oprot.trans.flush()
3090 
 
1894 vikas 3091 
  def process_getAddressById(self, seqid, iprot, oprot):
3092 
    args = getAddressById_args()
3093 
    args.read(iprot)
3094 
    iprot.readMessageEnd()
3095 
    result = getAddressById_result()
3096 
    try:
3097 
      result.success = self._handler.getAddressById(args.addressId)
3098 
    except UserContextException, ucx:
3099 
      result.ucx = ucx
3100 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
3101 
    result.write(oprot)
3102 
    oprot.writeMessageEnd()
3103 
    oprot.trans.flush()
3104 
 
594 rajveer 3105 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
3106 
    args = getDefaultAddressId_args()
3107 
    args.read(iprot)
3108 
    iprot.readMessageEnd()
3109 
    result = getDefaultAddressId_result()
3110 
    try:
3111 
      result.success = self._handler.getDefaultAddressId(args.userId)
3112 
    except UserContextException, ucx:
3113 
      result.ucx = ucx
3114 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
3115 
    result.write(oprot)
3116 
    oprot.writeMessageEnd()
3117 
    oprot.trans.flush()
3118 
 
785 rajveer 3119 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
3120 
    args = getDefaultPincode_args()
3121 
    args.read(iprot)
3122 
    iprot.readMessageEnd()
3123 
    result = getDefaultPincode_result()
3124 
    try:
3125 
      result.success = self._handler.getDefaultPincode(args.userId)
3126 
    except UserContextException, ucx:
3127 
      result.ucx = ucx
3128 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
3129 
    result.write(oprot)
3130 
    oprot.writeMessageEnd()
3131 
    oprot.trans.flush()
3132 
 
1274 varun.gupt 3133 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
3134 
    args = saveUserCommunication_args()
3135 
    args.read(iprot)
3136 
    iprot.readMessageEnd()
3137 
    result = saveUserCommunication_result()
3138 
    try:
3139 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
3140 
    except UserCommunicationException, ucx:
3141 
      result.ucx = ucx
3142 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
3143 
    result.write(oprot)
3144 
    oprot.writeMessageEnd()
3145 
    oprot.trans.flush()
3146 
 
1590 varun.gupt 3147 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
3148 
    args = getUserCommunicationById_args()
3149 
    args.read(iprot)
3150 
    iprot.readMessageEnd()
3151 
    result = getUserCommunicationById_result()
3152 
    try:
3153 
      result.success = self._handler.getUserCommunicationById(args.id)
3154 
    except UserCommunicationException, ucx:
3155 
      result.ucx = ucx
3156 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
3157 
    result.write(oprot)
3158 
    oprot.writeMessageEnd()
3159 
    oprot.trans.flush()
3160 
 
3161 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
3162 
    args = getUserCommunicationByUser_args()
3163 
    args.read(iprot)
3164 
    iprot.readMessageEnd()
3165 
    result = getUserCommunicationByUser_result()
3166 
    try:
3167 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
3168 
    except UserCommunicationException, ucx:
3169 
      result.ucx = ucx
3170 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
3171 
    result.write(oprot)
3172 
    oprot.writeMessageEnd()
3173 
    oprot.trans.flush()
3174 
 
3175 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
3176 
    args = getAllUserCommunications_args()
3177 
    args.read(iprot)
3178 
    iprot.readMessageEnd()
3179 
    result = getAllUserCommunications_result()
3180 
    try:
3181 
      result.success = self._handler.getAllUserCommunications()
3182 
    except UserCommunicationException, ucx:
3183 
      result.ucx = ucx
3184 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
3185 
    result.write(oprot)
3186 
    oprot.writeMessageEnd()
3187 
    oprot.trans.flush()
3188 
 
1845 vikas 3189 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
3190 
    args = createMasterAffiliate_args()
3191 
    args.read(iprot)
3192 
    iprot.readMessageEnd()
3193 
    result = createMasterAffiliate_result()
3194 
    try:
1859 vikas 3195 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 3196 
    except UserAffiliateException, utx:
1845 vikas 3197 
      result.utx = utx
3198 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
3199 
    result.write(oprot)
3200 
    oprot.writeMessageEnd()
3201 
    oprot.trans.flush()
3202 
 
1899 vikas 3203 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
3204 
    args = getAllMasterAffiliates_args()
3205 
    args.read(iprot)
3206 
    iprot.readMessageEnd()
3207 
    result = getAllMasterAffiliates_result()
3208 
    try:
3209 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 3210 
    except UserAffiliateException, utx:
1899 vikas 3211 
      result.utx = utx
3212 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
3213 
    result.write(oprot)
3214 
    oprot.writeMessageEnd()
3215 
    oprot.trans.flush()
3216 
 
1845 vikas 3217 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
3218 
    args = getMasterAffiliateById_args()
3219 
    args.read(iprot)
3220 
    iprot.readMessageEnd()
3221 
    result = getMasterAffiliateById_result()
3222 
    try:
3223 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 3224 
    except UserAffiliateException, utx:
1845 vikas 3225 
      result.utx = utx
3226 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
3227 
    result.write(oprot)
3228 
    oprot.writeMessageEnd()
3229 
    oprot.trans.flush()
3230 
 
3231 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
3232 
    args = getMasterAffiliateByName_args()
3233 
    args.read(iprot)
3234 
    iprot.readMessageEnd()
3235 
    result = getMasterAffiliateByName_result()
3236 
    try:
3237 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 3238 
    except UserAffiliateException, utx:
1845 vikas 3239 
      result.utx = utx
3240 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
3241 
    result.write(oprot)
3242 
    oprot.writeMessageEnd()
3243 
    oprot.trans.flush()
3244 
 
3245 
  def process_createAffiliate(self, seqid, iprot, oprot):
3246 
    args = createAffiliate_args()
3247 
    args.read(iprot)
3248 
    iprot.readMessageEnd()
3249 
    result = createAffiliate_result()
3250 
    try:
1859 vikas 3251 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 3252 
    except UserAffiliateException, utx:
1845 vikas 3253 
      result.utx = utx
3254 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
3255 
    result.write(oprot)
3256 
    oprot.writeMessageEnd()
3257 
    oprot.trans.flush()
3258 
 
3259 
  def process_getAffiliateById(self, seqid, iprot, oprot):
3260 
    args = getAffiliateById_args()
3261 
    args.read(iprot)
3262 
    iprot.readMessageEnd()
3263 
    result = getAffiliateById_result()
3264 
    try:
3265 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 3266 
    except UserAffiliateException, utx:
1845 vikas 3267 
      result.utx = utx
3268 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
3269 
    result.write(oprot)
3270 
    oprot.writeMessageEnd()
3271 
    oprot.trans.flush()
3272 
 
3273 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
3274 
    args = getAffiliateByName_args()
3275 
    args.read(iprot)
3276 
    iprot.readMessageEnd()
3277 
    result = getAffiliateByName_result()
3278 
    try:
3279 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 3280 
    except UserAffiliateException, utx:
1845 vikas 3281 
      result.utx = utx
3282 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
3283 
    result.write(oprot)
3284 
    oprot.writeMessageEnd()
3285 
    oprot.trans.flush()
3286 
 
3287 
  def process_getTrackerById(self, seqid, iprot, oprot):
3288 
    args = getTrackerById_args()
3289 
    args.read(iprot)
3290 
    iprot.readMessageEnd()
3291 
    result = getTrackerById_result()
3292 
    try:
1996 vikas 3293 
      result.success = self._handler.getTrackerById(args.id)
3294 
    except UserAffiliateException, utx:
1845 vikas 3295 
      result.utx = utx
3296 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
3297 
    result.write(oprot)
3298 
    oprot.writeMessageEnd()
3299 
    oprot.trans.flush()
3300 
 
1996 vikas 3301 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
3302 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 3303 
    args.read(iprot)
3304 
    iprot.readMessageEnd()
1996 vikas 3305 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 3306 
    try:
1996 vikas 3307 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
3308 
    except UserAffiliateException, utx:
1845 vikas 3309 
      result.utx = utx
1996 vikas 3310 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3311 
    result.write(oprot)
3312 
    oprot.writeMessageEnd()
3313 
    oprot.trans.flush()
3314 
 
3315 
  def process_addTrackLog(self, seqid, iprot, oprot):
3316 
    args = addTrackLog_args()
3317 
    args.read(iprot)
3318 
    iprot.readMessageEnd()
3319 
    result = addTrackLog_result()
3320 
    try:
1996 vikas 3321 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
3322 
    except UserAffiliateException, utx:
1845 vikas 3323 
      result.utx = utx
3324 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
3325 
    result.write(oprot)
3326 
    oprot.writeMessageEnd()
3327 
    oprot.trans.flush()
3328 
 
3329 
  def process_getTrackLogById(self, seqid, iprot, oprot):
3330 
    args = getTrackLogById_args()
3331 
    args.read(iprot)
3332 
    iprot.readMessageEnd()
3333 
    result = getTrackLogById_result()
3334 
    try:
3335 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 3336 
    except UserAffiliateException, utx:
1845 vikas 3337 
      result.utx = utx
3338 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
3339 
    result.write(oprot)
3340 
    oprot.writeMessageEnd()
3341 
    oprot.trans.flush()
3342 
 
1996 vikas 3343 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
3344 
    args = getTrackLogsByAffiliate_args()
1845 vikas 3345 
    args.read(iprot)
3346 
    iprot.readMessageEnd()
1996 vikas 3347 
    result = getTrackLogsByAffiliate_result()
1845 vikas 3348 
    try:
1996 vikas 3349 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId)
3350 
    except UserAffiliateException, utx:
1845 vikas 3351 
      result.utx = utx
1996 vikas 3352 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3353 
    result.write(oprot)
3354 
    oprot.writeMessageEnd()
3355 
    oprot.trans.flush()
3356 
 
3357 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
3358 
    args = getTrackLogsByUser_args()
3359 
    args.read(iprot)
3360 
    iprot.readMessageEnd()
3361 
    result = getTrackLogsByUser_result()
3362 
    try:
3363 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 3364 
    except UserAffiliateException, utx:
1845 vikas 3365 
      result.utx = utx
3366 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
3367 
    result.write(oprot)
3368 
    oprot.writeMessageEnd()
3369 
    oprot.trans.flush()
3370 
 
3371 
  def process_getTrackLogs(self, seqid, iprot, oprot):
3372 
    args = getTrackLogs_args()
3373 
    args.read(iprot)
3374 
    iprot.readMessageEnd()
3375 
    result = getTrackLogs_result()
3376 
    try:
1996 vikas 3377 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
3378 
    except UserAffiliateException, utx:
1845 vikas 3379 
      result.utx = utx
3380 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
3381 
    result.write(oprot)
3382 
    oprot.writeMessageEnd()
3383 
    oprot.trans.flush()
3384 
 
559 chandransh 3385 
  def process_createCart(self, seqid, iprot, oprot):
3386 
    args = createCart_args()
94 ashish 3387 
    args.read(iprot)
3388 
    iprot.readMessageEnd()
559 chandransh 3389 
    result = createCart_result()
94 ashish 3390 
    try:
559 chandransh 3391 
      result.success = self._handler.createCart(args.userId)
3392 
    except ShoppingCartException, scx:
3393 
      result.scx = scx
3394 
    oprot.writeMessageBegin("createCart", TMessageType.REPLY, seqid)
94 ashish 3395 
    result.write(oprot)
3396 
    oprot.writeMessageEnd()
3397 
    oprot.trans.flush()
3398 
 
559 chandransh 3399 
  def process_getCurrentCart(self, seqid, iprot, oprot):
3400 
    args = getCurrentCart_args()
94 ashish 3401 
    args.read(iprot)
3402 
    iprot.readMessageEnd()
559 chandransh 3403 
    result = getCurrentCart_result()
94 ashish 3404 
    try:
559 chandransh 3405 
      result.success = self._handler.getCurrentCart(args.userId)
3406 
    except ShoppingCartException, scx:
3407 
      result.scx = scx
3408 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 3409 
    result.write(oprot)
3410 
    oprot.writeMessageEnd()
3411 
    oprot.trans.flush()
3412 
 
559 chandransh 3413 
  def process_getCart(self, seqid, iprot, oprot):
3414 
    args = getCart_args()
94 ashish 3415 
    args.read(iprot)
3416 
    iprot.readMessageEnd()
559 chandransh 3417 
    result = getCart_result()
94 ashish 3418 
    try:
559 chandransh 3419 
      result.success = self._handler.getCart(args.cartId)
3420 
    except ShoppingCartException, scx:
3421 
      result.scx = scx
3422 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 3423 
    result.write(oprot)
3424 
    oprot.writeMessageEnd()
3425 
    oprot.trans.flush()
3426 
 
559 chandransh 3427 
  def process_getCartsForUser(self, seqid, iprot, oprot):
3428 
    args = getCartsForUser_args()
94 ashish 3429 
    args.read(iprot)
3430 
    iprot.readMessageEnd()
559 chandransh 3431 
    result = getCartsForUser_result()
94 ashish 3432 
    try:
559 chandransh 3433 
      result.success = self._handler.getCartsForUser(args.userId, args.status)
3434 
    except ShoppingCartException, scx:
3435 
      result.scx = scx
3436 
    oprot.writeMessageBegin("getCartsForUser", TMessageType.REPLY, seqid)
94 ashish 3437 
    result.write(oprot)
3438 
    oprot.writeMessageEnd()
3439 
    oprot.trans.flush()
3440 
 
559 chandransh 3441 
  def process_getCartsByStatus(self, seqid, iprot, oprot):
3442 
    args = getCartsByStatus_args()
94 ashish 3443 
    args.read(iprot)
3444 
    iprot.readMessageEnd()
559 chandransh 3445 
    result = getCartsByStatus_result()
94 ashish 3446 
    try:
559 chandransh 3447 
      result.success = self._handler.getCartsByStatus(args.status)
3448 
    except ShoppingCartException, scx:
3449 
      result.scx = scx
3450 
    oprot.writeMessageBegin("getCartsByStatus", TMessageType.REPLY, seqid)
94 ashish 3451 
    result.write(oprot)
3452 
    oprot.writeMessageEnd()
3453 
    oprot.trans.flush()
3454 
 
559 chandransh 3455 
  def process_getCartsByTime(self, seqid, iprot, oprot):
3456 
    args = getCartsByTime_args()
94 ashish 3457 
    args.read(iprot)
3458 
    iprot.readMessageEnd()
559 chandransh 3459 
    result = getCartsByTime_result()
94 ashish 3460 
    try:
559 chandransh 3461 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
3462 
    except ShoppingCartException, scx:
3463 
      result.scx = scx
3464 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 3465 
    result.write(oprot)
3466 
    oprot.writeMessageEnd()
3467 
    oprot.trans.flush()
3468 
 
559 chandransh 3469 
  def process_changeCartStatus(self, seqid, iprot, oprot):
3470 
    args = changeCartStatus_args()
130 ashish 3471 
    args.read(iprot)
3472 
    iprot.readMessageEnd()
559 chandransh 3473 
    result = changeCartStatus_result()
130 ashish 3474 
    try:
559 chandransh 3475 
      self._handler.changeCartStatus(args.cartId, args.status)
3476 
    except ShoppingCartException, scx:
3477 
      result.scx = scx
3478 
    oprot.writeMessageBegin("changeCartStatus", TMessageType.REPLY, seqid)
130 ashish 3479 
    result.write(oprot)
3480 
    oprot.writeMessageEnd()
3481 
    oprot.trans.flush()
94 ashish 3482 
 
559 chandransh 3483 
  def process_addItemToCart(self, seqid, iprot, oprot):
3484 
    args = addItemToCart_args()
130 ashish 3485 
    args.read(iprot)
3486 
    iprot.readMessageEnd()
559 chandransh 3487 
    result = addItemToCart_result()
130 ashish 3488 
    try:
559 chandransh 3489 
      self._handler.addItemToCart(args.cartId, args.itemId, args.quantity)
3490 
    except ShoppingCartException, scx:
3491 
      result.scx = scx
3492 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 3493 
    result.write(oprot)
3494 
    oprot.writeMessageEnd()
3495 
    oprot.trans.flush()
3496 
 
559 chandransh 3497 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
3498 
    args = deleteItemFromCart_args()
3499 
    args.read(iprot)
3500 
    iprot.readMessageEnd()
3501 
    result = deleteItemFromCart_result()
3502 
    try:
3503 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
3504 
    except ShoppingCartException, scx:
3505 
      result.scx = scx
3506 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
3507 
    result.write(oprot)
3508 
    oprot.writeMessageEnd()
3509 
    oprot.trans.flush()
130 ashish 3510 
 
559 chandransh 3511 
  def process_changeQuantity(self, seqid, iprot, oprot):
3512 
    args = changeQuantity_args()
3513 
    args.read(iprot)
3514 
    iprot.readMessageEnd()
3515 
    result = changeQuantity_result()
3516 
    try:
3517 
      self._handler.changeQuantity(args.cartId, args.itemId, args.quantity)
3518 
    except ShoppingCartException, scx:
3519 
      result.scx = scx
3520 
    oprot.writeMessageBegin("changeQuantity", TMessageType.REPLY, seqid)
3521 
    result.write(oprot)
3522 
    oprot.writeMessageEnd()
3523 
    oprot.trans.flush()
3524 
 
3525 
  def process_changeItemStatus(self, seqid, iprot, oprot):
3526 
    args = changeItemStatus_args()
3527 
    args.read(iprot)
3528 
    iprot.readMessageEnd()
3529 
    result = changeItemStatus_result()
3530 
    try:
3531 
      self._handler.changeItemStatus(args.cartId, args.itemId, args.status)
3532 
    except ShoppingCartException, scx:
3533 
      result.scx = scx
3534 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
3535 
    result.write(oprot)
3536 
    oprot.writeMessageEnd()
3537 
    oprot.trans.flush()
3538 
 
3539 
  def process_addAddressToCart(self, seqid, iprot, oprot):
3540 
    args = addAddressToCart_args()
3541 
    args.read(iprot)
3542 
    iprot.readMessageEnd()
3543 
    result = addAddressToCart_result()
575 chandransh 3544 
    try:
3545 
      self._handler.addAddressToCart(args.cartId, args.addressId)
3546 
    except ShoppingCartException, scx:
3547 
      result.scx = scx
559 chandransh 3548 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
3549 
    result.write(oprot)
3550 
    oprot.writeMessageEnd()
3551 
    oprot.trans.flush()
3552 
 
1976 varun.gupt 3553 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
3554 
    args = applyCouponToCart_args()
3555 
    args.read(iprot)
3556 
    iprot.readMessageEnd()
3557 
    result = applyCouponToCart_result()
3558 
    try:
3559 
      self._handler.applyCouponToCart(args.cartId, args.couponCode, args.totalPrice, args.discountedPrice)
3560 
    except ShoppingCartException, scx:
3561 
      result.scx = scx
3562 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
3563 
    result.write(oprot)
3564 
    oprot.writeMessageEnd()
3565 
    oprot.trans.flush()
3566 
 
3567 
  def process_removeCoupon(self, seqid, iprot, oprot):
3568 
    args = removeCoupon_args()
3569 
    args.read(iprot)
3570 
    iprot.readMessageEnd()
3571 
    result = removeCoupon_result()
3572 
    try:
3573 
      self._handler.removeCoupon(args.cartId)
3574 
    except ShoppingCartException, scx:
3575 
      result.scx = scx
3576 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
3577 
    result.write(oprot)
3578 
    oprot.writeMessageEnd()
3579 
    oprot.trans.flush()
3580 
 
690 chandransh 3581 
  def process_createOrders(self, seqid, iprot, oprot):
3582 
    args = createOrders_args()
559 chandransh 3583 
    args.read(iprot)
3584 
    iprot.readMessageEnd()
690 chandransh 3585 
    result = createOrders_result()
559 chandransh 3586 
    try:
690 chandransh 3587 
      result.success = self._handler.createOrders(args.cartId)
559 chandransh 3588 
    except ShoppingCartException, scx:
3589 
      result.scx = scx
690 chandransh 3590 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 3591 
    result.write(oprot)
3592 
    oprot.writeMessageEnd()
3593 
    oprot.trans.flush()
3594 
 
3595 
  def process_validateCart(self, seqid, iprot, oprot):
3596 
    args = validateCart_args()
3597 
    args.read(iprot)
3598 
    iprot.readMessageEnd()
3599 
    result = validateCart_result()
575 chandransh 3600 
    try:
3601 
      result.success = self._handler.validateCart(args.cartId)
3602 
    except ShoppingCartException, scex:
3603 
      result.scex = scex
559 chandransh 3604 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
3605 
    result.write(oprot)
3606 
    oprot.writeMessageEnd()
3607 
    oprot.trans.flush()
3608 
 
690 chandransh 3609 
  def process_mergeCart(self, seqid, iprot, oprot):
3610 
    args = mergeCart_args()
575 chandransh 3611 
    args.read(iprot)
3612 
    iprot.readMessageEnd()
690 chandransh 3613 
    result = mergeCart_result()
3614 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
3615 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
3616 
    result.write(oprot)
3617 
    oprot.writeMessageEnd()
3618 
    oprot.trans.flush()
3619 
 
3620 
  def process_checkOut(self, seqid, iprot, oprot):
3621 
    args = checkOut_args()
3622 
    args.read(iprot)
3623 
    iprot.readMessageEnd()
3624 
    result = checkOut_result()
575 chandransh 3625 
    try:
690 chandransh 3626 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 3627 
    except ShoppingCartException, scex:
3628 
      result.scex = scex
690 chandransh 3629 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 3630 
    result.write(oprot)
3631 
    oprot.writeMessageEnd()
3632 
    oprot.trans.flush()
3633 
 
690 chandransh 3634 
  def process_resetCart(self, seqid, iprot, oprot):
3635 
    args = resetCart_args()
559 chandransh 3636 
    args.read(iprot)
3637 
    iprot.readMessageEnd()
690 chandransh 3638 
    result = resetCart_result()
3639 
    try:
3640 
      result.success = self._handler.resetCart(args.cartId, args.items)
3641 
    except ShoppingCartException, scex:
3642 
      result.scex = scex
3643 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 3644 
    result.write(oprot)
3645 
    oprot.writeMessageEnd()
3646 
    oprot.trans.flush()
3647 
 
3648 
  def process_getMyResearch(self, seqid, iprot, oprot):
3649 
    args = getMyResearch_args()
3650 
    args.read(iprot)
3651 
    iprot.readMessageEnd()
3652 
    result = getMyResearch_result()
3653 
    try:
772 rajveer 3654 
      result.success = self._handler.getMyResearch(args.userId)
559 chandransh 3655 
    except WidgetException, scx:
3656 
      result.scx = scx
3657 
    oprot.writeMessageBegin("getMyResearch", TMessageType.REPLY, seqid)
3658 
    result.write(oprot)
3659 
    oprot.writeMessageEnd()
3660 
    oprot.trans.flush()
3661 
 
3662 
  def process_updateMyResearch(self, seqid, iprot, oprot):
3663 
    args = updateMyResearch_args()
3664 
    args.read(iprot)
3665 
    iprot.readMessageEnd()
3666 
    result = updateMyResearch_result()
3667 
    try:
772 rajveer 3668 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
559 chandransh 3669 
    except WidgetException, scx:
3670 
      result.scx = scx
3671 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
3672 
    result.write(oprot)
3673 
    oprot.writeMessageEnd()
3674 
    oprot.trans.flush()
3675 
 
3676 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
3677 
    args = deleteItemFromMyResearch_args()
3678 
    args.read(iprot)
3679 
    iprot.readMessageEnd()
3680 
    result = deleteItemFromMyResearch_result()
3681 
    try:
772 rajveer 3682 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
559 chandransh 3683 
    except WidgetException, scx:
3684 
      result.scx = scx
3685 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
3686 
    result.write(oprot)
3687 
    oprot.writeMessageEnd()
3688 
    oprot.trans.flush()
3689 
 
3690 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
3691 
    args = updateBrowseHistory_args()
3692 
    args.read(iprot)
3693 
    iprot.readMessageEnd()
3694 
    result = updateBrowseHistory_result()
772 rajveer 3695 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
559 chandransh 3696 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
3697 
    result.write(oprot)
3698 
    oprot.writeMessageEnd()
3699 
    oprot.trans.flush()
3700 
 
3701 
  def process_getBrowseHistory(self, seqid, iprot, oprot):
3702 
    args = getBrowseHistory_args()
3703 
    args.read(iprot)
3704 
    iprot.readMessageEnd()
3705 
    result = getBrowseHistory_result()
3706 
    try:
772 rajveer 3707 
      result.success = self._handler.getBrowseHistory(args.userId)
559 chandransh 3708 
    except WidgetException, scx:
3709 
      result.scx = scx
3710 
    oprot.writeMessageBegin("getBrowseHistory", TMessageType.REPLY, seqid)
3711 
    result.write(oprot)
3712 
    oprot.writeMessageEnd()
3713 
    oprot.trans.flush()
3714 
 
772 rajveer 3715 
  def process_mergeBrowseHistory(self, seqid, iprot, oprot):
3716 
    args = mergeBrowseHistory_args()
3717 
    args.read(iprot)
3718 
    iprot.readMessageEnd()
3719 
    result = mergeBrowseHistory_result()
3720 
    self._handler.mergeBrowseHistory(args.fromUserId, args.toUserId)
3721 
    oprot.writeMessageBegin("mergeBrowseHistory", TMessageType.REPLY, seqid)
3722 
    result.write(oprot)
3723 
    oprot.writeMessageEnd()
3724 
    oprot.trans.flush()
559 chandransh 3725 
 
1596 ankur.sing 3726 
  def process_getUserCount(self, seqid, iprot, oprot):
3727 
    args = getUserCount_args()
3728 
    args.read(iprot)
3729 
    iprot.readMessageEnd()
3730 
    result = getUserCount_result()
3731 
    result.success = self._handler.getUserCount(args.userType)
3732 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
3733 
    result.write(oprot)
3734 
    oprot.writeMessageEnd()
3735 
    oprot.trans.flush()
772 rajveer 3736 
 
1673 ankur.sing 3737 
  def process_getAllUsers(self, seqid, iprot, oprot):
3738 
    args = getAllUsers_args()
3739 
    args.read(iprot)
3740 
    iprot.readMessageEnd()
3741 
    result = getAllUsers_result()
1891 ankur.sing 3742 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
1673 ankur.sing 3743 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
3744 
    result.write(oprot)
3745 
    oprot.writeMessageEnd()
3746 
    oprot.trans.flush()
1596 ankur.sing 3747 
 
1673 ankur.sing 3748 
 
94 ashish 3749 
# HELPER FUNCTIONS AND STRUCTURES
3750 
 
765 rajveer 3751 
class closeSession_args:
3752 
 
3753 
  thrift_spec = (
3754 
  )
3755 
 
3756 
  def read(self, iprot):
3757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3759 
      return
3760 
    iprot.readStructBegin()
3761 
    while True:
3762 
      (fname, ftype, fid) = iprot.readFieldBegin()
3763 
      if ftype == TType.STOP:
3764 
        break
3765 
      else:
3766 
        iprot.skip(ftype)
3767 
      iprot.readFieldEnd()
3768 
    iprot.readStructEnd()
3769 
 
3770 
  def write(self, oprot):
3771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3773 
      return
3774 
    oprot.writeStructBegin('closeSession_args')
3775 
    oprot.writeFieldStop()
3776 
    oprot.writeStructEnd()
3777 
 
3778 
  def __repr__(self):
3779 
    L = ['%s=%r' % (key, value)
3780 
      for key, value in self.__dict__.iteritems()]
3781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3782 
 
3783 
  def __eq__(self, other):
3784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3785 
 
3786 
  def __ne__(self, other):
3787 
    return not (self == other)
3788 
 
3789 
class closeSession_result:
3790 
 
3791 
  thrift_spec = (
3792 
  )
3793 
 
3794 
  def read(self, iprot):
3795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3797 
      return
3798 
    iprot.readStructBegin()
3799 
    while True:
3800 
      (fname, ftype, fid) = iprot.readFieldBegin()
3801 
      if ftype == TType.STOP:
3802 
        break
3803 
      else:
3804 
        iprot.skip(ftype)
3805 
      iprot.readFieldEnd()
3806 
    iprot.readStructEnd()
3807 
 
3808 
  def write(self, oprot):
3809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3811 
      return
3812 
    oprot.writeStructBegin('closeSession_result')
3813 
    oprot.writeFieldStop()
3814 
    oprot.writeStructEnd()
3815 
 
3816 
  def __repr__(self):
3817 
    L = ['%s=%r' % (key, value)
3818 
      for key, value in self.__dict__.iteritems()]
3819 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3820 
 
3821 
  def __eq__(self, other):
3822 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3823 
 
3824 
  def __ne__(self, other):
3825 
    return not (self == other)
3826 
 
559 chandransh 3827 
class createAnonymousUser_args:
94 ashish 3828 
  """
3829 
  Attributes:
559 chandransh 3830 
   - jsessionId
94 ashish 3831 
  """
3832 
 
3833 
  thrift_spec = (
3834 
    None, # 0
559 chandransh 3835 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 3836 
  )
3837 
 
559 chandransh 3838 
  def __init__(self, jsessionId=None,):
3839 
    self.jsessionId = jsessionId
94 ashish 3840 
 
3841 
  def read(self, iprot):
3842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3844 
      return
3845 
    iprot.readStructBegin()
3846 
    while True:
3847 
      (fname, ftype, fid) = iprot.readFieldBegin()
3848 
      if ftype == TType.STOP:
3849 
        break
3850 
      if fid == 1:
559 chandransh 3851 
        if ftype == TType.STRING:
3852 
          self.jsessionId = iprot.readString();
94 ashish 3853 
        else:
3854 
          iprot.skip(ftype)
3855 
      else:
3856 
        iprot.skip(ftype)
3857 
      iprot.readFieldEnd()
3858 
    iprot.readStructEnd()
3859 
 
3860 
  def write(self, oprot):
3861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3863 
      return
559 chandransh 3864 
    oprot.writeStructBegin('createAnonymousUser_args')
3865 
    if self.jsessionId != None:
3866 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
3867 
      oprot.writeString(self.jsessionId)
94 ashish 3868 
      oprot.writeFieldEnd()
3869 
    oprot.writeFieldStop()
3870 
    oprot.writeStructEnd()
3871 
 
3872 
  def __repr__(self):
3873 
    L = ['%s=%r' % (key, value)
3874 
      for key, value in self.__dict__.iteritems()]
3875 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3876 
 
3877 
  def __eq__(self, other):
3878 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3879 
 
3880 
  def __ne__(self, other):
3881 
    return not (self == other)
3882 
 
559 chandransh 3883 
class createAnonymousUser_result:
94 ashish 3884 
  """
3885 
  Attributes:
3886 
   - success
559 chandransh 3887 
   - ucex
94 ashish 3888 
  """
3889 
 
3890 
  thrift_spec = (
559 chandransh 3891 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
3892 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 3893 
  )
3894 
 
559 chandransh 3895 
  def __init__(self, success=None, ucex=None,):
94 ashish 3896 
    self.success = success
559 chandransh 3897 
    self.ucex = ucex
94 ashish 3898 
 
3899 
  def read(self, iprot):
3900 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3901 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3902 
      return
3903 
    iprot.readStructBegin()
3904 
    while True:
3905 
      (fname, ftype, fid) = iprot.readFieldBegin()
3906 
      if ftype == TType.STOP:
3907 
        break
3908 
      if fid == 0:
3909 
        if ftype == TType.STRUCT:
559 chandransh 3910 
          self.success = User()
94 ashish 3911 
          self.success.read(iprot)
3912 
        else:
3913 
          iprot.skip(ftype)
3914 
      elif fid == 1:
3915 
        if ftype == TType.STRUCT:
559 chandransh 3916 
          self.ucex = UserContextException()
3917 
          self.ucex.read(iprot)
94 ashish 3918 
        else:
3919 
          iprot.skip(ftype)
3920 
      else:
3921 
        iprot.skip(ftype)
3922 
      iprot.readFieldEnd()
3923 
    iprot.readStructEnd()
3924 
 
3925 
  def write(self, oprot):
3926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3928 
      return
559 chandransh 3929 
    oprot.writeStructBegin('createAnonymousUser_result')
94 ashish 3930 
    if self.success != None:
3931 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3932 
      self.success.write(oprot)
3933 
      oprot.writeFieldEnd()
559 chandransh 3934 
    if self.ucex != None:
3935 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
3936 
      self.ucex.write(oprot)
94 ashish 3937 
      oprot.writeFieldEnd()
3938 
    oprot.writeFieldStop()
3939 
    oprot.writeStructEnd()
3940 
 
3941 
  def __repr__(self):
3942 
    L = ['%s=%r' % (key, value)
3943 
      for key, value in self.__dict__.iteritems()]
3944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3945 
 
3946 
  def __eq__(self, other):
3947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3948 
 
3949 
  def __ne__(self, other):
3950 
    return not (self == other)
3951 
 
559 chandransh 3952 
class getUserById_args:
94 ashish 3953 
  """
3954 
  Attributes:
3955 
   - userId
3956 
  """
3957 
 
3958 
  thrift_spec = (
3959 
    None, # 0
3960 
    (1, TType.I64, 'userId', None, None, ), # 1
3961 
  )
3962 
 
559 chandransh 3963 
  def __init__(self, userId=None,):
94 ashish 3964 
    self.userId = userId
3965 
 
3966 
  def read(self, iprot):
3967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3969 
      return
3970 
    iprot.readStructBegin()
3971 
    while True:
3972 
      (fname, ftype, fid) = iprot.readFieldBegin()
3973 
      if ftype == TType.STOP:
3974 
        break
3975 
      if fid == 1:
3976 
        if ftype == TType.I64:
3977 
          self.userId = iprot.readI64();
3978 
        else:
3979 
          iprot.skip(ftype)
3980 
      else:
3981 
        iprot.skip(ftype)
3982 
      iprot.readFieldEnd()
3983 
    iprot.readStructEnd()
3984 
 
3985 
  def write(self, oprot):
3986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3988 
      return
559 chandransh 3989 
    oprot.writeStructBegin('getUserById_args')
94 ashish 3990 
    if self.userId != None:
3991 
      oprot.writeFieldBegin('userId', TType.I64, 1)
3992 
      oprot.writeI64(self.userId)
3993 
      oprot.writeFieldEnd()
3994 
    oprot.writeFieldStop()
3995 
    oprot.writeStructEnd()
3996 
 
3997 
  def __repr__(self):
3998 
    L = ['%s=%r' % (key, value)
3999 
      for key, value in self.__dict__.iteritems()]
4000 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4001 
 
4002 
  def __eq__(self, other):
4003 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4004 
 
4005 
  def __ne__(self, other):
4006 
    return not (self == other)
4007 
 
559 chandransh 4008 
class getUserById_result:
94 ashish 4009 
  """
4010 
  Attributes:
4011 
   - success
559 chandransh 4012 
   - ucex
94 ashish 4013 
  """
4014 
 
4015 
  thrift_spec = (
559 chandransh 4016 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4017 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4018 
  )
4019 
 
559 chandransh 4020 
  def __init__(self, success=None, ucex=None,):
94 ashish 4021 
    self.success = success
559 chandransh 4022 
    self.ucex = ucex
94 ashish 4023 
 
4024 
  def read(self, iprot):
4025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4027 
      return
4028 
    iprot.readStructBegin()
4029 
    while True:
4030 
      (fname, ftype, fid) = iprot.readFieldBegin()
4031 
      if ftype == TType.STOP:
4032 
        break
4033 
      if fid == 0:
4034 
        if ftype == TType.STRUCT:
559 chandransh 4035 
          self.success = User()
94 ashish 4036 
          self.success.read(iprot)
4037 
        else:
4038 
          iprot.skip(ftype)
4039 
      elif fid == 1:
4040 
        if ftype == TType.STRUCT:
559 chandransh 4041 
          self.ucex = UserContextException()
4042 
          self.ucex.read(iprot)
94 ashish 4043 
        else:
4044 
          iprot.skip(ftype)
4045 
      else:
4046 
        iprot.skip(ftype)
4047 
      iprot.readFieldEnd()
4048 
    iprot.readStructEnd()
4049 
 
4050 
  def write(self, oprot):
4051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4053 
      return
559 chandransh 4054 
    oprot.writeStructBegin('getUserById_result')
94 ashish 4055 
    if self.success != None:
4056 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4057 
      self.success.write(oprot)
4058 
      oprot.writeFieldEnd()
559 chandransh 4059 
    if self.ucex != None:
4060 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4061 
      self.ucex.write(oprot)
94 ashish 4062 
      oprot.writeFieldEnd()
4063 
    oprot.writeFieldStop()
4064 
    oprot.writeStructEnd()
4065 
 
4066 
  def __repr__(self):
4067 
    L = ['%s=%r' % (key, value)
4068 
      for key, value in self.__dict__.iteritems()]
4069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4070 
 
4071 
  def __eq__(self, other):
4072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4073 
 
4074 
  def __ne__(self, other):
4075 
    return not (self == other)
4076 
 
1491 vikas 4077 
class getUserByEmail_args:
4078 
  """
4079 
  Attributes:
4080 
   - email
4081 
  """
4082 
 
4083 
  thrift_spec = (
4084 
    None, # 0
4085 
    (1, TType.STRING, 'email', None, None, ), # 1
4086 
  )
4087 
 
4088 
  def __init__(self, email=None,):
4089 
    self.email = email
4090 
 
4091 
  def read(self, iprot):
4092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4094 
      return
4095 
    iprot.readStructBegin()
4096 
    while True:
4097 
      (fname, ftype, fid) = iprot.readFieldBegin()
4098 
      if ftype == TType.STOP:
4099 
        break
4100 
      if fid == 1:
4101 
        if ftype == TType.STRING:
4102 
          self.email = iprot.readString();
4103 
        else:
4104 
          iprot.skip(ftype)
4105 
      else:
4106 
        iprot.skip(ftype)
4107 
      iprot.readFieldEnd()
4108 
    iprot.readStructEnd()
4109 
 
4110 
  def write(self, oprot):
4111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4113 
      return
4114 
    oprot.writeStructBegin('getUserByEmail_args')
4115 
    if self.email != None:
4116 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4117 
      oprot.writeString(self.email)
4118 
      oprot.writeFieldEnd()
4119 
    oprot.writeFieldStop()
4120 
    oprot.writeStructEnd()
4121 
 
4122 
  def __repr__(self):
4123 
    L = ['%s=%r' % (key, value)
4124 
      for key, value in self.__dict__.iteritems()]
4125 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4126 
 
4127 
  def __eq__(self, other):
4128 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4129 
 
4130 
  def __ne__(self, other):
4131 
    return not (self == other)
4132 
 
4133 
class getUserByEmail_result:
4134 
  """
4135 
  Attributes:
4136 
   - success
4137 
   - ucex
4138 
  """
4139 
 
4140 
  thrift_spec = (
4141 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4142 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4143 
  )
4144 
 
4145 
  def __init__(self, success=None, ucex=None,):
4146 
    self.success = success
4147 
    self.ucex = ucex
4148 
 
4149 
  def read(self, iprot):
4150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4152 
      return
4153 
    iprot.readStructBegin()
4154 
    while True:
4155 
      (fname, ftype, fid) = iprot.readFieldBegin()
4156 
      if ftype == TType.STOP:
4157 
        break
4158 
      if fid == 0:
4159 
        if ftype == TType.STRUCT:
4160 
          self.success = User()
4161 
          self.success.read(iprot)
4162 
        else:
4163 
          iprot.skip(ftype)
4164 
      elif fid == 1:
4165 
        if ftype == TType.STRUCT:
4166 
          self.ucex = UserContextException()
4167 
          self.ucex.read(iprot)
4168 
        else:
4169 
          iprot.skip(ftype)
4170 
      else:
4171 
        iprot.skip(ftype)
4172 
      iprot.readFieldEnd()
4173 
    iprot.readStructEnd()
4174 
 
4175 
  def write(self, oprot):
4176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4178 
      return
4179 
    oprot.writeStructBegin('getUserByEmail_result')
4180 
    if self.success != None:
4181 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4182 
      self.success.write(oprot)
4183 
      oprot.writeFieldEnd()
4184 
    if self.ucex != None:
4185 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4186 
      self.ucex.write(oprot)
4187 
      oprot.writeFieldEnd()
4188 
    oprot.writeFieldStop()
4189 
    oprot.writeStructEnd()
4190 
 
4191 
  def __repr__(self):
4192 
    L = ['%s=%r' % (key, value)
4193 
      for key, value in self.__dict__.iteritems()]
4194 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4195 
 
4196 
  def __eq__(self, other):
4197 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4198 
 
4199 
  def __ne__(self, other):
4200 
    return not (self == other)
4201 
 
559 chandransh 4202 
class createUser_args:
94 ashish 4203 
  """
4204 
  Attributes:
559 chandransh 4205 
   - user
94 ashish 4206 
  """
4207 
 
4208 
  thrift_spec = (
4209 
    None, # 0
559 chandransh 4210 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4211 
  )
4212 
 
559 chandransh 4213 
  def __init__(self, user=None,):
4214 
    self.user = user
94 ashish 4215 
 
4216 
  def read(self, iprot):
4217 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4218 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4219 
      return
4220 
    iprot.readStructBegin()
4221 
    while True:
4222 
      (fname, ftype, fid) = iprot.readFieldBegin()
4223 
      if ftype == TType.STOP:
4224 
        break
4225 
      if fid == 1:
559 chandransh 4226 
        if ftype == TType.STRUCT:
4227 
          self.user = User()
4228 
          self.user.read(iprot)
94 ashish 4229 
        else:
4230 
          iprot.skip(ftype)
4231 
      else:
4232 
        iprot.skip(ftype)
4233 
      iprot.readFieldEnd()
4234 
    iprot.readStructEnd()
4235 
 
4236 
  def write(self, oprot):
4237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4239 
      return
559 chandransh 4240 
    oprot.writeStructBegin('createUser_args')
4241 
    if self.user != None:
4242 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4243 
      self.user.write(oprot)
94 ashish 4244 
      oprot.writeFieldEnd()
4245 
    oprot.writeFieldStop()
4246 
    oprot.writeStructEnd()
4247 
 
4248 
  def __repr__(self):
4249 
    L = ['%s=%r' % (key, value)
4250 
      for key, value in self.__dict__.iteritems()]
4251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4252 
 
4253 
  def __eq__(self, other):
4254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4255 
 
4256 
  def __ne__(self, other):
4257 
    return not (self == other)
4258 
 
559 chandransh 4259 
class createUser_result:
94 ashish 4260 
  """
4261 
  Attributes:
4262 
   - success
559 chandransh 4263 
   - ucex
94 ashish 4264 
  """
4265 
 
4266 
  thrift_spec = (
559 chandransh 4267 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4268 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4269 
  )
4270 
 
559 chandransh 4271 
  def __init__(self, success=None, ucex=None,):
94 ashish 4272 
    self.success = success
559 chandransh 4273 
    self.ucex = ucex
94 ashish 4274 
 
4275 
  def read(self, iprot):
4276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4278 
      return
4279 
    iprot.readStructBegin()
4280 
    while True:
4281 
      (fname, ftype, fid) = iprot.readFieldBegin()
4282 
      if ftype == TType.STOP:
4283 
        break
4284 
      if fid == 0:
4285 
        if ftype == TType.STRUCT:
559 chandransh 4286 
          self.success = User()
94 ashish 4287 
          self.success.read(iprot)
4288 
        else:
4289 
          iprot.skip(ftype)
4290 
      elif fid == 1:
4291 
        if ftype == TType.STRUCT:
559 chandransh 4292 
          self.ucex = UserContextException()
4293 
          self.ucex.read(iprot)
94 ashish 4294 
        else:
4295 
          iprot.skip(ftype)
4296 
      else:
4297 
        iprot.skip(ftype)
4298 
      iprot.readFieldEnd()
4299 
    iprot.readStructEnd()
4300 
 
4301 
  def write(self, oprot):
4302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4304 
      return
559 chandransh 4305 
    oprot.writeStructBegin('createUser_result')
94 ashish 4306 
    if self.success != None:
4307 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4308 
      self.success.write(oprot)
4309 
      oprot.writeFieldEnd()
559 chandransh 4310 
    if self.ucex != None:
4311 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4312 
      self.ucex.write(oprot)
94 ashish 4313 
      oprot.writeFieldEnd()
4314 
    oprot.writeFieldStop()
4315 
    oprot.writeStructEnd()
4316 
 
4317 
  def __repr__(self):
4318 
    L = ['%s=%r' % (key, value)
4319 
      for key, value in self.__dict__.iteritems()]
4320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4321 
 
4322 
  def __eq__(self, other):
4323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4324 
 
4325 
  def __ne__(self, other):
4326 
    return not (self == other)
4327 
 
559 chandransh 4328 
class updateUser_args:
94 ashish 4329 
  """
4330 
  Attributes:
559 chandransh 4331 
   - user
94 ashish 4332 
  """
4333 
 
4334 
  thrift_spec = (
4335 
    None, # 0
559 chandransh 4336 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4337 
  )
4338 
 
559 chandransh 4339 
  def __init__(self, user=None,):
4340 
    self.user = user
94 ashish 4341 
 
4342 
  def read(self, iprot):
4343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4345 
      return
4346 
    iprot.readStructBegin()
4347 
    while True:
4348 
      (fname, ftype, fid) = iprot.readFieldBegin()
4349 
      if ftype == TType.STOP:
4350 
        break
4351 
      if fid == 1:
559 chandransh 4352 
        if ftype == TType.STRUCT:
4353 
          self.user = User()
4354 
          self.user.read(iprot)
94 ashish 4355 
        else:
4356 
          iprot.skip(ftype)
4357 
      else:
4358 
        iprot.skip(ftype)
4359 
      iprot.readFieldEnd()
4360 
    iprot.readStructEnd()
4361 
 
4362 
  def write(self, oprot):
4363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4365 
      return
559 chandransh 4366 
    oprot.writeStructBegin('updateUser_args')
4367 
    if self.user != None:
4368 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4369 
      self.user.write(oprot)
94 ashish 4370 
      oprot.writeFieldEnd()
4371 
    oprot.writeFieldStop()
4372 
    oprot.writeStructEnd()
4373 
 
4374 
  def __repr__(self):
4375 
    L = ['%s=%r' % (key, value)
4376 
      for key, value in self.__dict__.iteritems()]
4377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4378 
 
4379 
  def __eq__(self, other):
4380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4381 
 
4382 
  def __ne__(self, other):
4383 
    return not (self == other)
4384 
 
559 chandransh 4385 
class updateUser_result:
94 ashish 4386 
  """
4387 
  Attributes:
4388 
   - success
559 chandransh 4389 
   - ucex
94 ashish 4390 
  """
4391 
 
4392 
  thrift_spec = (
559 chandransh 4393 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4394 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4395 
  )
4396 
 
559 chandransh 4397 
  def __init__(self, success=None, ucex=None,):
94 ashish 4398 
    self.success = success
559 chandransh 4399 
    self.ucex = ucex
94 ashish 4400 
 
4401 
  def read(self, iprot):
4402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4404 
      return
4405 
    iprot.readStructBegin()
4406 
    while True:
4407 
      (fname, ftype, fid) = iprot.readFieldBegin()
4408 
      if ftype == TType.STOP:
4409 
        break
4410 
      if fid == 0:
4411 
        if ftype == TType.STRUCT:
559 chandransh 4412 
          self.success = User()
94 ashish 4413 
          self.success.read(iprot)
4414 
        else:
4415 
          iprot.skip(ftype)
4416 
      elif fid == 1:
4417 
        if ftype == TType.STRUCT:
559 chandransh 4418 
          self.ucex = UserContextException()
4419 
          self.ucex.read(iprot)
94 ashish 4420 
        else:
4421 
          iprot.skip(ftype)
4422 
      else:
4423 
        iprot.skip(ftype)
4424 
      iprot.readFieldEnd()
4425 
    iprot.readStructEnd()
4426 
 
4427 
  def write(self, oprot):
4428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4430 
      return
559 chandransh 4431 
    oprot.writeStructBegin('updateUser_result')
94 ashish 4432 
    if self.success != None:
4433 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4434 
      self.success.write(oprot)
4435 
      oprot.writeFieldEnd()
559 chandransh 4436 
    if self.ucex != None:
4437 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4438 
      self.ucex.write(oprot)
94 ashish 4439 
      oprot.writeFieldEnd()
4440 
    oprot.writeFieldStop()
4441 
    oprot.writeStructEnd()
4442 
 
4443 
  def __repr__(self):
4444 
    L = ['%s=%r' % (key, value)
4445 
      for key, value in self.__dict__.iteritems()]
4446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4447 
 
4448 
  def __eq__(self, other):
4449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4450 
 
4451 
  def __ne__(self, other):
4452 
    return not (self == other)
4453 
 
559 chandransh 4454 
class deleteUser_args:
94 ashish 4455 
  """
4456 
  Attributes:
4457 
   - userId
4458 
  """
4459 
 
4460 
  thrift_spec = (
4461 
    None, # 0
4462 
    (1, TType.I64, 'userId', None, None, ), # 1
4463 
  )
4464 
 
559 chandransh 4465 
  def __init__(self, userId=None,):
94 ashish 4466 
    self.userId = userId
4467 
 
4468 
  def read(self, iprot):
4469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4471 
      return
4472 
    iprot.readStructBegin()
4473 
    while True:
4474 
      (fname, ftype, fid) = iprot.readFieldBegin()
4475 
      if ftype == TType.STOP:
4476 
        break
4477 
      if fid == 1:
4478 
        if ftype == TType.I64:
4479 
          self.userId = iprot.readI64();
4480 
        else:
4481 
          iprot.skip(ftype)
4482 
      else:
4483 
        iprot.skip(ftype)
4484 
      iprot.readFieldEnd()
4485 
    iprot.readStructEnd()
4486 
 
4487 
  def write(self, oprot):
4488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4490 
      return
559 chandransh 4491 
    oprot.writeStructBegin('deleteUser_args')
94 ashish 4492 
    if self.userId != None:
4493 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4494 
      oprot.writeI64(self.userId)
4495 
      oprot.writeFieldEnd()
4496 
    oprot.writeFieldStop()
4497 
    oprot.writeStructEnd()
4498 
 
4499 
  def __repr__(self):
4500 
    L = ['%s=%r' % (key, value)
4501 
      for key, value in self.__dict__.iteritems()]
4502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4503 
 
4504 
  def __eq__(self, other):
4505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4506 
 
4507 
  def __ne__(self, other):
4508 
    return not (self == other)
4509 
 
559 chandransh 4510 
class deleteUser_result:
94 ashish 4511 
  """
4512 
  Attributes:
4513 
   - success
559 chandransh 4514 
   - ucex
94 ashish 4515 
  """
4516 
 
4517 
  thrift_spec = (
559 chandransh 4518 
    (0, TType.BOOL, 'success', None, None, ), # 0
4519 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4520 
  )
4521 
 
559 chandransh 4522 
  def __init__(self, success=None, ucex=None,):
94 ashish 4523 
    self.success = success
559 chandransh 4524 
    self.ucex = ucex
94 ashish 4525 
 
4526 
  def read(self, iprot):
4527 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4528 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4529 
      return
4530 
    iprot.readStructBegin()
4531 
    while True:
4532 
      (fname, ftype, fid) = iprot.readFieldBegin()
4533 
      if ftype == TType.STOP:
4534 
        break
4535 
      if fid == 0:
559 chandransh 4536 
        if ftype == TType.BOOL:
4537 
          self.success = iprot.readBool();
94 ashish 4538 
        else:
4539 
          iprot.skip(ftype)
4540 
      elif fid == 1:
4541 
        if ftype == TType.STRUCT:
559 chandransh 4542 
          self.ucex = UserContextException()
4543 
          self.ucex.read(iprot)
94 ashish 4544 
        else:
4545 
          iprot.skip(ftype)
4546 
      else:
4547 
        iprot.skip(ftype)
4548 
      iprot.readFieldEnd()
4549 
    iprot.readStructEnd()
4550 
 
4551 
  def write(self, oprot):
4552 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4553 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4554 
      return
559 chandransh 4555 
    oprot.writeStructBegin('deleteUser_result')
94 ashish 4556 
    if self.success != None:
559 chandransh 4557 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4558 
      oprot.writeBool(self.success)
94 ashish 4559 
      oprot.writeFieldEnd()
559 chandransh 4560 
    if self.ucex != None:
4561 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4562 
      self.ucex.write(oprot)
94 ashish 4563 
      oprot.writeFieldEnd()
4564 
    oprot.writeFieldStop()
4565 
    oprot.writeStructEnd()
4566 
 
4567 
  def __repr__(self):
4568 
    L = ['%s=%r' % (key, value)
4569 
      for key, value in self.__dict__.iteritems()]
4570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4571 
 
4572 
  def __eq__(self, other):
4573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4574 
 
4575 
  def __ne__(self, other):
4576 
    return not (self == other)
4577 
 
559 chandransh 4578 
class getUserState_args:
94 ashish 4579 
  """
4580 
  Attributes:
4581 
   - userId
4582 
  """
4583 
 
4584 
  thrift_spec = (
4585 
    None, # 0
4586 
    (1, TType.I64, 'userId', None, None, ), # 1
4587 
  )
4588 
 
559 chandransh 4589 
  def __init__(self, userId=None,):
94 ashish 4590 
    self.userId = userId
4591 
 
4592 
  def read(self, iprot):
4593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4595 
      return
4596 
    iprot.readStructBegin()
4597 
    while True:
4598 
      (fname, ftype, fid) = iprot.readFieldBegin()
4599 
      if ftype == TType.STOP:
4600 
        break
4601 
      if fid == 1:
4602 
        if ftype == TType.I64:
4603 
          self.userId = iprot.readI64();
4604 
        else:
4605 
          iprot.skip(ftype)
4606 
      else:
4607 
        iprot.skip(ftype)
4608 
      iprot.readFieldEnd()
4609 
    iprot.readStructEnd()
4610 
 
4611 
  def write(self, oprot):
4612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4614 
      return
559 chandransh 4615 
    oprot.writeStructBegin('getUserState_args')
94 ashish 4616 
    if self.userId != None:
4617 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4618 
      oprot.writeI64(self.userId)
4619 
      oprot.writeFieldEnd()
4620 
    oprot.writeFieldStop()
4621 
    oprot.writeStructEnd()
4622 
 
4623 
  def __repr__(self):
4624 
    L = ['%s=%r' % (key, value)
4625 
      for key, value in self.__dict__.iteritems()]
4626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4627 
 
4628 
  def __eq__(self, other):
4629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4630 
 
4631 
  def __ne__(self, other):
4632 
    return not (self == other)
4633 
 
559 chandransh 4634 
class getUserState_result:
94 ashish 4635 
  """
4636 
  Attributes:
4637 
   - success
559 chandransh 4638 
   - ucex
94 ashish 4639 
  """
4640 
 
4641 
  thrift_spec = (
559 chandransh 4642 
    (0, TType.STRUCT, 'success', (UserState, UserState.thrift_spec), None, ), # 0
4643 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4644 
  )
4645 
 
559 chandransh 4646 
  def __init__(self, success=None, ucex=None,):
94 ashish 4647 
    self.success = success
559 chandransh 4648 
    self.ucex = ucex
94 ashish 4649 
 
4650 
  def read(self, iprot):
4651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4653 
      return
4654 
    iprot.readStructBegin()
4655 
    while True:
4656 
      (fname, ftype, fid) = iprot.readFieldBegin()
4657 
      if ftype == TType.STOP:
4658 
        break
4659 
      if fid == 0:
4660 
        if ftype == TType.STRUCT:
559 chandransh 4661 
          self.success = UserState()
94 ashish 4662 
          self.success.read(iprot)
4663 
        else:
4664 
          iprot.skip(ftype)
4665 
      elif fid == 1:
4666 
        if ftype == TType.STRUCT:
559 chandransh 4667 
          self.ucex = UserContextException()
4668 
          self.ucex.read(iprot)
94 ashish 4669 
        else:
4670 
          iprot.skip(ftype)
4671 
      else:
4672 
        iprot.skip(ftype)
4673 
      iprot.readFieldEnd()
4674 
    iprot.readStructEnd()
4675 
 
4676 
  def write(self, oprot):
4677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4679 
      return
559 chandransh 4680 
    oprot.writeStructBegin('getUserState_result')
94 ashish 4681 
    if self.success != None:
4682 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4683 
      self.success.write(oprot)
4684 
      oprot.writeFieldEnd()
559 chandransh 4685 
    if self.ucex != None:
4686 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4687 
      self.ucex.write(oprot)
94 ashish 4688 
      oprot.writeFieldEnd()
4689 
    oprot.writeFieldStop()
4690 
    oprot.writeStructEnd()
4691 
 
4692 
  def __repr__(self):
4693 
    L = ['%s=%r' % (key, value)
4694 
      for key, value in self.__dict__.iteritems()]
4695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4696 
 
4697 
  def __eq__(self, other):
4698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4699 
 
4700 
  def __ne__(self, other):
4701 
    return not (self == other)
4702 
 
559 chandransh 4703 
class authenticateUser_args:
94 ashish 4704 
  """
4705 
  Attributes:
4706 
   - email
4707 
   - password
4708 
  """
4709 
 
4710 
  thrift_spec = (
4711 
    None, # 0
4712 
    (1, TType.STRING, 'email', None, None, ), # 1
4713 
    (2, TType.STRING, 'password', None, None, ), # 2
4714 
  )
4715 
 
4716 
  def __init__(self, email=None, password=None,):
4717 
    self.email = email
4718 
    self.password = password
4719 
 
4720 
  def read(self, iprot):
4721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4723 
      return
4724 
    iprot.readStructBegin()
4725 
    while True:
4726 
      (fname, ftype, fid) = iprot.readFieldBegin()
4727 
      if ftype == TType.STOP:
4728 
        break
4729 
      if fid == 1:
4730 
        if ftype == TType.STRING:
4731 
          self.email = iprot.readString();
4732 
        else:
4733 
          iprot.skip(ftype)
4734 
      elif fid == 2:
4735 
        if ftype == TType.STRING:
4736 
          self.password = iprot.readString();
4737 
        else:
4738 
          iprot.skip(ftype)
4739 
      else:
4740 
        iprot.skip(ftype)
4741 
      iprot.readFieldEnd()
4742 
    iprot.readStructEnd()
4743 
 
4744 
  def write(self, oprot):
4745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4747 
      return
559 chandransh 4748 
    oprot.writeStructBegin('authenticateUser_args')
94 ashish 4749 
    if self.email != None:
4750 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4751 
      oprot.writeString(self.email)
4752 
      oprot.writeFieldEnd()
4753 
    if self.password != None:
4754 
      oprot.writeFieldBegin('password', TType.STRING, 2)
4755 
      oprot.writeString(self.password)
4756 
      oprot.writeFieldEnd()
4757 
    oprot.writeFieldStop()
4758 
    oprot.writeStructEnd()
4759 
 
4760 
  def __repr__(self):
4761 
    L = ['%s=%r' % (key, value)
4762 
      for key, value in self.__dict__.iteritems()]
4763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4764 
 
4765 
  def __eq__(self, other):
4766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4767 
 
4768 
  def __ne__(self, other):
4769 
    return not (self == other)
4770 
 
559 chandransh 4771 
class authenticateUser_result:
94 ashish 4772 
  """
4773 
  Attributes:
4774 
   - success
559 chandransh 4775 
   - auex
94 ashish 4776 
  """
4777 
 
4778 
  thrift_spec = (
559 chandransh 4779 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4780 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 4781 
  )
4782 
 
559 chandransh 4783 
  def __init__(self, success=None, auex=None,):
94 ashish 4784 
    self.success = success
559 chandransh 4785 
    self.auex = auex
94 ashish 4786 
 
4787 
  def read(self, iprot):
4788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4790 
      return
4791 
    iprot.readStructBegin()
4792 
    while True:
4793 
      (fname, ftype, fid) = iprot.readFieldBegin()
4794 
      if ftype == TType.STOP:
4795 
        break
4796 
      if fid == 0:
4797 
        if ftype == TType.STRUCT:
559 chandransh 4798 
          self.success = User()
94 ashish 4799 
          self.success.read(iprot)
4800 
        else:
4801 
          iprot.skip(ftype)
4802 
      elif fid == 1:
4803 
        if ftype == TType.STRUCT:
559 chandransh 4804 
          self.auex = AuthenticationException()
4805 
          self.auex.read(iprot)
94 ashish 4806 
        else:
4807 
          iprot.skip(ftype)
4808 
      else:
4809 
        iprot.skip(ftype)
4810 
      iprot.readFieldEnd()
4811 
    iprot.readStructEnd()
4812 
 
4813 
  def write(self, oprot):
4814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4816 
      return
559 chandransh 4817 
    oprot.writeStructBegin('authenticateUser_result')
94 ashish 4818 
    if self.success != None:
4819 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4820 
      self.success.write(oprot)
4821 
      oprot.writeFieldEnd()
559 chandransh 4822 
    if self.auex != None:
4823 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
4824 
      self.auex.write(oprot)
94 ashish 4825 
      oprot.writeFieldEnd()
4826 
    oprot.writeFieldStop()
4827 
    oprot.writeStructEnd()
4828 
 
4829 
  def __repr__(self):
4830 
    L = ['%s=%r' % (key, value)
4831 
      for key, value in self.__dict__.iteritems()]
4832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4833 
 
4834 
  def __eq__(self, other):
4835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4836 
 
4837 
  def __ne__(self, other):
4838 
    return not (self == other)
4839 
 
559 chandransh 4840 
class userExists_args:
122 ashish 4841 
  """
4842 
  Attributes:
559 chandransh 4843 
   - email
122 ashish 4844 
  """
4845 
 
4846 
  thrift_spec = (
4847 
    None, # 0
559 chandransh 4848 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 4849 
  )
4850 
 
559 chandransh 4851 
  def __init__(self, email=None,):
4852 
    self.email = email
122 ashish 4853 
 
4854 
  def read(self, iprot):
4855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4857 
      return
4858 
    iprot.readStructBegin()
4859 
    while True:
4860 
      (fname, ftype, fid) = iprot.readFieldBegin()
4861 
      if ftype == TType.STOP:
4862 
        break
4863 
      if fid == 1:
4864 
        if ftype == TType.STRING:
559 chandransh 4865 
          self.email = iprot.readString();
122 ashish 4866 
        else:
4867 
          iprot.skip(ftype)
559 chandransh 4868 
      else:
4869 
        iprot.skip(ftype)
4870 
      iprot.readFieldEnd()
4871 
    iprot.readStructEnd()
4872 
 
4873 
  def write(self, oprot):
4874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4876 
      return
4877 
    oprot.writeStructBegin('userExists_args')
4878 
    if self.email != None:
4879 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4880 
      oprot.writeString(self.email)
4881 
      oprot.writeFieldEnd()
4882 
    oprot.writeFieldStop()
4883 
    oprot.writeStructEnd()
4884 
 
4885 
  def __repr__(self):
4886 
    L = ['%s=%r' % (key, value)
4887 
      for key, value in self.__dict__.iteritems()]
4888 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4889 
 
4890 
  def __eq__(self, other):
4891 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4892 
 
4893 
  def __ne__(self, other):
4894 
    return not (self == other)
4895 
 
4896 
class userExists_result:
4897 
  """
4898 
  Attributes:
4899 
   - success
4900 
   - ucx
4901 
  """
4902 
 
4903 
  thrift_spec = (
4904 
    (0, TType.BOOL, 'success', None, None, ), # 0
4905 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4906 
  )
4907 
 
4908 
  def __init__(self, success=None, ucx=None,):
4909 
    self.success = success
4910 
    self.ucx = ucx
4911 
 
4912 
  def read(self, iprot):
4913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4915 
      return
4916 
    iprot.readStructBegin()
4917 
    while True:
4918 
      (fname, ftype, fid) = iprot.readFieldBegin()
4919 
      if ftype == TType.STOP:
4920 
        break
4921 
      if fid == 0:
4922 
        if ftype == TType.BOOL:
4923 
          self.success = iprot.readBool();
4924 
        else:
4925 
          iprot.skip(ftype)
4926 
      elif fid == 1:
4927 
        if ftype == TType.STRUCT:
4928 
          self.ucx = UserContextException()
4929 
          self.ucx.read(iprot)
4930 
        else:
4931 
          iprot.skip(ftype)
4932 
      else:
4933 
        iprot.skip(ftype)
4934 
      iprot.readFieldEnd()
4935 
    iprot.readStructEnd()
4936 
 
4937 
  def write(self, oprot):
4938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4940 
      return
4941 
    oprot.writeStructBegin('userExists_result')
4942 
    if self.success != None:
4943 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4944 
      oprot.writeBool(self.success)
4945 
      oprot.writeFieldEnd()
4946 
    if self.ucx != None:
4947 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4948 
      self.ucx.write(oprot)
4949 
      oprot.writeFieldEnd()
4950 
    oprot.writeFieldStop()
4951 
    oprot.writeStructEnd()
4952 
 
4953 
  def __repr__(self):
4954 
    L = ['%s=%r' % (key, value)
4955 
      for key, value in self.__dict__.iteritems()]
4956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4957 
 
4958 
  def __eq__(self, other):
4959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4960 
 
4961 
  def __ne__(self, other):
4962 
    return not (self == other)
4963 
 
4964 
class addAddressForUser_args:
4965 
  """
4966 
  Attributes:
4967 
   - userId
4968 
   - address
4969 
   - setDefault
4970 
  """
4971 
 
4972 
  thrift_spec = (
4973 
    None, # 0
4974 
    (1, TType.I64, 'userId', None, None, ), # 1
4975 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 4976 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 4977 
  )
4978 
 
567 rajveer 4979 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 4980 
    self.userId = userId
4981 
    self.address = address
4982 
    self.setDefault = setDefault
4983 
 
4984 
  def read(self, iprot):
4985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4987 
      return
4988 
    iprot.readStructBegin()
4989 
    while True:
4990 
      (fname, ftype, fid) = iprot.readFieldBegin()
4991 
      if ftype == TType.STOP:
4992 
        break
4993 
      if fid == 1:
4994 
        if ftype == TType.I64:
4995 
          self.userId = iprot.readI64();
4996 
        else:
4997 
          iprot.skip(ftype)
122 ashish 4998 
      elif fid == 2:
559 chandransh 4999 
        if ftype == TType.STRUCT:
5000 
          self.address = Address()
5001 
          self.address.read(iprot)
122 ashish 5002 
        else:
5003 
          iprot.skip(ftype)
5004 
      elif fid == 3:
5005 
        if ftype == TType.BOOL:
559 chandransh 5006 
          self.setDefault = iprot.readBool();
122 ashish 5007 
        else:
5008 
          iprot.skip(ftype)
5009 
      else:
5010 
        iprot.skip(ftype)
5011 
      iprot.readFieldEnd()
5012 
    iprot.readStructEnd()
5013 
 
5014 
  def write(self, oprot):
5015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5017 
      return
559 chandransh 5018 
    oprot.writeStructBegin('addAddressForUser_args')
5019 
    if self.userId != None:
5020 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5021 
      oprot.writeI64(self.userId)
122 ashish 5022 
      oprot.writeFieldEnd()
559 chandransh 5023 
    if self.address != None:
5024 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
5025 
      self.address.write(oprot)
122 ashish 5026 
      oprot.writeFieldEnd()
559 chandransh 5027 
    if self.setDefault != None:
567 rajveer 5028 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 5029 
      oprot.writeBool(self.setDefault)
5030 
      oprot.writeFieldEnd()
122 ashish 5031 
    oprot.writeFieldStop()
5032 
    oprot.writeStructEnd()
5033 
 
5034 
  def __repr__(self):
5035 
    L = ['%s=%r' % (key, value)
5036 
      for key, value in self.__dict__.iteritems()]
5037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5038 
 
5039 
  def __eq__(self, other):
5040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5041 
 
5042 
  def __ne__(self, other):
5043 
    return not (self == other)
5044 
 
559 chandransh 5045 
class addAddressForUser_result:
122 ashish 5046 
  """
5047 
  Attributes:
5048 
   - success
559 chandransh 5049 
   - ucx
122 ashish 5050 
  """
5051 
 
5052 
  thrift_spec = (
567 rajveer 5053 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 5054 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 5055 
  )
5056 
 
559 chandransh 5057 
  def __init__(self, success=None, ucx=None,):
122 ashish 5058 
    self.success = success
559 chandransh 5059 
    self.ucx = ucx
122 ashish 5060 
 
5061 
  def read(self, iprot):
5062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5064 
      return
5065 
    iprot.readStructBegin()
5066 
    while True:
5067 
      (fname, ftype, fid) = iprot.readFieldBegin()
5068 
      if ftype == TType.STOP:
5069 
        break
5070 
      if fid == 0:
567 rajveer 5071 
        if ftype == TType.I64:
5072 
          self.success = iprot.readI64();
122 ashish 5073 
        else:
5074 
          iprot.skip(ftype)
5075 
      elif fid == 1:
5076 
        if ftype == TType.STRUCT:
559 chandransh 5077 
          self.ucx = UserContextException()
5078 
          self.ucx.read(iprot)
122 ashish 5079 
        else:
5080 
          iprot.skip(ftype)
5081 
      else:
5082 
        iprot.skip(ftype)
5083 
      iprot.readFieldEnd()
5084 
    iprot.readStructEnd()
5085 
 
5086 
  def write(self, oprot):
5087 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5088 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5089 
      return
559 chandransh 5090 
    oprot.writeStructBegin('addAddressForUser_result')
122 ashish 5091 
    if self.success != None:
567 rajveer 5092 
      oprot.writeFieldBegin('success', TType.I64, 0)
5093 
      oprot.writeI64(self.success)
122 ashish 5094 
      oprot.writeFieldEnd()
559 chandransh 5095 
    if self.ucx != None:
5096 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5097 
      self.ucx.write(oprot)
122 ashish 5098 
      oprot.writeFieldEnd()
5099 
    oprot.writeFieldStop()
5100 
    oprot.writeStructEnd()
5101 
 
5102 
  def __repr__(self):
5103 
    L = ['%s=%r' % (key, value)
5104 
      for key, value in self.__dict__.iteritems()]
5105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5106 
 
5107 
  def __eq__(self, other):
5108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5109 
 
5110 
  def __ne__(self, other):
5111 
    return not (self == other)
5112 
 
559 chandransh 5113 
class removeAddressForUser_args:
94 ashish 5114 
  """
5115 
  Attributes:
559 chandransh 5116 
   - userid
5117 
   - addressId
94 ashish 5118 
  """
5119 
 
5120 
  thrift_spec = (
5121 
    None, # 0
559 chandransh 5122 
    (1, TType.I64, 'userid', None, None, ), # 1
5123 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 5124 
  )
5125 
 
559 chandransh 5126 
  def __init__(self, userid=None, addressId=None,):
5127 
    self.userid = userid
5128 
    self.addressId = addressId
94 ashish 5129 
 
5130 
  def read(self, iprot):
5131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5133 
      return
5134 
    iprot.readStructBegin()
5135 
    while True:
5136 
      (fname, ftype, fid) = iprot.readFieldBegin()
5137 
      if ftype == TType.STOP:
5138 
        break
5139 
      if fid == 1:
559 chandransh 5140 
        if ftype == TType.I64:
5141 
          self.userid = iprot.readI64();
94 ashish 5142 
        else:
5143 
          iprot.skip(ftype)
559 chandransh 5144 
      elif fid == 2:
5145 
        if ftype == TType.I64:
5146 
          self.addressId = iprot.readI64();
5147 
        else:
5148 
          iprot.skip(ftype)
94 ashish 5149 
      else:
5150 
        iprot.skip(ftype)
5151 
      iprot.readFieldEnd()
5152 
    iprot.readStructEnd()
5153 
 
5154 
  def write(self, oprot):
5155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5157 
      return
559 chandransh 5158 
    oprot.writeStructBegin('removeAddressForUser_args')
5159 
    if self.userid != None:
5160 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5161 
      oprot.writeI64(self.userid)
94 ashish 5162 
      oprot.writeFieldEnd()
559 chandransh 5163 
    if self.addressId != None:
5164 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5165 
      oprot.writeI64(self.addressId)
5166 
      oprot.writeFieldEnd()
94 ashish 5167 
    oprot.writeFieldStop()
5168 
    oprot.writeStructEnd()
5169 
 
5170 
  def __repr__(self):
5171 
    L = ['%s=%r' % (key, value)
5172 
      for key, value in self.__dict__.iteritems()]
5173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5174 
 
5175 
  def __eq__(self, other):
5176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5177 
 
5178 
  def __ne__(self, other):
5179 
    return not (self == other)
5180 
 
559 chandransh 5181 
class removeAddressForUser_result:
94 ashish 5182 
  """
5183 
  Attributes:
5184 
   - success
5185 
   - ucx
5186 
  """
5187 
 
5188 
  thrift_spec = (
5189 
    (0, TType.BOOL, 'success', None, None, ), # 0
5190 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5191 
  )
5192 
 
5193 
  def __init__(self, success=None, ucx=None,):
5194 
    self.success = success
5195 
    self.ucx = ucx
5196 
 
5197 
  def read(self, iprot):
5198 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5199 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5200 
      return
5201 
    iprot.readStructBegin()
5202 
    while True:
5203 
      (fname, ftype, fid) = iprot.readFieldBegin()
5204 
      if ftype == TType.STOP:
5205 
        break
5206 
      if fid == 0:
5207 
        if ftype == TType.BOOL:
5208 
          self.success = iprot.readBool();
5209 
        else:
5210 
          iprot.skip(ftype)
5211 
      elif fid == 1:
5212 
        if ftype == TType.STRUCT:
5213 
          self.ucx = UserContextException()
5214 
          self.ucx.read(iprot)
5215 
        else:
5216 
          iprot.skip(ftype)
5217 
      else:
5218 
        iprot.skip(ftype)
5219 
      iprot.readFieldEnd()
5220 
    iprot.readStructEnd()
5221 
 
5222 
  def write(self, oprot):
5223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5225 
      return
559 chandransh 5226 
    oprot.writeStructBegin('removeAddressForUser_result')
94 ashish 5227 
    if self.success != None:
5228 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5229 
      oprot.writeBool(self.success)
5230 
      oprot.writeFieldEnd()
5231 
    if self.ucx != None:
5232 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5233 
      self.ucx.write(oprot)
5234 
      oprot.writeFieldEnd()
5235 
    oprot.writeFieldStop()
5236 
    oprot.writeStructEnd()
5237 
 
5238 
  def __repr__(self):
5239 
    L = ['%s=%r' % (key, value)
5240 
      for key, value in self.__dict__.iteritems()]
5241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5242 
 
5243 
  def __eq__(self, other):
5244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5245 
 
5246 
  def __ne__(self, other):
5247 
    return not (self == other)
5248 
 
559 chandransh 5249 
class setUserAsLoggedIn_args:
94 ashish 5250 
  """
5251 
  Attributes:
559 chandransh 5252 
   - userId
94 ashish 5253 
   - timestamp
5254 
  """
5255 
 
5256 
  thrift_spec = (
5257 
    None, # 0
559 chandransh 5258 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 5259 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5260 
  )
5261 
 
559 chandransh 5262 
  def __init__(self, userId=None, timestamp=None,):
5263 
    self.userId = userId
94 ashish 5264 
    self.timestamp = timestamp
5265 
 
5266 
  def read(self, iprot):
5267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5269 
      return
5270 
    iprot.readStructBegin()
5271 
    while True:
5272 
      (fname, ftype, fid) = iprot.readFieldBegin()
5273 
      if ftype == TType.STOP:
5274 
        break
5275 
      if fid == 1:
559 chandransh 5276 
        if ftype == TType.I64:
5277 
          self.userId = iprot.readI64();
94 ashish 5278 
        else:
5279 
          iprot.skip(ftype)
5280 
      elif fid == 2:
5281 
        if ftype == TType.I64:
5282 
          self.timestamp = iprot.readI64();
5283 
        else:
5284 
          iprot.skip(ftype)
5285 
      else:
5286 
        iprot.skip(ftype)
5287 
      iprot.readFieldEnd()
5288 
    iprot.readStructEnd()
5289 
 
5290 
  def write(self, oprot):
5291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5293 
      return
559 chandransh 5294 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
5295 
    if self.userId != None:
5296 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5297 
      oprot.writeI64(self.userId)
94 ashish 5298 
      oprot.writeFieldEnd()
5299 
    if self.timestamp != None:
5300 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5301 
      oprot.writeI64(self.timestamp)
5302 
      oprot.writeFieldEnd()
5303 
    oprot.writeFieldStop()
5304 
    oprot.writeStructEnd()
5305 
 
5306 
  def __repr__(self):
5307 
    L = ['%s=%r' % (key, value)
5308 
      for key, value in self.__dict__.iteritems()]
5309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5310 
 
5311 
  def __eq__(self, other):
5312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5313 
 
5314 
  def __ne__(self, other):
5315 
    return not (self == other)
5316 
 
559 chandransh 5317 
class setUserAsLoggedIn_result:
94 ashish 5318 
  """
5319 
  Attributes:
5320 
   - success
5321 
   - ucx
5322 
  """
5323 
 
5324 
  thrift_spec = (
5325 
    (0, TType.BOOL, 'success', None, None, ), # 0
5326 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5327 
  )
5328 
 
5329 
  def __init__(self, success=None, ucx=None,):
5330 
    self.success = success
5331 
    self.ucx = ucx
5332 
 
5333 
  def read(self, iprot):
5334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5336 
      return
5337 
    iprot.readStructBegin()
5338 
    while True:
5339 
      (fname, ftype, fid) = iprot.readFieldBegin()
5340 
      if ftype == TType.STOP:
5341 
        break
5342 
      if fid == 0:
5343 
        if ftype == TType.BOOL:
5344 
          self.success = iprot.readBool();
5345 
        else:
5346 
          iprot.skip(ftype)
5347 
      elif fid == 1:
5348 
        if ftype == TType.STRUCT:
5349 
          self.ucx = UserContextException()
5350 
          self.ucx.read(iprot)
5351 
        else:
5352 
          iprot.skip(ftype)
5353 
      else:
5354 
        iprot.skip(ftype)
5355 
      iprot.readFieldEnd()
5356 
    iprot.readStructEnd()
5357 
 
5358 
  def write(self, oprot):
5359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5361 
      return
559 chandransh 5362 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
94 ashish 5363 
    if self.success != None:
5364 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5365 
      oprot.writeBool(self.success)
5366 
      oprot.writeFieldEnd()
5367 
    if self.ucx != None:
5368 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5369 
      self.ucx.write(oprot)
5370 
      oprot.writeFieldEnd()
5371 
    oprot.writeFieldStop()
5372 
    oprot.writeStructEnd()
5373 
 
5374 
  def __repr__(self):
5375 
    L = ['%s=%r' % (key, value)
5376 
      for key, value in self.__dict__.iteritems()]
5377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5378 
 
5379 
  def __eq__(self, other):
5380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5381 
 
5382 
  def __ne__(self, other):
5383 
    return not (self == other)
5384 
 
559 chandransh 5385 
class setUserAsLoggedOut_args:
94 ashish 5386 
  """
5387 
  Attributes:
5388 
   - userid
5389 
   - timestamp
5390 
  """
5391 
 
5392 
  thrift_spec = (
5393 
    None, # 0
559 chandransh 5394 
    (1, TType.I64, 'userid', None, None, ), # 1
5395 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 5396 
  )
5397 
 
559 chandransh 5398 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 5399 
    self.userid = userid
5400 
    self.timestamp = timestamp
5401 
 
5402 
  def read(self, iprot):
5403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5405 
      return
5406 
    iprot.readStructBegin()
5407 
    while True:
5408 
      (fname, ftype, fid) = iprot.readFieldBegin()
5409 
      if ftype == TType.STOP:
5410 
        break
5411 
      if fid == 1:
5412 
        if ftype == TType.I64:
5413 
          self.userid = iprot.readI64();
5414 
        else:
5415 
          iprot.skip(ftype)
559 chandransh 5416 
      elif fid == 2:
94 ashish 5417 
        if ftype == TType.I64:
5418 
          self.timestamp = iprot.readI64();
5419 
        else:
5420 
          iprot.skip(ftype)
5421 
      else:
5422 
        iprot.skip(ftype)
5423 
      iprot.readFieldEnd()
5424 
    iprot.readStructEnd()
5425 
 
5426 
  def write(self, oprot):
5427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5429 
      return
559 chandransh 5430 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
94 ashish 5431 
    if self.userid != None:
559 chandransh 5432 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 5433 
      oprot.writeI64(self.userid)
5434 
      oprot.writeFieldEnd()
5435 
    if self.timestamp != None:
559 chandransh 5436 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 5437 
      oprot.writeI64(self.timestamp)
5438 
      oprot.writeFieldEnd()
5439 
    oprot.writeFieldStop()
5440 
    oprot.writeStructEnd()
5441 
 
5442 
  def __repr__(self):
5443 
    L = ['%s=%r' % (key, value)
5444 
      for key, value in self.__dict__.iteritems()]
5445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5446 
 
5447 
  def __eq__(self, other):
5448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5449 
 
5450 
  def __ne__(self, other):
5451 
    return not (self == other)
5452 
 
559 chandransh 5453 
class setUserAsLoggedOut_result:
94 ashish 5454 
  """
5455 
  Attributes:
5456 
   - success
5457 
   - ucx
5458 
  """
5459 
 
5460 
  thrift_spec = (
5461 
    (0, TType.BOOL, 'success', None, None, ), # 0
5462 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5463 
  )
5464 
 
5465 
  def __init__(self, success=None, ucx=None,):
5466 
    self.success = success
5467 
    self.ucx = ucx
5468 
 
5469 
  def read(self, iprot):
5470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5472 
      return
5473 
    iprot.readStructBegin()
5474 
    while True:
5475 
      (fname, ftype, fid) = iprot.readFieldBegin()
5476 
      if ftype == TType.STOP:
5477 
        break
5478 
      if fid == 0:
5479 
        if ftype == TType.BOOL:
5480 
          self.success = iprot.readBool();
5481 
        else:
5482 
          iprot.skip(ftype)
5483 
      elif fid == 1:
5484 
        if ftype == TType.STRUCT:
5485 
          self.ucx = UserContextException()
5486 
          self.ucx.read(iprot)
5487 
        else:
5488 
          iprot.skip(ftype)
5489 
      else:
5490 
        iprot.skip(ftype)
5491 
      iprot.readFieldEnd()
5492 
    iprot.readStructEnd()
5493 
 
5494 
  def write(self, oprot):
5495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5497 
      return
559 chandransh 5498 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
94 ashish 5499 
    if self.success != None:
5500 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5501 
      oprot.writeBool(self.success)
5502 
      oprot.writeFieldEnd()
5503 
    if self.ucx != None:
5504 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5505 
      self.ucx.write(oprot)
5506 
      oprot.writeFieldEnd()
5507 
    oprot.writeFieldStop()
5508 
    oprot.writeStructEnd()
5509 
 
5510 
  def __repr__(self):
5511 
    L = ['%s=%r' % (key, value)
5512 
      for key, value in self.__dict__.iteritems()]
5513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5514 
 
5515 
  def __eq__(self, other):
5516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5517 
 
5518 
  def __ne__(self, other):
5519 
    return not (self == other)
5520 
 
559 chandransh 5521 
class setDefaultAddress_args:
94 ashish 5522 
  """
5523 
  Attributes:
5524 
   - userid
5525 
   - addressId
5526 
  """
5527 
 
5528 
  thrift_spec = (
5529 
    None, # 0
5530 
    (1, TType.I64, 'userid', None, None, ), # 1
5531 
    (2, TType.I64, 'addressId', None, None, ), # 2
5532 
  )
5533 
 
5534 
  def __init__(self, userid=None, addressId=None,):
5535 
    self.userid = userid
5536 
    self.addressId = addressId
5537 
 
5538 
  def read(self, iprot):
5539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5541 
      return
5542 
    iprot.readStructBegin()
5543 
    while True:
5544 
      (fname, ftype, fid) = iprot.readFieldBegin()
5545 
      if ftype == TType.STOP:
5546 
        break
5547 
      if fid == 1:
5548 
        if ftype == TType.I64:
5549 
          self.userid = iprot.readI64();
5550 
        else:
5551 
          iprot.skip(ftype)
5552 
      elif fid == 2:
5553 
        if ftype == TType.I64:
5554 
          self.addressId = iprot.readI64();
5555 
        else:
5556 
          iprot.skip(ftype)
5557 
      else:
5558 
        iprot.skip(ftype)
5559 
      iprot.readFieldEnd()
5560 
    iprot.readStructEnd()
5561 
 
5562 
  def write(self, oprot):
5563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5565 
      return
559 chandransh 5566 
    oprot.writeStructBegin('setDefaultAddress_args')
94 ashish 5567 
    if self.userid != None:
5568 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5569 
      oprot.writeI64(self.userid)
5570 
      oprot.writeFieldEnd()
5571 
    if self.addressId != None:
5572 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5573 
      oprot.writeI64(self.addressId)
5574 
      oprot.writeFieldEnd()
5575 
    oprot.writeFieldStop()
5576 
    oprot.writeStructEnd()
5577 
 
5578 
  def __repr__(self):
5579 
    L = ['%s=%r' % (key, value)
5580 
      for key, value in self.__dict__.iteritems()]
5581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5582 
 
5583 
  def __eq__(self, other):
5584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5585 
 
5586 
  def __ne__(self, other):
5587 
    return not (self == other)
5588 
 
559 chandransh 5589 
class setDefaultAddress_result:
94 ashish 5590 
  """
5591 
  Attributes:
5592 
   - success
5593 
   - ucx
5594 
  """
5595 
 
5596 
  thrift_spec = (
5597 
    (0, TType.BOOL, 'success', None, None, ), # 0
5598 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5599 
  )
5600 
 
5601 
  def __init__(self, success=None, ucx=None,):
5602 
    self.success = success
5603 
    self.ucx = ucx
5604 
 
5605 
  def read(self, iprot):
5606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5608 
      return
5609 
    iprot.readStructBegin()
5610 
    while True:
5611 
      (fname, ftype, fid) = iprot.readFieldBegin()
5612 
      if ftype == TType.STOP:
5613 
        break
5614 
      if fid == 0:
5615 
        if ftype == TType.BOOL:
5616 
          self.success = iprot.readBool();
5617 
        else:
5618 
          iprot.skip(ftype)
5619 
      elif fid == 1:
5620 
        if ftype == TType.STRUCT:
5621 
          self.ucx = UserContextException()
5622 
          self.ucx.read(iprot)
5623 
        else:
5624 
          iprot.skip(ftype)
5625 
      else:
5626 
        iprot.skip(ftype)
5627 
      iprot.readFieldEnd()
5628 
    iprot.readStructEnd()
5629 
 
5630 
  def write(self, oprot):
5631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5633 
      return
559 chandransh 5634 
    oprot.writeStructBegin('setDefaultAddress_result')
94 ashish 5635 
    if self.success != None:
5636 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5637 
      oprot.writeBool(self.success)
5638 
      oprot.writeFieldEnd()
5639 
    if self.ucx != None:
5640 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5641 
      self.ucx.write(oprot)
5642 
      oprot.writeFieldEnd()
5643 
    oprot.writeFieldStop()
5644 
    oprot.writeStructEnd()
5645 
 
5646 
  def __repr__(self):
5647 
    L = ['%s=%r' % (key, value)
5648 
      for key, value in self.__dict__.iteritems()]
5649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5650 
 
5651 
  def __eq__(self, other):
5652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5653 
 
5654 
  def __ne__(self, other):
5655 
    return not (self == other)
5656 
 
559 chandransh 5657 
class updatePassword_args:
94 ashish 5658 
  """
5659 
  Attributes:
559 chandransh 5660 
   - userid
594 rajveer 5661 
   - oldPassword
5662 
   - newPassword
94 ashish 5663 
  """
5664 
 
5665 
  thrift_spec = (
5666 
    None, # 0
559 chandransh 5667 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 5668 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
5669 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 5670 
  )
5671 
 
594 rajveer 5672 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 5673 
    self.userid = userid
594 rajveer 5674 
    self.oldPassword = oldPassword
5675 
    self.newPassword = newPassword
94 ashish 5676 
 
5677 
  def read(self, iprot):
5678 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5679 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5680 
      return
5681 
    iprot.readStructBegin()
5682 
    while True:
5683 
      (fname, ftype, fid) = iprot.readFieldBegin()
5684 
      if ftype == TType.STOP:
5685 
        break
5686 
      if fid == 1:
5687 
        if ftype == TType.I64:
559 chandransh 5688 
          self.userid = iprot.readI64();
94 ashish 5689 
        else:
5690 
          iprot.skip(ftype)
5691 
      elif fid == 2:
559 chandransh 5692 
        if ftype == TType.STRING:
594 rajveer 5693 
          self.oldPassword = iprot.readString();
94 ashish 5694 
        else:
5695 
          iprot.skip(ftype)
594 rajveer 5696 
      elif fid == 3:
5697 
        if ftype == TType.STRING:
5698 
          self.newPassword = iprot.readString();
5699 
        else:
5700 
          iprot.skip(ftype)
94 ashish 5701 
      else:
5702 
        iprot.skip(ftype)
5703 
      iprot.readFieldEnd()
5704 
    iprot.readStructEnd()
5705 
 
5706 
  def write(self, oprot):
5707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5709 
      return
559 chandransh 5710 
    oprot.writeStructBegin('updatePassword_args')
5711 
    if self.userid != None:
5712 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5713 
      oprot.writeI64(self.userid)
94 ashish 5714 
      oprot.writeFieldEnd()
594 rajveer 5715 
    if self.oldPassword != None:
5716 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
5717 
      oprot.writeString(self.oldPassword)
94 ashish 5718 
      oprot.writeFieldEnd()
594 rajveer 5719 
    if self.newPassword != None:
5720 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
5721 
      oprot.writeString(self.newPassword)
5722 
      oprot.writeFieldEnd()
94 ashish 5723 
    oprot.writeFieldStop()
5724 
    oprot.writeStructEnd()
5725 
 
5726 
  def __repr__(self):
5727 
    L = ['%s=%r' % (key, value)
5728 
      for key, value in self.__dict__.iteritems()]
5729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5730 
 
5731 
  def __eq__(self, other):
5732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5733 
 
5734 
  def __ne__(self, other):
5735 
    return not (self == other)
5736 
 
559 chandransh 5737 
class updatePassword_result:
94 ashish 5738 
  """
5739 
  Attributes:
5740 
   - success
5741 
   - ucx
5742 
  """
5743 
 
5744 
  thrift_spec = (
5745 
    (0, TType.BOOL, 'success', None, None, ), # 0
5746 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5747 
  )
5748 
 
5749 
  def __init__(self, success=None, ucx=None,):
5750 
    self.success = success
5751 
    self.ucx = ucx
5752 
 
5753 
  def read(self, iprot):
5754 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5755 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5756 
      return
5757 
    iprot.readStructBegin()
5758 
    while True:
5759 
      (fname, ftype, fid) = iprot.readFieldBegin()
5760 
      if ftype == TType.STOP:
5761 
        break
5762 
      if fid == 0:
5763 
        if ftype == TType.BOOL:
5764 
          self.success = iprot.readBool();
5765 
        else:
5766 
          iprot.skip(ftype)
5767 
      elif fid == 1:
5768 
        if ftype == TType.STRUCT:
5769 
          self.ucx = UserContextException()
5770 
          self.ucx.read(iprot)
5771 
        else:
5772 
          iprot.skip(ftype)
5773 
      else:
5774 
        iprot.skip(ftype)
5775 
      iprot.readFieldEnd()
5776 
    iprot.readStructEnd()
5777 
 
5778 
  def write(self, oprot):
5779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5781 
      return
559 chandransh 5782 
    oprot.writeStructBegin('updatePassword_result')
94 ashish 5783 
    if self.success != None:
5784 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5785 
      oprot.writeBool(self.success)
5786 
      oprot.writeFieldEnd()
5787 
    if self.ucx != None:
5788 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5789 
      self.ucx.write(oprot)
5790 
      oprot.writeFieldEnd()
5791 
    oprot.writeFieldStop()
5792 
    oprot.writeStructEnd()
5793 
 
5794 
  def __repr__(self):
5795 
    L = ['%s=%r' % (key, value)
5796 
      for key, value in self.__dict__.iteritems()]
5797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5798 
 
5799 
  def __eq__(self, other):
5800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5801 
 
5802 
  def __ne__(self, other):
5803 
    return not (self == other)
5804 
 
581 rajveer 5805 
class forgotPassword_args:
5806 
  """
5807 
  Attributes:
5808 
   - email
884 rajveer 5809 
   - newPassword
581 rajveer 5810 
  """
5811 
 
5812 
  thrift_spec = (
5813 
    None, # 0
5814 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 5815 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 5816 
  )
5817 
 
884 rajveer 5818 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 5819 
    self.email = email
884 rajveer 5820 
    self.newPassword = newPassword
581 rajveer 5821 
 
5822 
  def read(self, iprot):
5823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5825 
      return
5826 
    iprot.readStructBegin()
5827 
    while True:
5828 
      (fname, ftype, fid) = iprot.readFieldBegin()
5829 
      if ftype == TType.STOP:
5830 
        break
5831 
      if fid == 1:
5832 
        if ftype == TType.STRING:
5833 
          self.email = iprot.readString();
5834 
        else:
5835 
          iprot.skip(ftype)
884 rajveer 5836 
      elif fid == 2:
5837 
        if ftype == TType.STRING:
5838 
          self.newPassword = iprot.readString();
5839 
        else:
5840 
          iprot.skip(ftype)
581 rajveer 5841 
      else:
5842 
        iprot.skip(ftype)
5843 
      iprot.readFieldEnd()
5844 
    iprot.readStructEnd()
5845 
 
5846 
  def write(self, oprot):
5847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5849 
      return
5850 
    oprot.writeStructBegin('forgotPassword_args')
5851 
    if self.email != None:
5852 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5853 
      oprot.writeString(self.email)
5854 
      oprot.writeFieldEnd()
884 rajveer 5855 
    if self.newPassword != None:
5856 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
5857 
      oprot.writeString(self.newPassword)
5858 
      oprot.writeFieldEnd()
581 rajveer 5859 
    oprot.writeFieldStop()
5860 
    oprot.writeStructEnd()
5861 
 
5862 
  def __repr__(self):
5863 
    L = ['%s=%r' % (key, value)
5864 
      for key, value in self.__dict__.iteritems()]
5865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5866 
 
5867 
  def __eq__(self, other):
5868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5869 
 
5870 
  def __ne__(self, other):
5871 
    return not (self == other)
5872 
 
5873 
class forgotPassword_result:
5874 
  """
5875 
  Attributes:
5876 
   - success
5877 
   - ucx
5878 
  """
5879 
 
5880 
  thrift_spec = (
5881 
    (0, TType.BOOL, 'success', None, None, ), # 0
5882 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5883 
  )
5884 
 
5885 
  def __init__(self, success=None, ucx=None,):
5886 
    self.success = success
5887 
    self.ucx = ucx
5888 
 
5889 
  def read(self, iprot):
5890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5892 
      return
5893 
    iprot.readStructBegin()
5894 
    while True:
5895 
      (fname, ftype, fid) = iprot.readFieldBegin()
5896 
      if ftype == TType.STOP:
5897 
        break
5898 
      if fid == 0:
5899 
        if ftype == TType.BOOL:
5900 
          self.success = iprot.readBool();
5901 
        else:
5902 
          iprot.skip(ftype)
5903 
      elif fid == 1:
5904 
        if ftype == TType.STRUCT:
5905 
          self.ucx = UserContextException()
5906 
          self.ucx.read(iprot)
5907 
        else:
5908 
          iprot.skip(ftype)
5909 
      else:
5910 
        iprot.skip(ftype)
5911 
      iprot.readFieldEnd()
5912 
    iprot.readStructEnd()
5913 
 
5914 
  def write(self, oprot):
5915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5917 
      return
5918 
    oprot.writeStructBegin('forgotPassword_result')
5919 
    if self.success != None:
5920 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5921 
      oprot.writeBool(self.success)
5922 
      oprot.writeFieldEnd()
5923 
    if self.ucx != None:
5924 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5925 
      self.ucx.write(oprot)
5926 
      oprot.writeFieldEnd()
5927 
    oprot.writeFieldStop()
5928 
    oprot.writeStructEnd()
5929 
 
5930 
  def __repr__(self):
5931 
    L = ['%s=%r' % (key, value)
5932 
      for key, value in self.__dict__.iteritems()]
5933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5934 
 
5935 
  def __eq__(self, other):
5936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5937 
 
5938 
  def __ne__(self, other):
5939 
    return not (self == other)
5940 
 
594 rajveer 5941 
class getAllAddressesForUser_args:
5942 
  """
5943 
  Attributes:
5944 
   - userId
5945 
  """
5946 
 
5947 
  thrift_spec = (
5948 
    None, # 0
5949 
    (1, TType.I64, 'userId', None, None, ), # 1
5950 
  )
5951 
 
5952 
  def __init__(self, userId=None,):
5953 
    self.userId = userId
5954 
 
5955 
  def read(self, iprot):
5956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5958 
      return
5959 
    iprot.readStructBegin()
5960 
    while True:
5961 
      (fname, ftype, fid) = iprot.readFieldBegin()
5962 
      if ftype == TType.STOP:
5963 
        break
5964 
      if fid == 1:
5965 
        if ftype == TType.I64:
5966 
          self.userId = iprot.readI64();
5967 
        else:
5968 
          iprot.skip(ftype)
5969 
      else:
5970 
        iprot.skip(ftype)
5971 
      iprot.readFieldEnd()
5972 
    iprot.readStructEnd()
5973 
 
5974 
  def write(self, oprot):
5975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5977 
      return
5978 
    oprot.writeStructBegin('getAllAddressesForUser_args')
5979 
    if self.userId != None:
5980 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5981 
      oprot.writeI64(self.userId)
5982 
      oprot.writeFieldEnd()
5983 
    oprot.writeFieldStop()
5984 
    oprot.writeStructEnd()
5985 
 
5986 
  def __repr__(self):
5987 
    L = ['%s=%r' % (key, value)
5988 
      for key, value in self.__dict__.iteritems()]
5989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5990 
 
5991 
  def __eq__(self, other):
5992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5993 
 
5994 
  def __ne__(self, other):
5995 
    return not (self == other)
5996 
 
5997 
class getAllAddressesForUser_result:
5998 
  """
5999 
  Attributes:
6000 
   - success
6001 
   - ucx
6002 
  """
6003 
 
6004 
  thrift_spec = (
6005 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
6006 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6007 
  )
6008 
 
6009 
  def __init__(self, success=None, ucx=None,):
6010 
    self.success = success
6011 
    self.ucx = ucx
6012 
 
6013 
  def read(self, iprot):
6014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6016 
      return
6017 
    iprot.readStructBegin()
6018 
    while True:
6019 
      (fname, ftype, fid) = iprot.readFieldBegin()
6020 
      if ftype == TType.STOP:
6021 
        break
6022 
      if fid == 0:
6023 
        if ftype == TType.LIST:
6024 
          self.success = []
1976 varun.gupt 6025 
          (_etype38, _size35) = iprot.readListBegin()
6026 
          for _i39 in xrange(_size35):
6027 
            _elem40 = Address()
6028 
            _elem40.read(iprot)
6029 
            self.success.append(_elem40)
594 rajveer 6030 
          iprot.readListEnd()
6031 
        else:
6032 
          iprot.skip(ftype)
6033 
      elif fid == 1:
6034 
        if ftype == TType.STRUCT:
6035 
          self.ucx = UserContextException()
6036 
          self.ucx.read(iprot)
6037 
        else:
6038 
          iprot.skip(ftype)
6039 
      else:
6040 
        iprot.skip(ftype)
6041 
      iprot.readFieldEnd()
6042 
    iprot.readStructEnd()
6043 
 
6044 
  def write(self, oprot):
6045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6047 
      return
6048 
    oprot.writeStructBegin('getAllAddressesForUser_result')
6049 
    if self.success != None:
6050 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6051 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 6052 
      for iter41 in self.success:
6053 
        iter41.write(oprot)
594 rajveer 6054 
      oprot.writeListEnd()
6055 
      oprot.writeFieldEnd()
6056 
    if self.ucx != None:
6057 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6058 
      self.ucx.write(oprot)
6059 
      oprot.writeFieldEnd()
6060 
    oprot.writeFieldStop()
6061 
    oprot.writeStructEnd()
6062 
 
6063 
  def __repr__(self):
6064 
    L = ['%s=%r' % (key, value)
6065 
      for key, value in self.__dict__.iteritems()]
6066 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6067 
 
6068 
  def __eq__(self, other):
6069 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6070 
 
6071 
  def __ne__(self, other):
6072 
    return not (self == other)
6073 
 
1894 vikas 6074 
class getAddressById_args:
6075 
  """
6076 
  Attributes:
6077 
   - addressId
6078 
  """
6079 
 
6080 
  thrift_spec = (
6081 
    None, # 0
6082 
    (1, TType.I64, 'addressId', None, None, ), # 1
6083 
  )
6084 
 
6085 
  def __init__(self, addressId=None,):
6086 
    self.addressId = addressId
6087 
 
6088 
  def read(self, iprot):
6089 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6090 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6091 
      return
6092 
    iprot.readStructBegin()
6093 
    while True:
6094 
      (fname, ftype, fid) = iprot.readFieldBegin()
6095 
      if ftype == TType.STOP:
6096 
        break
6097 
      if fid == 1:
6098 
        if ftype == TType.I64:
6099 
          self.addressId = iprot.readI64();
6100 
        else:
6101 
          iprot.skip(ftype)
6102 
      else:
6103 
        iprot.skip(ftype)
6104 
      iprot.readFieldEnd()
6105 
    iprot.readStructEnd()
6106 
 
6107 
  def write(self, oprot):
6108 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6109 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6110 
      return
6111 
    oprot.writeStructBegin('getAddressById_args')
6112 
    if self.addressId != None:
6113 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
6114 
      oprot.writeI64(self.addressId)
6115 
      oprot.writeFieldEnd()
6116 
    oprot.writeFieldStop()
6117 
    oprot.writeStructEnd()
6118 
 
6119 
  def __repr__(self):
6120 
    L = ['%s=%r' % (key, value)
6121 
      for key, value in self.__dict__.iteritems()]
6122 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6123 
 
6124 
  def __eq__(self, other):
6125 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6126 
 
6127 
  def __ne__(self, other):
6128 
    return not (self == other)
6129 
 
6130 
class getAddressById_result:
6131 
  """
6132 
  Attributes:
6133 
   - success
6134 
   - ucx
6135 
  """
6136 
 
6137 
  thrift_spec = (
6138 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
6139 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6140 
  )
6141 
 
6142 
  def __init__(self, success=None, ucx=None,):
6143 
    self.success = success
6144 
    self.ucx = ucx
6145 
 
6146 
  def read(self, iprot):
6147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6149 
      return
6150 
    iprot.readStructBegin()
6151 
    while True:
6152 
      (fname, ftype, fid) = iprot.readFieldBegin()
6153 
      if ftype == TType.STOP:
6154 
        break
6155 
      if fid == 0:
6156 
        if ftype == TType.STRUCT:
6157 
          self.success = Address()
6158 
          self.success.read(iprot)
6159 
        else:
6160 
          iprot.skip(ftype)
6161 
      elif fid == 1:
6162 
        if ftype == TType.STRUCT:
6163 
          self.ucx = UserContextException()
6164 
          self.ucx.read(iprot)
6165 
        else:
6166 
          iprot.skip(ftype)
6167 
      else:
6168 
        iprot.skip(ftype)
6169 
      iprot.readFieldEnd()
6170 
    iprot.readStructEnd()
6171 
 
6172 
  def write(self, oprot):
6173 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6174 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6175 
      return
6176 
    oprot.writeStructBegin('getAddressById_result')
6177 
    if self.success != None:
6178 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6179 
      self.success.write(oprot)
6180 
      oprot.writeFieldEnd()
6181 
    if self.ucx != None:
6182 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6183 
      self.ucx.write(oprot)
6184 
      oprot.writeFieldEnd()
6185 
    oprot.writeFieldStop()
6186 
    oprot.writeStructEnd()
6187 
 
6188 
  def __repr__(self):
6189 
    L = ['%s=%r' % (key, value)
6190 
      for key, value in self.__dict__.iteritems()]
6191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6192 
 
6193 
  def __eq__(self, other):
6194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6195 
 
6196 
  def __ne__(self, other):
6197 
    return not (self == other)
6198 
 
594 rajveer 6199 
class getDefaultAddressId_args:
6200 
  """
6201 
  Attributes:
6202 
   - userId
6203 
  """
6204 
 
6205 
  thrift_spec = (
6206 
    None, # 0
6207 
    (1, TType.I64, 'userId', None, None, ), # 1
6208 
  )
6209 
 
6210 
  def __init__(self, userId=None,):
6211 
    self.userId = userId
6212 
 
6213 
  def read(self, iprot):
6214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6216 
      return
6217 
    iprot.readStructBegin()
6218 
    while True:
6219 
      (fname, ftype, fid) = iprot.readFieldBegin()
6220 
      if ftype == TType.STOP:
6221 
        break
6222 
      if fid == 1:
6223 
        if ftype == TType.I64:
6224 
          self.userId = iprot.readI64();
6225 
        else:
6226 
          iprot.skip(ftype)
6227 
      else:
6228 
        iprot.skip(ftype)
6229 
      iprot.readFieldEnd()
6230 
    iprot.readStructEnd()
6231 
 
6232 
  def write(self, oprot):
6233 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6234 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6235 
      return
6236 
    oprot.writeStructBegin('getDefaultAddressId_args')
6237 
    if self.userId != None:
6238 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6239 
      oprot.writeI64(self.userId)
6240 
      oprot.writeFieldEnd()
6241 
    oprot.writeFieldStop()
6242 
    oprot.writeStructEnd()
6243 
 
6244 
  def __repr__(self):
6245 
    L = ['%s=%r' % (key, value)
6246 
      for key, value in self.__dict__.iteritems()]
6247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6248 
 
6249 
  def __eq__(self, other):
6250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6251 
 
6252 
  def __ne__(self, other):
6253 
    return not (self == other)
6254 
 
6255 
class getDefaultAddressId_result:
6256 
  """
6257 
  Attributes:
6258 
   - success
6259 
   - ucx
6260 
  """
6261 
 
6262 
  thrift_spec = (
6263 
    (0, TType.I64, 'success', None, None, ), # 0
6264 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6265 
  )
6266 
 
6267 
  def __init__(self, success=None, ucx=None,):
6268 
    self.success = success
6269 
    self.ucx = ucx
6270 
 
6271 
  def read(self, iprot):
6272 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6273 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6274 
      return
6275 
    iprot.readStructBegin()
6276 
    while True:
6277 
      (fname, ftype, fid) = iprot.readFieldBegin()
6278 
      if ftype == TType.STOP:
6279 
        break
6280 
      if fid == 0:
6281 
        if ftype == TType.I64:
6282 
          self.success = iprot.readI64();
6283 
        else:
6284 
          iprot.skip(ftype)
6285 
      elif fid == 1:
6286 
        if ftype == TType.STRUCT:
6287 
          self.ucx = UserContextException()
6288 
          self.ucx.read(iprot)
6289 
        else:
6290 
          iprot.skip(ftype)
6291 
      else:
6292 
        iprot.skip(ftype)
6293 
      iprot.readFieldEnd()
6294 
    iprot.readStructEnd()
6295 
 
6296 
  def write(self, oprot):
6297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6299 
      return
6300 
    oprot.writeStructBegin('getDefaultAddressId_result')
6301 
    if self.success != None:
6302 
      oprot.writeFieldBegin('success', TType.I64, 0)
6303 
      oprot.writeI64(self.success)
6304 
      oprot.writeFieldEnd()
6305 
    if self.ucx != None:
6306 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6307 
      self.ucx.write(oprot)
6308 
      oprot.writeFieldEnd()
6309 
    oprot.writeFieldStop()
6310 
    oprot.writeStructEnd()
6311 
 
6312 
  def __repr__(self):
6313 
    L = ['%s=%r' % (key, value)
6314 
      for key, value in self.__dict__.iteritems()]
6315 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6316 
 
6317 
  def __eq__(self, other):
6318 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6319 
 
6320 
  def __ne__(self, other):
6321 
    return not (self == other)
6322 
 
785 rajveer 6323 
class getDefaultPincode_args:
6324 
  """
6325 
  Attributes:
6326 
   - userId
6327 
  """
6328 
 
6329 
  thrift_spec = (
6330 
    None, # 0
6331 
    (1, TType.I64, 'userId', None, None, ), # 1
6332 
  )
6333 
 
6334 
  def __init__(self, userId=None,):
6335 
    self.userId = userId
6336 
 
6337 
  def read(self, iprot):
6338 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6339 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6340 
      return
6341 
    iprot.readStructBegin()
6342 
    while True:
6343 
      (fname, ftype, fid) = iprot.readFieldBegin()
6344 
      if ftype == TType.STOP:
6345 
        break
6346 
      if fid == 1:
6347 
        if ftype == TType.I64:
6348 
          self.userId = iprot.readI64();
6349 
        else:
6350 
          iprot.skip(ftype)
6351 
      else:
6352 
        iprot.skip(ftype)
6353 
      iprot.readFieldEnd()
6354 
    iprot.readStructEnd()
6355 
 
6356 
  def write(self, oprot):
6357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6359 
      return
6360 
    oprot.writeStructBegin('getDefaultPincode_args')
6361 
    if self.userId != None:
6362 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6363 
      oprot.writeI64(self.userId)
6364 
      oprot.writeFieldEnd()
6365 
    oprot.writeFieldStop()
6366 
    oprot.writeStructEnd()
6367 
 
6368 
  def __repr__(self):
6369 
    L = ['%s=%r' % (key, value)
6370 
      for key, value in self.__dict__.iteritems()]
6371 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6372 
 
6373 
  def __eq__(self, other):
6374 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6375 
 
6376 
  def __ne__(self, other):
6377 
    return not (self == other)
6378 
 
6379 
class getDefaultPincode_result:
6380 
  """
6381 
  Attributes:
6382 
   - success
6383 
   - ucx
6384 
  """
6385 
 
6386 
  thrift_spec = (
6387 
    (0, TType.STRING, 'success', None, None, ), # 0
6388 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6389 
  )
6390 
 
6391 
  def __init__(self, success=None, ucx=None,):
6392 
    self.success = success
6393 
    self.ucx = ucx
6394 
 
6395 
  def read(self, iprot):
6396 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6397 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6398 
      return
6399 
    iprot.readStructBegin()
6400 
    while True:
6401 
      (fname, ftype, fid) = iprot.readFieldBegin()
6402 
      if ftype == TType.STOP:
6403 
        break
6404 
      if fid == 0:
6405 
        if ftype == TType.STRING:
6406 
          self.success = iprot.readString();
6407 
        else:
6408 
          iprot.skip(ftype)
6409 
      elif fid == 1:
6410 
        if ftype == TType.STRUCT:
6411 
          self.ucx = UserContextException()
6412 
          self.ucx.read(iprot)
6413 
        else:
6414 
          iprot.skip(ftype)
6415 
      else:
6416 
        iprot.skip(ftype)
6417 
      iprot.readFieldEnd()
6418 
    iprot.readStructEnd()
6419 
 
6420 
  def write(self, oprot):
6421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6423 
      return
6424 
    oprot.writeStructBegin('getDefaultPincode_result')
6425 
    if self.success != None:
6426 
      oprot.writeFieldBegin('success', TType.STRING, 0)
6427 
      oprot.writeString(self.success)
6428 
      oprot.writeFieldEnd()
6429 
    if self.ucx != None:
6430 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6431 
      self.ucx.write(oprot)
6432 
      oprot.writeFieldEnd()
6433 
    oprot.writeFieldStop()
6434 
    oprot.writeStructEnd()
6435 
 
6436 
  def __repr__(self):
6437 
    L = ['%s=%r' % (key, value)
6438 
      for key, value in self.__dict__.iteritems()]
6439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6440 
 
6441 
  def __eq__(self, other):
6442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6443 
 
6444 
  def __ne__(self, other):
6445 
    return not (self == other)
6446 
 
1274 varun.gupt 6447 
class saveUserCommunication_args:
6448 
  """
6449 
  Attributes:
6450 
   - userId
6451 
   - replyTo
6452 
   - communicationType
6453 
   - orderId
6454 
   - airwaybillNo
6455 
   - productName
6456 
   - subject
6457 
   - message
6458 
  """
6459 
 
6460 
  thrift_spec = (
6461 
    None, # 0
6462 
    (1, TType.I64, 'userId', None, None, ), # 1
6463 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
6464 
    (3, TType.I64, 'communicationType', None, None, ), # 3
6465 
    (4, TType.I64, 'orderId', None, None, ), # 4
6466 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
6467 
    (6, TType.STRING, 'productName', None, None, ), # 6
6468 
    (7, TType.STRING, 'subject', None, None, ), # 7
6469 
    (8, TType.STRING, 'message', None, None, ), # 8
6470 
  )
6471 
 
6472 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
6473 
    self.userId = userId
6474 
    self.replyTo = replyTo
6475 
    self.communicationType = communicationType
6476 
    self.orderId = orderId
6477 
    self.airwaybillNo = airwaybillNo
6478 
    self.productName = productName
6479 
    self.subject = subject
6480 
    self.message = message
6481 
 
6482 
  def read(self, iprot):
6483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6485 
      return
6486 
    iprot.readStructBegin()
6487 
    while True:
6488 
      (fname, ftype, fid) = iprot.readFieldBegin()
6489 
      if ftype == TType.STOP:
6490 
        break
6491 
      if fid == 1:
6492 
        if ftype == TType.I64:
6493 
          self.userId = iprot.readI64();
6494 
        else:
6495 
          iprot.skip(ftype)
6496 
      elif fid == 2:
6497 
        if ftype == TType.STRING:
6498 
          self.replyTo = iprot.readString();
6499 
        else:
6500 
          iprot.skip(ftype)
6501 
      elif fid == 3:
6502 
        if ftype == TType.I64:
6503 
          self.communicationType = iprot.readI64();
6504 
        else:
6505 
          iprot.skip(ftype)
6506 
      elif fid == 4:
6507 
        if ftype == TType.I64:
6508 
          self.orderId = iprot.readI64();
6509 
        else:
6510 
          iprot.skip(ftype)
6511 
      elif fid == 5:
6512 
        if ftype == TType.STRING:
6513 
          self.airwaybillNo = iprot.readString();
6514 
        else:
6515 
          iprot.skip(ftype)
6516 
      elif fid == 6:
6517 
        if ftype == TType.STRING:
6518 
          self.productName = iprot.readString();
6519 
        else:
6520 
          iprot.skip(ftype)
6521 
      elif fid == 7:
6522 
        if ftype == TType.STRING:
6523 
          self.subject = iprot.readString();
6524 
        else:
6525 
          iprot.skip(ftype)
6526 
      elif fid == 8:
6527 
        if ftype == TType.STRING:
6528 
          self.message = iprot.readString();
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('saveUserCommunication_args')
6541 
    if self.userId != None:
6542 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6543 
      oprot.writeI64(self.userId)
6544 
      oprot.writeFieldEnd()
6545 
    if self.replyTo != None:
6546 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
6547 
      oprot.writeString(self.replyTo)
6548 
      oprot.writeFieldEnd()
6549 
    if self.communicationType != None:
6550 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
6551 
      oprot.writeI64(self.communicationType)
6552 
      oprot.writeFieldEnd()
6553 
    if self.orderId != None:
6554 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
6555 
      oprot.writeI64(self.orderId)
6556 
      oprot.writeFieldEnd()
6557 
    if self.airwaybillNo != None:
6558 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
6559 
      oprot.writeString(self.airwaybillNo)
6560 
      oprot.writeFieldEnd()
6561 
    if self.productName != None:
6562 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
6563 
      oprot.writeString(self.productName)
6564 
      oprot.writeFieldEnd()
6565 
    if self.subject != None:
6566 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
6567 
      oprot.writeString(self.subject)
6568 
      oprot.writeFieldEnd()
6569 
    if self.message != None:
6570 
      oprot.writeFieldBegin('message', TType.STRING, 8)
6571 
      oprot.writeString(self.message)
6572 
      oprot.writeFieldEnd()
6573 
    oprot.writeFieldStop()
6574 
    oprot.writeStructEnd()
6575 
 
6576 
  def __repr__(self):
6577 
    L = ['%s=%r' % (key, value)
6578 
      for key, value in self.__dict__.iteritems()]
6579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6580 
 
6581 
  def __eq__(self, other):
6582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6583 
 
6584 
  def __ne__(self, other):
6585 
    return not (self == other)
6586 
 
6587 
class saveUserCommunication_result:
6588 
  """
6589 
  Attributes:
6590 
   - success
6591 
   - ucx
6592 
  """
6593 
 
6594 
  thrift_spec = (
6595 
    (0, TType.BOOL, 'success', None, None, ), # 0
6596 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6597 
  )
6598 
 
6599 
  def __init__(self, success=None, ucx=None,):
6600 
    self.success = success
6601 
    self.ucx = ucx
6602 
 
6603 
  def read(self, iprot):
6604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6606 
      return
6607 
    iprot.readStructBegin()
6608 
    while True:
6609 
      (fname, ftype, fid) = iprot.readFieldBegin()
6610 
      if ftype == TType.STOP:
6611 
        break
6612 
      if fid == 0:
6613 
        if ftype == TType.BOOL:
6614 
          self.success = iprot.readBool();
6615 
        else:
6616 
          iprot.skip(ftype)
6617 
      elif fid == 1:
6618 
        if ftype == TType.STRUCT:
6619 
          self.ucx = UserCommunicationException()
6620 
          self.ucx.read(iprot)
6621 
        else:
6622 
          iprot.skip(ftype)
6623 
      else:
6624 
        iprot.skip(ftype)
6625 
      iprot.readFieldEnd()
6626 
    iprot.readStructEnd()
6627 
 
6628 
  def write(self, oprot):
6629 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6630 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6631 
      return
6632 
    oprot.writeStructBegin('saveUserCommunication_result')
6633 
    if self.success != None:
6634 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6635 
      oprot.writeBool(self.success)
6636 
      oprot.writeFieldEnd()
6637 
    if self.ucx != None:
6638 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6639 
      self.ucx.write(oprot)
6640 
      oprot.writeFieldEnd()
6641 
    oprot.writeFieldStop()
6642 
    oprot.writeStructEnd()
6643 
 
6644 
  def __repr__(self):
6645 
    L = ['%s=%r' % (key, value)
6646 
      for key, value in self.__dict__.iteritems()]
6647 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6648 
 
6649 
  def __eq__(self, other):
6650 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6651 
 
6652 
  def __ne__(self, other):
6653 
    return not (self == other)
6654 
 
1590 varun.gupt 6655 
class getUserCommunicationById_args:
6656 
  """
6657 
  Attributes:
6658 
   - id
6659 
  """
6660 
 
6661 
  thrift_spec = (
6662 
    None, # 0
6663 
    (1, TType.I64, 'id', None, None, ), # 1
6664 
  )
6665 
 
6666 
  def __init__(self, id=None,):
6667 
    self.id = id
6668 
 
6669 
  def read(self, iprot):
6670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6672 
      return
6673 
    iprot.readStructBegin()
6674 
    while True:
6675 
      (fname, ftype, fid) = iprot.readFieldBegin()
6676 
      if ftype == TType.STOP:
6677 
        break
6678 
      if fid == 1:
6679 
        if ftype == TType.I64:
6680 
          self.id = iprot.readI64();
6681 
        else:
6682 
          iprot.skip(ftype)
6683 
      else:
6684 
        iprot.skip(ftype)
6685 
      iprot.readFieldEnd()
6686 
    iprot.readStructEnd()
6687 
 
6688 
  def write(self, oprot):
6689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6691 
      return
6692 
    oprot.writeStructBegin('getUserCommunicationById_args')
6693 
    if self.id != None:
6694 
      oprot.writeFieldBegin('id', TType.I64, 1)
6695 
      oprot.writeI64(self.id)
6696 
      oprot.writeFieldEnd()
6697 
    oprot.writeFieldStop()
6698 
    oprot.writeStructEnd()
6699 
 
6700 
  def __repr__(self):
6701 
    L = ['%s=%r' % (key, value)
6702 
      for key, value in self.__dict__.iteritems()]
6703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6704 
 
6705 
  def __eq__(self, other):
6706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6707 
 
6708 
  def __ne__(self, other):
6709 
    return not (self == other)
6710 
 
6711 
class getUserCommunicationById_result:
6712 
  """
6713 
  Attributes:
6714 
   - success
6715 
   - ucx
6716 
  """
6717 
 
6718 
  thrift_spec = (
6719 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
6720 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6721 
  )
6722 
 
6723 
  def __init__(self, success=None, ucx=None,):
6724 
    self.success = success
6725 
    self.ucx = ucx
6726 
 
6727 
  def read(self, iprot):
6728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6730 
      return
6731 
    iprot.readStructBegin()
6732 
    while True:
6733 
      (fname, ftype, fid) = iprot.readFieldBegin()
6734 
      if ftype == TType.STOP:
6735 
        break
6736 
      if fid == 0:
6737 
        if ftype == TType.STRUCT:
6738 
          self.success = UserCommunication()
6739 
          self.success.read(iprot)
6740 
        else:
6741 
          iprot.skip(ftype)
6742 
      elif fid == 1:
6743 
        if ftype == TType.STRUCT:
6744 
          self.ucx = UserCommunicationException()
6745 
          self.ucx.read(iprot)
6746 
        else:
6747 
          iprot.skip(ftype)
6748 
      else:
6749 
        iprot.skip(ftype)
6750 
      iprot.readFieldEnd()
6751 
    iprot.readStructEnd()
6752 
 
6753 
  def write(self, oprot):
6754 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6755 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6756 
      return
6757 
    oprot.writeStructBegin('getUserCommunicationById_result')
6758 
    if self.success != None:
6759 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6760 
      self.success.write(oprot)
6761 
      oprot.writeFieldEnd()
6762 
    if self.ucx != None:
6763 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6764 
      self.ucx.write(oprot)
6765 
      oprot.writeFieldEnd()
6766 
    oprot.writeFieldStop()
6767 
    oprot.writeStructEnd()
6768 
 
6769 
  def __repr__(self):
6770 
    L = ['%s=%r' % (key, value)
6771 
      for key, value in self.__dict__.iteritems()]
6772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6773 
 
6774 
  def __eq__(self, other):
6775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6776 
 
6777 
  def __ne__(self, other):
6778 
    return not (self == other)
6779 
 
6780 
class getUserCommunicationByUser_args:
6781 
  """
6782 
  Attributes:
6783 
   - userId
6784 
  """
6785 
 
6786 
  thrift_spec = (
6787 
    None, # 0
6788 
    (1, TType.I64, 'userId', None, None, ), # 1
6789 
  )
6790 
 
6791 
  def __init__(self, userId=None,):
6792 
    self.userId = userId
6793 
 
6794 
  def read(self, iprot):
6795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6797 
      return
6798 
    iprot.readStructBegin()
6799 
    while True:
6800 
      (fname, ftype, fid) = iprot.readFieldBegin()
6801 
      if ftype == TType.STOP:
6802 
        break
6803 
      if fid == 1:
6804 
        if ftype == TType.I64:
6805 
          self.userId = iprot.readI64();
6806 
        else:
6807 
          iprot.skip(ftype)
6808 
      else:
6809 
        iprot.skip(ftype)
6810 
      iprot.readFieldEnd()
6811 
    iprot.readStructEnd()
6812 
 
6813 
  def write(self, oprot):
6814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6816 
      return
6817 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
6818 
    if self.userId != None:
6819 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6820 
      oprot.writeI64(self.userId)
6821 
      oprot.writeFieldEnd()
6822 
    oprot.writeFieldStop()
6823 
    oprot.writeStructEnd()
6824 
 
6825 
  def __repr__(self):
6826 
    L = ['%s=%r' % (key, value)
6827 
      for key, value in self.__dict__.iteritems()]
6828 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6829 
 
6830 
  def __eq__(self, other):
6831 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6832 
 
6833 
  def __ne__(self, other):
6834 
    return not (self == other)
6835 
 
6836 
class getUserCommunicationByUser_result:
6837 
  """
6838 
  Attributes:
6839 
   - success
6840 
   - ucx
6841 
  """
6842 
 
6843 
  thrift_spec = (
6844 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
6845 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6846 
  )
6847 
 
6848 
  def __init__(self, success=None, ucx=None,):
6849 
    self.success = success
6850 
    self.ucx = ucx
6851 
 
6852 
  def read(self, iprot):
6853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6855 
      return
6856 
    iprot.readStructBegin()
6857 
    while True:
6858 
      (fname, ftype, fid) = iprot.readFieldBegin()
6859 
      if ftype == TType.STOP:
6860 
        break
6861 
      if fid == 0:
6862 
        if ftype == TType.LIST:
6863 
          self.success = []
1976 varun.gupt 6864 
          (_etype45, _size42) = iprot.readListBegin()
6865 
          for _i46 in xrange(_size42):
6866 
            _elem47 = UserCommunication()
6867 
            _elem47.read(iprot)
6868 
            self.success.append(_elem47)
1590 varun.gupt 6869 
          iprot.readListEnd()
6870 
        else:
6871 
          iprot.skip(ftype)
6872 
      elif fid == 1:
6873 
        if ftype == TType.STRUCT:
6874 
          self.ucx = UserCommunicationException()
6875 
          self.ucx.read(iprot)
6876 
        else:
6877 
          iprot.skip(ftype)
6878 
      else:
6879 
        iprot.skip(ftype)
6880 
      iprot.readFieldEnd()
6881 
    iprot.readStructEnd()
6882 
 
6883 
  def write(self, oprot):
6884 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6885 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6886 
      return
6887 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
6888 
    if self.success != None:
6889 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6890 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 6891 
      for iter48 in self.success:
6892 
        iter48.write(oprot)
1590 varun.gupt 6893 
      oprot.writeListEnd()
6894 
      oprot.writeFieldEnd()
6895 
    if self.ucx != None:
6896 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6897 
      self.ucx.write(oprot)
6898 
      oprot.writeFieldEnd()
6899 
    oprot.writeFieldStop()
6900 
    oprot.writeStructEnd()
6901 
 
6902 
  def __repr__(self):
6903 
    L = ['%s=%r' % (key, value)
6904 
      for key, value in self.__dict__.iteritems()]
6905 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6906 
 
6907 
  def __eq__(self, other):
6908 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6909 
 
6910 
  def __ne__(self, other):
6911 
    return not (self == other)
6912 
 
6913 
class getAllUserCommunications_args:
6914 
 
6915 
  thrift_spec = (
6916 
  )
6917 
 
6918 
  def read(self, iprot):
6919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6921 
      return
6922 
    iprot.readStructBegin()
6923 
    while True:
6924 
      (fname, ftype, fid) = iprot.readFieldBegin()
6925 
      if ftype == TType.STOP:
6926 
        break
6927 
      else:
6928 
        iprot.skip(ftype)
6929 
      iprot.readFieldEnd()
6930 
    iprot.readStructEnd()
6931 
 
6932 
  def write(self, oprot):
6933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6935 
      return
6936 
    oprot.writeStructBegin('getAllUserCommunications_args')
6937 
    oprot.writeFieldStop()
6938 
    oprot.writeStructEnd()
6939 
 
6940 
  def __repr__(self):
6941 
    L = ['%s=%r' % (key, value)
6942 
      for key, value in self.__dict__.iteritems()]
6943 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6944 
 
6945 
  def __eq__(self, other):
6946 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6947 
 
6948 
  def __ne__(self, other):
6949 
    return not (self == other)
6950 
 
6951 
class getAllUserCommunications_result:
6952 
  """
6953 
  Attributes:
6954 
   - success
6955 
   - ucx
6956 
  """
6957 
 
6958 
  thrift_spec = (
6959 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
6960 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6961 
  )
6962 
 
6963 
  def __init__(self, success=None, ucx=None,):
6964 
    self.success = success
6965 
    self.ucx = ucx
6966 
 
6967 
  def read(self, iprot):
6968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6970 
      return
6971 
    iprot.readStructBegin()
6972 
    while True:
6973 
      (fname, ftype, fid) = iprot.readFieldBegin()
6974 
      if ftype == TType.STOP:
6975 
        break
6976 
      if fid == 0:
6977 
        if ftype == TType.LIST:
6978 
          self.success = []
1976 varun.gupt 6979 
          (_etype52, _size49) = iprot.readListBegin()
6980 
          for _i53 in xrange(_size49):
6981 
            _elem54 = UserCommunication()
6982 
            _elem54.read(iprot)
6983 
            self.success.append(_elem54)
1590 varun.gupt 6984 
          iprot.readListEnd()
6985 
        else:
6986 
          iprot.skip(ftype)
6987 
      elif fid == 1:
6988 
        if ftype == TType.STRUCT:
6989 
          self.ucx = UserCommunicationException()
6990 
          self.ucx.read(iprot)
6991 
        else:
6992 
          iprot.skip(ftype)
6993 
      else:
6994 
        iprot.skip(ftype)
6995 
      iprot.readFieldEnd()
6996 
    iprot.readStructEnd()
6997 
 
6998 
  def write(self, oprot):
6999 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7000 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7001 
      return
7002 
    oprot.writeStructBegin('getAllUserCommunications_result')
7003 
    if self.success != None:
7004 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7005 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 7006 
      for iter55 in self.success:
7007 
        iter55.write(oprot)
1590 varun.gupt 7008 
      oprot.writeListEnd()
7009 
      oprot.writeFieldEnd()
7010 
    if self.ucx != None:
7011 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7012 
      self.ucx.write(oprot)
7013 
      oprot.writeFieldEnd()
7014 
    oprot.writeFieldStop()
7015 
    oprot.writeStructEnd()
7016 
 
7017 
  def __repr__(self):
7018 
    L = ['%s=%r' % (key, value)
7019 
      for key, value in self.__dict__.iteritems()]
7020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7021 
 
7022 
  def __eq__(self, other):
7023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7024 
 
7025 
  def __ne__(self, other):
7026 
    return not (self == other)
7027 
 
1845 vikas 7028 
class createMasterAffiliate_args:
7029 
  """
7030 
  Attributes:
7031 
   - name
1859 vikas 7032 
   - addedOn
1845 vikas 7033 
  """
7034 
 
7035 
  thrift_spec = (
7036 
    None, # 0
7037 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 7038 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 7039 
  )
7040 
 
1859 vikas 7041 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 7042 
    self.name = name
1859 vikas 7043 
    self.addedOn = addedOn
1845 vikas 7044 
 
7045 
  def read(self, iprot):
7046 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7047 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7048 
      return
7049 
    iprot.readStructBegin()
7050 
    while True:
7051 
      (fname, ftype, fid) = iprot.readFieldBegin()
7052 
      if ftype == TType.STOP:
7053 
        break
7054 
      if fid == 1:
7055 
        if ftype == TType.STRING:
7056 
          self.name = iprot.readString();
7057 
        else:
7058 
          iprot.skip(ftype)
1859 vikas 7059 
      elif fid == 2:
7060 
        if ftype == TType.I64:
7061 
          self.addedOn = iprot.readI64();
7062 
        else:
7063 
          iprot.skip(ftype)
1845 vikas 7064 
      else:
7065 
        iprot.skip(ftype)
7066 
      iprot.readFieldEnd()
7067 
    iprot.readStructEnd()
7068 
 
7069 
  def write(self, oprot):
7070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7072 
      return
7073 
    oprot.writeStructBegin('createMasterAffiliate_args')
7074 
    if self.name != None:
7075 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7076 
      oprot.writeString(self.name)
7077 
      oprot.writeFieldEnd()
1859 vikas 7078 
    if self.addedOn != None:
7079 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
7080 
      oprot.writeI64(self.addedOn)
7081 
      oprot.writeFieldEnd()
1845 vikas 7082 
    oprot.writeFieldStop()
7083 
    oprot.writeStructEnd()
7084 
 
7085 
  def __repr__(self):
7086 
    L = ['%s=%r' % (key, value)
7087 
      for key, value in self.__dict__.iteritems()]
7088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7089 
 
7090 
  def __eq__(self, other):
7091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7092 
 
7093 
  def __ne__(self, other):
7094 
    return not (self == other)
7095 
 
7096 
class createMasterAffiliate_result:
7097 
  """
7098 
  Attributes:
7099 
   - success
7100 
   - utx
7101 
  """
7102 
 
7103 
  thrift_spec = (
7104 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7105 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7106 
  )
7107 
 
7108 
  def __init__(self, success=None, utx=None,):
7109 
    self.success = success
7110 
    self.utx = utx
7111 
 
7112 
  def read(self, iprot):
7113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7115 
      return
7116 
    iprot.readStructBegin()
7117 
    while True:
7118 
      (fname, ftype, fid) = iprot.readFieldBegin()
7119 
      if ftype == TType.STOP:
7120 
        break
7121 
      if fid == 0:
7122 
        if ftype == TType.STRUCT:
7123 
          self.success = MasterAffiliate()
7124 
          self.success.read(iprot)
7125 
        else:
7126 
          iprot.skip(ftype)
7127 
      elif fid == 1:
7128 
        if ftype == TType.STRUCT:
1996 vikas 7129 
          self.utx = UserAffiliateException()
1845 vikas 7130 
          self.utx.read(iprot)
7131 
        else:
7132 
          iprot.skip(ftype)
7133 
      else:
7134 
        iprot.skip(ftype)
7135 
      iprot.readFieldEnd()
7136 
    iprot.readStructEnd()
7137 
 
7138 
  def write(self, oprot):
7139 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7140 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7141 
      return
7142 
    oprot.writeStructBegin('createMasterAffiliate_result')
7143 
    if self.success != None:
7144 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7145 
      self.success.write(oprot)
7146 
      oprot.writeFieldEnd()
7147 
    if self.utx != None:
7148 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7149 
      self.utx.write(oprot)
7150 
      oprot.writeFieldEnd()
7151 
    oprot.writeFieldStop()
7152 
    oprot.writeStructEnd()
7153 
 
7154 
  def __repr__(self):
7155 
    L = ['%s=%r' % (key, value)
7156 
      for key, value in self.__dict__.iteritems()]
7157 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7158 
 
7159 
  def __eq__(self, other):
7160 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7161 
 
7162 
  def __ne__(self, other):
7163 
    return not (self == other)
7164 
 
1899 vikas 7165 
class getAllMasterAffiliates_args:
7166 
 
7167 
  thrift_spec = (
7168 
  )
7169 
 
7170 
  def read(self, iprot):
7171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7173 
      return
7174 
    iprot.readStructBegin()
7175 
    while True:
7176 
      (fname, ftype, fid) = iprot.readFieldBegin()
7177 
      if ftype == TType.STOP:
7178 
        break
7179 
      else:
7180 
        iprot.skip(ftype)
7181 
      iprot.readFieldEnd()
7182 
    iprot.readStructEnd()
7183 
 
7184 
  def write(self, oprot):
7185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7187 
      return
7188 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
7189 
    oprot.writeFieldStop()
7190 
    oprot.writeStructEnd()
7191 
 
7192 
  def __repr__(self):
7193 
    L = ['%s=%r' % (key, value)
7194 
      for key, value in self.__dict__.iteritems()]
7195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7196 
 
7197 
  def __eq__(self, other):
7198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7199 
 
7200 
  def __ne__(self, other):
7201 
    return not (self == other)
7202 
 
7203 
class getAllMasterAffiliates_result:
7204 
  """
7205 
  Attributes:
7206 
   - success
7207 
   - utx
7208 
  """
7209 
 
7210 
  thrift_spec = (
7211 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 7212 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 7213 
  )
7214 
 
7215 
  def __init__(self, success=None, utx=None,):
7216 
    self.success = success
7217 
    self.utx = utx
7218 
 
7219 
  def read(self, iprot):
7220 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7221 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7222 
      return
7223 
    iprot.readStructBegin()
7224 
    while True:
7225 
      (fname, ftype, fid) = iprot.readFieldBegin()
7226 
      if ftype == TType.STOP:
7227 
        break
7228 
      if fid == 0:
7229 
        if ftype == TType.LIST:
7230 
          self.success = []
1976 varun.gupt 7231 
          (_etype59, _size56) = iprot.readListBegin()
7232 
          for _i60 in xrange(_size56):
7233 
            _elem61 = MasterAffiliate()
7234 
            _elem61.read(iprot)
7235 
            self.success.append(_elem61)
1899 vikas 7236 
          iprot.readListEnd()
7237 
        else:
7238 
          iprot.skip(ftype)
7239 
      elif fid == 1:
7240 
        if ftype == TType.STRUCT:
1996 vikas 7241 
          self.utx = UserAffiliateException()
1899 vikas 7242 
          self.utx.read(iprot)
7243 
        else:
7244 
          iprot.skip(ftype)
7245 
      else:
7246 
        iprot.skip(ftype)
7247 
      iprot.readFieldEnd()
7248 
    iprot.readStructEnd()
7249 
 
7250 
  def write(self, oprot):
7251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7253 
      return
7254 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
7255 
    if self.success != None:
7256 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7257 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 7258 
      for iter62 in self.success:
7259 
        iter62.write(oprot)
1899 vikas 7260 
      oprot.writeListEnd()
7261 
      oprot.writeFieldEnd()
7262 
    if self.utx != None:
7263 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7264 
      self.utx.write(oprot)
7265 
      oprot.writeFieldEnd()
7266 
    oprot.writeFieldStop()
7267 
    oprot.writeStructEnd()
7268 
 
7269 
  def __repr__(self):
7270 
    L = ['%s=%r' % (key, value)
7271 
      for key, value in self.__dict__.iteritems()]
7272 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7273 
 
7274 
  def __eq__(self, other):
7275 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7276 
 
7277 
  def __ne__(self, other):
7278 
    return not (self == other)
7279 
 
1845 vikas 7280 
class getMasterAffiliateById_args:
7281 
  """
7282 
  Attributes:
7283 
   - id
7284 
  """
7285 
 
7286 
  thrift_spec = (
7287 
    None, # 0
7288 
    (1, TType.I64, 'id', None, None, ), # 1
7289 
  )
7290 
 
7291 
  def __init__(self, id=None,):
7292 
    self.id = id
7293 
 
7294 
  def read(self, iprot):
7295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7297 
      return
7298 
    iprot.readStructBegin()
7299 
    while True:
7300 
      (fname, ftype, fid) = iprot.readFieldBegin()
7301 
      if ftype == TType.STOP:
7302 
        break
7303 
      if fid == 1:
7304 
        if ftype == TType.I64:
7305 
          self.id = iprot.readI64();
7306 
        else:
7307 
          iprot.skip(ftype)
7308 
      else:
7309 
        iprot.skip(ftype)
7310 
      iprot.readFieldEnd()
7311 
    iprot.readStructEnd()
7312 
 
7313 
  def write(self, oprot):
7314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7316 
      return
7317 
    oprot.writeStructBegin('getMasterAffiliateById_args')
7318 
    if self.id != None:
7319 
      oprot.writeFieldBegin('id', TType.I64, 1)
7320 
      oprot.writeI64(self.id)
7321 
      oprot.writeFieldEnd()
7322 
    oprot.writeFieldStop()
7323 
    oprot.writeStructEnd()
7324 
 
7325 
  def __repr__(self):
7326 
    L = ['%s=%r' % (key, value)
7327 
      for key, value in self.__dict__.iteritems()]
7328 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7329 
 
7330 
  def __eq__(self, other):
7331 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7332 
 
7333 
  def __ne__(self, other):
7334 
    return not (self == other)
7335 
 
7336 
class getMasterAffiliateById_result:
7337 
  """
7338 
  Attributes:
7339 
   - success
7340 
   - utx
7341 
  """
7342 
 
7343 
  thrift_spec = (
7344 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7345 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7346 
  )
7347 
 
7348 
  def __init__(self, success=None, utx=None,):
7349 
    self.success = success
7350 
    self.utx = utx
7351 
 
7352 
  def read(self, iprot):
7353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7355 
      return
7356 
    iprot.readStructBegin()
7357 
    while True:
7358 
      (fname, ftype, fid) = iprot.readFieldBegin()
7359 
      if ftype == TType.STOP:
7360 
        break
7361 
      if fid == 0:
7362 
        if ftype == TType.STRUCT:
7363 
          self.success = MasterAffiliate()
7364 
          self.success.read(iprot)
7365 
        else:
7366 
          iprot.skip(ftype)
7367 
      elif fid == 1:
7368 
        if ftype == TType.STRUCT:
1996 vikas 7369 
          self.utx = UserAffiliateException()
1845 vikas 7370 
          self.utx.read(iprot)
7371 
        else:
7372 
          iprot.skip(ftype)
7373 
      else:
7374 
        iprot.skip(ftype)
7375 
      iprot.readFieldEnd()
7376 
    iprot.readStructEnd()
7377 
 
7378 
  def write(self, oprot):
7379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7381 
      return
7382 
    oprot.writeStructBegin('getMasterAffiliateById_result')
7383 
    if self.success != None:
7384 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7385 
      self.success.write(oprot)
7386 
      oprot.writeFieldEnd()
7387 
    if self.utx != None:
7388 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7389 
      self.utx.write(oprot)
7390 
      oprot.writeFieldEnd()
7391 
    oprot.writeFieldStop()
7392 
    oprot.writeStructEnd()
7393 
 
7394 
  def __repr__(self):
7395 
    L = ['%s=%r' % (key, value)
7396 
      for key, value in self.__dict__.iteritems()]
7397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7398 
 
7399 
  def __eq__(self, other):
7400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7401 
 
7402 
  def __ne__(self, other):
7403 
    return not (self == other)
7404 
 
7405 
class getMasterAffiliateByName_args:
7406 
  """
7407 
  Attributes:
7408 
   - name
7409 
  """
7410 
 
7411 
  thrift_spec = (
7412 
    None, # 0
7413 
    (1, TType.STRING, 'name', None, None, ), # 1
7414 
  )
7415 
 
7416 
  def __init__(self, name=None,):
7417 
    self.name = name
7418 
 
7419 
  def read(self, iprot):
7420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7422 
      return
7423 
    iprot.readStructBegin()
7424 
    while True:
7425 
      (fname, ftype, fid) = iprot.readFieldBegin()
7426 
      if ftype == TType.STOP:
7427 
        break
7428 
      if fid == 1:
7429 
        if ftype == TType.STRING:
7430 
          self.name = iprot.readString();
7431 
        else:
7432 
          iprot.skip(ftype)
7433 
      else:
7434 
        iprot.skip(ftype)
7435 
      iprot.readFieldEnd()
7436 
    iprot.readStructEnd()
7437 
 
7438 
  def write(self, oprot):
7439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7441 
      return
7442 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
7443 
    if self.name != None:
7444 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7445 
      oprot.writeString(self.name)
7446 
      oprot.writeFieldEnd()
7447 
    oprot.writeFieldStop()
7448 
    oprot.writeStructEnd()
7449 
 
7450 
  def __repr__(self):
7451 
    L = ['%s=%r' % (key, value)
7452 
      for key, value in self.__dict__.iteritems()]
7453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7454 
 
7455 
  def __eq__(self, other):
7456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7457 
 
7458 
  def __ne__(self, other):
7459 
    return not (self == other)
7460 
 
7461 
class getMasterAffiliateByName_result:
7462 
  """
7463 
  Attributes:
7464 
   - success
7465 
   - utx
7466 
  """
7467 
 
7468 
  thrift_spec = (
7469 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7470 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7471 
  )
7472 
 
7473 
  def __init__(self, success=None, utx=None,):
7474 
    self.success = success
7475 
    self.utx = utx
7476 
 
7477 
  def read(self, iprot):
7478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7480 
      return
7481 
    iprot.readStructBegin()
7482 
    while True:
7483 
      (fname, ftype, fid) = iprot.readFieldBegin()
7484 
      if ftype == TType.STOP:
7485 
        break
7486 
      if fid == 0:
7487 
        if ftype == TType.STRUCT:
7488 
          self.success = MasterAffiliate()
7489 
          self.success.read(iprot)
7490 
        else:
7491 
          iprot.skip(ftype)
7492 
      elif fid == 1:
7493 
        if ftype == TType.STRUCT:
1996 vikas 7494 
          self.utx = UserAffiliateException()
1845 vikas 7495 
          self.utx.read(iprot)
7496 
        else:
7497 
          iprot.skip(ftype)
7498 
      else:
7499 
        iprot.skip(ftype)
7500 
      iprot.readFieldEnd()
7501 
    iprot.readStructEnd()
7502 
 
7503 
  def write(self, oprot):
7504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7506 
      return
7507 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
7508 
    if self.success != None:
7509 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7510 
      self.success.write(oprot)
7511 
      oprot.writeFieldEnd()
7512 
    if self.utx != None:
7513 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7514 
      self.utx.write(oprot)
7515 
      oprot.writeFieldEnd()
7516 
    oprot.writeFieldStop()
7517 
    oprot.writeStructEnd()
7518 
 
7519 
  def __repr__(self):
7520 
    L = ['%s=%r' % (key, value)
7521 
      for key, value in self.__dict__.iteritems()]
7522 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7523 
 
7524 
  def __eq__(self, other):
7525 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7526 
 
7527 
  def __ne__(self, other):
7528 
    return not (self == other)
7529 
 
7530 
class createAffiliate_args:
7531 
  """
7532 
  Attributes:
7533 
   - name
7534 
   - url
7535 
   - masterAffiliateId
1859 vikas 7536 
   - addedOn
1845 vikas 7537 
  """
7538 
 
7539 
  thrift_spec = (
7540 
    None, # 0
7541 
    (1, TType.STRING, 'name', None, None, ), # 1
7542 
    (2, TType.STRING, 'url', None, None, ), # 2
7543 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 7544 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 7545 
  )
7546 
 
1859 vikas 7547 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 7548 
    self.name = name
7549 
    self.url = url
7550 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 7551 
    self.addedOn = addedOn
1845 vikas 7552 
 
7553 
  def read(self, iprot):
7554 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7555 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7556 
      return
7557 
    iprot.readStructBegin()
7558 
    while True:
7559 
      (fname, ftype, fid) = iprot.readFieldBegin()
7560 
      if ftype == TType.STOP:
7561 
        break
7562 
      if fid == 1:
7563 
        if ftype == TType.STRING:
7564 
          self.name = iprot.readString();
7565 
        else:
7566 
          iprot.skip(ftype)
7567 
      elif fid == 2:
7568 
        if ftype == TType.STRING:
7569 
          self.url = iprot.readString();
7570 
        else:
7571 
          iprot.skip(ftype)
7572 
      elif fid == 3:
7573 
        if ftype == TType.I64:
7574 
          self.masterAffiliateId = iprot.readI64();
7575 
        else:
7576 
          iprot.skip(ftype)
1859 vikas 7577 
      elif fid == 4:
7578 
        if ftype == TType.I64:
7579 
          self.addedOn = iprot.readI64();
7580 
        else:
7581 
          iprot.skip(ftype)
1845 vikas 7582 
      else:
7583 
        iprot.skip(ftype)
7584 
      iprot.readFieldEnd()
7585 
    iprot.readStructEnd()
7586 
 
7587 
  def write(self, oprot):
7588 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7589 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7590 
      return
7591 
    oprot.writeStructBegin('createAffiliate_args')
7592 
    if self.name != None:
7593 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7594 
      oprot.writeString(self.name)
7595 
      oprot.writeFieldEnd()
7596 
    if self.url != None:
7597 
      oprot.writeFieldBegin('url', TType.STRING, 2)
7598 
      oprot.writeString(self.url)
7599 
      oprot.writeFieldEnd()
7600 
    if self.masterAffiliateId != None:
7601 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
7602 
      oprot.writeI64(self.masterAffiliateId)
7603 
      oprot.writeFieldEnd()
1859 vikas 7604 
    if self.addedOn != None:
7605 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
7606 
      oprot.writeI64(self.addedOn)
7607 
      oprot.writeFieldEnd()
1845 vikas 7608 
    oprot.writeFieldStop()
7609 
    oprot.writeStructEnd()
7610 
 
7611 
  def __repr__(self):
7612 
    L = ['%s=%r' % (key, value)
7613 
      for key, value in self.__dict__.iteritems()]
7614 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7615 
 
7616 
  def __eq__(self, other):
7617 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7618 
 
7619 
  def __ne__(self, other):
7620 
    return not (self == other)
7621 
 
7622 
class createAffiliate_result:
7623 
  """
7624 
  Attributes:
7625 
   - success
7626 
   - utx
7627 
  """
7628 
 
7629 
  thrift_spec = (
7630 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 7631 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7632 
  )
7633 
 
7634 
  def __init__(self, success=None, utx=None,):
7635 
    self.success = success
7636 
    self.utx = utx
7637 
 
7638 
  def read(self, iprot):
7639 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7640 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7641 
      return
7642 
    iprot.readStructBegin()
7643 
    while True:
7644 
      (fname, ftype, fid) = iprot.readFieldBegin()
7645 
      if ftype == TType.STOP:
7646 
        break
7647 
      if fid == 0:
7648 
        if ftype == TType.STRUCT:
7649 
          self.success = Affiliate()
7650 
          self.success.read(iprot)
7651 
        else:
7652 
          iprot.skip(ftype)
7653 
      elif fid == 1:
7654 
        if ftype == TType.STRUCT:
1996 vikas 7655 
          self.utx = UserAffiliateException()
1845 vikas 7656 
          self.utx.read(iprot)
7657 
        else:
7658 
          iprot.skip(ftype)
7659 
      else:
7660 
        iprot.skip(ftype)
7661 
      iprot.readFieldEnd()
7662 
    iprot.readStructEnd()
7663 
 
7664 
  def write(self, oprot):
7665 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7666 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7667 
      return
7668 
    oprot.writeStructBegin('createAffiliate_result')
7669 
    if self.success != None:
7670 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7671 
      self.success.write(oprot)
7672 
      oprot.writeFieldEnd()
7673 
    if self.utx != None:
7674 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7675 
      self.utx.write(oprot)
7676 
      oprot.writeFieldEnd()
7677 
    oprot.writeFieldStop()
7678 
    oprot.writeStructEnd()
7679 
 
7680 
  def __repr__(self):
7681 
    L = ['%s=%r' % (key, value)
7682 
      for key, value in self.__dict__.iteritems()]
7683 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7684 
 
7685 
  def __eq__(self, other):
7686 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7687 
 
7688 
  def __ne__(self, other):
7689 
    return not (self == other)
7690 
 
7691 
class getAffiliateById_args:
7692 
  """
7693 
  Attributes:
7694 
   - id
7695 
  """
7696 
 
7697 
  thrift_spec = (
7698 
    None, # 0
7699 
    (1, TType.I64, 'id', None, None, ), # 1
7700 
  )
7701 
 
7702 
  def __init__(self, id=None,):
7703 
    self.id = id
7704 
 
7705 
  def read(self, iprot):
7706 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7707 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7708 
      return
7709 
    iprot.readStructBegin()
7710 
    while True:
7711 
      (fname, ftype, fid) = iprot.readFieldBegin()
7712 
      if ftype == TType.STOP:
7713 
        break
7714 
      if fid == 1:
7715 
        if ftype == TType.I64:
7716 
          self.id = iprot.readI64();
7717 
        else:
7718 
          iprot.skip(ftype)
7719 
      else:
7720 
        iprot.skip(ftype)
7721 
      iprot.readFieldEnd()
7722 
    iprot.readStructEnd()
7723 
 
7724 
  def write(self, oprot):
7725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7727 
      return
7728 
    oprot.writeStructBegin('getAffiliateById_args')
7729 
    if self.id != None:
7730 
      oprot.writeFieldBegin('id', TType.I64, 1)
7731 
      oprot.writeI64(self.id)
7732 
      oprot.writeFieldEnd()
7733 
    oprot.writeFieldStop()
7734 
    oprot.writeStructEnd()
7735 
 
7736 
  def __repr__(self):
7737 
    L = ['%s=%r' % (key, value)
7738 
      for key, value in self.__dict__.iteritems()]
7739 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7740 
 
7741 
  def __eq__(self, other):
7742 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7743 
 
7744 
  def __ne__(self, other):
7745 
    return not (self == other)
7746 
 
7747 
class getAffiliateById_result:
7748 
  """
7749 
  Attributes:
7750 
   - success
7751 
   - utx
7752 
  """
7753 
 
7754 
  thrift_spec = (
7755 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 7756 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7757 
  )
7758 
 
7759 
  def __init__(self, success=None, utx=None,):
7760 
    self.success = success
7761 
    self.utx = utx
7762 
 
7763 
  def read(self, iprot):
7764 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7765 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7766 
      return
7767 
    iprot.readStructBegin()
7768 
    while True:
7769 
      (fname, ftype, fid) = iprot.readFieldBegin()
7770 
      if ftype == TType.STOP:
7771 
        break
7772 
      if fid == 0:
7773 
        if ftype == TType.STRUCT:
7774 
          self.success = Affiliate()
7775 
          self.success.read(iprot)
7776 
        else:
7777 
          iprot.skip(ftype)
7778 
      elif fid == 1:
7779 
        if ftype == TType.STRUCT:
1996 vikas 7780 
          self.utx = UserAffiliateException()
1845 vikas 7781 
          self.utx.read(iprot)
7782 
        else:
7783 
          iprot.skip(ftype)
7784 
      else:
7785 
        iprot.skip(ftype)
7786 
      iprot.readFieldEnd()
7787 
    iprot.readStructEnd()
7788 
 
7789 
  def write(self, oprot):
7790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7792 
      return
7793 
    oprot.writeStructBegin('getAffiliateById_result')
7794 
    if self.success != None:
7795 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7796 
      self.success.write(oprot)
7797 
      oprot.writeFieldEnd()
7798 
    if self.utx != None:
7799 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7800 
      self.utx.write(oprot)
7801 
      oprot.writeFieldEnd()
7802 
    oprot.writeFieldStop()
7803 
    oprot.writeStructEnd()
7804 
 
7805 
  def __repr__(self):
7806 
    L = ['%s=%r' % (key, value)
7807 
      for key, value in self.__dict__.iteritems()]
7808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7809 
 
7810 
  def __eq__(self, other):
7811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7812 
 
7813 
  def __ne__(self, other):
7814 
    return not (self == other)
7815 
 
7816 
class getAffiliateByName_args:
7817 
  """
7818 
  Attributes:
7819 
   - name
7820 
  """
7821 
 
7822 
  thrift_spec = (
7823 
    None, # 0
7824 
    (1, TType.STRING, 'name', None, None, ), # 1
7825 
  )
7826 
 
7827 
  def __init__(self, name=None,):
7828 
    self.name = name
7829 
 
7830 
  def read(self, iprot):
7831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7833 
      return
7834 
    iprot.readStructBegin()
7835 
    while True:
7836 
      (fname, ftype, fid) = iprot.readFieldBegin()
7837 
      if ftype == TType.STOP:
7838 
        break
7839 
      if fid == 1:
7840 
        if ftype == TType.STRING:
7841 
          self.name = iprot.readString();
7842 
        else:
7843 
          iprot.skip(ftype)
7844 
      else:
7845 
        iprot.skip(ftype)
7846 
      iprot.readFieldEnd()
7847 
    iprot.readStructEnd()
7848 
 
7849 
  def write(self, oprot):
7850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7852 
      return
7853 
    oprot.writeStructBegin('getAffiliateByName_args')
7854 
    if self.name != None:
7855 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7856 
      oprot.writeString(self.name)
7857 
      oprot.writeFieldEnd()
7858 
    oprot.writeFieldStop()
7859 
    oprot.writeStructEnd()
7860 
 
7861 
  def __repr__(self):
7862 
    L = ['%s=%r' % (key, value)
7863 
      for key, value in self.__dict__.iteritems()]
7864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7865 
 
7866 
  def __eq__(self, other):
7867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7868 
 
7869 
  def __ne__(self, other):
7870 
    return not (self == other)
7871 
 
7872 
class getAffiliateByName_result:
7873 
  """
7874 
  Attributes:
7875 
   - success
7876 
   - utx
7877 
  """
7878 
 
7879 
  thrift_spec = (
7880 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 7881 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7882 
  )
7883 
 
7884 
  def __init__(self, success=None, utx=None,):
7885 
    self.success = success
7886 
    self.utx = utx
7887 
 
7888 
  def read(self, iprot):
7889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7891 
      return
7892 
    iprot.readStructBegin()
7893 
    while True:
7894 
      (fname, ftype, fid) = iprot.readFieldBegin()
7895 
      if ftype == TType.STOP:
7896 
        break
7897 
      if fid == 0:
7898 
        if ftype == TType.STRUCT:
7899 
          self.success = Affiliate()
7900 
          self.success.read(iprot)
7901 
        else:
7902 
          iprot.skip(ftype)
7903 
      elif fid == 1:
7904 
        if ftype == TType.STRUCT:
1996 vikas 7905 
          self.utx = UserAffiliateException()
1845 vikas 7906 
          self.utx.read(iprot)
7907 
        else:
7908 
          iprot.skip(ftype)
7909 
      else:
7910 
        iprot.skip(ftype)
7911 
      iprot.readFieldEnd()
7912 
    iprot.readStructEnd()
7913 
 
7914 
  def write(self, oprot):
7915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7917 
      return
7918 
    oprot.writeStructBegin('getAffiliateByName_result')
7919 
    if self.success != None:
7920 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7921 
      self.success.write(oprot)
7922 
      oprot.writeFieldEnd()
7923 
    if self.utx != None:
7924 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7925 
      self.utx.write(oprot)
7926 
      oprot.writeFieldEnd()
7927 
    oprot.writeFieldStop()
7928 
    oprot.writeStructEnd()
7929 
 
7930 
  def __repr__(self):
7931 
    L = ['%s=%r' % (key, value)
7932 
      for key, value in self.__dict__.iteritems()]
7933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7934 
 
7935 
  def __eq__(self, other):
7936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7937 
 
7938 
  def __ne__(self, other):
7939 
    return not (self == other)
7940 
 
1996 vikas 7941 
class getTrackerById_args:
1845 vikas 7942 
  """
7943 
  Attributes:
7944 
   - id
7945 
  """
7946 
 
7947 
  thrift_spec = (
7948 
    None, # 0
7949 
    (1, TType.I64, 'id', None, None, ), # 1
7950 
  )
7951 
 
7952 
  def __init__(self, id=None,):
7953 
    self.id = id
7954 
 
7955 
  def read(self, iprot):
7956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7958 
      return
7959 
    iprot.readStructBegin()
7960 
    while True:
7961 
      (fname, ftype, fid) = iprot.readFieldBegin()
7962 
      if ftype == TType.STOP:
7963 
        break
7964 
      if fid == 1:
7965 
        if ftype == TType.I64:
7966 
          self.id = iprot.readI64();
7967 
        else:
7968 
          iprot.skip(ftype)
7969 
      else:
7970 
        iprot.skip(ftype)
7971 
      iprot.readFieldEnd()
7972 
    iprot.readStructEnd()
7973 
 
7974 
  def write(self, oprot):
7975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7977 
      return
1996 vikas 7978 
    oprot.writeStructBegin('getTrackerById_args')
1845 vikas 7979 
    if self.id != None:
7980 
      oprot.writeFieldBegin('id', TType.I64, 1)
7981 
      oprot.writeI64(self.id)
7982 
      oprot.writeFieldEnd()
7983 
    oprot.writeFieldStop()
7984 
    oprot.writeStructEnd()
7985 
 
7986 
  def __repr__(self):
7987 
    L = ['%s=%r' % (key, value)
7988 
      for key, value in self.__dict__.iteritems()]
7989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7990 
 
7991 
  def __eq__(self, other):
7992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7993 
 
7994 
  def __ne__(self, other):
7995 
    return not (self == other)
7996 
 
7997 
class getTrackerById_result:
7998 
  """
7999 
  Attributes:
8000 
   - success
8001 
   - utx
8002 
  """
8003 
 
8004 
  thrift_spec = (
8005 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 8006 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8007 
  )
8008 
 
8009 
  def __init__(self, success=None, utx=None,):
8010 
    self.success = success
8011 
    self.utx = utx
8012 
 
8013 
  def read(self, iprot):
8014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8016 
      return
8017 
    iprot.readStructBegin()
8018 
    while True:
8019 
      (fname, ftype, fid) = iprot.readFieldBegin()
8020 
      if ftype == TType.STOP:
8021 
        break
8022 
      if fid == 0:
8023 
        if ftype == TType.STRUCT:
8024 
          self.success = Tracker()
8025 
          self.success.read(iprot)
8026 
        else:
8027 
          iprot.skip(ftype)
8028 
      elif fid == 1:
8029 
        if ftype == TType.STRUCT:
1996 vikas 8030 
          self.utx = UserAffiliateException()
1845 vikas 8031 
          self.utx.read(iprot)
8032 
        else:
8033 
          iprot.skip(ftype)
8034 
      else:
8035 
        iprot.skip(ftype)
8036 
      iprot.readFieldEnd()
8037 
    iprot.readStructEnd()
8038 
 
8039 
  def write(self, oprot):
8040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8042 
      return
8043 
    oprot.writeStructBegin('getTrackerById_result')
8044 
    if self.success != None:
8045 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8046 
      self.success.write(oprot)
8047 
      oprot.writeFieldEnd()
8048 
    if self.utx != None:
8049 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8050 
      self.utx.write(oprot)
8051 
      oprot.writeFieldEnd()
8052 
    oprot.writeFieldStop()
8053 
    oprot.writeStructEnd()
8054 
 
8055 
  def __repr__(self):
8056 
    L = ['%s=%r' % (key, value)
8057 
      for key, value in self.__dict__.iteritems()]
8058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8059 
 
8060 
  def __eq__(self, other):
8061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8062 
 
8063 
  def __ne__(self, other):
8064 
    return not (self == other)
8065 
 
1996 vikas 8066 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 8067 
  """
8068 
  Attributes:
1996 vikas 8069 
   - id
1845 vikas 8070 
  """
8071 
 
8072 
  thrift_spec = (
8073 
    None, # 0
1996 vikas 8074 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 8075 
  )
8076 
 
1996 vikas 8077 
  def __init__(self, id=None,):
8078 
    self.id = id
1845 vikas 8079 
 
8080 
  def read(self, iprot):
8081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8083 
      return
8084 
    iprot.readStructBegin()
8085 
    while True:
8086 
      (fname, ftype, fid) = iprot.readFieldBegin()
8087 
      if ftype == TType.STOP:
8088 
        break
8089 
      if fid == 1:
8090 
        if ftype == TType.I64:
1996 vikas 8091 
          self.id = iprot.readI64();
1845 vikas 8092 
        else:
8093 
          iprot.skip(ftype)
8094 
      else:
8095 
        iprot.skip(ftype)
8096 
      iprot.readFieldEnd()
8097 
    iprot.readStructEnd()
8098 
 
8099 
  def write(self, oprot):
8100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8102 
      return
1996 vikas 8103 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
8104 
    if self.id != None:
8105 
      oprot.writeFieldBegin('id', TType.I64, 1)
8106 
      oprot.writeI64(self.id)
1845 vikas 8107 
      oprot.writeFieldEnd()
8108 
    oprot.writeFieldStop()
8109 
    oprot.writeStructEnd()
8110 
 
8111 
  def __repr__(self):
8112 
    L = ['%s=%r' % (key, value)
8113 
      for key, value in self.__dict__.iteritems()]
8114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8115 
 
8116 
  def __eq__(self, other):
8117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8118 
 
8119 
  def __ne__(self, other):
8120 
    return not (self == other)
8121 
 
1996 vikas 8122 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 8123 
  """
8124 
  Attributes:
8125 
   - success
8126 
   - utx
8127 
  """
8128 
 
8129 
  thrift_spec = (
1996 vikas 8130 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
8131 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8132 
  )
8133 
 
8134 
  def __init__(self, success=None, utx=None,):
8135 
    self.success = success
8136 
    self.utx = utx
8137 
 
8138 
  def read(self, iprot):
8139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8141 
      return
8142 
    iprot.readStructBegin()
8143 
    while True:
8144 
      (fname, ftype, fid) = iprot.readFieldBegin()
8145 
      if ftype == TType.STOP:
8146 
        break
8147 
      if fid == 0:
8148 
        if ftype == TType.LIST:
8149 
          self.success = []
1996 vikas 8150 
          (_etype66, _size63) = iprot.readListBegin()
8151 
          for _i67 in xrange(_size63):
8152 
            _elem68 = Affiliate()
8153 
            _elem68.read(iprot)
8154 
            self.success.append(_elem68)
1845 vikas 8155 
          iprot.readListEnd()
8156 
        else:
8157 
          iprot.skip(ftype)
8158 
      elif fid == 1:
8159 
        if ftype == TType.STRUCT:
1996 vikas 8160 
          self.utx = UserAffiliateException()
1845 vikas 8161 
          self.utx.read(iprot)
8162 
        else:
8163 
          iprot.skip(ftype)
8164 
      else:
8165 
        iprot.skip(ftype)
8166 
      iprot.readFieldEnd()
8167 
    iprot.readStructEnd()
8168 
 
8169 
  def write(self, oprot):
8170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8172 
      return
1996 vikas 8173 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
1845 vikas 8174 
    if self.success != None:
8175 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8176 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 8177 
      for iter69 in self.success:
8178 
        iter69.write(oprot)
1845 vikas 8179 
      oprot.writeListEnd()
8180 
      oprot.writeFieldEnd()
8181 
    if self.utx != None:
8182 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8183 
      self.utx.write(oprot)
8184 
      oprot.writeFieldEnd()
8185 
    oprot.writeFieldStop()
8186 
    oprot.writeStructEnd()
8187 
 
8188 
  def __repr__(self):
8189 
    L = ['%s=%r' % (key, value)
8190 
      for key, value in self.__dict__.iteritems()]
8191 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8192 
 
8193 
  def __eq__(self, other):
8194 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8195 
 
8196 
  def __ne__(self, other):
8197 
    return not (self == other)
8198 
 
8199 
class addTrackLog_args:
8200 
  """
8201 
  Attributes:
1996 vikas 8202 
   - affiliateId
1845 vikas 8203 
   - userId
8204 
   - event
8205 
   - url
8206 
   - data
1859 vikas 8207 
   - addedOn
1845 vikas 8208 
  """
8209 
 
8210 
  thrift_spec = (
8211 
    None, # 0
1996 vikas 8212 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 8213 
    (2, TType.I64, 'userId', None, None, ), # 2
8214 
    (3, TType.STRING, 'event', None, None, ), # 3
8215 
    (4, TType.STRING, 'url', None, None, ), # 4
8216 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 8217 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 8218 
  )
8219 
 
1996 vikas 8220 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
8221 
    self.affiliateId = affiliateId
1845 vikas 8222 
    self.userId = userId
8223 
    self.event = event
8224 
    self.url = url
8225 
    self.data = data
1859 vikas 8226 
    self.addedOn = addedOn
1845 vikas 8227 
 
8228 
  def read(self, iprot):
8229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8231 
      return
8232 
    iprot.readStructBegin()
8233 
    while True:
8234 
      (fname, ftype, fid) = iprot.readFieldBegin()
8235 
      if ftype == TType.STOP:
8236 
        break
8237 
      if fid == 1:
8238 
        if ftype == TType.I64:
1996 vikas 8239 
          self.affiliateId = iprot.readI64();
1845 vikas 8240 
        else:
8241 
          iprot.skip(ftype)
8242 
      elif fid == 2:
8243 
        if ftype == TType.I64:
8244 
          self.userId = iprot.readI64();
8245 
        else:
8246 
          iprot.skip(ftype)
8247 
      elif fid == 3:
8248 
        if ftype == TType.STRING:
8249 
          self.event = iprot.readString();
8250 
        else:
8251 
          iprot.skip(ftype)
8252 
      elif fid == 4:
8253 
        if ftype == TType.STRING:
8254 
          self.url = iprot.readString();
8255 
        else:
8256 
          iprot.skip(ftype)
8257 
      elif fid == 5:
8258 
        if ftype == TType.STRING:
8259 
          self.data = iprot.readString();
8260 
        else:
8261 
          iprot.skip(ftype)
1859 vikas 8262 
      elif fid == 6:
8263 
        if ftype == TType.I64:
8264 
          self.addedOn = iprot.readI64();
8265 
        else:
8266 
          iprot.skip(ftype)
1845 vikas 8267 
      else:
8268 
        iprot.skip(ftype)
8269 
      iprot.readFieldEnd()
8270 
    iprot.readStructEnd()
8271 
 
8272 
  def write(self, oprot):
8273 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8274 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8275 
      return
8276 
    oprot.writeStructBegin('addTrackLog_args')
1996 vikas 8277 
    if self.affiliateId != None:
8278 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
8279 
      oprot.writeI64(self.affiliateId)
1845 vikas 8280 
      oprot.writeFieldEnd()
8281 
    if self.userId != None:
8282 
      oprot.writeFieldBegin('userId', TType.I64, 2)
8283 
      oprot.writeI64(self.userId)
8284 
      oprot.writeFieldEnd()
8285 
    if self.event != None:
8286 
      oprot.writeFieldBegin('event', TType.STRING, 3)
8287 
      oprot.writeString(self.event)
8288 
      oprot.writeFieldEnd()
8289 
    if self.url != None:
8290 
      oprot.writeFieldBegin('url', TType.STRING, 4)
8291 
      oprot.writeString(self.url)
8292 
      oprot.writeFieldEnd()
8293 
    if self.data != None:
8294 
      oprot.writeFieldBegin('data', TType.STRING, 5)
8295 
      oprot.writeString(self.data)
8296 
      oprot.writeFieldEnd()
1859 vikas 8297 
    if self.addedOn != None:
8298 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
8299 
      oprot.writeI64(self.addedOn)
8300 
      oprot.writeFieldEnd()
1845 vikas 8301 
    oprot.writeFieldStop()
8302 
    oprot.writeStructEnd()
8303 
 
8304 
  def __repr__(self):
8305 
    L = ['%s=%r' % (key, value)
8306 
      for key, value in self.__dict__.iteritems()]
8307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8308 
 
8309 
  def __eq__(self, other):
8310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8311 
 
8312 
  def __ne__(self, other):
8313 
    return not (self == other)
8314 
 
8315 
class addTrackLog_result:
8316 
  """
8317 
  Attributes:
8318 
   - success
8319 
   - utx
8320 
  """
8321 
 
8322 
  thrift_spec = (
8323 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 8324 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8325 
  )
8326 
 
8327 
  def __init__(self, success=None, utx=None,):
8328 
    self.success = success
8329 
    self.utx = utx
8330 
 
8331 
  def read(self, iprot):
8332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8334 
      return
8335 
    iprot.readStructBegin()
8336 
    while True:
8337 
      (fname, ftype, fid) = iprot.readFieldBegin()
8338 
      if ftype == TType.STOP:
8339 
        break
8340 
      if fid == 0:
8341 
        if ftype == TType.I64:
8342 
          self.success = iprot.readI64();
8343 
        else:
8344 
          iprot.skip(ftype)
8345 
      elif fid == 1:
8346 
        if ftype == TType.STRUCT:
1996 vikas 8347 
          self.utx = UserAffiliateException()
1845 vikas 8348 
          self.utx.read(iprot)
8349 
        else:
8350 
          iprot.skip(ftype)
8351 
      else:
8352 
        iprot.skip(ftype)
8353 
      iprot.readFieldEnd()
8354 
    iprot.readStructEnd()
8355 
 
8356 
  def write(self, oprot):
8357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8359 
      return
8360 
    oprot.writeStructBegin('addTrackLog_result')
8361 
    if self.success != None:
8362 
      oprot.writeFieldBegin('success', TType.I64, 0)
8363 
      oprot.writeI64(self.success)
8364 
      oprot.writeFieldEnd()
8365 
    if self.utx != None:
8366 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8367 
      self.utx.write(oprot)
8368 
      oprot.writeFieldEnd()
8369 
    oprot.writeFieldStop()
8370 
    oprot.writeStructEnd()
8371 
 
8372 
  def __repr__(self):
8373 
    L = ['%s=%r' % (key, value)
8374 
      for key, value in self.__dict__.iteritems()]
8375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8376 
 
8377 
  def __eq__(self, other):
8378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8379 
 
8380 
  def __ne__(self, other):
8381 
    return not (self == other)
8382 
 
8383 
class getTrackLogById_args:
8384 
  """
8385 
  Attributes:
8386 
   - id
8387 
  """
8388 
 
8389 
  thrift_spec = (
8390 
    None, # 0
8391 
    (1, TType.I64, 'id', None, None, ), # 1
8392 
  )
8393 
 
8394 
  def __init__(self, id=None,):
8395 
    self.id = id
8396 
 
8397 
  def read(self, iprot):
8398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8400 
      return
8401 
    iprot.readStructBegin()
8402 
    while True:
8403 
      (fname, ftype, fid) = iprot.readFieldBegin()
8404 
      if ftype == TType.STOP:
8405 
        break
8406 
      if fid == 1:
8407 
        if ftype == TType.I64:
8408 
          self.id = iprot.readI64();
8409 
        else:
8410 
          iprot.skip(ftype)
8411 
      else:
8412 
        iprot.skip(ftype)
8413 
      iprot.readFieldEnd()
8414 
    iprot.readStructEnd()
8415 
 
8416 
  def write(self, oprot):
8417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8419 
      return
8420 
    oprot.writeStructBegin('getTrackLogById_args')
8421 
    if self.id != None:
8422 
      oprot.writeFieldBegin('id', TType.I64, 1)
8423 
      oprot.writeI64(self.id)
8424 
      oprot.writeFieldEnd()
8425 
    oprot.writeFieldStop()
8426 
    oprot.writeStructEnd()
8427 
 
8428 
  def __repr__(self):
8429 
    L = ['%s=%r' % (key, value)
8430 
      for key, value in self.__dict__.iteritems()]
8431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8432 
 
8433 
  def __eq__(self, other):
8434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8435 
 
8436 
  def __ne__(self, other):
8437 
    return not (self == other)
8438 
 
8439 
class getTrackLogById_result:
8440 
  """
8441 
  Attributes:
8442 
   - success
8443 
   - utx
8444 
  """
8445 
 
8446 
  thrift_spec = (
8447 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 8448 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8449 
  )
8450 
 
8451 
  def __init__(self, success=None, utx=None,):
8452 
    self.success = success
8453 
    self.utx = utx
8454 
 
8455 
  def read(self, iprot):
8456 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8457 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8458 
      return
8459 
    iprot.readStructBegin()
8460 
    while True:
8461 
      (fname, ftype, fid) = iprot.readFieldBegin()
8462 
      if ftype == TType.STOP:
8463 
        break
8464 
      if fid == 0:
8465 
        if ftype == TType.STRUCT:
8466 
          self.success = TrackLog()
8467 
          self.success.read(iprot)
8468 
        else:
8469 
          iprot.skip(ftype)
8470 
      elif fid == 1:
8471 
        if ftype == TType.STRUCT:
1996 vikas 8472 
          self.utx = UserAffiliateException()
1845 vikas 8473 
          self.utx.read(iprot)
8474 
        else:
8475 
          iprot.skip(ftype)
8476 
      else:
8477 
        iprot.skip(ftype)
8478 
      iprot.readFieldEnd()
8479 
    iprot.readStructEnd()
8480 
 
8481 
  def write(self, oprot):
8482 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8483 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8484 
      return
8485 
    oprot.writeStructBegin('getTrackLogById_result')
8486 
    if self.success != None:
8487 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8488 
      self.success.write(oprot)
8489 
      oprot.writeFieldEnd()
8490 
    if self.utx != None:
8491 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8492 
      self.utx.write(oprot)
8493 
      oprot.writeFieldEnd()
8494 
    oprot.writeFieldStop()
8495 
    oprot.writeStructEnd()
8496 
 
8497 
  def __repr__(self):
8498 
    L = ['%s=%r' % (key, value)
8499 
      for key, value in self.__dict__.iteritems()]
8500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8501 
 
8502 
  def __eq__(self, other):
8503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8504 
 
8505 
  def __ne__(self, other):
8506 
    return not (self == other)
8507 
 
1996 vikas 8508 
class getTrackLogsByAffiliate_args:
1845 vikas 8509 
  """
8510 
  Attributes:
1996 vikas 8511 
   - affiliateId
1845 vikas 8512 
  """
8513 
 
8514 
  thrift_spec = (
8515 
    None, # 0
1996 vikas 8516 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 8517 
  )
8518 
 
1996 vikas 8519 
  def __init__(self, affiliateId=None,):
8520 
    self.affiliateId = affiliateId
1845 vikas 8521 
 
8522 
  def read(self, iprot):
8523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8525 
      return
8526 
    iprot.readStructBegin()
8527 
    while True:
8528 
      (fname, ftype, fid) = iprot.readFieldBegin()
8529 
      if ftype == TType.STOP:
8530 
        break
8531 
      if fid == 1:
8532 
        if ftype == TType.I64:
1996 vikas 8533 
          self.affiliateId = iprot.readI64();
1845 vikas 8534 
        else:
8535 
          iprot.skip(ftype)
8536 
      else:
8537 
        iprot.skip(ftype)
8538 
      iprot.readFieldEnd()
8539 
    iprot.readStructEnd()
8540 
 
8541 
  def write(self, oprot):
8542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8544 
      return
1996 vikas 8545 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
8546 
    if self.affiliateId != None:
8547 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
8548 
      oprot.writeI64(self.affiliateId)
1845 vikas 8549 
      oprot.writeFieldEnd()
8550 
    oprot.writeFieldStop()
8551 
    oprot.writeStructEnd()
8552 
 
8553 
  def __repr__(self):
8554 
    L = ['%s=%r' % (key, value)
8555 
      for key, value in self.__dict__.iteritems()]
8556 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8557 
 
8558 
  def __eq__(self, other):
8559 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8560 
 
8561 
  def __ne__(self, other):
8562 
    return not (self == other)
8563 
 
1996 vikas 8564 
class getTrackLogsByAffiliate_result:
1845 vikas 8565 
  """
8566 
  Attributes:
8567 
   - success
8568 
   - utx
8569 
  """
8570 
 
8571 
  thrift_spec = (
8572 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 8573 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8574 
  )
8575 
 
8576 
  def __init__(self, success=None, utx=None,):
8577 
    self.success = success
8578 
    self.utx = utx
8579 
 
8580 
  def read(self, iprot):
8581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8583 
      return
8584 
    iprot.readStructBegin()
8585 
    while True:
8586 
      (fname, ftype, fid) = iprot.readFieldBegin()
8587 
      if ftype == TType.STOP:
8588 
        break
8589 
      if fid == 0:
8590 
        if ftype == TType.LIST:
8591 
          self.success = []
1996 vikas 8592 
          (_etype73, _size70) = iprot.readListBegin()
8593 
          for _i74 in xrange(_size70):
8594 
            _elem75 = TrackLog()
8595 
            _elem75.read(iprot)
8596 
            self.success.append(_elem75)
1845 vikas 8597 
          iprot.readListEnd()
8598 
        else:
8599 
          iprot.skip(ftype)
8600 
      elif fid == 1:
8601 
        if ftype == TType.STRUCT:
1996 vikas 8602 
          self.utx = UserAffiliateException()
1845 vikas 8603 
          self.utx.read(iprot)
8604 
        else:
8605 
          iprot.skip(ftype)
8606 
      else:
8607 
        iprot.skip(ftype)
8608 
      iprot.readFieldEnd()
8609 
    iprot.readStructEnd()
8610 
 
8611 
  def write(self, oprot):
8612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8614 
      return
1996 vikas 8615 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
1845 vikas 8616 
    if self.success != None:
8617 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8618 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 8619 
      for iter76 in self.success:
8620 
        iter76.write(oprot)
1845 vikas 8621 
      oprot.writeListEnd()
8622 
      oprot.writeFieldEnd()
8623 
    if self.utx != None:
8624 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8625 
      self.utx.write(oprot)
8626 
      oprot.writeFieldEnd()
8627 
    oprot.writeFieldStop()
8628 
    oprot.writeStructEnd()
8629 
 
8630 
  def __repr__(self):
8631 
    L = ['%s=%r' % (key, value)
8632 
      for key, value in self.__dict__.iteritems()]
8633 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8634 
 
8635 
  def __eq__(self, other):
8636 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8637 
 
8638 
  def __ne__(self, other):
8639 
    return not (self == other)
8640 
 
8641 
class getTrackLogsByUser_args:
8642 
  """
8643 
  Attributes:
8644 
   - userId
8645 
  """
8646 
 
8647 
  thrift_spec = (
8648 
    None, # 0
8649 
    (1, TType.I64, 'userId', None, None, ), # 1
8650 
  )
8651 
 
8652 
  def __init__(self, userId=None,):
8653 
    self.userId = userId
8654 
 
8655 
  def read(self, iprot):
8656 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8657 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8658 
      return
8659 
    iprot.readStructBegin()
8660 
    while True:
8661 
      (fname, ftype, fid) = iprot.readFieldBegin()
8662 
      if ftype == TType.STOP:
8663 
        break
8664 
      if fid == 1:
8665 
        if ftype == TType.I64:
8666 
          self.userId = iprot.readI64();
8667 
        else:
8668 
          iprot.skip(ftype)
8669 
      else:
8670 
        iprot.skip(ftype)
8671 
      iprot.readFieldEnd()
8672 
    iprot.readStructEnd()
8673 
 
8674 
  def write(self, oprot):
8675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8677 
      return
8678 
    oprot.writeStructBegin('getTrackLogsByUser_args')
8679 
    if self.userId != None:
8680 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8681 
      oprot.writeI64(self.userId)
8682 
      oprot.writeFieldEnd()
8683 
    oprot.writeFieldStop()
8684 
    oprot.writeStructEnd()
8685 
 
8686 
  def __repr__(self):
8687 
    L = ['%s=%r' % (key, value)
8688 
      for key, value in self.__dict__.iteritems()]
8689 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8690 
 
8691 
  def __eq__(self, other):
8692 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8693 
 
8694 
  def __ne__(self, other):
8695 
    return not (self == other)
8696 
 
8697 
class getTrackLogsByUser_result:
8698 
  """
8699 
  Attributes:
8700 
   - success
8701 
   - utx
8702 
  """
8703 
 
8704 
  thrift_spec = (
8705 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 8706 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8707 
  )
8708 
 
8709 
  def __init__(self, success=None, utx=None,):
8710 
    self.success = success
8711 
    self.utx = utx
8712 
 
8713 
  def read(self, iprot):
8714 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8715 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8716 
      return
8717 
    iprot.readStructBegin()
8718 
    while True:
8719 
      (fname, ftype, fid) = iprot.readFieldBegin()
8720 
      if ftype == TType.STOP:
8721 
        break
8722 
      if fid == 0:
8723 
        if ftype == TType.LIST:
8724 
          self.success = []
1996 vikas 8725 
          (_etype80, _size77) = iprot.readListBegin()
8726 
          for _i81 in xrange(_size77):
8727 
            _elem82 = TrackLog()
8728 
            _elem82.read(iprot)
8729 
            self.success.append(_elem82)
1845 vikas 8730 
          iprot.readListEnd()
8731 
        else:
8732 
          iprot.skip(ftype)
8733 
      elif fid == 1:
8734 
        if ftype == TType.STRUCT:
1996 vikas 8735 
          self.utx = UserAffiliateException()
1845 vikas 8736 
          self.utx.read(iprot)
8737 
        else:
8738 
          iprot.skip(ftype)
8739 
      else:
8740 
        iprot.skip(ftype)
8741 
      iprot.readFieldEnd()
8742 
    iprot.readStructEnd()
8743 
 
8744 
  def write(self, oprot):
8745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8747 
      return
8748 
    oprot.writeStructBegin('getTrackLogsByUser_result')
8749 
    if self.success != None:
8750 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8751 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 8752 
      for iter83 in self.success:
8753 
        iter83.write(oprot)
1845 vikas 8754 
      oprot.writeListEnd()
8755 
      oprot.writeFieldEnd()
8756 
    if self.utx != None:
8757 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8758 
      self.utx.write(oprot)
8759 
      oprot.writeFieldEnd()
8760 
    oprot.writeFieldStop()
8761 
    oprot.writeStructEnd()
8762 
 
8763 
  def __repr__(self):
8764 
    L = ['%s=%r' % (key, value)
8765 
      for key, value in self.__dict__.iteritems()]
8766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8767 
 
8768 
  def __eq__(self, other):
8769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8770 
 
8771 
  def __ne__(self, other):
8772 
    return not (self == other)
8773 
 
8774 
class getTrackLogs_args:
8775 
  """
8776 
  Attributes:
8777 
   - userId
8778 
   - event
8779 
   - url
8780 
  """
8781 
 
8782 
  thrift_spec = (
8783 
    None, # 0
1996 vikas 8784 
    (1, TType.I64, 'userId', None, None, ), # 1
8785 
    (2, TType.STRING, 'event', None, None, ), # 2
8786 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 8787 
  )
8788 
 
1996 vikas 8789 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 8790 
    self.userId = userId
8791 
    self.event = event
8792 
    self.url = url
8793 
 
8794 
  def read(self, iprot):
8795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8797 
      return
8798 
    iprot.readStructBegin()
8799 
    while True:
8800 
      (fname, ftype, fid) = iprot.readFieldBegin()
8801 
      if ftype == TType.STOP:
8802 
        break
8803 
      if fid == 1:
8804 
        if ftype == TType.I64:
1996 vikas 8805 
          self.userId = iprot.readI64();
1845 vikas 8806 
        else:
8807 
          iprot.skip(ftype)
8808 
      elif fid == 2:
8809 
        if ftype == TType.STRING:
8810 
          self.event = iprot.readString();
8811 
        else:
8812 
          iprot.skip(ftype)
1996 vikas 8813 
      elif fid == 3:
1845 vikas 8814 
        if ftype == TType.STRING:
8815 
          self.url = iprot.readString();
8816 
        else:
8817 
          iprot.skip(ftype)
8818 
      else:
8819 
        iprot.skip(ftype)
8820 
      iprot.readFieldEnd()
8821 
    iprot.readStructEnd()
8822 
 
8823 
  def write(self, oprot):
8824 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8825 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8826 
      return
8827 
    oprot.writeStructBegin('getTrackLogs_args')
8828 
    if self.userId != None:
1996 vikas 8829 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 8830 
      oprot.writeI64(self.userId)
8831 
      oprot.writeFieldEnd()
8832 
    if self.event != None:
1996 vikas 8833 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 8834 
      oprot.writeString(self.event)
8835 
      oprot.writeFieldEnd()
8836 
    if self.url != None:
1996 vikas 8837 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 8838 
      oprot.writeString(self.url)
8839 
      oprot.writeFieldEnd()
8840 
    oprot.writeFieldStop()
8841 
    oprot.writeStructEnd()
8842 
 
8843 
  def __repr__(self):
8844 
    L = ['%s=%r' % (key, value)
8845 
      for key, value in self.__dict__.iteritems()]
8846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8847 
 
8848 
  def __eq__(self, other):
8849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8850 
 
8851 
  def __ne__(self, other):
8852 
    return not (self == other)
8853 
 
8854 
class getTrackLogs_result:
8855 
  """
8856 
  Attributes:
8857 
   - success
8858 
   - utx
8859 
  """
8860 
 
8861 
  thrift_spec = (
8862 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 8863 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8864 
  )
8865 
 
8866 
  def __init__(self, success=None, utx=None,):
8867 
    self.success = success
8868 
    self.utx = utx
8869 
 
8870 
  def read(self, iprot):
8871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8873 
      return
8874 
    iprot.readStructBegin()
8875 
    while True:
8876 
      (fname, ftype, fid) = iprot.readFieldBegin()
8877 
      if ftype == TType.STOP:
8878 
        break
8879 
      if fid == 0:
8880 
        if ftype == TType.LIST:
8881 
          self.success = []
1996 vikas 8882 
          (_etype87, _size84) = iprot.readListBegin()
8883 
          for _i88 in xrange(_size84):
8884 
            _elem89 = TrackLog()
8885 
            _elem89.read(iprot)
8886 
            self.success.append(_elem89)
1845 vikas 8887 
          iprot.readListEnd()
8888 
        else:
8889 
          iprot.skip(ftype)
8890 
      elif fid == 1:
8891 
        if ftype == TType.STRUCT:
1996 vikas 8892 
          self.utx = UserAffiliateException()
1845 vikas 8893 
          self.utx.read(iprot)
8894 
        else:
8895 
          iprot.skip(ftype)
8896 
      else:
8897 
        iprot.skip(ftype)
8898 
      iprot.readFieldEnd()
8899 
    iprot.readStructEnd()
8900 
 
8901 
  def write(self, oprot):
8902 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8903 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8904 
      return
8905 
    oprot.writeStructBegin('getTrackLogs_result')
8906 
    if self.success != None:
8907 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8908 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 8909 
      for iter90 in self.success:
8910 
        iter90.write(oprot)
1845 vikas 8911 
      oprot.writeListEnd()
8912 
      oprot.writeFieldEnd()
8913 
    if self.utx != None:
8914 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8915 
      self.utx.write(oprot)
8916 
      oprot.writeFieldEnd()
8917 
    oprot.writeFieldStop()
8918 
    oprot.writeStructEnd()
8919 
 
8920 
  def __repr__(self):
8921 
    L = ['%s=%r' % (key, value)
8922 
      for key, value in self.__dict__.iteritems()]
8923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8924 
 
8925 
  def __eq__(self, other):
8926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8927 
 
8928 
  def __ne__(self, other):
8929 
    return not (self == other)
8930 
 
559 chandransh 8931 
class createCart_args:
94 ashish 8932 
  """
8933 
  Attributes:
559 chandransh 8934 
   - userId
94 ashish 8935 
  """
8936 
 
8937 
  thrift_spec = (
8938 
    None, # 0
559 chandransh 8939 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 8940 
  )
8941 
 
559 chandransh 8942 
  def __init__(self, userId=None,):
8943 
    self.userId = userId
94 ashish 8944 
 
8945 
  def read(self, iprot):
8946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8948 
      return
8949 
    iprot.readStructBegin()
8950 
    while True:
8951 
      (fname, ftype, fid) = iprot.readFieldBegin()
8952 
      if ftype == TType.STOP:
8953 
        break
8954 
      if fid == 1:
8955 
        if ftype == TType.I64:
559 chandransh 8956 
          self.userId = iprot.readI64();
94 ashish 8957 
        else:
8958 
          iprot.skip(ftype)
559 chandransh 8959 
      else:
8960 
        iprot.skip(ftype)
8961 
      iprot.readFieldEnd()
8962 
    iprot.readStructEnd()
8963 
 
8964 
  def write(self, oprot):
8965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8967 
      return
8968 
    oprot.writeStructBegin('createCart_args')
8969 
    if self.userId != None:
8970 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8971 
      oprot.writeI64(self.userId)
8972 
      oprot.writeFieldEnd()
8973 
    oprot.writeFieldStop()
8974 
    oprot.writeStructEnd()
8975 
 
8976 
  def __repr__(self):
8977 
    L = ['%s=%r' % (key, value)
8978 
      for key, value in self.__dict__.iteritems()]
8979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8980 
 
8981 
  def __eq__(self, other):
8982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8983 
 
8984 
  def __ne__(self, other):
8985 
    return not (self == other)
8986 
 
8987 
class createCart_result:
8988 
  """
8989 
  Attributes:
8990 
   - success
8991 
   - scx
8992 
  """
8993 
 
8994 
  thrift_spec = (
8995 
    (0, TType.I64, 'success', None, None, ), # 0
8996 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
8997 
  )
8998 
 
8999 
  def __init__(self, success=None, scx=None,):
9000 
    self.success = success
9001 
    self.scx = scx
9002 
 
9003 
  def read(self, iprot):
9004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9006 
      return
9007 
    iprot.readStructBegin()
9008 
    while True:
9009 
      (fname, ftype, fid) = iprot.readFieldBegin()
9010 
      if ftype == TType.STOP:
9011 
        break
9012 
      if fid == 0:
94 ashish 9013 
        if ftype == TType.I64:
559 chandransh 9014 
          self.success = iprot.readI64();
94 ashish 9015 
        else:
9016 
          iprot.skip(ftype)
559 chandransh 9017 
      elif fid == 1:
9018 
        if ftype == TType.STRUCT:
9019 
          self.scx = ShoppingCartException()
9020 
          self.scx.read(iprot)
9021 
        else:
9022 
          iprot.skip(ftype)
94 ashish 9023 
      else:
9024 
        iprot.skip(ftype)
9025 
      iprot.readFieldEnd()
9026 
    iprot.readStructEnd()
9027 
 
9028 
  def write(self, oprot):
9029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9031 
      return
559 chandransh 9032 
    oprot.writeStructBegin('createCart_result')
9033 
    if self.success != None:
9034 
      oprot.writeFieldBegin('success', TType.I64, 0)
9035 
      oprot.writeI64(self.success)
94 ashish 9036 
      oprot.writeFieldEnd()
559 chandransh 9037 
    if self.scx != None:
9038 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9039 
      self.scx.write(oprot)
94 ashish 9040 
      oprot.writeFieldEnd()
9041 
    oprot.writeFieldStop()
9042 
    oprot.writeStructEnd()
9043 
 
9044 
  def __repr__(self):
9045 
    L = ['%s=%r' % (key, value)
9046 
      for key, value in self.__dict__.iteritems()]
9047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9048 
 
9049 
  def __eq__(self, other):
9050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9051 
 
9052 
  def __ne__(self, other):
9053 
    return not (self == other)
9054 
 
559 chandransh 9055 
class getCurrentCart_args:
94 ashish 9056 
  """
9057 
  Attributes:
559 chandransh 9058 
   - userId
9059 
  """
9060 
 
9061 
  thrift_spec = (
9062 
    None, # 0
9063 
    (1, TType.I64, 'userId', None, None, ), # 1
9064 
  )
9065 
 
9066 
  def __init__(self, userId=None,):
9067 
    self.userId = userId
9068 
 
9069 
  def read(self, iprot):
9070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9072 
      return
9073 
    iprot.readStructBegin()
9074 
    while True:
9075 
      (fname, ftype, fid) = iprot.readFieldBegin()
9076 
      if ftype == TType.STOP:
9077 
        break
9078 
      if fid == 1:
9079 
        if ftype == TType.I64:
9080 
          self.userId = iprot.readI64();
9081 
        else:
9082 
          iprot.skip(ftype)
9083 
      else:
9084 
        iprot.skip(ftype)
9085 
      iprot.readFieldEnd()
9086 
    iprot.readStructEnd()
9087 
 
9088 
  def write(self, oprot):
9089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9091 
      return
9092 
    oprot.writeStructBegin('getCurrentCart_args')
9093 
    if self.userId != None:
9094 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9095 
      oprot.writeI64(self.userId)
9096 
      oprot.writeFieldEnd()
9097 
    oprot.writeFieldStop()
9098 
    oprot.writeStructEnd()
9099 
 
9100 
  def __repr__(self):
9101 
    L = ['%s=%r' % (key, value)
9102 
      for key, value in self.__dict__.iteritems()]
9103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9104 
 
9105 
  def __eq__(self, other):
9106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9107 
 
9108 
  def __ne__(self, other):
9109 
    return not (self == other)
9110 
 
9111 
class getCurrentCart_result:
9112 
  """
9113 
  Attributes:
94 ashish 9114 
   - success
559 chandransh 9115 
   - scx
94 ashish 9116 
  """
9117 
 
9118 
  thrift_spec = (
559 chandransh 9119 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9120 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9121 
  )
9122 
 
559 chandransh 9123 
  def __init__(self, success=None, scx=None,):
94 ashish 9124 
    self.success = success
559 chandransh 9125 
    self.scx = scx
94 ashish 9126 
 
9127 
  def read(self, iprot):
9128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9130 
      return
9131 
    iprot.readStructBegin()
9132 
    while True:
9133 
      (fname, ftype, fid) = iprot.readFieldBegin()
9134 
      if ftype == TType.STOP:
9135 
        break
9136 
      if fid == 0:
559 chandransh 9137 
        if ftype == TType.STRUCT:
9138 
          self.success = Cart()
9139 
          self.success.read(iprot)
94 ashish 9140 
        else:
9141 
          iprot.skip(ftype)
9142 
      elif fid == 1:
9143 
        if ftype == TType.STRUCT:
559 chandransh 9144 
          self.scx = ShoppingCartException()
9145 
          self.scx.read(iprot)
94 ashish 9146 
        else:
9147 
          iprot.skip(ftype)
9148 
      else:
9149 
        iprot.skip(ftype)
9150 
      iprot.readFieldEnd()
9151 
    iprot.readStructEnd()
9152 
 
9153 
  def write(self, oprot):
9154 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9155 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9156 
      return
559 chandransh 9157 
    oprot.writeStructBegin('getCurrentCart_result')
94 ashish 9158 
    if self.success != None:
559 chandransh 9159 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9160 
      self.success.write(oprot)
94 ashish 9161 
      oprot.writeFieldEnd()
559 chandransh 9162 
    if self.scx != None:
9163 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9164 
      self.scx.write(oprot)
94 ashish 9165 
      oprot.writeFieldEnd()
9166 
    oprot.writeFieldStop()
9167 
    oprot.writeStructEnd()
9168 
 
9169 
  def __repr__(self):
9170 
    L = ['%s=%r' % (key, value)
9171 
      for key, value in self.__dict__.iteritems()]
9172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9173 
 
9174 
  def __eq__(self, other):
9175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9176 
 
9177 
  def __ne__(self, other):
9178 
    return not (self == other)
9179 
 
559 chandransh 9180 
class getCart_args:
504 rajveer 9181 
  """
9182 
  Attributes:
559 chandransh 9183 
   - cartId
504 rajveer 9184 
  """
9185 
 
9186 
  thrift_spec = (
9187 
    None, # 0
559 chandransh 9188 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 9189 
  )
9190 
 
559 chandransh 9191 
  def __init__(self, cartId=None,):
9192 
    self.cartId = cartId
504 rajveer 9193 
 
9194 
  def read(self, iprot):
9195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9197 
      return
9198 
    iprot.readStructBegin()
9199 
    while True:
9200 
      (fname, ftype, fid) = iprot.readFieldBegin()
9201 
      if ftype == TType.STOP:
9202 
        break
9203 
      if fid == 1:
9204 
        if ftype == TType.I64:
559 chandransh 9205 
          self.cartId = iprot.readI64();
504 rajveer 9206 
        else:
9207 
          iprot.skip(ftype)
9208 
      else:
9209 
        iprot.skip(ftype)
9210 
      iprot.readFieldEnd()
9211 
    iprot.readStructEnd()
9212 
 
9213 
  def write(self, oprot):
9214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9216 
      return
559 chandransh 9217 
    oprot.writeStructBegin('getCart_args')
9218 
    if self.cartId != None:
9219 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9220 
      oprot.writeI64(self.cartId)
504 rajveer 9221 
      oprot.writeFieldEnd()
9222 
    oprot.writeFieldStop()
9223 
    oprot.writeStructEnd()
9224 
 
9225 
  def __repr__(self):
9226 
    L = ['%s=%r' % (key, value)
9227 
      for key, value in self.__dict__.iteritems()]
9228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9229 
 
9230 
  def __eq__(self, other):
9231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9232 
 
9233 
  def __ne__(self, other):
9234 
    return not (self == other)
9235 
 
559 chandransh 9236 
class getCart_result:
504 rajveer 9237 
  """
9238 
  Attributes:
9239 
   - success
559 chandransh 9240 
   - scx
504 rajveer 9241 
  """
9242 
 
9243 
  thrift_spec = (
559 chandransh 9244 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9245 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 9246 
  )
9247 
 
559 chandransh 9248 
  def __init__(self, success=None, scx=None,):
504 rajveer 9249 
    self.success = success
559 chandransh 9250 
    self.scx = scx
504 rajveer 9251 
 
9252 
  def read(self, iprot):
9253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9255 
      return
9256 
    iprot.readStructBegin()
9257 
    while True:
9258 
      (fname, ftype, fid) = iprot.readFieldBegin()
9259 
      if ftype == TType.STOP:
9260 
        break
9261 
      if fid == 0:
559 chandransh 9262 
        if ftype == TType.STRUCT:
9263 
          self.success = Cart()
9264 
          self.success.read(iprot)
504 rajveer 9265 
        else:
9266 
          iprot.skip(ftype)
9267 
      elif fid == 1:
9268 
        if ftype == TType.STRUCT:
559 chandransh 9269 
          self.scx = ShoppingCartException()
9270 
          self.scx.read(iprot)
504 rajveer 9271 
        else:
9272 
          iprot.skip(ftype)
9273 
      else:
9274 
        iprot.skip(ftype)
9275 
      iprot.readFieldEnd()
9276 
    iprot.readStructEnd()
9277 
 
9278 
  def write(self, oprot):
9279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9281 
      return
559 chandransh 9282 
    oprot.writeStructBegin('getCart_result')
504 rajveer 9283 
    if self.success != None:
559 chandransh 9284 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9285 
      self.success.write(oprot)
504 rajveer 9286 
      oprot.writeFieldEnd()
559 chandransh 9287 
    if self.scx != None:
9288 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9289 
      self.scx.write(oprot)
504 rajveer 9290 
      oprot.writeFieldEnd()
9291 
    oprot.writeFieldStop()
9292 
    oprot.writeStructEnd()
9293 
 
9294 
  def __repr__(self):
9295 
    L = ['%s=%r' % (key, value)
9296 
      for key, value in self.__dict__.iteritems()]
9297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9298 
 
9299 
  def __eq__(self, other):
9300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9301 
 
9302 
  def __ne__(self, other):
9303 
    return not (self == other)
9304 
 
559 chandransh 9305 
class getCartsForUser_args:
94 ashish 9306 
  """
9307 
  Attributes:
559 chandransh 9308 
   - userId
9309 
   - status
94 ashish 9310 
  """
9311 
 
9312 
  thrift_spec = (
9313 
    None, # 0
559 chandransh 9314 
    (1, TType.I64, 'userId', None, None, ), # 1
9315 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 9316 
  )
9317 
 
559 chandransh 9318 
  def __init__(self, userId=None, status=None,):
9319 
    self.userId = userId
9320 
    self.status = status
94 ashish 9321 
 
9322 
  def read(self, iprot):
9323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9325 
      return
9326 
    iprot.readStructBegin()
9327 
    while True:
9328 
      (fname, ftype, fid) = iprot.readFieldBegin()
9329 
      if ftype == TType.STOP:
9330 
        break
9331 
      if fid == 1:
9332 
        if ftype == TType.I64:
559 chandransh 9333 
          self.userId = iprot.readI64();
94 ashish 9334 
        else:
9335 
          iprot.skip(ftype)
9336 
      elif fid == 2:
559 chandransh 9337 
        if ftype == TType.I32:
9338 
          self.status = iprot.readI32();
94 ashish 9339 
        else:
9340 
          iprot.skip(ftype)
9341 
      else:
9342 
        iprot.skip(ftype)
9343 
      iprot.readFieldEnd()
9344 
    iprot.readStructEnd()
9345 
 
9346 
  def write(self, oprot):
9347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9349 
      return
559 chandransh 9350 
    oprot.writeStructBegin('getCartsForUser_args')
9351 
    if self.userId != None:
9352 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9353 
      oprot.writeI64(self.userId)
94 ashish 9354 
      oprot.writeFieldEnd()
559 chandransh 9355 
    if self.status != None:
9356 
      oprot.writeFieldBegin('status', TType.I32, 2)
9357 
      oprot.writeI32(self.status)
94 ashish 9358 
      oprot.writeFieldEnd()
9359 
    oprot.writeFieldStop()
9360 
    oprot.writeStructEnd()
9361 
 
9362 
  def __repr__(self):
9363 
    L = ['%s=%r' % (key, value)
9364 
      for key, value in self.__dict__.iteritems()]
9365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9366 
 
9367 
  def __eq__(self, other):
9368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9369 
 
9370 
  def __ne__(self, other):
9371 
    return not (self == other)
9372 
 
559 chandransh 9373 
class getCartsForUser_result:
94 ashish 9374 
  """
9375 
  Attributes:
9376 
   - success
559 chandransh 9377 
   - scx
94 ashish 9378 
  """
9379 
 
9380 
  thrift_spec = (
559 chandransh 9381 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9382 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9383 
  )
9384 
 
559 chandransh 9385 
  def __init__(self, success=None, scx=None,):
94 ashish 9386 
    self.success = success
559 chandransh 9387 
    self.scx = scx
94 ashish 9388 
 
9389 
  def read(self, iprot):
9390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9392 
      return
9393 
    iprot.readStructBegin()
9394 
    while True:
9395 
      (fname, ftype, fid) = iprot.readFieldBegin()
9396 
      if ftype == TType.STOP:
9397 
        break
9398 
      if fid == 0:
559 chandransh 9399 
        if ftype == TType.LIST:
9400 
          self.success = []
1996 vikas 9401 
          (_etype94, _size91) = iprot.readListBegin()
9402 
          for _i95 in xrange(_size91):
9403 
            _elem96 = Cart()
9404 
            _elem96.read(iprot)
9405 
            self.success.append(_elem96)
559 chandransh 9406 
          iprot.readListEnd()
94 ashish 9407 
        else:
9408 
          iprot.skip(ftype)
9409 
      elif fid == 1:
9410 
        if ftype == TType.STRUCT:
559 chandransh 9411 
          self.scx = ShoppingCartException()
9412 
          self.scx.read(iprot)
94 ashish 9413 
        else:
9414 
          iprot.skip(ftype)
9415 
      else:
9416 
        iprot.skip(ftype)
9417 
      iprot.readFieldEnd()
9418 
    iprot.readStructEnd()
9419 
 
9420 
  def write(self, oprot):
9421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9423 
      return
559 chandransh 9424 
    oprot.writeStructBegin('getCartsForUser_result')
94 ashish 9425 
    if self.success != None:
559 chandransh 9426 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9427 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 9428 
      for iter97 in self.success:
9429 
        iter97.write(oprot)
559 chandransh 9430 
      oprot.writeListEnd()
94 ashish 9431 
      oprot.writeFieldEnd()
559 chandransh 9432 
    if self.scx != None:
9433 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9434 
      self.scx.write(oprot)
94 ashish 9435 
      oprot.writeFieldEnd()
9436 
    oprot.writeFieldStop()
9437 
    oprot.writeStructEnd()
9438 
 
9439 
  def __repr__(self):
9440 
    L = ['%s=%r' % (key, value)
9441 
      for key, value in self.__dict__.iteritems()]
9442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9443 
 
9444 
  def __eq__(self, other):
9445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9446 
 
9447 
  def __ne__(self, other):
9448 
    return not (self == other)
9449 
 
559 chandransh 9450 
class getCartsByStatus_args:
94 ashish 9451 
  """
9452 
  Attributes:
559 chandransh 9453 
   - status
94 ashish 9454 
  """
9455 
 
9456 
  thrift_spec = (
9457 
    None, # 0
559 chandransh 9458 
    (1, TType.I32, 'status', None, None, ), # 1
94 ashish 9459 
  )
9460 
 
559 chandransh 9461 
  def __init__(self, status=None,):
9462 
    self.status = status
94 ashish 9463 
 
9464 
  def read(self, iprot):
9465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9467 
      return
9468 
    iprot.readStructBegin()
9469 
    while True:
9470 
      (fname, ftype, fid) = iprot.readFieldBegin()
9471 
      if ftype == TType.STOP:
9472 
        break
9473 
      if fid == 1:
559 chandransh 9474 
        if ftype == TType.I32:
9475 
          self.status = iprot.readI32();
9476 
        else:
9477 
          iprot.skip(ftype)
9478 
      else:
9479 
        iprot.skip(ftype)
9480 
      iprot.readFieldEnd()
9481 
    iprot.readStructEnd()
9482 
 
9483 
  def write(self, oprot):
9484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9486 
      return
9487 
    oprot.writeStructBegin('getCartsByStatus_args')
9488 
    if self.status != None:
9489 
      oprot.writeFieldBegin('status', TType.I32, 1)
9490 
      oprot.writeI32(self.status)
9491 
      oprot.writeFieldEnd()
9492 
    oprot.writeFieldStop()
9493 
    oprot.writeStructEnd()
9494 
 
9495 
  def __repr__(self):
9496 
    L = ['%s=%r' % (key, value)
9497 
      for key, value in self.__dict__.iteritems()]
9498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9499 
 
9500 
  def __eq__(self, other):
9501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9502 
 
9503 
  def __ne__(self, other):
9504 
    return not (self == other)
9505 
 
9506 
class getCartsByStatus_result:
9507 
  """
9508 
  Attributes:
9509 
   - success
9510 
   - scx
9511 
  """
9512 
 
9513 
  thrift_spec = (
9514 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9515 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9516 
  )
9517 
 
9518 
  def __init__(self, success=None, scx=None,):
9519 
    self.success = success
9520 
    self.scx = scx
9521 
 
9522 
  def read(self, iprot):
9523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9525 
      return
9526 
    iprot.readStructBegin()
9527 
    while True:
9528 
      (fname, ftype, fid) = iprot.readFieldBegin()
9529 
      if ftype == TType.STOP:
9530 
        break
9531 
      if fid == 0:
9532 
        if ftype == TType.LIST:
9533 
          self.success = []
1996 vikas 9534 
          (_etype101, _size98) = iprot.readListBegin()
9535 
          for _i102 in xrange(_size98):
9536 
            _elem103 = Cart()
9537 
            _elem103.read(iprot)
9538 
            self.success.append(_elem103)
559 chandransh 9539 
          iprot.readListEnd()
9540 
        else:
9541 
          iprot.skip(ftype)
9542 
      elif fid == 1:
9543 
        if ftype == TType.STRUCT:
9544 
          self.scx = ShoppingCartException()
9545 
          self.scx.read(iprot)
9546 
        else:
9547 
          iprot.skip(ftype)
9548 
      else:
9549 
        iprot.skip(ftype)
9550 
      iprot.readFieldEnd()
9551 
    iprot.readStructEnd()
9552 
 
9553 
  def write(self, oprot):
9554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9556 
      return
9557 
    oprot.writeStructBegin('getCartsByStatus_result')
9558 
    if self.success != None:
9559 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9560 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 9561 
      for iter104 in self.success:
9562 
        iter104.write(oprot)
559 chandransh 9563 
      oprot.writeListEnd()
9564 
      oprot.writeFieldEnd()
9565 
    if self.scx != None:
9566 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9567 
      self.scx.write(oprot)
9568 
      oprot.writeFieldEnd()
9569 
    oprot.writeFieldStop()
9570 
    oprot.writeStructEnd()
9571 
 
9572 
  def __repr__(self):
9573 
    L = ['%s=%r' % (key, value)
9574 
      for key, value in self.__dict__.iteritems()]
9575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9576 
 
9577 
  def __eq__(self, other):
9578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9579 
 
9580 
  def __ne__(self, other):
9581 
    return not (self == other)
9582 
 
9583 
class getCartsByTime_args:
9584 
  """
9585 
  Attributes:
9586 
   - from_time
9587 
   - to_time
9588 
   - status
9589 
  """
9590 
 
9591 
  thrift_spec = (
9592 
    None, # 0
9593 
    (1, TType.I64, 'from_time', None, None, ), # 1
9594 
    (2, TType.I64, 'to_time', None, None, ), # 2
9595 
    (3, TType.I32, 'status', None, None, ), # 3
9596 
  )
9597 
 
9598 
  def __init__(self, from_time=None, to_time=None, status=None,):
9599 
    self.from_time = from_time
9600 
    self.to_time = to_time
9601 
    self.status = status
9602 
 
9603 
  def read(self, iprot):
9604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9606 
      return
9607 
    iprot.readStructBegin()
9608 
    while True:
9609 
      (fname, ftype, fid) = iprot.readFieldBegin()
9610 
      if ftype == TType.STOP:
9611 
        break
9612 
      if fid == 1:
94 ashish 9613 
        if ftype == TType.I64:
559 chandransh 9614 
          self.from_time = iprot.readI64();
94 ashish 9615 
        else:
9616 
          iprot.skip(ftype)
122 ashish 9617 
      elif fid == 2:
559 chandransh 9618 
        if ftype == TType.I64:
9619 
          self.to_time = iprot.readI64();
122 ashish 9620 
        else:
9621 
          iprot.skip(ftype)
559 chandransh 9622 
      elif fid == 3:
9623 
        if ftype == TType.I32:
9624 
          self.status = iprot.readI32();
9625 
        else:
9626 
          iprot.skip(ftype)
94 ashish 9627 
      else:
9628 
        iprot.skip(ftype)
9629 
      iprot.readFieldEnd()
9630 
    iprot.readStructEnd()
9631 
 
9632 
  def write(self, oprot):
9633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9635 
      return
559 chandransh 9636 
    oprot.writeStructBegin('getCartsByTime_args')
9637 
    if self.from_time != None:
9638 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
9639 
      oprot.writeI64(self.from_time)
94 ashish 9640 
      oprot.writeFieldEnd()
559 chandransh 9641 
    if self.to_time != None:
9642 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
9643 
      oprot.writeI64(self.to_time)
122 ashish 9644 
      oprot.writeFieldEnd()
559 chandransh 9645 
    if self.status != None:
9646 
      oprot.writeFieldBegin('status', TType.I32, 3)
9647 
      oprot.writeI32(self.status)
9648 
      oprot.writeFieldEnd()
94 ashish 9649 
    oprot.writeFieldStop()
9650 
    oprot.writeStructEnd()
9651 
 
9652 
  def __repr__(self):
9653 
    L = ['%s=%r' % (key, value)
9654 
      for key, value in self.__dict__.iteritems()]
9655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9656 
 
9657 
  def __eq__(self, other):
9658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9659 
 
9660 
  def __ne__(self, other):
9661 
    return not (self == other)
9662 
 
559 chandransh 9663 
class getCartsByTime_result:
94 ashish 9664 
  """
9665 
  Attributes:
9666 
   - success
559 chandransh 9667 
   - scx
94 ashish 9668 
  """
9669 
 
9670 
  thrift_spec = (
559 chandransh 9671 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9672 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9673 
  )
9674 
 
559 chandransh 9675 
  def __init__(self, success=None, scx=None,):
94 ashish 9676 
    self.success = success
559 chandransh 9677 
    self.scx = scx
94 ashish 9678 
 
9679 
  def read(self, iprot):
9680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9682 
      return
9683 
    iprot.readStructBegin()
9684 
    while True:
9685 
      (fname, ftype, fid) = iprot.readFieldBegin()
9686 
      if ftype == TType.STOP:
9687 
        break
9688 
      if fid == 0:
559 chandransh 9689 
        if ftype == TType.LIST:
9690 
          self.success = []
1996 vikas 9691 
          (_etype108, _size105) = iprot.readListBegin()
9692 
          for _i109 in xrange(_size105):
9693 
            _elem110 = Cart()
9694 
            _elem110.read(iprot)
9695 
            self.success.append(_elem110)
559 chandransh 9696 
          iprot.readListEnd()
94 ashish 9697 
        else:
9698 
          iprot.skip(ftype)
9699 
      elif fid == 1:
9700 
        if ftype == TType.STRUCT:
559 chandransh 9701 
          self.scx = ShoppingCartException()
9702 
          self.scx.read(iprot)
94 ashish 9703 
        else:
9704 
          iprot.skip(ftype)
9705 
      else:
9706 
        iprot.skip(ftype)
9707 
      iprot.readFieldEnd()
9708 
    iprot.readStructEnd()
9709 
 
9710 
  def write(self, oprot):
9711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9713 
      return
559 chandransh 9714 
    oprot.writeStructBegin('getCartsByTime_result')
94 ashish 9715 
    if self.success != None:
559 chandransh 9716 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9717 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 9718 
      for iter111 in self.success:
9719 
        iter111.write(oprot)
559 chandransh 9720 
      oprot.writeListEnd()
94 ashish 9721 
      oprot.writeFieldEnd()
559 chandransh 9722 
    if self.scx != None:
9723 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9724 
      self.scx.write(oprot)
94 ashish 9725 
      oprot.writeFieldEnd()
9726 
    oprot.writeFieldStop()
9727 
    oprot.writeStructEnd()
9728 
 
9729 
  def __repr__(self):
9730 
    L = ['%s=%r' % (key, value)
9731 
      for key, value in self.__dict__.iteritems()]
9732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9733 
 
9734 
  def __eq__(self, other):
9735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9736 
 
9737 
  def __ne__(self, other):
9738 
    return not (self == other)
9739 
 
559 chandransh 9740 
class changeCartStatus_args:
94 ashish 9741 
  """
9742 
  Attributes:
559 chandransh 9743 
   - cartId
9744 
   - status
94 ashish 9745 
  """
9746 
 
9747 
  thrift_spec = (
9748 
    None, # 0
559 chandransh 9749 
    (1, TType.I64, 'cartId', None, None, ), # 1
9750 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 9751 
  )
9752 
 
559 chandransh 9753 
  def __init__(self, cartId=None, status=None,):
9754 
    self.cartId = cartId
9755 
    self.status = status
94 ashish 9756 
 
9757 
  def read(self, iprot):
9758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9760 
      return
9761 
    iprot.readStructBegin()
9762 
    while True:
9763 
      (fname, ftype, fid) = iprot.readFieldBegin()
9764 
      if ftype == TType.STOP:
9765 
        break
9766 
      if fid == 1:
9767 
        if ftype == TType.I64:
559 chandransh 9768 
          self.cartId = iprot.readI64();
94 ashish 9769 
        else:
9770 
          iprot.skip(ftype)
559 chandransh 9771 
      elif fid == 2:
9772 
        if ftype == TType.I32:
9773 
          self.status = iprot.readI32();
9774 
        else:
9775 
          iprot.skip(ftype)
94 ashish 9776 
      else:
9777 
        iprot.skip(ftype)
9778 
      iprot.readFieldEnd()
9779 
    iprot.readStructEnd()
9780 
 
9781 
  def write(self, oprot):
9782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9784 
      return
559 chandransh 9785 
    oprot.writeStructBegin('changeCartStatus_args')
9786 
    if self.cartId != None:
9787 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9788 
      oprot.writeI64(self.cartId)
94 ashish 9789 
      oprot.writeFieldEnd()
559 chandransh 9790 
    if self.status != None:
9791 
      oprot.writeFieldBegin('status', TType.I32, 2)
9792 
      oprot.writeI32(self.status)
9793 
      oprot.writeFieldEnd()
94 ashish 9794 
    oprot.writeFieldStop()
9795 
    oprot.writeStructEnd()
9796 
 
9797 
  def __repr__(self):
9798 
    L = ['%s=%r' % (key, value)
9799 
      for key, value in self.__dict__.iteritems()]
9800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9801 
 
9802 
  def __eq__(self, other):
9803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9804 
 
9805 
  def __ne__(self, other):
9806 
    return not (self == other)
9807 
 
559 chandransh 9808 
class changeCartStatus_result:
94 ashish 9809 
  """
9810 
  Attributes:
559 chandransh 9811 
   - scx
9812 
  """
9813 
 
9814 
  thrift_spec = (
9815 
    None, # 0
9816 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9817 
  )
9818 
 
9819 
  def __init__(self, scx=None,):
9820 
    self.scx = scx
9821 
 
9822 
  def read(self, iprot):
9823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9825 
      return
9826 
    iprot.readStructBegin()
9827 
    while True:
9828 
      (fname, ftype, fid) = iprot.readFieldBegin()
9829 
      if ftype == TType.STOP:
9830 
        break
9831 
      if fid == 1:
9832 
        if ftype == TType.STRUCT:
9833 
          self.scx = ShoppingCartException()
9834 
          self.scx.read(iprot)
9835 
        else:
9836 
          iprot.skip(ftype)
9837 
      else:
9838 
        iprot.skip(ftype)
9839 
      iprot.readFieldEnd()
9840 
    iprot.readStructEnd()
9841 
 
9842 
  def write(self, oprot):
9843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9845 
      return
9846 
    oprot.writeStructBegin('changeCartStatus_result')
9847 
    if self.scx != None:
9848 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9849 
      self.scx.write(oprot)
9850 
      oprot.writeFieldEnd()
9851 
    oprot.writeFieldStop()
9852 
    oprot.writeStructEnd()
9853 
 
9854 
  def __repr__(self):
9855 
    L = ['%s=%r' % (key, value)
9856 
      for key, value in self.__dict__.iteritems()]
9857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9858 
 
9859 
  def __eq__(self, other):
9860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9861 
 
9862 
  def __ne__(self, other):
9863 
    return not (self == other)
9864 
 
9865 
class addItemToCart_args:
9866 
  """
9867 
  Attributes:
9868 
   - cartId
9869 
   - itemId
9870 
   - quantity
9871 
  """
9872 
 
9873 
  thrift_spec = (
9874 
    None, # 0
9875 
    (1, TType.I64, 'cartId', None, None, ), # 1
9876 
    (2, TType.I64, 'itemId', None, None, ), # 2
9877 
    (3, TType.I64, 'quantity', None, None, ), # 3
9878 
  )
9879 
 
9880 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
9881 
    self.cartId = cartId
9882 
    self.itemId = itemId
9883 
    self.quantity = quantity
9884 
 
9885 
  def read(self, iprot):
9886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9888 
      return
9889 
    iprot.readStructBegin()
9890 
    while True:
9891 
      (fname, ftype, fid) = iprot.readFieldBegin()
9892 
      if ftype == TType.STOP:
9893 
        break
9894 
      if fid == 1:
9895 
        if ftype == TType.I64:
9896 
          self.cartId = iprot.readI64();
9897 
        else:
9898 
          iprot.skip(ftype)
9899 
      elif fid == 2:
9900 
        if ftype == TType.I64:
9901 
          self.itemId = iprot.readI64();
9902 
        else:
9903 
          iprot.skip(ftype)
9904 
      elif fid == 3:
9905 
        if ftype == TType.I64:
9906 
          self.quantity = iprot.readI64();
9907 
        else:
9908 
          iprot.skip(ftype)
9909 
      else:
9910 
        iprot.skip(ftype)
9911 
      iprot.readFieldEnd()
9912 
    iprot.readStructEnd()
9913 
 
9914 
  def write(self, oprot):
9915 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9916 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9917 
      return
9918 
    oprot.writeStructBegin('addItemToCart_args')
9919 
    if self.cartId != None:
9920 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9921 
      oprot.writeI64(self.cartId)
9922 
      oprot.writeFieldEnd()
9923 
    if self.itemId != None:
9924 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
9925 
      oprot.writeI64(self.itemId)
9926 
      oprot.writeFieldEnd()
9927 
    if self.quantity != None:
9928 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
9929 
      oprot.writeI64(self.quantity)
9930 
      oprot.writeFieldEnd()
9931 
    oprot.writeFieldStop()
9932 
    oprot.writeStructEnd()
9933 
 
9934 
  def __repr__(self):
9935 
    L = ['%s=%r' % (key, value)
9936 
      for key, value in self.__dict__.iteritems()]
9937 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9938 
 
9939 
  def __eq__(self, other):
9940 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9941 
 
9942 
  def __ne__(self, other):
9943 
    return not (self == other)
9944 
 
9945 
class addItemToCart_result:
9946 
  """
9947 
  Attributes:
9948 
   - scx
9949 
  """
9950 
 
9951 
  thrift_spec = (
9952 
    None, # 0
9953 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9954 
  )
9955 
 
9956 
  def __init__(self, scx=None,):
9957 
    self.scx = scx
9958 
 
9959 
  def read(self, iprot):
9960 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9961 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9962 
      return
9963 
    iprot.readStructBegin()
9964 
    while True:
9965 
      (fname, ftype, fid) = iprot.readFieldBegin()
9966 
      if ftype == TType.STOP:
9967 
        break
9968 
      if fid == 1:
9969 
        if ftype == TType.STRUCT:
9970 
          self.scx = ShoppingCartException()
9971 
          self.scx.read(iprot)
9972 
        else:
9973 
          iprot.skip(ftype)
9974 
      else:
9975 
        iprot.skip(ftype)
9976 
      iprot.readFieldEnd()
9977 
    iprot.readStructEnd()
9978 
 
9979 
  def write(self, oprot):
9980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9982 
      return
9983 
    oprot.writeStructBegin('addItemToCart_result')
9984 
    if self.scx != None:
9985 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9986 
      self.scx.write(oprot)
9987 
      oprot.writeFieldEnd()
9988 
    oprot.writeFieldStop()
9989 
    oprot.writeStructEnd()
9990 
 
9991 
  def __repr__(self):
9992 
    L = ['%s=%r' % (key, value)
9993 
      for key, value in self.__dict__.iteritems()]
9994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9995 
 
9996 
  def __eq__(self, other):
9997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9998 
 
9999 
  def __ne__(self, other):
10000 
    return not (self == other)
10001 
 
10002 
class deleteItemFromCart_args:
10003 
  """
10004 
  Attributes:
10005 
   - cartId
10006 
   - itemId
10007 
  """
10008 
 
10009 
  thrift_spec = (
10010 
    None, # 0
10011 
    (1, TType.I64, 'cartId', None, None, ), # 1
10012 
    (2, TType.I64, 'itemId', None, None, ), # 2
10013 
  )
10014 
 
10015 
  def __init__(self, cartId=None, itemId=None,):
10016 
    self.cartId = cartId
10017 
    self.itemId = itemId
10018 
 
10019 
  def read(self, iprot):
10020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10022 
      return
10023 
    iprot.readStructBegin()
10024 
    while True:
10025 
      (fname, ftype, fid) = iprot.readFieldBegin()
10026 
      if ftype == TType.STOP:
10027 
        break
10028 
      if fid == 1:
10029 
        if ftype == TType.I64:
10030 
          self.cartId = iprot.readI64();
10031 
        else:
10032 
          iprot.skip(ftype)
10033 
      elif fid == 2:
10034 
        if ftype == TType.I64:
10035 
          self.itemId = iprot.readI64();
10036 
        else:
10037 
          iprot.skip(ftype)
10038 
      else:
10039 
        iprot.skip(ftype)
10040 
      iprot.readFieldEnd()
10041 
    iprot.readStructEnd()
10042 
 
10043 
  def write(self, oprot):
10044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10046 
      return
10047 
    oprot.writeStructBegin('deleteItemFromCart_args')
10048 
    if self.cartId != None:
10049 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10050 
      oprot.writeI64(self.cartId)
10051 
      oprot.writeFieldEnd()
10052 
    if self.itemId != None:
10053 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10054 
      oprot.writeI64(self.itemId)
10055 
      oprot.writeFieldEnd()
10056 
    oprot.writeFieldStop()
10057 
    oprot.writeStructEnd()
10058 
 
10059 
  def __repr__(self):
10060 
    L = ['%s=%r' % (key, value)
10061 
      for key, value in self.__dict__.iteritems()]
10062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10063 
 
10064 
  def __eq__(self, other):
10065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10066 
 
10067 
  def __ne__(self, other):
10068 
    return not (self == other)
10069 
 
10070 
class deleteItemFromCart_result:
10071 
  """
10072 
  Attributes:
10073 
   - scx
10074 
  """
10075 
 
10076 
  thrift_spec = (
10077 
    None, # 0
10078 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10079 
  )
10080 
 
10081 
  def __init__(self, scx=None,):
10082 
    self.scx = scx
10083 
 
10084 
  def read(self, iprot):
10085 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10086 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10087 
      return
10088 
    iprot.readStructBegin()
10089 
    while True:
10090 
      (fname, ftype, fid) = iprot.readFieldBegin()
10091 
      if ftype == TType.STOP:
10092 
        break
10093 
      if fid == 1:
10094 
        if ftype == TType.STRUCT:
10095 
          self.scx = ShoppingCartException()
10096 
          self.scx.read(iprot)
10097 
        else:
10098 
          iprot.skip(ftype)
10099 
      else:
10100 
        iprot.skip(ftype)
10101 
      iprot.readFieldEnd()
10102 
    iprot.readStructEnd()
10103 
 
10104 
  def write(self, oprot):
10105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10107 
      return
10108 
    oprot.writeStructBegin('deleteItemFromCart_result')
10109 
    if self.scx != None:
10110 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10111 
      self.scx.write(oprot)
10112 
      oprot.writeFieldEnd()
10113 
    oprot.writeFieldStop()
10114 
    oprot.writeStructEnd()
10115 
 
10116 
  def __repr__(self):
10117 
    L = ['%s=%r' % (key, value)
10118 
      for key, value in self.__dict__.iteritems()]
10119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10120 
 
10121 
  def __eq__(self, other):
10122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10123 
 
10124 
  def __ne__(self, other):
10125 
    return not (self == other)
10126 
 
10127 
class changeQuantity_args:
10128 
  """
10129 
  Attributes:
10130 
   - cartId
10131 
   - itemId
10132 
   - quantity
10133 
  """
10134 
 
10135 
  thrift_spec = (
10136 
    None, # 0
10137 
    (1, TType.I64, 'cartId', None, None, ), # 1
10138 
    (2, TType.I64, 'itemId', None, None, ), # 2
10139 
    (3, TType.I64, 'quantity', None, None, ), # 3
10140 
  )
10141 
 
10142 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
10143 
    self.cartId = cartId
10144 
    self.itemId = itemId
10145 
    self.quantity = quantity
10146 
 
10147 
  def read(self, iprot):
10148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10150 
      return
10151 
    iprot.readStructBegin()
10152 
    while True:
10153 
      (fname, ftype, fid) = iprot.readFieldBegin()
10154 
      if ftype == TType.STOP:
10155 
        break
10156 
      if fid == 1:
10157 
        if ftype == TType.I64:
10158 
          self.cartId = iprot.readI64();
10159 
        else:
10160 
          iprot.skip(ftype)
10161 
      elif fid == 2:
10162 
        if ftype == TType.I64:
10163 
          self.itemId = iprot.readI64();
10164 
        else:
10165 
          iprot.skip(ftype)
10166 
      elif fid == 3:
10167 
        if ftype == TType.I64:
10168 
          self.quantity = iprot.readI64();
10169 
        else:
10170 
          iprot.skip(ftype)
10171 
      else:
10172 
        iprot.skip(ftype)
10173 
      iprot.readFieldEnd()
10174 
    iprot.readStructEnd()
10175 
 
10176 
  def write(self, oprot):
10177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10179 
      return
10180 
    oprot.writeStructBegin('changeQuantity_args')
10181 
    if self.cartId != None:
10182 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10183 
      oprot.writeI64(self.cartId)
10184 
      oprot.writeFieldEnd()
10185 
    if self.itemId != None:
10186 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10187 
      oprot.writeI64(self.itemId)
10188 
      oprot.writeFieldEnd()
10189 
    if self.quantity != None:
10190 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10191 
      oprot.writeI64(self.quantity)
10192 
      oprot.writeFieldEnd()
10193 
    oprot.writeFieldStop()
10194 
    oprot.writeStructEnd()
10195 
 
10196 
  def __repr__(self):
10197 
    L = ['%s=%r' % (key, value)
10198 
      for key, value in self.__dict__.iteritems()]
10199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10200 
 
10201 
  def __eq__(self, other):
10202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10203 
 
10204 
  def __ne__(self, other):
10205 
    return not (self == other)
10206 
 
10207 
class changeQuantity_result:
10208 
  """
10209 
  Attributes:
10210 
   - scx
10211 
  """
10212 
 
10213 
  thrift_spec = (
10214 
    None, # 0
10215 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10216 
  )
10217 
 
10218 
  def __init__(self, scx=None,):
10219 
    self.scx = scx
10220 
 
10221 
  def read(self, iprot):
10222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10224 
      return
10225 
    iprot.readStructBegin()
10226 
    while True:
10227 
      (fname, ftype, fid) = iprot.readFieldBegin()
10228 
      if ftype == TType.STOP:
10229 
        break
10230 
      if fid == 1:
10231 
        if ftype == TType.STRUCT:
10232 
          self.scx = ShoppingCartException()
10233 
          self.scx.read(iprot)
10234 
        else:
10235 
          iprot.skip(ftype)
10236 
      else:
10237 
        iprot.skip(ftype)
10238 
      iprot.readFieldEnd()
10239 
    iprot.readStructEnd()
10240 
 
10241 
  def write(self, oprot):
10242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10244 
      return
10245 
    oprot.writeStructBegin('changeQuantity_result')
10246 
    if self.scx != None:
10247 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10248 
      self.scx.write(oprot)
10249 
      oprot.writeFieldEnd()
10250 
    oprot.writeFieldStop()
10251 
    oprot.writeStructEnd()
10252 
 
10253 
  def __repr__(self):
10254 
    L = ['%s=%r' % (key, value)
10255 
      for key, value in self.__dict__.iteritems()]
10256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10257 
 
10258 
  def __eq__(self, other):
10259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10260 
 
10261 
  def __ne__(self, other):
10262 
    return not (self == other)
10263 
 
10264 
class changeItemStatus_args:
10265 
  """
10266 
  Attributes:
10267 
   - cartId
10268 
   - itemId
10269 
   - status
10270 
  """
10271 
 
10272 
  thrift_spec = (
10273 
    None, # 0
10274 
    (1, TType.I64, 'cartId', None, None, ), # 1
10275 
    (2, TType.I64, 'itemId', None, None, ), # 2
10276 
    (3, TType.I32, 'status', None, None, ), # 3
10277 
  )
10278 
 
10279 
  def __init__(self, cartId=None, itemId=None, status=None,):
10280 
    self.cartId = cartId
10281 
    self.itemId = itemId
10282 
    self.status = status
10283 
 
10284 
  def read(self, iprot):
10285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10287 
      return
10288 
    iprot.readStructBegin()
10289 
    while True:
10290 
      (fname, ftype, fid) = iprot.readFieldBegin()
10291 
      if ftype == TType.STOP:
10292 
        break
10293 
      if fid == 1:
10294 
        if ftype == TType.I64:
10295 
          self.cartId = iprot.readI64();
10296 
        else:
10297 
          iprot.skip(ftype)
10298 
      elif fid == 2:
10299 
        if ftype == TType.I64:
10300 
          self.itemId = iprot.readI64();
10301 
        else:
10302 
          iprot.skip(ftype)
10303 
      elif fid == 3:
10304 
        if ftype == TType.I32:
10305 
          self.status = iprot.readI32();
10306 
        else:
10307 
          iprot.skip(ftype)
10308 
      else:
10309 
        iprot.skip(ftype)
10310 
      iprot.readFieldEnd()
10311 
    iprot.readStructEnd()
10312 
 
10313 
  def write(self, oprot):
10314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10316 
      return
10317 
    oprot.writeStructBegin('changeItemStatus_args')
10318 
    if self.cartId != None:
10319 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10320 
      oprot.writeI64(self.cartId)
10321 
      oprot.writeFieldEnd()
10322 
    if self.itemId != None:
10323 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10324 
      oprot.writeI64(self.itemId)
10325 
      oprot.writeFieldEnd()
10326 
    if self.status != None:
10327 
      oprot.writeFieldBegin('status', TType.I32, 3)
10328 
      oprot.writeI32(self.status)
10329 
      oprot.writeFieldEnd()
10330 
    oprot.writeFieldStop()
10331 
    oprot.writeStructEnd()
10332 
 
10333 
  def __repr__(self):
10334 
    L = ['%s=%r' % (key, value)
10335 
      for key, value in self.__dict__.iteritems()]
10336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10337 
 
10338 
  def __eq__(self, other):
10339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10340 
 
10341 
  def __ne__(self, other):
10342 
    return not (self == other)
10343 
 
10344 
class changeItemStatus_result:
10345 
  """
10346 
  Attributes:
10347 
   - scx
10348 
  """
10349 
 
10350 
  thrift_spec = (
10351 
    None, # 0
10352 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10353 
  )
10354 
 
10355 
  def __init__(self, scx=None,):
10356 
    self.scx = scx
10357 
 
10358 
  def read(self, iprot):
10359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10361 
      return
10362 
    iprot.readStructBegin()
10363 
    while True:
10364 
      (fname, ftype, fid) = iprot.readFieldBegin()
10365 
      if ftype == TType.STOP:
10366 
        break
10367 
      if fid == 1:
10368 
        if ftype == TType.STRUCT:
10369 
          self.scx = ShoppingCartException()
10370 
          self.scx.read(iprot)
10371 
        else:
10372 
          iprot.skip(ftype)
10373 
      else:
10374 
        iprot.skip(ftype)
10375 
      iprot.readFieldEnd()
10376 
    iprot.readStructEnd()
10377 
 
10378 
  def write(self, oprot):
10379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10381 
      return
10382 
    oprot.writeStructBegin('changeItemStatus_result')
10383 
    if self.scx != None:
10384 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10385 
      self.scx.write(oprot)
10386 
      oprot.writeFieldEnd()
10387 
    oprot.writeFieldStop()
10388 
    oprot.writeStructEnd()
10389 
 
10390 
  def __repr__(self):
10391 
    L = ['%s=%r' % (key, value)
10392 
      for key, value in self.__dict__.iteritems()]
10393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10394 
 
10395 
  def __eq__(self, other):
10396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10397 
 
10398 
  def __ne__(self, other):
10399 
    return not (self == other)
10400 
 
10401 
class addAddressToCart_args:
10402 
  """
10403 
  Attributes:
10404 
   - cartId
10405 
   - addressId
10406 
  """
10407 
 
10408 
  thrift_spec = (
10409 
    None, # 0
10410 
    (1, TType.I64, 'cartId', None, None, ), # 1
10411 
    (2, TType.I64, 'addressId', None, None, ), # 2
10412 
  )
10413 
 
10414 
  def __init__(self, cartId=None, addressId=None,):
10415 
    self.cartId = cartId
10416 
    self.addressId = addressId
10417 
 
10418 
  def read(self, iprot):
10419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10421 
      return
10422 
    iprot.readStructBegin()
10423 
    while True:
10424 
      (fname, ftype, fid) = iprot.readFieldBegin()
10425 
      if ftype == TType.STOP:
10426 
        break
10427 
      if fid == 1:
10428 
        if ftype == TType.I64:
10429 
          self.cartId = iprot.readI64();
10430 
        else:
10431 
          iprot.skip(ftype)
10432 
      elif fid == 2:
10433 
        if ftype == TType.I64:
10434 
          self.addressId = iprot.readI64();
10435 
        else:
10436 
          iprot.skip(ftype)
10437 
      else:
10438 
        iprot.skip(ftype)
10439 
      iprot.readFieldEnd()
10440 
    iprot.readStructEnd()
10441 
 
10442 
  def write(self, oprot):
10443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10445 
      return
10446 
    oprot.writeStructBegin('addAddressToCart_args')
10447 
    if self.cartId != None:
10448 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10449 
      oprot.writeI64(self.cartId)
10450 
      oprot.writeFieldEnd()
10451 
    if self.addressId != None:
10452 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
10453 
      oprot.writeI64(self.addressId)
10454 
      oprot.writeFieldEnd()
10455 
    oprot.writeFieldStop()
10456 
    oprot.writeStructEnd()
10457 
 
10458 
  def __repr__(self):
10459 
    L = ['%s=%r' % (key, value)
10460 
      for key, value in self.__dict__.iteritems()]
10461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10462 
 
10463 
  def __eq__(self, other):
10464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10465 
 
10466 
  def __ne__(self, other):
10467 
    return not (self == other)
10468 
 
10469 
class addAddressToCart_result:
575 chandransh 10470 
  """
10471 
  Attributes:
10472 
   - scx
10473 
  """
559 chandransh 10474 
 
10475 
  thrift_spec = (
575 chandransh 10476 
    None, # 0
10477 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 10478 
  )
10479 
 
575 chandransh 10480 
  def __init__(self, scx=None,):
10481 
    self.scx = scx
10482 
 
559 chandransh 10483 
  def read(self, iprot):
10484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10486 
      return
10487 
    iprot.readStructBegin()
10488 
    while True:
10489 
      (fname, ftype, fid) = iprot.readFieldBegin()
10490 
      if ftype == TType.STOP:
10491 
        break
575 chandransh 10492 
      if fid == 1:
10493 
        if ftype == TType.STRUCT:
10494 
          self.scx = ShoppingCartException()
10495 
          self.scx.read(iprot)
10496 
        else:
10497 
          iprot.skip(ftype)
559 chandransh 10498 
      else:
10499 
        iprot.skip(ftype)
10500 
      iprot.readFieldEnd()
10501 
    iprot.readStructEnd()
10502 
 
10503 
  def write(self, oprot):
10504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10506 
      return
10507 
    oprot.writeStructBegin('addAddressToCart_result')
575 chandransh 10508 
    if self.scx != None:
10509 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10510 
      self.scx.write(oprot)
10511 
      oprot.writeFieldEnd()
559 chandransh 10512 
    oprot.writeFieldStop()
10513 
    oprot.writeStructEnd()
10514 
 
10515 
  def __repr__(self):
10516 
    L = ['%s=%r' % (key, value)
10517 
      for key, value in self.__dict__.iteritems()]
10518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10519 
 
10520 
  def __eq__(self, other):
10521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10522 
 
10523 
  def __ne__(self, other):
10524 
    return not (self == other)
10525 
 
1976 varun.gupt 10526 
class applyCouponToCart_args:
10527 
  """
10528 
  Attributes:
10529 
   - cartId
10530 
   - couponCode
10531 
   - totalPrice
10532 
   - discountedPrice
10533 
  """
10534 
 
10535 
  thrift_spec = (
10536 
    None, # 0
10537 
    (1, TType.I64, 'cartId', None, None, ), # 1
10538 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
10539 
    (3, TType.DOUBLE, 'totalPrice', None, None, ), # 3
10540 
    (4, TType.DOUBLE, 'discountedPrice', None, None, ), # 4
10541 
  )
10542 
 
10543 
  def __init__(self, cartId=None, couponCode=None, totalPrice=None, discountedPrice=None,):
10544 
    self.cartId = cartId
10545 
    self.couponCode = couponCode
10546 
    self.totalPrice = totalPrice
10547 
    self.discountedPrice = discountedPrice
10548 
 
10549 
  def read(self, iprot):
10550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10552 
      return
10553 
    iprot.readStructBegin()
10554 
    while True:
10555 
      (fname, ftype, fid) = iprot.readFieldBegin()
10556 
      if ftype == TType.STOP:
10557 
        break
10558 
      if fid == 1:
10559 
        if ftype == TType.I64:
10560 
          self.cartId = iprot.readI64();
10561 
        else:
10562 
          iprot.skip(ftype)
10563 
      elif fid == 2:
10564 
        if ftype == TType.STRING:
10565 
          self.couponCode = iprot.readString();
10566 
        else:
10567 
          iprot.skip(ftype)
10568 
      elif fid == 3:
10569 
        if ftype == TType.DOUBLE:
10570 
          self.totalPrice = iprot.readDouble();
10571 
        else:
10572 
          iprot.skip(ftype)
10573 
      elif fid == 4:
10574 
        if ftype == TType.DOUBLE:
10575 
          self.discountedPrice = iprot.readDouble();
10576 
        else:
10577 
          iprot.skip(ftype)
10578 
      else:
10579 
        iprot.skip(ftype)
10580 
      iprot.readFieldEnd()
10581 
    iprot.readStructEnd()
10582 
 
10583 
  def write(self, oprot):
10584 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10585 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10586 
      return
10587 
    oprot.writeStructBegin('applyCouponToCart_args')
10588 
    if self.cartId != None:
10589 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10590 
      oprot.writeI64(self.cartId)
10591 
      oprot.writeFieldEnd()
10592 
    if self.couponCode != None:
10593 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
10594 
      oprot.writeString(self.couponCode)
10595 
      oprot.writeFieldEnd()
10596 
    if self.totalPrice != None:
10597 
      oprot.writeFieldBegin('totalPrice', TType.DOUBLE, 3)
10598 
      oprot.writeDouble(self.totalPrice)
10599 
      oprot.writeFieldEnd()
10600 
    if self.discountedPrice != None:
10601 
      oprot.writeFieldBegin('discountedPrice', TType.DOUBLE, 4)
10602 
      oprot.writeDouble(self.discountedPrice)
10603 
      oprot.writeFieldEnd()
10604 
    oprot.writeFieldStop()
10605 
    oprot.writeStructEnd()
10606 
 
10607 
  def __repr__(self):
10608 
    L = ['%s=%r' % (key, value)
10609 
      for key, value in self.__dict__.iteritems()]
10610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10611 
 
10612 
  def __eq__(self, other):
10613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10614 
 
10615 
  def __ne__(self, other):
10616 
    return not (self == other)
10617 
 
10618 
class applyCouponToCart_result:
10619 
  """
10620 
  Attributes:
10621 
   - scx
10622 
  """
10623 
 
10624 
  thrift_spec = (
10625 
    None, # 0
10626 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10627 
  )
10628 
 
10629 
  def __init__(self, scx=None,):
10630 
    self.scx = scx
10631 
 
10632 
  def read(self, iprot):
10633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10635 
      return
10636 
    iprot.readStructBegin()
10637 
    while True:
10638 
      (fname, ftype, fid) = iprot.readFieldBegin()
10639 
      if ftype == TType.STOP:
10640 
        break
10641 
      if fid == 1:
10642 
        if ftype == TType.STRUCT:
10643 
          self.scx = ShoppingCartException()
10644 
          self.scx.read(iprot)
10645 
        else:
10646 
          iprot.skip(ftype)
10647 
      else:
10648 
        iprot.skip(ftype)
10649 
      iprot.readFieldEnd()
10650 
    iprot.readStructEnd()
10651 
 
10652 
  def write(self, oprot):
10653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10655 
      return
10656 
    oprot.writeStructBegin('applyCouponToCart_result')
10657 
    if self.scx != None:
10658 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10659 
      self.scx.write(oprot)
10660 
      oprot.writeFieldEnd()
10661 
    oprot.writeFieldStop()
10662 
    oprot.writeStructEnd()
10663 
 
10664 
  def __repr__(self):
10665 
    L = ['%s=%r' % (key, value)
10666 
      for key, value in self.__dict__.iteritems()]
10667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10668 
 
10669 
  def __eq__(self, other):
10670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10671 
 
10672 
  def __ne__(self, other):
10673 
    return not (self == other)
10674 
 
10675 
class removeCoupon_args:
10676 
  """
10677 
  Attributes:
10678 
   - cartId
10679 
  """
10680 
 
10681 
  thrift_spec = (
10682 
    None, # 0
10683 
    (1, TType.I64, 'cartId', None, None, ), # 1
10684 
  )
10685 
 
10686 
  def __init__(self, cartId=None,):
10687 
    self.cartId = cartId
10688 
 
10689 
  def read(self, iprot):
10690 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10691 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10692 
      return
10693 
    iprot.readStructBegin()
10694 
    while True:
10695 
      (fname, ftype, fid) = iprot.readFieldBegin()
10696 
      if ftype == TType.STOP:
10697 
        break
10698 
      if fid == 1:
10699 
        if ftype == TType.I64:
10700 
          self.cartId = iprot.readI64();
10701 
        else:
10702 
          iprot.skip(ftype)
10703 
      else:
10704 
        iprot.skip(ftype)
10705 
      iprot.readFieldEnd()
10706 
    iprot.readStructEnd()
10707 
 
10708 
  def write(self, oprot):
10709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10711 
      return
10712 
    oprot.writeStructBegin('removeCoupon_args')
10713 
    if self.cartId != None:
10714 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10715 
      oprot.writeI64(self.cartId)
10716 
      oprot.writeFieldEnd()
10717 
    oprot.writeFieldStop()
10718 
    oprot.writeStructEnd()
10719 
 
10720 
  def __repr__(self):
10721 
    L = ['%s=%r' % (key, value)
10722 
      for key, value in self.__dict__.iteritems()]
10723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10724 
 
10725 
  def __eq__(self, other):
10726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10727 
 
10728 
  def __ne__(self, other):
10729 
    return not (self == other)
10730 
 
10731 
class removeCoupon_result:
10732 
  """
10733 
  Attributes:
10734 
   - scx
10735 
  """
10736 
 
10737 
  thrift_spec = (
10738 
    None, # 0
10739 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10740 
  )
10741 
 
10742 
  def __init__(self, scx=None,):
10743 
    self.scx = scx
10744 
 
10745 
  def read(self, iprot):
10746 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10747 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10748 
      return
10749 
    iprot.readStructBegin()
10750 
    while True:
10751 
      (fname, ftype, fid) = iprot.readFieldBegin()
10752 
      if ftype == TType.STOP:
10753 
        break
10754 
      if fid == 1:
10755 
        if ftype == TType.STRUCT:
10756 
          self.scx = ShoppingCartException()
10757 
          self.scx.read(iprot)
10758 
        else:
10759 
          iprot.skip(ftype)
10760 
      else:
10761 
        iprot.skip(ftype)
10762 
      iprot.readFieldEnd()
10763 
    iprot.readStructEnd()
10764 
 
10765 
  def write(self, oprot):
10766 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10767 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10768 
      return
10769 
    oprot.writeStructBegin('removeCoupon_result')
10770 
    if self.scx != None:
10771 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10772 
      self.scx.write(oprot)
10773 
      oprot.writeFieldEnd()
10774 
    oprot.writeFieldStop()
10775 
    oprot.writeStructEnd()
10776 
 
10777 
  def __repr__(self):
10778 
    L = ['%s=%r' % (key, value)
10779 
      for key, value in self.__dict__.iteritems()]
10780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10781 
 
10782 
  def __eq__(self, other):
10783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10784 
 
10785 
  def __ne__(self, other):
10786 
    return not (self == other)
10787 
 
690 chandransh 10788 
class createOrders_args:
559 chandransh 10789 
  """
10790 
  Attributes:
10791 
   - cartId
10792 
  """
10793 
 
10794 
  thrift_spec = (
10795 
    None, # 0
10796 
    (1, TType.I64, 'cartId', None, None, ), # 1
10797 
  )
10798 
 
10799 
  def __init__(self, cartId=None,):
10800 
    self.cartId = cartId
10801 
 
10802 
  def read(self, iprot):
10803 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10804 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10805 
      return
10806 
    iprot.readStructBegin()
10807 
    while True:
10808 
      (fname, ftype, fid) = iprot.readFieldBegin()
10809 
      if ftype == TType.STOP:
10810 
        break
10811 
      if fid == 1:
10812 
        if ftype == TType.I64:
10813 
          self.cartId = iprot.readI64();
10814 
        else:
10815 
          iprot.skip(ftype)
10816 
      else:
10817 
        iprot.skip(ftype)
10818 
      iprot.readFieldEnd()
10819 
    iprot.readStructEnd()
10820 
 
10821 
  def write(self, oprot):
10822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10824 
      return
690 chandransh 10825 
    oprot.writeStructBegin('createOrders_args')
559 chandransh 10826 
    if self.cartId != None:
10827 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10828 
      oprot.writeI64(self.cartId)
10829 
      oprot.writeFieldEnd()
10830 
    oprot.writeFieldStop()
10831 
    oprot.writeStructEnd()
10832 
 
10833 
  def __repr__(self):
10834 
    L = ['%s=%r' % (key, value)
10835 
      for key, value in self.__dict__.iteritems()]
10836 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10837 
 
10838 
  def __eq__(self, other):
10839 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10840 
 
10841 
  def __ne__(self, other):
10842 
    return not (self == other)
10843 
 
690 chandransh 10844 
class createOrders_result:
559 chandransh 10845 
  """
10846 
  Attributes:
94 ashish 10847 
   - success
559 chandransh 10848 
   - scx
94 ashish 10849 
  """
10850 
 
10851 
  thrift_spec = (
575 chandransh 10852 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 10853 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10854 
  )
10855 
 
559 chandransh 10856 
  def __init__(self, success=None, scx=None,):
94 ashish 10857 
    self.success = success
559 chandransh 10858 
    self.scx = scx
94 ashish 10859 
 
10860 
  def read(self, iprot):
10861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10863 
      return
10864 
    iprot.readStructBegin()
10865 
    while True:
10866 
      (fname, ftype, fid) = iprot.readFieldBegin()
10867 
      if ftype == TType.STOP:
10868 
        break
10869 
      if fid == 0:
575 chandransh 10870 
        if ftype == TType.I64:
10871 
          self.success = iprot.readI64();
94 ashish 10872 
        else:
10873 
          iprot.skip(ftype)
10874 
      elif fid == 1:
10875 
        if ftype == TType.STRUCT:
559 chandransh 10876 
          self.scx = ShoppingCartException()
10877 
          self.scx.read(iprot)
94 ashish 10878 
        else:
10879 
          iprot.skip(ftype)
10880 
      else:
10881 
        iprot.skip(ftype)
10882 
      iprot.readFieldEnd()
10883 
    iprot.readStructEnd()
10884 
 
10885 
  def write(self, oprot):
10886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10888 
      return
690 chandransh 10889 
    oprot.writeStructBegin('createOrders_result')
94 ashish 10890 
    if self.success != None:
575 chandransh 10891 
      oprot.writeFieldBegin('success', TType.I64, 0)
10892 
      oprot.writeI64(self.success)
94 ashish 10893 
      oprot.writeFieldEnd()
559 chandransh 10894 
    if self.scx != None:
10895 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10896 
      self.scx.write(oprot)
94 ashish 10897 
      oprot.writeFieldEnd()
10898 
    oprot.writeFieldStop()
10899 
    oprot.writeStructEnd()
10900 
 
10901 
  def __repr__(self):
10902 
    L = ['%s=%r' % (key, value)
10903 
      for key, value in self.__dict__.iteritems()]
10904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10905 
 
10906 
  def __eq__(self, other):
10907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10908 
 
10909 
  def __ne__(self, other):
10910 
    return not (self == other)
10911 
 
559 chandransh 10912 
class validateCart_args:
94 ashish 10913 
  """
10914 
  Attributes:
559 chandransh 10915 
   - cartId
94 ashish 10916 
  """
10917 
 
10918 
  thrift_spec = (
10919 
    None, # 0
559 chandransh 10920 
    (1, TType.I64, 'cartId', None, None, ), # 1
94 ashish 10921 
  )
10922 
 
559 chandransh 10923 
  def __init__(self, cartId=None,):
10924 
    self.cartId = cartId
94 ashish 10925 
 
10926 
  def read(self, iprot):
10927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10929 
      return
10930 
    iprot.readStructBegin()
10931 
    while True:
10932 
      (fname, ftype, fid) = iprot.readFieldBegin()
10933 
      if ftype == TType.STOP:
10934 
        break
10935 
      if fid == 1:
10936 
        if ftype == TType.I64:
559 chandransh 10937 
          self.cartId = iprot.readI64();
94 ashish 10938 
        else:
10939 
          iprot.skip(ftype)
10940 
      else:
10941 
        iprot.skip(ftype)
10942 
      iprot.readFieldEnd()
10943 
    iprot.readStructEnd()
10944 
 
10945 
  def write(self, oprot):
10946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10948 
      return
559 chandransh 10949 
    oprot.writeStructBegin('validateCart_args')
10950 
    if self.cartId != None:
10951 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10952 
      oprot.writeI64(self.cartId)
94 ashish 10953 
      oprot.writeFieldEnd()
10954 
    oprot.writeFieldStop()
10955 
    oprot.writeStructEnd()
10956 
 
10957 
  def __repr__(self):
10958 
    L = ['%s=%r' % (key, value)
10959 
      for key, value in self.__dict__.iteritems()]
10960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10961 
 
10962 
  def __eq__(self, other):
10963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10964 
 
10965 
  def __ne__(self, other):
10966 
    return not (self == other)
10967 
 
559 chandransh 10968 
class validateCart_result:
94 ashish 10969 
  """
10970 
  Attributes:
10971 
   - success
575 chandransh 10972 
   - scex
94 ashish 10973 
  """
10974 
 
10975 
  thrift_spec = (
1466 ankur.sing 10976 
    (0, TType.STRING, 'success', None, None, ), # 0
575 chandransh 10977 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10978 
  )
10979 
 
575 chandransh 10980 
  def __init__(self, success=None, scex=None,):
94 ashish 10981 
    self.success = success
575 chandransh 10982 
    self.scex = scex
94 ashish 10983 
 
10984 
  def read(self, iprot):
10985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10987 
      return
10988 
    iprot.readStructBegin()
10989 
    while True:
10990 
      (fname, ftype, fid) = iprot.readFieldBegin()
10991 
      if ftype == TType.STOP:
10992 
        break
10993 
      if fid == 0:
1466 ankur.sing 10994 
        if ftype == TType.STRING:
10995 
          self.success = iprot.readString();
94 ashish 10996 
        else:
10997 
          iprot.skip(ftype)
575 chandransh 10998 
      elif fid == 1:
10999 
        if ftype == TType.STRUCT:
11000 
          self.scex = ShoppingCartException()
11001 
          self.scex.read(iprot)
11002 
        else:
11003 
          iprot.skip(ftype)
94 ashish 11004 
      else:
11005 
        iprot.skip(ftype)
11006 
      iprot.readFieldEnd()
11007 
    iprot.readStructEnd()
11008 
 
11009 
  def write(self, oprot):
11010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11012 
      return
559 chandransh 11013 
    oprot.writeStructBegin('validateCart_result')
94 ashish 11014 
    if self.success != None:
1466 ankur.sing 11015 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11016 
      oprot.writeString(self.success)
94 ashish 11017 
      oprot.writeFieldEnd()
575 chandransh 11018 
    if self.scex != None:
11019 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11020 
      self.scex.write(oprot)
11021 
      oprot.writeFieldEnd()
559 chandransh 11022 
    oprot.writeFieldStop()
11023 
    oprot.writeStructEnd()
11024 
 
11025 
  def __repr__(self):
11026 
    L = ['%s=%r' % (key, value)
11027 
      for key, value in self.__dict__.iteritems()]
11028 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11029 
 
11030 
  def __eq__(self, other):
11031 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11032 
 
11033 
  def __ne__(self, other):
11034 
    return not (self == other)
11035 
 
690 chandransh 11036 
class mergeCart_args:
575 chandransh 11037 
  """
11038 
  Attributes:
690 chandransh 11039 
   - fromCartId
11040 
   - toCartId
11041 
  """
11042 
 
11043 
  thrift_spec = (
11044 
    None, # 0
11045 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
11046 
    (2, TType.I64, 'toCartId', None, None, ), # 2
11047 
  )
11048 
 
11049 
  def __init__(self, fromCartId=None, toCartId=None,):
11050 
    self.fromCartId = fromCartId
11051 
    self.toCartId = toCartId
11052 
 
11053 
  def read(self, iprot):
11054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11056 
      return
11057 
    iprot.readStructBegin()
11058 
    while True:
11059 
      (fname, ftype, fid) = iprot.readFieldBegin()
11060 
      if ftype == TType.STOP:
11061 
        break
11062 
      if fid == 1:
11063 
        if ftype == TType.I64:
11064 
          self.fromCartId = iprot.readI64();
11065 
        else:
11066 
          iprot.skip(ftype)
11067 
      elif fid == 2:
11068 
        if ftype == TType.I64:
11069 
          self.toCartId = iprot.readI64();
11070 
        else:
11071 
          iprot.skip(ftype)
11072 
      else:
11073 
        iprot.skip(ftype)
11074 
      iprot.readFieldEnd()
11075 
    iprot.readStructEnd()
11076 
 
11077 
  def write(self, oprot):
11078 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11079 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11080 
      return
11081 
    oprot.writeStructBegin('mergeCart_args')
11082 
    if self.fromCartId != None:
11083 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
11084 
      oprot.writeI64(self.fromCartId)
11085 
      oprot.writeFieldEnd()
11086 
    if self.toCartId != None:
11087 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
11088 
      oprot.writeI64(self.toCartId)
11089 
      oprot.writeFieldEnd()
11090 
    oprot.writeFieldStop()
11091 
    oprot.writeStructEnd()
11092 
 
11093 
  def __repr__(self):
11094 
    L = ['%s=%r' % (key, value)
11095 
      for key, value in self.__dict__.iteritems()]
11096 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11097 
 
11098 
  def __eq__(self, other):
11099 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11100 
 
11101 
  def __ne__(self, other):
11102 
    return not (self == other)
11103 
 
11104 
class mergeCart_result:
11105 
 
11106 
  thrift_spec = (
11107 
  )
11108 
 
11109 
  def read(self, iprot):
11110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11112 
      return
11113 
    iprot.readStructBegin()
11114 
    while True:
11115 
      (fname, ftype, fid) = iprot.readFieldBegin()
11116 
      if ftype == TType.STOP:
11117 
        break
11118 
      else:
11119 
        iprot.skip(ftype)
11120 
      iprot.readFieldEnd()
11121 
    iprot.readStructEnd()
11122 
 
11123 
  def write(self, oprot):
11124 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11125 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11126 
      return
11127 
    oprot.writeStructBegin('mergeCart_result')
11128 
    oprot.writeFieldStop()
11129 
    oprot.writeStructEnd()
11130 
 
11131 
  def __repr__(self):
11132 
    L = ['%s=%r' % (key, value)
11133 
      for key, value in self.__dict__.iteritems()]
11134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11135 
 
11136 
  def __eq__(self, other):
11137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11138 
 
11139 
  def __ne__(self, other):
11140 
    return not (self == other)
11141 
 
11142 
class checkOut_args:
11143 
  """
11144 
  Attributes:
575 chandransh 11145 
   - cartId
11146 
  """
11147 
 
11148 
  thrift_spec = (
11149 
    None, # 0
11150 
    (1, TType.I64, 'cartId', None, None, ), # 1
11151 
  )
11152 
 
11153 
  def __init__(self, cartId=None,):
11154 
    self.cartId = cartId
11155 
 
11156 
  def read(self, iprot):
11157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11159 
      return
11160 
    iprot.readStructBegin()
11161 
    while True:
11162 
      (fname, ftype, fid) = iprot.readFieldBegin()
11163 
      if ftype == TType.STOP:
11164 
        break
11165 
      if fid == 1:
11166 
        if ftype == TType.I64:
11167 
          self.cartId = iprot.readI64();
11168 
        else:
11169 
          iprot.skip(ftype)
11170 
      else:
11171 
        iprot.skip(ftype)
11172 
      iprot.readFieldEnd()
11173 
    iprot.readStructEnd()
11174 
 
11175 
  def write(self, oprot):
11176 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11177 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11178 
      return
690 chandransh 11179 
    oprot.writeStructBegin('checkOut_args')
575 chandransh 11180 
    if self.cartId != None:
11181 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11182 
      oprot.writeI64(self.cartId)
11183 
      oprot.writeFieldEnd()
11184 
    oprot.writeFieldStop()
11185 
    oprot.writeStructEnd()
11186 
 
11187 
  def __repr__(self):
11188 
    L = ['%s=%r' % (key, value)
11189 
      for key, value in self.__dict__.iteritems()]
11190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11191 
 
11192 
  def __eq__(self, other):
11193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11194 
 
11195 
  def __ne__(self, other):
11196 
    return not (self == other)
11197 
 
690 chandransh 11198 
class checkOut_result:
575 chandransh 11199 
  """
11200 
  Attributes:
11201 
   - success
11202 
   - scex
11203 
  """
11204 
 
11205 
  thrift_spec = (
11206 
    (0, TType.BOOL, 'success', None, None, ), # 0
11207 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11208 
  )
11209 
 
11210 
  def __init__(self, success=None, scex=None,):
11211 
    self.success = success
11212 
    self.scex = scex
11213 
 
11214 
  def read(self, iprot):
11215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11217 
      return
11218 
    iprot.readStructBegin()
11219 
    while True:
11220 
      (fname, ftype, fid) = iprot.readFieldBegin()
11221 
      if ftype == TType.STOP:
11222 
        break
11223 
      if fid == 0:
11224 
        if ftype == TType.BOOL:
11225 
          self.success = iprot.readBool();
11226 
        else:
11227 
          iprot.skip(ftype)
11228 
      elif fid == 1:
11229 
        if ftype == TType.STRUCT:
11230 
          self.scex = ShoppingCartException()
11231 
          self.scex.read(iprot)
11232 
        else:
11233 
          iprot.skip(ftype)
11234 
      else:
11235 
        iprot.skip(ftype)
11236 
      iprot.readFieldEnd()
11237 
    iprot.readStructEnd()
11238 
 
11239 
  def write(self, oprot):
11240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11242 
      return
690 chandransh 11243 
    oprot.writeStructBegin('checkOut_result')
575 chandransh 11244 
    if self.success != None:
11245 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11246 
      oprot.writeBool(self.success)
11247 
      oprot.writeFieldEnd()
11248 
    if self.scex != None:
11249 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11250 
      self.scex.write(oprot)
11251 
      oprot.writeFieldEnd()
11252 
    oprot.writeFieldStop()
11253 
    oprot.writeStructEnd()
11254 
 
11255 
  def __repr__(self):
11256 
    L = ['%s=%r' % (key, value)
11257 
      for key, value in self.__dict__.iteritems()]
11258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11259 
 
11260 
  def __eq__(self, other):
11261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11262 
 
11263 
  def __ne__(self, other):
11264 
    return not (self == other)
11265 
 
690 chandransh 11266 
class resetCart_args:
559 chandransh 11267 
  """
11268 
  Attributes:
690 chandransh 11269 
   - cartId
11270 
   - items
559 chandransh 11271 
  """
11272 
 
11273 
  thrift_spec = (
11274 
    None, # 0
690 chandransh 11275 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 11276 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 11277 
  )
11278 
 
690 chandransh 11279 
  def __init__(self, cartId=None, items=None,):
11280 
    self.cartId = cartId
11281 
    self.items = items
559 chandransh 11282 
 
11283 
  def read(self, iprot):
11284 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11285 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11286 
      return
11287 
    iprot.readStructBegin()
11288 
    while True:
11289 
      (fname, ftype, fid) = iprot.readFieldBegin()
11290 
      if ftype == TType.STOP:
11291 
        break
11292 
      if fid == 1:
11293 
        if ftype == TType.I64:
690 chandransh 11294 
          self.cartId = iprot.readI64();
559 chandransh 11295 
        else:
11296 
          iprot.skip(ftype)
11297 
      elif fid == 2:
690 chandransh 11298 
        if ftype == TType.MAP:
11299 
          self.items = {}
1996 vikas 11300 
          (_ktype113, _vtype114, _size112 ) = iprot.readMapBegin()
11301 
          for _i116 in xrange(_size112):
11302 
            _key117 = iprot.readI64();
11303 
            _val118 = iprot.readDouble();
11304 
            self.items[_key117] = _val118
690 chandransh 11305 
          iprot.readMapEnd()
559 chandransh 11306 
        else:
11307 
          iprot.skip(ftype)
11308 
      else:
11309 
        iprot.skip(ftype)
11310 
      iprot.readFieldEnd()
11311 
    iprot.readStructEnd()
11312 
 
11313 
  def write(self, oprot):
11314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11316 
      return
690 chandransh 11317 
    oprot.writeStructBegin('resetCart_args')
11318 
    if self.cartId != None:
11319 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11320 
      oprot.writeI64(self.cartId)
94 ashish 11321 
      oprot.writeFieldEnd()
690 chandransh 11322 
    if self.items != None:
11323 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 11324 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
1996 vikas 11325 
      for kiter119,viter120 in self.items.items():
11326 
        oprot.writeI64(kiter119)
11327 
        oprot.writeDouble(viter120)
690 chandransh 11328 
      oprot.writeMapEnd()
559 chandransh 11329 
      oprot.writeFieldEnd()
94 ashish 11330 
    oprot.writeFieldStop()
11331 
    oprot.writeStructEnd()
11332 
 
11333 
  def __repr__(self):
11334 
    L = ['%s=%r' % (key, value)
11335 
      for key, value in self.__dict__.iteritems()]
11336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11337 
 
11338 
  def __eq__(self, other):
11339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11340 
 
11341 
  def __ne__(self, other):
11342 
    return not (self == other)
11343 
 
690 chandransh 11344 
class resetCart_result:
11345 
  """
11346 
  Attributes:
11347 
   - success
11348 
   - scex
11349 
  """
559 chandransh 11350 
 
11351 
  thrift_spec = (
690 chandransh 11352 
    (0, TType.BOOL, 'success', None, None, ), # 0
11353 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11354 
  )
11355 
 
690 chandransh 11356 
  def __init__(self, success=None, scex=None,):
11357 
    self.success = success
11358 
    self.scex = scex
11359 
 
559 chandransh 11360 
  def read(self, iprot):
11361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11363 
      return
11364 
    iprot.readStructBegin()
11365 
    while True:
11366 
      (fname, ftype, fid) = iprot.readFieldBegin()
11367 
      if ftype == TType.STOP:
11368 
        break
690 chandransh 11369 
      if fid == 0:
11370 
        if ftype == TType.BOOL:
11371 
          self.success = iprot.readBool();
11372 
        else:
11373 
          iprot.skip(ftype)
11374 
      elif fid == 1:
11375 
        if ftype == TType.STRUCT:
11376 
          self.scex = ShoppingCartException()
11377 
          self.scex.read(iprot)
11378 
        else:
11379 
          iprot.skip(ftype)
559 chandransh 11380 
      else:
11381 
        iprot.skip(ftype)
11382 
      iprot.readFieldEnd()
11383 
    iprot.readStructEnd()
11384 
 
11385 
  def write(self, oprot):
11386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11388 
      return
690 chandransh 11389 
    oprot.writeStructBegin('resetCart_result')
11390 
    if self.success != None:
11391 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11392 
      oprot.writeBool(self.success)
11393 
      oprot.writeFieldEnd()
11394 
    if self.scex != None:
11395 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11396 
      self.scex.write(oprot)
11397 
      oprot.writeFieldEnd()
559 chandransh 11398 
    oprot.writeFieldStop()
11399 
    oprot.writeStructEnd()
11400 
 
11401 
  def __repr__(self):
11402 
    L = ['%s=%r' % (key, value)
11403 
      for key, value in self.__dict__.iteritems()]
11404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11405 
 
11406 
  def __eq__(self, other):
11407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11408 
 
11409 
  def __ne__(self, other):
11410 
    return not (self == other)
11411 
 
772 rajveer 11412 
class getMyResearch_args:
94 ashish 11413 
  """
11414 
  Attributes:
559 chandransh 11415 
   - userId
11416 
  """
11417 
 
11418 
  thrift_spec = (
11419 
    None, # 0
772 rajveer 11420 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 11421 
  )
11422 
 
772 rajveer 11423 
  def __init__(self, userId=None,):
559 chandransh 11424 
    self.userId = userId
11425 
 
11426 
  def read(self, iprot):
11427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11429 
      return
11430 
    iprot.readStructBegin()
11431 
    while True:
11432 
      (fname, ftype, fid) = iprot.readFieldBegin()
11433 
      if ftype == TType.STOP:
11434 
        break
11435 
      if fid == 1:
11436 
        if ftype == TType.I64:
11437 
          self.userId = iprot.readI64();
11438 
        else:
11439 
          iprot.skip(ftype)
11440 
      else:
11441 
        iprot.skip(ftype)
11442 
      iprot.readFieldEnd()
11443 
    iprot.readStructEnd()
11444 
 
11445 
  def write(self, oprot):
11446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11448 
      return
772 rajveer 11449 
    oprot.writeStructBegin('getMyResearch_args')
559 chandransh 11450 
    if self.userId != None:
772 rajveer 11451 
      oprot.writeFieldBegin('userId', TType.I64, 1)
559 chandransh 11452 
      oprot.writeI64(self.userId)
11453 
      oprot.writeFieldEnd()
11454 
    oprot.writeFieldStop()
11455 
    oprot.writeStructEnd()
11456 
 
11457 
  def __repr__(self):
11458 
    L = ['%s=%r' % (key, value)
11459 
      for key, value in self.__dict__.iteritems()]
11460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11461 
 
11462 
  def __eq__(self, other):
11463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11464 
 
11465 
  def __ne__(self, other):
11466 
    return not (self == other)
11467 
 
11468 
class getMyResearch_result:
94 ashish 11469 
  """
11470 
  Attributes:
11471 
   - success
559 chandransh 11472 
   - scx
94 ashish 11473 
  """
11474 
 
11475 
  thrift_spec = (
559 chandransh 11476 
    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
11477 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
94 ashish 11478 
  )
11479 
 
559 chandransh 11480 
  def __init__(self, success=None, scx=None,):
94 ashish 11481 
    self.success = success
559 chandransh 11482 
    self.scx = scx
94 ashish 11483 
 
11484 
  def read(self, iprot):
11485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11487 
      return
11488 
    iprot.readStructBegin()
11489 
    while True:
11490 
      (fname, ftype, fid) = iprot.readFieldBegin()
11491 
      if ftype == TType.STOP:
11492 
        break
11493 
      if fid == 0:
559 chandransh 11494 
        if ftype == TType.STRUCT:
11495 
          self.success = Widget()
11496 
          self.success.read(iprot)
94 ashish 11497 
        else:
11498 
          iprot.skip(ftype)
11499 
      elif fid == 1:
11500 
        if ftype == TType.STRUCT:
559 chandransh 11501 
          self.scx = WidgetException()
11502 
          self.scx.read(iprot)
94 ashish 11503 
        else:
11504 
          iprot.skip(ftype)
11505 
      else:
11506 
        iprot.skip(ftype)
11507 
      iprot.readFieldEnd()
11508 
    iprot.readStructEnd()
11509 
 
11510 
  def write(self, oprot):
11511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11513 
      return
559 chandransh 11514 
    oprot.writeStructBegin('getMyResearch_result')
94 ashish 11515 
    if self.success != None:
559 chandransh 11516 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11517 
      self.success.write(oprot)
94 ashish 11518 
      oprot.writeFieldEnd()
559 chandransh 11519 
    if self.scx != None:
11520 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11521 
      self.scx.write(oprot)
94 ashish 11522 
      oprot.writeFieldEnd()
11523 
    oprot.writeFieldStop()
11524 
    oprot.writeStructEnd()
11525 
 
11526 
  def __repr__(self):
11527 
    L = ['%s=%r' % (key, value)
11528 
      for key, value in self.__dict__.iteritems()]
11529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11530 
 
11531 
  def __eq__(self, other):
11532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11533 
 
11534 
  def __ne__(self, other):
11535 
    return not (self == other)
11536 
 
559 chandransh 11537 
class updateMyResearch_args:
94 ashish 11538 
  """
11539 
  Attributes:
772 rajveer 11540 
   - userId
11541 
   - itemId
94 ashish 11542 
  """
11543 
 
11544 
  thrift_spec = (
11545 
    None, # 0
772 rajveer 11546 
    (1, TType.I64, 'userId', None, None, ), # 1
11547 
    (2, TType.I64, 'itemId', None, None, ), # 2
94 ashish 11548 
  )
11549 
 
772 rajveer 11550 
  def __init__(self, userId=None, itemId=None,):
11551 
    self.userId = userId
11552 
    self.itemId = itemId
94 ashish 11553 
 
11554 
  def read(self, iprot):
11555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11557 
      return
11558 
    iprot.readStructBegin()
11559 
    while True:
11560 
      (fname, ftype, fid) = iprot.readFieldBegin()
11561 
      if ftype == TType.STOP:
11562 
        break
11563 
      if fid == 1:
11564 
        if ftype == TType.I64:
772 rajveer 11565 
          self.userId = iprot.readI64();
94 ashish 11566 
        else:
11567 
          iprot.skip(ftype)
11568 
      elif fid == 2:
559 chandransh 11569 
        if ftype == TType.I64:
772 rajveer 11570 
          self.itemId = iprot.readI64();
94 ashish 11571 
        else:
11572 
          iprot.skip(ftype)
11573 
      else:
11574 
        iprot.skip(ftype)
11575 
      iprot.readFieldEnd()
11576 
    iprot.readStructEnd()
11577 
 
11578 
  def write(self, oprot):
11579 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11580 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11581 
      return
559 chandransh 11582 
    oprot.writeStructBegin('updateMyResearch_args')
772 rajveer 11583 
    if self.userId != None:
11584 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11585 
      oprot.writeI64(self.userId)
94 ashish 11586 
      oprot.writeFieldEnd()
772 rajveer 11587 
    if self.itemId != None:
11588 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11589 
      oprot.writeI64(self.itemId)
94 ashish 11590 
      oprot.writeFieldEnd()
11591 
    oprot.writeFieldStop()
11592 
    oprot.writeStructEnd()
11593 
 
11594 
  def __repr__(self):
11595 
    L = ['%s=%r' % (key, value)
11596 
      for key, value in self.__dict__.iteritems()]
11597 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11598 
 
11599 
  def __eq__(self, other):
11600 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11601 
 
11602 
  def __ne__(self, other):
11603 
    return not (self == other)
11604 
 
559 chandransh 11605 
class updateMyResearch_result:
94 ashish 11606 
  """
11607 
  Attributes:
11608 
   - success
559 chandransh 11609 
   - scx
94 ashish 11610 
  """
11611 
 
11612 
  thrift_spec = (
11613 
    (0, TType.BOOL, 'success', None, None, ), # 0
559 chandransh 11614 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
94 ashish 11615 
  )
11616 
 
559 chandransh 11617 
  def __init__(self, success=None, scx=None,):
94 ashish 11618 
    self.success = success
559 chandransh 11619 
    self.scx = scx
94 ashish 11620 
 
11621 
  def read(self, iprot):
11622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11624 
      return
11625 
    iprot.readStructBegin()
11626 
    while True:
11627 
      (fname, ftype, fid) = iprot.readFieldBegin()
11628 
      if ftype == TType.STOP:
11629 
        break
11630 
      if fid == 0:
11631 
        if ftype == TType.BOOL:
11632 
          self.success = iprot.readBool();
11633 
        else:
11634 
          iprot.skip(ftype)
11635 
      elif fid == 1:
11636 
        if ftype == TType.STRUCT:
559 chandransh 11637 
          self.scx = WidgetException()
11638 
          self.scx.read(iprot)
94 ashish 11639 
        else:
11640 
          iprot.skip(ftype)
11641 
      else:
11642 
        iprot.skip(ftype)
11643 
      iprot.readFieldEnd()
11644 
    iprot.readStructEnd()
11645 
 
11646 
  def write(self, oprot):
11647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11649 
      return
559 chandransh 11650 
    oprot.writeStructBegin('updateMyResearch_result')
94 ashish 11651 
    if self.success != None:
11652 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11653 
      oprot.writeBool(self.success)
11654 
      oprot.writeFieldEnd()
559 chandransh 11655 
    if self.scx != None:
11656 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11657 
      self.scx.write(oprot)
94 ashish 11658 
      oprot.writeFieldEnd()
11659 
    oprot.writeFieldStop()
11660 
    oprot.writeStructEnd()
11661 
 
11662 
  def __repr__(self):
11663 
    L = ['%s=%r' % (key, value)
11664 
      for key, value in self.__dict__.iteritems()]
11665 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11666 
 
11667 
  def __eq__(self, other):
11668 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11669 
 
11670 
  def __ne__(self, other):
11671 
    return not (self == other)
11672 
 
559 chandransh 11673 
class deleteItemFromMyResearch_args:
130 ashish 11674 
  """
11675 
  Attributes:
772 rajveer 11676 
   - userId
11677 
   - itemId
130 ashish 11678 
  """
94 ashish 11679 
 
130 ashish 11680 
  thrift_spec = (
11681 
    None, # 0
772 rajveer 11682 
    (1, TType.I64, 'userId', None, None, ), # 1
11683 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 11684 
  )
11685 
 
772 rajveer 11686 
  def __init__(self, userId=None, itemId=None,):
11687 
    self.userId = userId
11688 
    self.itemId = itemId
130 ashish 11689 
 
11690 
  def read(self, iprot):
11691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11693 
      return
11694 
    iprot.readStructBegin()
11695 
    while True:
11696 
      (fname, ftype, fid) = iprot.readFieldBegin()
11697 
      if ftype == TType.STOP:
11698 
        break
11699 
      if fid == 1:
11700 
        if ftype == TType.I64:
772 rajveer 11701 
          self.userId = iprot.readI64();
130 ashish 11702 
        else:
11703 
          iprot.skip(ftype)
559 chandransh 11704 
      elif fid == 2:
11705 
        if ftype == TType.I64:
772 rajveer 11706 
          self.itemId = iprot.readI64();
559 chandransh 11707 
        else:
11708 
          iprot.skip(ftype)
130 ashish 11709 
      else:
11710 
        iprot.skip(ftype)
11711 
      iprot.readFieldEnd()
11712 
    iprot.readStructEnd()
11713 
 
11714 
  def write(self, oprot):
11715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11717 
      return
559 chandransh 11718 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
772 rajveer 11719 
    if self.userId != None:
11720 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11721 
      oprot.writeI64(self.userId)
130 ashish 11722 
      oprot.writeFieldEnd()
772 rajveer 11723 
    if self.itemId != None:
11724 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11725 
      oprot.writeI64(self.itemId)
559 chandransh 11726 
      oprot.writeFieldEnd()
130 ashish 11727 
    oprot.writeFieldStop()
11728 
    oprot.writeStructEnd()
11729 
 
11730 
  def __repr__(self):
11731 
    L = ['%s=%r' % (key, value)
11732 
      for key, value in self.__dict__.iteritems()]
11733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11734 
 
11735 
  def __eq__(self, other):
11736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11737 
 
11738 
  def __ne__(self, other):
11739 
    return not (self == other)
11740 
 
559 chandransh 11741 
class deleteItemFromMyResearch_result:
130 ashish 11742 
  """
11743 
  Attributes:
559 chandransh 11744 
   - scx
11745 
  """
11746 
 
11747 
  thrift_spec = (
11748 
    None, # 0
11749 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
11750 
  )
11751 
 
11752 
  def __init__(self, scx=None,):
11753 
    self.scx = scx
11754 
 
11755 
  def read(self, iprot):
11756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11758 
      return
11759 
    iprot.readStructBegin()
11760 
    while True:
11761 
      (fname, ftype, fid) = iprot.readFieldBegin()
11762 
      if ftype == TType.STOP:
11763 
        break
11764 
      if fid == 1:
11765 
        if ftype == TType.STRUCT:
11766 
          self.scx = WidgetException()
11767 
          self.scx.read(iprot)
11768 
        else:
11769 
          iprot.skip(ftype)
11770 
      else:
11771 
        iprot.skip(ftype)
11772 
      iprot.readFieldEnd()
11773 
    iprot.readStructEnd()
11774 
 
11775 
  def write(self, oprot):
11776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11778 
      return
11779 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
11780 
    if self.scx != None:
11781 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11782 
      self.scx.write(oprot)
11783 
      oprot.writeFieldEnd()
11784 
    oprot.writeFieldStop()
11785 
    oprot.writeStructEnd()
11786 
 
11787 
  def __repr__(self):
11788 
    L = ['%s=%r' % (key, value)
11789 
      for key, value in self.__dict__.iteritems()]
11790 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11791 
 
11792 
  def __eq__(self, other):
11793 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11794 
 
11795 
  def __ne__(self, other):
11796 
    return not (self == other)
11797 
 
772 rajveer 11798 
class updateBrowseHistory_args:
559 chandransh 11799 
  """
11800 
  Attributes:
772 rajveer 11801 
   - userId
11802 
   - itemId
559 chandransh 11803 
  """
11804 
 
11805 
  thrift_spec = (
11806 
    None, # 0
772 rajveer 11807 
    (1, TType.I64, 'userId', None, None, ), # 1
11808 
    (2, TType.I64, 'itemId', None, None, ), # 2
559 chandransh 11809 
  )
11810 
 
772 rajveer 11811 
  def __init__(self, userId=None, itemId=None,):
11812 
    self.userId = userId
11813 
    self.itemId = itemId
559 chandransh 11814 
 
11815 
  def read(self, iprot):
11816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11818 
      return
11819 
    iprot.readStructBegin()
11820 
    while True:
11821 
      (fname, ftype, fid) = iprot.readFieldBegin()
11822 
      if ftype == TType.STOP:
11823 
        break
11824 
      if fid == 1:
11825 
        if ftype == TType.I64:
772 rajveer 11826 
          self.userId = iprot.readI64();
559 chandransh 11827 
        else:
11828 
          iprot.skip(ftype)
11829 
      elif fid == 2:
11830 
        if ftype == TType.I64:
772 rajveer 11831 
          self.itemId = iprot.readI64();
559 chandransh 11832 
        else:
11833 
          iprot.skip(ftype)
11834 
      else:
11835 
        iprot.skip(ftype)
11836 
      iprot.readFieldEnd()
11837 
    iprot.readStructEnd()
11838 
 
11839 
  def write(self, oprot):
11840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11842 
      return
772 rajveer 11843 
    oprot.writeStructBegin('updateBrowseHistory_args')
11844 
    if self.userId != None:
11845 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11846 
      oprot.writeI64(self.userId)
559 chandransh 11847 
      oprot.writeFieldEnd()
772 rajveer 11848 
    if self.itemId != None:
11849 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11850 
      oprot.writeI64(self.itemId)
559 chandransh 11851 
      oprot.writeFieldEnd()
11852 
    oprot.writeFieldStop()
11853 
    oprot.writeStructEnd()
11854 
 
11855 
  def __repr__(self):
11856 
    L = ['%s=%r' % (key, value)
11857 
      for key, value in self.__dict__.iteritems()]
11858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11859 
 
11860 
  def __eq__(self, other):
11861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11862 
 
11863 
  def __ne__(self, other):
11864 
    return not (self == other)
11865 
 
772 rajveer 11866 
class updateBrowseHistory_result:
559 chandransh 11867 
 
11868 
  thrift_spec = (
11869 
  )
11870 
 
11871 
  def read(self, iprot):
11872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11874 
      return
11875 
    iprot.readStructBegin()
11876 
    while True:
11877 
      (fname, ftype, fid) = iprot.readFieldBegin()
11878 
      if ftype == TType.STOP:
11879 
        break
11880 
      else:
11881 
        iprot.skip(ftype)
11882 
      iprot.readFieldEnd()
11883 
    iprot.readStructEnd()
11884 
 
11885 
  def write(self, oprot):
11886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11888 
      return
772 rajveer 11889 
    oprot.writeStructBegin('updateBrowseHistory_result')
559 chandransh 11890 
    oprot.writeFieldStop()
11891 
    oprot.writeStructEnd()
11892 
 
11893 
  def __repr__(self):
11894 
    L = ['%s=%r' % (key, value)
11895 
      for key, value in self.__dict__.iteritems()]
11896 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11897 
 
11898 
  def __eq__(self, other):
11899 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11900 
 
11901 
  def __ne__(self, other):
11902 
    return not (self == other)
11903 
 
772 rajveer 11904 
class getBrowseHistory_args:
559 chandransh 11905 
  """
11906 
  Attributes:
772 rajveer 11907 
   - userId
559 chandransh 11908 
  """
11909 
 
11910 
  thrift_spec = (
11911 
    None, # 0
772 rajveer 11912 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 11913 
  )
11914 
 
772 rajveer 11915 
  def __init__(self, userId=None,):
11916 
    self.userId = userId
559 chandransh 11917 
 
11918 
  def read(self, iprot):
11919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11921 
      return
11922 
    iprot.readStructBegin()
11923 
    while True:
11924 
      (fname, ftype, fid) = iprot.readFieldBegin()
11925 
      if ftype == TType.STOP:
11926 
        break
11927 
      if fid == 1:
11928 
        if ftype == TType.I64:
772 rajveer 11929 
          self.userId = iprot.readI64();
559 chandransh 11930 
        else:
11931 
          iprot.skip(ftype)
11932 
      else:
11933 
        iprot.skip(ftype)
11934 
      iprot.readFieldEnd()
11935 
    iprot.readStructEnd()
11936 
 
11937 
  def write(self, oprot):
11938 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11939 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11940 
      return
772 rajveer 11941 
    oprot.writeStructBegin('getBrowseHistory_args')
11942 
    if self.userId != None:
11943 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11944 
      oprot.writeI64(self.userId)
559 chandransh 11945 
      oprot.writeFieldEnd()
11946 
    oprot.writeFieldStop()
11947 
    oprot.writeStructEnd()
11948 
 
11949 
  def __repr__(self):
11950 
    L = ['%s=%r' % (key, value)
11951 
      for key, value in self.__dict__.iteritems()]
11952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11953 
 
11954 
  def __eq__(self, other):
11955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11956 
 
11957 
  def __ne__(self, other):
11958 
    return not (self == other)
11959 
 
772 rajveer 11960 
class getBrowseHistory_result:
559 chandransh 11961 
  """
11962 
  Attributes:
130 ashish 11963 
   - success
559 chandransh 11964 
   - scx
130 ashish 11965 
  """
11966 
 
11967 
  thrift_spec = (
772 rajveer 11968 
    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
559 chandransh 11969 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 11970 
  )
11971 
 
559 chandransh 11972 
  def __init__(self, success=None, scx=None,):
130 ashish 11973 
    self.success = success
559 chandransh 11974 
    self.scx = scx
130 ashish 11975 
 
11976 
  def read(self, iprot):
11977 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11978 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11979 
      return
11980 
    iprot.readStructBegin()
11981 
    while True:
11982 
      (fname, ftype, fid) = iprot.readFieldBegin()
11983 
      if ftype == TType.STOP:
11984 
        break
11985 
      if fid == 0:
559 chandransh 11986 
        if ftype == TType.STRUCT:
772 rajveer 11987 
          self.success = Widget()
559 chandransh 11988 
          self.success.read(iprot)
130 ashish 11989 
        else:
11990 
          iprot.skip(ftype)
11991 
      elif fid == 1:
11992 
        if ftype == TType.STRUCT:
559 chandransh 11993 
          self.scx = WidgetException()
11994 
          self.scx.read(iprot)
130 ashish 11995 
        else:
11996 
          iprot.skip(ftype)
11997 
      else:
11998 
        iprot.skip(ftype)
11999 
      iprot.readFieldEnd()
12000 
    iprot.readStructEnd()
12001 
 
12002 
  def write(self, oprot):
12003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12005 
      return
772 rajveer 12006 
    oprot.writeStructBegin('getBrowseHistory_result')
130 ashish 12007 
    if self.success != None:
559 chandransh 12008 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12009 
      self.success.write(oprot)
130 ashish 12010 
      oprot.writeFieldEnd()
559 chandransh 12011 
    if self.scx != None:
12012 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12013 
      self.scx.write(oprot)
130 ashish 12014 
      oprot.writeFieldEnd()
12015 
    oprot.writeFieldStop()
12016 
    oprot.writeStructEnd()
12017 
 
12018 
  def __repr__(self):
12019 
    L = ['%s=%r' % (key, value)
12020 
      for key, value in self.__dict__.iteritems()]
12021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12022 
 
12023 
  def __eq__(self, other):
12024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12025 
 
12026 
  def __ne__(self, other):
12027 
    return not (self == other)
12028 
 
772 rajveer 12029 
class mergeBrowseHistory_args:
130 ashish 12030 
  """
12031 
  Attributes:
772 rajveer 12032 
   - fromUserId
12033 
   - toUserId
130 ashish 12034 
  """
12035 
 
12036 
  thrift_spec = (
12037 
    None, # 0
772 rajveer 12038 
    (1, TType.I64, 'fromUserId', None, None, ), # 1
12039 
    (2, TType.I64, 'toUserId', None, None, ), # 2
130 ashish 12040 
  )
12041 
 
772 rajveer 12042 
  def __init__(self, fromUserId=None, toUserId=None,):
12043 
    self.fromUserId = fromUserId
12044 
    self.toUserId = toUserId
130 ashish 12045 
 
12046 
  def read(self, iprot):
12047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12049 
      return
12050 
    iprot.readStructBegin()
12051 
    while True:
12052 
      (fname, ftype, fid) = iprot.readFieldBegin()
12053 
      if ftype == TType.STOP:
12054 
        break
12055 
      if fid == 1:
559 chandransh 12056 
        if ftype == TType.I64:
772 rajveer 12057 
          self.fromUserId = iprot.readI64();
130 ashish 12058 
        else:
12059 
          iprot.skip(ftype)
12060 
      elif fid == 2:
559 chandransh 12061 
        if ftype == TType.I64:
772 rajveer 12062 
          self.toUserId = iprot.readI64();
559 chandransh 12063 
        else:
12064 
          iprot.skip(ftype)
130 ashish 12065 
      else:
12066 
        iprot.skip(ftype)
12067 
      iprot.readFieldEnd()
12068 
    iprot.readStructEnd()
12069 
 
12070 
  def write(self, oprot):
12071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12073 
      return
772 rajveer 12074 
    oprot.writeStructBegin('mergeBrowseHistory_args')
12075 
    if self.fromUserId != None:
12076 
      oprot.writeFieldBegin('fromUserId', TType.I64, 1)
12077 
      oprot.writeI64(self.fromUserId)
130 ashish 12078 
      oprot.writeFieldEnd()
772 rajveer 12079 
    if self.toUserId != None:
12080 
      oprot.writeFieldBegin('toUserId', TType.I64, 2)
12081 
      oprot.writeI64(self.toUserId)
130 ashish 12082 
      oprot.writeFieldEnd()
12083 
    oprot.writeFieldStop()
12084 
    oprot.writeStructEnd()
12085 
 
12086 
  def __repr__(self):
12087 
    L = ['%s=%r' % (key, value)
12088 
      for key, value in self.__dict__.iteritems()]
12089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12090 
 
12091 
  def __eq__(self, other):
12092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12093 
 
12094 
  def __ne__(self, other):
12095 
    return not (self == other)
12096 
 
772 rajveer 12097 
class mergeBrowseHistory_result:
559 chandransh 12098 
 
12099 
  thrift_spec = (
12100 
  )
12101 
 
12102 
  def read(self, iprot):
12103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12105 
      return
12106 
    iprot.readStructBegin()
12107 
    while True:
12108 
      (fname, ftype, fid) = iprot.readFieldBegin()
12109 
      if ftype == TType.STOP:
12110 
        break
12111 
      else:
12112 
        iprot.skip(ftype)
12113 
      iprot.readFieldEnd()
12114 
    iprot.readStructEnd()
12115 
 
12116 
  def write(self, oprot):
12117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12119 
      return
772 rajveer 12120 
    oprot.writeStructBegin('mergeBrowseHistory_result')
559 chandransh 12121 
    oprot.writeFieldStop()
12122 
    oprot.writeStructEnd()
12123 
 
12124 
  def __repr__(self):
12125 
    L = ['%s=%r' % (key, value)
12126 
      for key, value in self.__dict__.iteritems()]
12127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12128 
 
12129 
  def __eq__(self, other):
12130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12131 
 
12132 
  def __ne__(self, other):
12133 
    return not (self == other)
12134 
 
1596 ankur.sing 12135 
class getUserCount_args:
12136 
  """
12137 
  Attributes:
12138 
   - userType
12139 
  """
559 chandransh 12140 
 
1596 ankur.sing 12141 
  thrift_spec = (
12142 
    None, # 0
12143 
    (1, TType.I32, 'userType', None, None, ), # 1
12144 
  )
12145 
 
12146 
  def __init__(self, userType=None,):
12147 
    self.userType = userType
12148 
 
12149 
  def read(self, iprot):
12150 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12151 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12152 
      return
12153 
    iprot.readStructBegin()
12154 
    while True:
12155 
      (fname, ftype, fid) = iprot.readFieldBegin()
12156 
      if ftype == TType.STOP:
12157 
        break
12158 
      if fid == 1:
12159 
        if ftype == TType.I32:
12160 
          self.userType = iprot.readI32();
12161 
        else:
12162 
          iprot.skip(ftype)
12163 
      else:
12164 
        iprot.skip(ftype)
12165 
      iprot.readFieldEnd()
12166 
    iprot.readStructEnd()
12167 
 
12168 
  def write(self, oprot):
12169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12171 
      return
12172 
    oprot.writeStructBegin('getUserCount_args')
12173 
    if self.userType != None:
12174 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12175 
      oprot.writeI32(self.userType)
12176 
      oprot.writeFieldEnd()
12177 
    oprot.writeFieldStop()
12178 
    oprot.writeStructEnd()
12179 
 
12180 
  def __repr__(self):
12181 
    L = ['%s=%r' % (key, value)
12182 
      for key, value in self.__dict__.iteritems()]
12183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12184 
 
12185 
  def __eq__(self, other):
12186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12187 
 
12188 
  def __ne__(self, other):
12189 
    return not (self == other)
12190 
 
12191 
class getUserCount_result:
12192 
  """
12193 
  Attributes:
12194 
   - success
12195 
  """
12196 
 
12197 
  thrift_spec = (
12198 
    (0, TType.I64, 'success', None, None, ), # 0
12199 
  )
12200 
 
12201 
  def __init__(self, success=None,):
12202 
    self.success = success
12203 
 
12204 
  def read(self, iprot):
12205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12207 
      return
12208 
    iprot.readStructBegin()
12209 
    while True:
12210 
      (fname, ftype, fid) = iprot.readFieldBegin()
12211 
      if ftype == TType.STOP:
12212 
        break
12213 
      if fid == 0:
12214 
        if ftype == TType.I64:
12215 
          self.success = iprot.readI64();
12216 
        else:
12217 
          iprot.skip(ftype)
12218 
      else:
12219 
        iprot.skip(ftype)
12220 
      iprot.readFieldEnd()
12221 
    iprot.readStructEnd()
12222 
 
12223 
  def write(self, oprot):
12224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12226 
      return
12227 
    oprot.writeStructBegin('getUserCount_result')
12228 
    if self.success != None:
12229 
      oprot.writeFieldBegin('success', TType.I64, 0)
12230 
      oprot.writeI64(self.success)
12231 
      oprot.writeFieldEnd()
12232 
    oprot.writeFieldStop()
12233 
    oprot.writeStructEnd()
12234 
 
12235 
  def __repr__(self):
12236 
    L = ['%s=%r' % (key, value)
12237 
      for key, value in self.__dict__.iteritems()]
12238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12239 
 
12240 
  def __eq__(self, other):
12241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12242 
 
12243 
  def __ne__(self, other):
12244 
    return not (self == other)
12245 
 
1673 ankur.sing 12246 
class getAllUsers_args:
12247 
  """
12248 
  Attributes:
12249 
   - userType
1891 ankur.sing 12250 
   - startDate
12251 
   - endDate
1673 ankur.sing 12252 
  """
1596 ankur.sing 12253 
 
1673 ankur.sing 12254 
  thrift_spec = (
12255 
    None, # 0
12256 
    (1, TType.I32, 'userType', None, None, ), # 1
1891 ankur.sing 12257 
    (2, TType.I64, 'startDate', None, None, ), # 2
12258 
    (3, TType.I64, 'endDate', None, None, ), # 3
1673 ankur.sing 12259 
  )
12260 
 
1891 ankur.sing 12261 
  def __init__(self, userType=None, startDate=None, endDate=None,):
1673 ankur.sing 12262 
    self.userType = userType
1891 ankur.sing 12263 
    self.startDate = startDate
12264 
    self.endDate = endDate
1673 ankur.sing 12265 
 
12266 
  def read(self, iprot):
12267 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12268 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12269 
      return
12270 
    iprot.readStructBegin()
12271 
    while True:
12272 
      (fname, ftype, fid) = iprot.readFieldBegin()
12273 
      if ftype == TType.STOP:
12274 
        break
12275 
      if fid == 1:
12276 
        if ftype == TType.I32:
12277 
          self.userType = iprot.readI32();
12278 
        else:
12279 
          iprot.skip(ftype)
1891 ankur.sing 12280 
      elif fid == 2:
12281 
        if ftype == TType.I64:
12282 
          self.startDate = iprot.readI64();
12283 
        else:
12284 
          iprot.skip(ftype)
12285 
      elif fid == 3:
12286 
        if ftype == TType.I64:
12287 
          self.endDate = iprot.readI64();
12288 
        else:
12289 
          iprot.skip(ftype)
1673 ankur.sing 12290 
      else:
12291 
        iprot.skip(ftype)
12292 
      iprot.readFieldEnd()
12293 
    iprot.readStructEnd()
12294 
 
12295 
  def write(self, oprot):
12296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12298 
      return
12299 
    oprot.writeStructBegin('getAllUsers_args')
12300 
    if self.userType != None:
12301 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12302 
      oprot.writeI32(self.userType)
12303 
      oprot.writeFieldEnd()
1891 ankur.sing 12304 
    if self.startDate != None:
12305 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
12306 
      oprot.writeI64(self.startDate)
12307 
      oprot.writeFieldEnd()
12308 
    if self.endDate != None:
12309 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
12310 
      oprot.writeI64(self.endDate)
12311 
      oprot.writeFieldEnd()
1673 ankur.sing 12312 
    oprot.writeFieldStop()
12313 
    oprot.writeStructEnd()
12314 
 
12315 
  def __repr__(self):
12316 
    L = ['%s=%r' % (key, value)
12317 
      for key, value in self.__dict__.iteritems()]
12318 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12319 
 
12320 
  def __eq__(self, other):
12321 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12322 
 
12323 
  def __ne__(self, other):
12324 
    return not (self == other)
12325 
 
12326 
class getAllUsers_result:
12327 
  """
12328 
  Attributes:
12329 
   - success
12330 
  """
12331 
 
12332 
  thrift_spec = (
12333 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
12334 
  )
12335 
 
12336 
  def __init__(self, success=None,):
12337 
    self.success = success
12338 
 
12339 
  def read(self, iprot):
12340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12342 
      return
12343 
    iprot.readStructBegin()
12344 
    while True:
12345 
      (fname, ftype, fid) = iprot.readFieldBegin()
12346 
      if ftype == TType.STOP:
12347 
        break
12348 
      if fid == 0:
12349 
        if ftype == TType.LIST:
12350 
          self.success = []
1996 vikas 12351 
          (_etype124, _size121) = iprot.readListBegin()
12352 
          for _i125 in xrange(_size121):
12353 
            _elem126 = User()
12354 
            _elem126.read(iprot)
12355 
            self.success.append(_elem126)
1673 ankur.sing 12356 
          iprot.readListEnd()
12357 
        else:
12358 
          iprot.skip(ftype)
12359 
      else:
12360 
        iprot.skip(ftype)
12361 
      iprot.readFieldEnd()
12362 
    iprot.readStructEnd()
12363 
 
12364 
  def write(self, oprot):
12365 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12366 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12367 
      return
12368 
    oprot.writeStructBegin('getAllUsers_result')
12369 
    if self.success != None:
12370 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12371 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 12372 
      for iter127 in self.success:
12373 
        iter127.write(oprot)
1673 ankur.sing 12374 
      oprot.writeListEnd()
12375 
      oprot.writeFieldEnd()
12376 
    oprot.writeFieldStop()
12377 
    oprot.writeStructEnd()
12378 
 
12379 
  def __repr__(self):
12380 
    L = ['%s=%r' % (key, value)
12381 
      for key, value in self.__dict__.iteritems()]
12382 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12383 
 
12384 
  def __eq__(self, other):
12385 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12386 
 
12387 
  def __ne__(self, other):
12388 
    return not (self == other)
12389 
 
12390