Subversion Repositories SmartDukaan

Rev

Rev 1673 | Rev 1859 | 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 
 
157 
  def getDefaultAddressId(self, userId):
158 
    """
159 
    Parameters:
160 
     - userId
161 
    """
162 
    pass
163 
 
785 rajveer 164 
  def getDefaultPincode(self, userId):
165 
    """
166 
    Parameters:
167 
     - userId
168 
    """
169 
    pass
170 
 
1274 varun.gupt 171 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
172 
    """
173 
    Parameters:
174 
     - userId
175 
     - replyTo
176 
     - communicationType
177 
     - orderId
178 
     - airwaybillNo
179 
     - productName
180 
     - subject
181 
     - message
182 
    """
183 
    pass
184 
 
1590 varun.gupt 185 
  def getUserCommunicationById(self, id):
186 
    """
187 
    Parameters:
188 
     - id
189 
    """
190 
    pass
191 
 
192 
  def getUserCommunicationByUser(self, userId):
193 
    """
194 
    Parameters:
195 
     - userId
196 
    """
197 
    pass
198 
 
199 
  def getAllUserCommunications(self, ):
200 
    pass
201 
 
1845 vikas 202 
  def createMasterAffiliate(self, name):
203 
    """
204 
    Parameters:
205 
     - name
206 
    """
207 
    pass
208 
 
209 
  def getMasterAffiliateById(self, id):
210 
    """
211 
    Parameters:
212 
     - id
213 
    """
214 
    pass
215 
 
216 
  def getMasterAffiliateByName(self, name):
217 
    """
218 
    Parameters:
219 
     - name
220 
    """
221 
    pass
222 
 
223 
  def createAffiliate(self, name, url, masterAffiliateId):
224 
    """
225 
    Parameters:
226 
     - name
227 
     - url
228 
     - masterAffiliateId
229 
    """
230 
    pass
231 
 
232 
  def getAffiliateById(self, id):
233 
    """
234 
    Parameters:
235 
     - id
236 
    """
237 
    pass
238 
 
239 
  def getAffiliateByName(self, name):
240 
    """
241 
    Parameters:
242 
     - name
243 
    """
244 
    pass
245 
 
246 
  def getAffiliatesByMasterAffiliate(self, id):
247 
    """
248 
    Parameters:
249 
     - id
250 
    """
251 
    pass
252 
 
253 
  def createTracker(self, affiliateId):
254 
    """
255 
    Parameters:
256 
     - affiliateId
257 
    """
258 
    pass
259 
 
260 
  def getTrackerById(self, trackerId):
261 
    """
262 
    Parameters:
263 
     - trackerId
264 
    """
265 
    pass
266 
 
267 
  def getTrackersByAffiliate(self, affiliateId):
268 
    """
269 
    Parameters:
270 
     - affiliateId
271 
    """
272 
    pass
273 
 
274 
  def addTrackLog(self, trackerId, userId, event, url, data):
275 
    """
276 
    Parameters:
277 
     - trackerId
278 
     - userId
279 
     - event
280 
     - url
281 
     - data
282 
    """
283 
    pass
284 
 
285 
  def getTrackLogById(self, id):
286 
    """
287 
    Parameters:
288 
     - id
289 
    """
290 
    pass
291 
 
292 
  def getTrackLogsByTracker(self, trackerId):
293 
    """
294 
    Parameters:
295 
     - trackerId
296 
    """
297 
    pass
298 
 
299 
  def getTrackLogsByUser(self, userId):
300 
    """
301 
    Parameters:
302 
     - userId
303 
    """
304 
    pass
305 
 
306 
  def getTrackLogs(self, trackerId, userId, event, url):
307 
    """
308 
    Parameters:
309 
     - trackerId
310 
     - userId
311 
     - event
312 
     - url
313 
    """
314 
    pass
315 
 
559 chandransh 316 
  def createCart(self, userId):
94 ashish 317 
    """
318 
    Parameters:
559 chandransh 319 
     - userId
94 ashish 320 
    """
321 
    pass
322 
 
559 chandransh 323 
  def getCurrentCart(self, userId):
94 ashish 324 
    """
325 
    Parameters:
559 chandransh 326 
     - userId
94 ashish 327 
    """
328 
    pass
329 
 
559 chandransh 330 
  def getCart(self, cartId):
94 ashish 331 
    """
332 
    Parameters:
559 chandransh 333 
     - cartId
94 ashish 334 
    """
335 
    pass
336 
 
559 chandransh 337 
  def getCartsForUser(self, userId, status):
94 ashish 338 
    """
339 
    Parameters:
559 chandransh 340 
     - userId
341 
     - status
94 ashish 342 
    """
343 
    pass
344 
 
559 chandransh 345 
  def getCartsByStatus(self, status):
94 ashish 346 
    """
347 
    Parameters:
559 chandransh 348 
     - status
94 ashish 349 
    """
350 
    pass
351 
 
559 chandransh 352 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 353 
    """
354 
    Parameters:
559 chandransh 355 
     - from_time
356 
     - to_time
357 
     - status
94 ashish 358 
    """
359 
    pass
360 
 
559 chandransh 361 
  def changeCartStatus(self, cartId, status):
130 ashish 362 
    """
363 
    Parameters:
559 chandransh 364 
     - cartId
365 
     - status
130 ashish 366 
    """
367 
    pass
94 ashish 368 
 
559 chandransh 369 
  def addItemToCart(self, cartId, itemId, quantity):
130 ashish 370 
    """
371 
    Parameters:
559 chandransh 372 
     - cartId
373 
     - itemId
374 
     - quantity
130 ashish 375 
    """
376 
    pass
377 
 
559 chandransh 378 
  def deleteItemFromCart(self, cartId, itemId):
379 
    """
380 
    Parameters:
381 
     - cartId
382 
     - itemId
383 
    """
384 
    pass
130 ashish 385 
 
559 chandransh 386 
  def changeQuantity(self, cartId, itemId, quantity):
387 
    """
388 
    Parameters:
389 
     - cartId
390 
     - itemId
391 
     - quantity
392 
    """
393 
    pass
394 
 
395 
  def changeItemStatus(self, cartId, itemId, status):
396 
    """
397 
    Parameters:
398 
     - cartId
399 
     - itemId
400 
     - status
401 
    """
402 
    pass
403 
 
404 
  def addAddressToCart(self, cartId, addressId):
405 
    """
406 
    Parameters:
407 
     - cartId
408 
     - addressId
409 
    """
410 
    pass
411 
 
690 chandransh 412 
  def createOrders(self, cartId):
559 chandransh 413 
    """
690 chandransh 414 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
415 
 
559 chandransh 416 
    Parameters:
417 
     - cartId
418 
    """
419 
    pass
420 
 
421 
  def validateCart(self, cartId):
422 
    """
690 chandransh 423 
    Validates that:
424 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 425 
    2. All of the lines in the cart are active items.
690 chandransh 426 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 427 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 428 
 
559 chandransh 429 
    Parameters:
430 
     - cartId
431 
    """
432 
    pass
433 
 
690 chandransh 434 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 435 
    """
690 chandransh 436 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
437 
 
575 chandransh 438 
    Parameters:
690 chandransh 439 
     - fromCartId
440 
     - toCartId
441 
    """
442 
    pass
443 
 
444 
  def checkOut(self, cartId):
445 
    """
446 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
447 
 
448 
    Parameters:
575 chandransh 449 
     - cartId
450 
    """
451 
    pass
452 
 
690 chandransh 453 
  def resetCart(self, cartId, items):
559 chandransh 454 
    """
690 chandransh 455 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
456 
    This methods removes the specified quantiry of the specified item from the cart.
457 
 
559 chandransh 458 
    Parameters:
690 chandransh 459 
     - cartId
460 
     - items
559 chandransh 461 
    """
462 
    pass
463 
 
772 rajveer 464 
  def getMyResearch(self, userId):
559 chandransh 465 
    """
772 rajveer 466 
    Widgets
467 
 
559 chandransh 468 
    Parameters:
772 rajveer 469 
     - userId
559 chandransh 470 
    """
471 
    pass
472 
 
772 rajveer 473 
  def updateMyResearch(self, userId, itemId):
559 chandransh 474 
    """
475 
    Parameters:
772 rajveer 476 
     - userId
477 
     - itemId
559 chandransh 478 
    """
479 
    pass
480 
 
772 rajveer 481 
  def deleteItemFromMyResearch(self, userId, itemId):
559 chandransh 482 
    """
483 
    Parameters:
772 rajveer 484 
     - userId
485 
     - itemId
559 chandransh 486 
    """
487 
    pass
488 
 
772 rajveer 489 
  def updateBrowseHistory(self, userId, itemId):
559 chandransh 490 
    """
491 
    Parameters:
772 rajveer 492 
     - userId
493 
     - itemId
559 chandransh 494 
    """
495 
    pass
496 
 
772 rajveer 497 
  def getBrowseHistory(self, userId):
559 chandransh 498 
    """
499 
    Parameters:
500 
     - userId
501 
    """
502 
    pass
503 
 
772 rajveer 504 
  def mergeBrowseHistory(self, fromUserId, toUserId):
559 chandransh 505 
    """
506 
    Parameters:
772 rajveer 507 
     - fromUserId
508 
     - toUserId
559 chandransh 509 
    """
510 
    pass
511 
 
1596 ankur.sing 512 
  def getUserCount(self, userType):
513 
    """
514 
    Returns number of registered users.
515 
    If userType = null, then it returns count of all users, including anonymous
516 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
517 
    If userType = UserType.USER, then it returns count of non-anonymous users only
518 
 
519 
    Parameters:
520 
     - userType
521 
    """
522 
    pass
559 chandransh 523 
 
1673 ankur.sing 524 
  def getAllUsers(self, userType):
525 
    """
526 
    Returns list of users of type userType. If userType is null, then returns all the users.
527 
 
528 
    Parameters:
529 
     - userType
530 
    """
531 
    pass
1596 ankur.sing 532 
 
1673 ankur.sing 533 
 
94 ashish 534 
class Client(Iface):
535 
  """
536 
  service
537 
  """
538 
  def __init__(self, iprot, oprot=None):
539 
    self._iprot = self._oprot = iprot
540 
    if oprot != None:
541 
      self._oprot = oprot
542 
    self._seqid = 0
543 
 
765 rajveer 544 
  def closeSession(self, ):
545 
    """
546 
    For closing the open session in sqlalchemy
547 
    """
548 
    self.send_closeSession()
549 
    self.recv_closeSession()
550 
 
551 
  def send_closeSession(self, ):
552 
    self._oprot.writeMessageBegin('closeSession', TMessageType.CALL, self._seqid)
553 
    args = closeSession_args()
554 
    args.write(self._oprot)
555 
    self._oprot.writeMessageEnd()
556 
    self._oprot.trans.flush()
557 
 
558 
  def recv_closeSession(self, ):
559 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
560 
    if mtype == TMessageType.EXCEPTION:
561 
      x = TApplicationException()
562 
      x.read(self._iprot)
563 
      self._iprot.readMessageEnd()
564 
      raise x
565 
    result = closeSession_result()
566 
    result.read(self._iprot)
567 
    self._iprot.readMessageEnd()
568 
    return
569 
 
559 chandransh 570 
  def createAnonymousUser(self, jsessionId):
94 ashish 571 
    """
572 
    Parameters:
559 chandransh 573 
     - jsessionId
94 ashish 574 
    """
559 chandransh 575 
    self.send_createAnonymousUser(jsessionId)
576 
    return self.recv_createAnonymousUser()
94 ashish 577 
 
559 chandransh 578 
  def send_createAnonymousUser(self, jsessionId):
579 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
580 
    args = createAnonymousUser_args()
581 
    args.jsessionId = jsessionId
94 ashish 582 
    args.write(self._oprot)
583 
    self._oprot.writeMessageEnd()
584 
    self._oprot.trans.flush()
585 
 
559 chandransh 586 
  def recv_createAnonymousUser(self, ):
94 ashish 587 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
588 
    if mtype == TMessageType.EXCEPTION:
589 
      x = TApplicationException()
590 
      x.read(self._iprot)
591 
      self._iprot.readMessageEnd()
592 
      raise x
559 chandransh 593 
    result = createAnonymousUser_result()
94 ashish 594 
    result.read(self._iprot)
595 
    self._iprot.readMessageEnd()
596 
    if result.success != None:
597 
      return result.success
559 chandransh 598 
    if result.ucex != None:
599 
      raise result.ucex
600 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 601 
 
559 chandransh 602 
  def getUserById(self, userId):
94 ashish 603 
    """
604 
    Parameters:
605 
     - userId
606 
    """
559 chandransh 607 
    self.send_getUserById(userId)
608 
    return self.recv_getUserById()
94 ashish 609 
 
559 chandransh 610 
  def send_getUserById(self, userId):
611 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
612 
    args = getUserById_args()
94 ashish 613 
    args.userId = userId
614 
    args.write(self._oprot)
615 
    self._oprot.writeMessageEnd()
616 
    self._oprot.trans.flush()
617 
 
559 chandransh 618 
  def recv_getUserById(self, ):
94 ashish 619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
620 
    if mtype == TMessageType.EXCEPTION:
621 
      x = TApplicationException()
622 
      x.read(self._iprot)
623 
      self._iprot.readMessageEnd()
624 
      raise x
559 chandransh 625 
    result = getUserById_result()
94 ashish 626 
    result.read(self._iprot)
627 
    self._iprot.readMessageEnd()
628 
    if result.success != None:
629 
      return result.success
559 chandransh 630 
    if result.ucex != None:
631 
      raise result.ucex
632 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 633 
 
1491 vikas 634 
  def getUserByEmail(self, email):
635 
    """
636 
    Parameters:
637 
     - email
638 
    """
639 
    self.send_getUserByEmail(email)
640 
    return self.recv_getUserByEmail()
641 
 
642 
  def send_getUserByEmail(self, email):
643 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
644 
    args = getUserByEmail_args()
645 
    args.email = email
646 
    args.write(self._oprot)
647 
    self._oprot.writeMessageEnd()
648 
    self._oprot.trans.flush()
649 
 
650 
  def recv_getUserByEmail(self, ):
651 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
652 
    if mtype == TMessageType.EXCEPTION:
653 
      x = TApplicationException()
654 
      x.read(self._iprot)
655 
      self._iprot.readMessageEnd()
656 
      raise x
657 
    result = getUserByEmail_result()
658 
    result.read(self._iprot)
659 
    self._iprot.readMessageEnd()
660 
    if result.success != None:
661 
      return result.success
662 
    if result.ucex != None:
663 
      raise result.ucex
664 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
665 
 
559 chandransh 666 
  def createUser(self, user):
94 ashish 667 
    """
668 
    Parameters:
559 chandransh 669 
     - user
94 ashish 670 
    """
559 chandransh 671 
    self.send_createUser(user)
672 
    return self.recv_createUser()
94 ashish 673 
 
559 chandransh 674 
  def send_createUser(self, user):
675 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
676 
    args = createUser_args()
677 
    args.user = user
94 ashish 678 
    args.write(self._oprot)
679 
    self._oprot.writeMessageEnd()
680 
    self._oprot.trans.flush()
681 
 
559 chandransh 682 
  def recv_createUser(self, ):
94 ashish 683 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
684 
    if mtype == TMessageType.EXCEPTION:
685 
      x = TApplicationException()
686 
      x.read(self._iprot)
687 
      self._iprot.readMessageEnd()
688 
      raise x
559 chandransh 689 
    result = createUser_result()
94 ashish 690 
    result.read(self._iprot)
691 
    self._iprot.readMessageEnd()
692 
    if result.success != None:
693 
      return result.success
559 chandransh 694 
    if result.ucex != None:
695 
      raise result.ucex
696 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 697 
 
559 chandransh 698 
  def updateUser(self, user):
94 ashish 699 
    """
700 
    Parameters:
559 chandransh 701 
     - user
94 ashish 702 
    """
559 chandransh 703 
    self.send_updateUser(user)
704 
    return self.recv_updateUser()
94 ashish 705 
 
559 chandransh 706 
  def send_updateUser(self, user):
707 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
708 
    args = updateUser_args()
709 
    args.user = user
94 ashish 710 
    args.write(self._oprot)
711 
    self._oprot.writeMessageEnd()
712 
    self._oprot.trans.flush()
713 
 
559 chandransh 714 
  def recv_updateUser(self, ):
94 ashish 715 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
716 
    if mtype == TMessageType.EXCEPTION:
717 
      x = TApplicationException()
718 
      x.read(self._iprot)
719 
      self._iprot.readMessageEnd()
720 
      raise x
559 chandransh 721 
    result = updateUser_result()
94 ashish 722 
    result.read(self._iprot)
723 
    self._iprot.readMessageEnd()
724 
    if result.success != None:
725 
      return result.success
559 chandransh 726 
    if result.ucex != None:
727 
      raise result.ucex
728 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 729 
 
559 chandransh 730 
  def deleteUser(self, userId):
94 ashish 731 
    """
732 
    Parameters:
733 
     - userId
734 
    """
559 chandransh 735 
    self.send_deleteUser(userId)
736 
    return self.recv_deleteUser()
94 ashish 737 
 
559 chandransh 738 
  def send_deleteUser(self, userId):
739 
    self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
740 
    args = deleteUser_args()
94 ashish 741 
    args.userId = userId
742 
    args.write(self._oprot)
743 
    self._oprot.writeMessageEnd()
744 
    self._oprot.trans.flush()
745 
 
559 chandransh 746 
  def recv_deleteUser(self, ):
94 ashish 747 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
748 
    if mtype == TMessageType.EXCEPTION:
749 
      x = TApplicationException()
750 
      x.read(self._iprot)
751 
      self._iprot.readMessageEnd()
752 
      raise x
559 chandransh 753 
    result = deleteUser_result()
94 ashish 754 
    result.read(self._iprot)
755 
    self._iprot.readMessageEnd()
756 
    if result.success != None:
757 
      return result.success
559 chandransh 758 
    if result.ucex != None:
759 
      raise result.ucex
760 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
94 ashish 761 
 
559 chandransh 762 
  def getUserState(self, userId):
94 ashish 763 
    """
764 
    Parameters:
765 
     - userId
766 
    """
559 chandransh 767 
    self.send_getUserState(userId)
768 
    return self.recv_getUserState()
94 ashish 769 
 
559 chandransh 770 
  def send_getUserState(self, userId):
771 
    self._oprot.writeMessageBegin('getUserState', TMessageType.CALL, self._seqid)
772 
    args = getUserState_args()
94 ashish 773 
    args.userId = userId
774 
    args.write(self._oprot)
775 
    self._oprot.writeMessageEnd()
776 
    self._oprot.trans.flush()
777 
 
559 chandransh 778 
  def recv_getUserState(self, ):
94 ashish 779 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
780 
    if mtype == TMessageType.EXCEPTION:
781 
      x = TApplicationException()
782 
      x.read(self._iprot)
783 
      self._iprot.readMessageEnd()
784 
      raise x
559 chandransh 785 
    result = getUserState_result()
94 ashish 786 
    result.read(self._iprot)
787 
    self._iprot.readMessageEnd()
788 
    if result.success != None:
789 
      return result.success
559 chandransh 790 
    if result.ucex != None:
791 
      raise result.ucex
792 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserState failed: unknown result");
94 ashish 793 
 
559 chandransh 794 
  def authenticateUser(self, email, password):
94 ashish 795 
    """
796 
    Parameters:
797 
     - email
798 
     - password
799 
    """
559 chandransh 800 
    self.send_authenticateUser(email, password)
122 ashish 801 
    return self.recv_authenticateUser()
802 
 
559 chandransh 803 
  def send_authenticateUser(self, email, password):
122 ashish 804 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
805 
    args = authenticateUser_args()
559 chandransh 806 
    args.email = email
122 ashish 807 
    args.password = password
808 
    args.write(self._oprot)
809 
    self._oprot.writeMessageEnd()
810 
    self._oprot.trans.flush()
811 
 
812 
  def recv_authenticateUser(self, ):
813 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
814 
    if mtype == TMessageType.EXCEPTION:
815 
      x = TApplicationException()
816 
      x.read(self._iprot)
817 
      self._iprot.readMessageEnd()
818 
      raise x
819 
    result = authenticateUser_result()
820 
    result.read(self._iprot)
821 
    self._iprot.readMessageEnd()
822 
    if result.success != None:
823 
      return result.success
559 chandransh 824 
    if result.auex != None:
825 
      raise result.auex
122 ashish 826 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
827 
 
94 ashish 828 
  def userExists(self, email):
829 
    """
830 
    Parameters:
831 
     - email
832 
    """
833 
    self.send_userExists(email)
834 
    return self.recv_userExists()
835 
 
836 
  def send_userExists(self, email):
837 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
838 
    args = userExists_args()
839 
    args.email = email
840 
    args.write(self._oprot)
841 
    self._oprot.writeMessageEnd()
842 
    self._oprot.trans.flush()
843 
 
844 
  def recv_userExists(self, ):
845 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
846 
    if mtype == TMessageType.EXCEPTION:
847 
      x = TApplicationException()
848 
      x.read(self._iprot)
849 
      self._iprot.readMessageEnd()
850 
      raise x
851 
    result = userExists_result()
852 
    result.read(self._iprot)
853 
    self._iprot.readMessageEnd()
854 
    if result.success != None:
855 
      return result.success
856 
    if result.ucx != None:
857 
      raise result.ucx
858 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
859 
 
567 rajveer 860 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 861 
    """
862 
    Parameters:
863 
     - userId
864 
     - address
513 rajveer 865 
     - setDefault
94 ashish 866 
    """
567 rajveer 867 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 868 
    return self.recv_addAddressForUser()
869 
 
567 rajveer 870 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 871 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
872 
    args = addAddressForUser_args()
559 chandransh 873 
    args.userId = userId
94 ashish 874 
    args.address = address
513 rajveer 875 
    args.setDefault = setDefault
94 ashish 876 
    args.write(self._oprot)
877 
    self._oprot.writeMessageEnd()
878 
    self._oprot.trans.flush()
879 
 
880 
  def recv_addAddressForUser(self, ):
881 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
882 
    if mtype == TMessageType.EXCEPTION:
883 
      x = TApplicationException()
884 
      x.read(self._iprot)
885 
      self._iprot.readMessageEnd()
886 
      raise x
887 
    result = addAddressForUser_result()
888 
    result.read(self._iprot)
889 
    self._iprot.readMessageEnd()
890 
    if result.success != None:
891 
      return result.success
892 
    if result.ucx != None:
893 
      raise result.ucx
894 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
895 
 
896 
  def removeAddressForUser(self, userid, addressId):
897 
    """
898 
    Parameters:
899 
     - userid
900 
     - addressId
901 
    """
902 
    self.send_removeAddressForUser(userid, addressId)
903 
    return self.recv_removeAddressForUser()
904 
 
905 
  def send_removeAddressForUser(self, userid, addressId):
906 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
907 
    args = removeAddressForUser_args()
908 
    args.userid = userid
909 
    args.addressId = addressId
910 
    args.write(self._oprot)
911 
    self._oprot.writeMessageEnd()
912 
    self._oprot.trans.flush()
913 
 
914 
  def recv_removeAddressForUser(self, ):
915 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
916 
    if mtype == TMessageType.EXCEPTION:
917 
      x = TApplicationException()
918 
      x.read(self._iprot)
919 
      self._iprot.readMessageEnd()
920 
      raise x
921 
    result = removeAddressForUser_result()
922 
    result.read(self._iprot)
923 
    self._iprot.readMessageEnd()
924 
    if result.success != None:
925 
      return result.success
926 
    if result.ucx != None:
927 
      raise result.ucx
928 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
929 
 
930 
  def setUserAsLoggedIn(self, userId, timestamp):
931 
    """
932 
    Parameters:
933 
     - userId
934 
     - timestamp
935 
    """
936 
    self.send_setUserAsLoggedIn(userId, timestamp)
937 
    return self.recv_setUserAsLoggedIn()
938 
 
939 
  def send_setUserAsLoggedIn(self, userId, timestamp):
940 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
941 
    args = setUserAsLoggedIn_args()
942 
    args.userId = userId
943 
    args.timestamp = timestamp
944 
    args.write(self._oprot)
945 
    self._oprot.writeMessageEnd()
946 
    self._oprot.trans.flush()
947 
 
948 
  def recv_setUserAsLoggedIn(self, ):
949 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
950 
    if mtype == TMessageType.EXCEPTION:
951 
      x = TApplicationException()
952 
      x.read(self._iprot)
953 
      self._iprot.readMessageEnd()
954 
      raise x
955 
    result = setUserAsLoggedIn_result()
956 
    result.read(self._iprot)
957 
    self._iprot.readMessageEnd()
958 
    if result.success != None:
959 
      return result.success
960 
    if result.ucx != None:
961 
      raise result.ucx
962 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
963 
 
964 
  def setUserAsLoggedOut(self, userid, timestamp):
965 
    """
966 
    Parameters:
967 
     - userid
968 
     - timestamp
969 
    """
970 
    self.send_setUserAsLoggedOut(userid, timestamp)
971 
    return self.recv_setUserAsLoggedOut()
972 
 
973 
  def send_setUserAsLoggedOut(self, userid, timestamp):
974 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
975 
    args = setUserAsLoggedOut_args()
976 
    args.userid = userid
977 
    args.timestamp = timestamp
978 
    args.write(self._oprot)
979 
    self._oprot.writeMessageEnd()
980 
    self._oprot.trans.flush()
981 
 
982 
  def recv_setUserAsLoggedOut(self, ):
983 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
984 
    if mtype == TMessageType.EXCEPTION:
985 
      x = TApplicationException()
986 
      x.read(self._iprot)
987 
      self._iprot.readMessageEnd()
988 
      raise x
989 
    result = setUserAsLoggedOut_result()
990 
    result.read(self._iprot)
991 
    self._iprot.readMessageEnd()
992 
    if result.success != None:
993 
      return result.success
994 
    if result.ucx != None:
995 
      raise result.ucx
996 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
997 
 
504 rajveer 998 
  def setDefaultAddress(self, userid, addressId):
999 
    """
1000 
    Parameters:
1001 
     - userid
1002 
     - addressId
1003 
    """
1004 
    self.send_setDefaultAddress(userid, addressId)
1005 
    return self.recv_setDefaultAddress()
1006 
 
1007 
  def send_setDefaultAddress(self, userid, addressId):
1008 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1009 
    args = setDefaultAddress_args()
1010 
    args.userid = userid
1011 
    args.addressId = addressId
1012 
    args.write(self._oprot)
1013 
    self._oprot.writeMessageEnd()
1014 
    self._oprot.trans.flush()
1015 
 
1016 
  def recv_setDefaultAddress(self, ):
1017 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1018 
    if mtype == TMessageType.EXCEPTION:
1019 
      x = TApplicationException()
1020 
      x.read(self._iprot)
1021 
      self._iprot.readMessageEnd()
1022 
      raise x
1023 
    result = setDefaultAddress_result()
1024 
    result.read(self._iprot)
1025 
    self._iprot.readMessageEnd()
1026 
    if result.success != None:
1027 
      return result.success
1028 
    if result.ucx != None:
1029 
      raise result.ucx
1030 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1031 
 
594 rajveer 1032 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1033 
    """
1034 
    Parameters:
1035 
     - userid
594 rajveer 1036 
     - oldPassword
1037 
     - newPassword
94 ashish 1038 
    """
594 rajveer 1039 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1040 
    return self.recv_updatePassword()
1041 
 
594 rajveer 1042 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1043 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1044 
    args = updatePassword_args()
1045 
    args.userid = userid
594 rajveer 1046 
    args.oldPassword = oldPassword
1047 
    args.newPassword = newPassword
94 ashish 1048 
    args.write(self._oprot)
1049 
    self._oprot.writeMessageEnd()
1050 
    self._oprot.trans.flush()
1051 
 
1052 
  def recv_updatePassword(self, ):
1053 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1054 
    if mtype == TMessageType.EXCEPTION:
1055 
      x = TApplicationException()
1056 
      x.read(self._iprot)
1057 
      self._iprot.readMessageEnd()
1058 
      raise x
1059 
    result = updatePassword_result()
1060 
    result.read(self._iprot)
1061 
    self._iprot.readMessageEnd()
1062 
    if result.success != None:
1063 
      return result.success
1064 
    if result.ucx != None:
1065 
      raise result.ucx
1066 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1067 
 
884 rajveer 1068 
  def forgotPassword(self, email, newPassword):
581 rajveer 1069 
    """
1070 
    Parameters:
1071 
     - email
884 rajveer 1072 
     - newPassword
581 rajveer 1073 
    """
884 rajveer 1074 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1075 
    return self.recv_forgotPassword()
1076 
 
884 rajveer 1077 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1078 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1079 
    args = forgotPassword_args()
1080 
    args.email = email
884 rajveer 1081 
    args.newPassword = newPassword
581 rajveer 1082 
    args.write(self._oprot)
1083 
    self._oprot.writeMessageEnd()
1084 
    self._oprot.trans.flush()
1085 
 
1086 
  def recv_forgotPassword(self, ):
1087 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1088 
    if mtype == TMessageType.EXCEPTION:
1089 
      x = TApplicationException()
1090 
      x.read(self._iprot)
1091 
      self._iprot.readMessageEnd()
1092 
      raise x
1093 
    result = forgotPassword_result()
1094 
    result.read(self._iprot)
1095 
    self._iprot.readMessageEnd()
1096 
    if result.success != None:
1097 
      return result.success
1098 
    if result.ucx != None:
1099 
      raise result.ucx
1100 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1101 
 
594 rajveer 1102 
  def getAllAddressesForUser(self, userId):
1103 
    """
1104 
    Parameters:
1105 
     - userId
1106 
    """
1107 
    self.send_getAllAddressesForUser(userId)
1108 
    return self.recv_getAllAddressesForUser()
1109 
 
1110 
  def send_getAllAddressesForUser(self, userId):
1111 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1112 
    args = getAllAddressesForUser_args()
1113 
    args.userId = userId
1114 
    args.write(self._oprot)
1115 
    self._oprot.writeMessageEnd()
1116 
    self._oprot.trans.flush()
1117 
 
1118 
  def recv_getAllAddressesForUser(self, ):
1119 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1120 
    if mtype == TMessageType.EXCEPTION:
1121 
      x = TApplicationException()
1122 
      x.read(self._iprot)
1123 
      self._iprot.readMessageEnd()
1124 
      raise x
1125 
    result = getAllAddressesForUser_result()
1126 
    result.read(self._iprot)
1127 
    self._iprot.readMessageEnd()
1128 
    if result.success != None:
1129 
      return result.success
1130 
    if result.ucx != None:
1131 
      raise result.ucx
1132 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1133 
 
1134 
  def getDefaultAddressId(self, userId):
1135 
    """
1136 
    Parameters:
1137 
     - userId
1138 
    """
1139 
    self.send_getDefaultAddressId(userId)
1140 
    return self.recv_getDefaultAddressId()
1141 
 
1142 
  def send_getDefaultAddressId(self, userId):
1143 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1144 
    args = getDefaultAddressId_args()
1145 
    args.userId = userId
1146 
    args.write(self._oprot)
1147 
    self._oprot.writeMessageEnd()
1148 
    self._oprot.trans.flush()
1149 
 
1150 
  def recv_getDefaultAddressId(self, ):
1151 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1152 
    if mtype == TMessageType.EXCEPTION:
1153 
      x = TApplicationException()
1154 
      x.read(self._iprot)
1155 
      self._iprot.readMessageEnd()
1156 
      raise x
1157 
    result = getDefaultAddressId_result()
1158 
    result.read(self._iprot)
1159 
    self._iprot.readMessageEnd()
1160 
    if result.success != None:
1161 
      return result.success
1162 
    if result.ucx != None:
1163 
      raise result.ucx
1164 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1165 
 
785 rajveer 1166 
  def getDefaultPincode(self, userId):
1167 
    """
1168 
    Parameters:
1169 
     - userId
1170 
    """
1171 
    self.send_getDefaultPincode(userId)
1172 
    return self.recv_getDefaultPincode()
1173 
 
1174 
  def send_getDefaultPincode(self, userId):
1175 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1176 
    args = getDefaultPincode_args()
1177 
    args.userId = userId
1178 
    args.write(self._oprot)
1179 
    self._oprot.writeMessageEnd()
1180 
    self._oprot.trans.flush()
1181 
 
1182 
  def recv_getDefaultPincode(self, ):
1183 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1184 
    if mtype == TMessageType.EXCEPTION:
1185 
      x = TApplicationException()
1186 
      x.read(self._iprot)
1187 
      self._iprot.readMessageEnd()
1188 
      raise x
1189 
    result = getDefaultPincode_result()
1190 
    result.read(self._iprot)
1191 
    self._iprot.readMessageEnd()
1192 
    if result.success != None:
1193 
      return result.success
1194 
    if result.ucx != None:
1195 
      raise result.ucx
1196 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1197 
 
1274 varun.gupt 1198 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1199 
    """
1200 
    Parameters:
1201 
     - userId
1202 
     - replyTo
1203 
     - communicationType
1204 
     - orderId
1205 
     - airwaybillNo
1206 
     - productName
1207 
     - subject
1208 
     - message
1209 
    """
1210 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1211 
    return self.recv_saveUserCommunication()
1212 
 
1213 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1214 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1215 
    args = saveUserCommunication_args()
1216 
    args.userId = userId
1217 
    args.replyTo = replyTo
1218 
    args.communicationType = communicationType
1219 
    args.orderId = orderId
1220 
    args.airwaybillNo = airwaybillNo
1221 
    args.productName = productName
1222 
    args.subject = subject
1223 
    args.message = message
1224 
    args.write(self._oprot)
1225 
    self._oprot.writeMessageEnd()
1226 
    self._oprot.trans.flush()
1227 
 
1228 
  def recv_saveUserCommunication(self, ):
1229 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1230 
    if mtype == TMessageType.EXCEPTION:
1231 
      x = TApplicationException()
1232 
      x.read(self._iprot)
1233 
      self._iprot.readMessageEnd()
1234 
      raise x
1235 
    result = saveUserCommunication_result()
1236 
    result.read(self._iprot)
1237 
    self._iprot.readMessageEnd()
1238 
    if result.success != None:
1239 
      return result.success
1240 
    if result.ucx != None:
1241 
      raise result.ucx
1242 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1243 
 
1590 varun.gupt 1244 
  def getUserCommunicationById(self, id):
1245 
    """
1246 
    Parameters:
1247 
     - id
1248 
    """
1249 
    self.send_getUserCommunicationById(id)
1250 
    return self.recv_getUserCommunicationById()
1251 
 
1252 
  def send_getUserCommunicationById(self, id):
1253 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1254 
    args = getUserCommunicationById_args()
1255 
    args.id = id
1256 
    args.write(self._oprot)
1257 
    self._oprot.writeMessageEnd()
1258 
    self._oprot.trans.flush()
1259 
 
1260 
  def recv_getUserCommunicationById(self, ):
1261 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1262 
    if mtype == TMessageType.EXCEPTION:
1263 
      x = TApplicationException()
1264 
      x.read(self._iprot)
1265 
      self._iprot.readMessageEnd()
1266 
      raise x
1267 
    result = getUserCommunicationById_result()
1268 
    result.read(self._iprot)
1269 
    self._iprot.readMessageEnd()
1270 
    if result.success != None:
1271 
      return result.success
1272 
    if result.ucx != None:
1273 
      raise result.ucx
1274 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1275 
 
1276 
  def getUserCommunicationByUser(self, userId):
1277 
    """
1278 
    Parameters:
1279 
     - userId
1280 
    """
1281 
    self.send_getUserCommunicationByUser(userId)
1282 
    return self.recv_getUserCommunicationByUser()
1283 
 
1284 
  def send_getUserCommunicationByUser(self, userId):
1285 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1286 
    args = getUserCommunicationByUser_args()
1287 
    args.userId = userId
1288 
    args.write(self._oprot)
1289 
    self._oprot.writeMessageEnd()
1290 
    self._oprot.trans.flush()
1291 
 
1292 
  def recv_getUserCommunicationByUser(self, ):
1293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1294 
    if mtype == TMessageType.EXCEPTION:
1295 
      x = TApplicationException()
1296 
      x.read(self._iprot)
1297 
      self._iprot.readMessageEnd()
1298 
      raise x
1299 
    result = getUserCommunicationByUser_result()
1300 
    result.read(self._iprot)
1301 
    self._iprot.readMessageEnd()
1302 
    if result.success != None:
1303 
      return result.success
1304 
    if result.ucx != None:
1305 
      raise result.ucx
1306 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1307 
 
1308 
  def getAllUserCommunications(self, ):
1309 
    self.send_getAllUserCommunications()
1310 
    return self.recv_getAllUserCommunications()
1311 
 
1312 
  def send_getAllUserCommunications(self, ):
1313 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1314 
    args = getAllUserCommunications_args()
1315 
    args.write(self._oprot)
1316 
    self._oprot.writeMessageEnd()
1317 
    self._oprot.trans.flush()
1318 
 
1319 
  def recv_getAllUserCommunications(self, ):
1320 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1321 
    if mtype == TMessageType.EXCEPTION:
1322 
      x = TApplicationException()
1323 
      x.read(self._iprot)
1324 
      self._iprot.readMessageEnd()
1325 
      raise x
1326 
    result = getAllUserCommunications_result()
1327 
    result.read(self._iprot)
1328 
    self._iprot.readMessageEnd()
1329 
    if result.success != None:
1330 
      return result.success
1331 
    if result.ucx != None:
1332 
      raise result.ucx
1333 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1334 
 
1845 vikas 1335 
  def createMasterAffiliate(self, name):
1336 
    """
1337 
    Parameters:
1338 
     - name
1339 
    """
1340 
    self.send_createMasterAffiliate(name)
1341 
    return self.recv_createMasterAffiliate()
1342 
 
1343 
  def send_createMasterAffiliate(self, name):
1344 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1345 
    args = createMasterAffiliate_args()
1346 
    args.name = name
1347 
    args.write(self._oprot)
1348 
    self._oprot.writeMessageEnd()
1349 
    self._oprot.trans.flush()
1350 
 
1351 
  def recv_createMasterAffiliate(self, ):
1352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1353 
    if mtype == TMessageType.EXCEPTION:
1354 
      x = TApplicationException()
1355 
      x.read(self._iprot)
1356 
      self._iprot.readMessageEnd()
1357 
      raise x
1358 
    result = createMasterAffiliate_result()
1359 
    result.read(self._iprot)
1360 
    self._iprot.readMessageEnd()
1361 
    if result.success != None:
1362 
      return result.success
1363 
    if result.utx != None:
1364 
      raise result.utx
1365 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1366 
 
1367 
  def getMasterAffiliateById(self, id):
1368 
    """
1369 
    Parameters:
1370 
     - id
1371 
    """
1372 
    self.send_getMasterAffiliateById(id)
1373 
    return self.recv_getMasterAffiliateById()
1374 
 
1375 
  def send_getMasterAffiliateById(self, id):
1376 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1377 
    args = getMasterAffiliateById_args()
1378 
    args.id = id
1379 
    args.write(self._oprot)
1380 
    self._oprot.writeMessageEnd()
1381 
    self._oprot.trans.flush()
1382 
 
1383 
  def recv_getMasterAffiliateById(self, ):
1384 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1385 
    if mtype == TMessageType.EXCEPTION:
1386 
      x = TApplicationException()
1387 
      x.read(self._iprot)
1388 
      self._iprot.readMessageEnd()
1389 
      raise x
1390 
    result = getMasterAffiliateById_result()
1391 
    result.read(self._iprot)
1392 
    self._iprot.readMessageEnd()
1393 
    if result.success != None:
1394 
      return result.success
1395 
    if result.utx != None:
1396 
      raise result.utx
1397 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1398 
 
1399 
  def getMasterAffiliateByName(self, name):
1400 
    """
1401 
    Parameters:
1402 
     - name
1403 
    """
1404 
    self.send_getMasterAffiliateByName(name)
1405 
    return self.recv_getMasterAffiliateByName()
1406 
 
1407 
  def send_getMasterAffiliateByName(self, name):
1408 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1409 
    args = getMasterAffiliateByName_args()
1410 
    args.name = name
1411 
    args.write(self._oprot)
1412 
    self._oprot.writeMessageEnd()
1413 
    self._oprot.trans.flush()
1414 
 
1415 
  def recv_getMasterAffiliateByName(self, ):
1416 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1417 
    if mtype == TMessageType.EXCEPTION:
1418 
      x = TApplicationException()
1419 
      x.read(self._iprot)
1420 
      self._iprot.readMessageEnd()
1421 
      raise x
1422 
    result = getMasterAffiliateByName_result()
1423 
    result.read(self._iprot)
1424 
    self._iprot.readMessageEnd()
1425 
    if result.success != None:
1426 
      return result.success
1427 
    if result.utx != None:
1428 
      raise result.utx
1429 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1430 
 
1431 
  def createAffiliate(self, name, url, masterAffiliateId):
1432 
    """
1433 
    Parameters:
1434 
     - name
1435 
     - url
1436 
     - masterAffiliateId
1437 
    """
1438 
    self.send_createAffiliate(name, url, masterAffiliateId)
1439 
    return self.recv_createAffiliate()
1440 
 
1441 
  def send_createAffiliate(self, name, url, masterAffiliateId):
1442 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1443 
    args = createAffiliate_args()
1444 
    args.name = name
1445 
    args.url = url
1446 
    args.masterAffiliateId = masterAffiliateId
1447 
    args.write(self._oprot)
1448 
    self._oprot.writeMessageEnd()
1449 
    self._oprot.trans.flush()
1450 
 
1451 
  def recv_createAffiliate(self, ):
1452 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1453 
    if mtype == TMessageType.EXCEPTION:
1454 
      x = TApplicationException()
1455 
      x.read(self._iprot)
1456 
      self._iprot.readMessageEnd()
1457 
      raise x
1458 
    result = createAffiliate_result()
1459 
    result.read(self._iprot)
1460 
    self._iprot.readMessageEnd()
1461 
    if result.success != None:
1462 
      return result.success
1463 
    if result.utx != None:
1464 
      raise result.utx
1465 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1466 
 
1467 
  def getAffiliateById(self, id):
1468 
    """
1469 
    Parameters:
1470 
     - id
1471 
    """
1472 
    self.send_getAffiliateById(id)
1473 
    return self.recv_getAffiliateById()
1474 
 
1475 
  def send_getAffiliateById(self, id):
1476 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1477 
    args = getAffiliateById_args()
1478 
    args.id = id
1479 
    args.write(self._oprot)
1480 
    self._oprot.writeMessageEnd()
1481 
    self._oprot.trans.flush()
1482 
 
1483 
  def recv_getAffiliateById(self, ):
1484 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1485 
    if mtype == TMessageType.EXCEPTION:
1486 
      x = TApplicationException()
1487 
      x.read(self._iprot)
1488 
      self._iprot.readMessageEnd()
1489 
      raise x
1490 
    result = getAffiliateById_result()
1491 
    result.read(self._iprot)
1492 
    self._iprot.readMessageEnd()
1493 
    if result.success != None:
1494 
      return result.success
1495 
    if result.utx != None:
1496 
      raise result.utx
1497 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1498 
 
1499 
  def getAffiliateByName(self, name):
1500 
    """
1501 
    Parameters:
1502 
     - name
1503 
    """
1504 
    self.send_getAffiliateByName(name)
1505 
    return self.recv_getAffiliateByName()
1506 
 
1507 
  def send_getAffiliateByName(self, name):
1508 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1509 
    args = getAffiliateByName_args()
1510 
    args.name = name
1511 
    args.write(self._oprot)
1512 
    self._oprot.writeMessageEnd()
1513 
    self._oprot.trans.flush()
1514 
 
1515 
  def recv_getAffiliateByName(self, ):
1516 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1517 
    if mtype == TMessageType.EXCEPTION:
1518 
      x = TApplicationException()
1519 
      x.read(self._iprot)
1520 
      self._iprot.readMessageEnd()
1521 
      raise x
1522 
    result = getAffiliateByName_result()
1523 
    result.read(self._iprot)
1524 
    self._iprot.readMessageEnd()
1525 
    if result.success != None:
1526 
      return result.success
1527 
    if result.utx != None:
1528 
      raise result.utx
1529 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1530 
 
1531 
  def getAffiliatesByMasterAffiliate(self, id):
1532 
    """
1533 
    Parameters:
1534 
     - id
1535 
    """
1536 
    self.send_getAffiliatesByMasterAffiliate(id)
1537 
    return self.recv_getAffiliatesByMasterAffiliate()
1538 
 
1539 
  def send_getAffiliatesByMasterAffiliate(self, id):
1540 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1541 
    args = getAffiliatesByMasterAffiliate_args()
1542 
    args.id = id
1543 
    args.write(self._oprot)
1544 
    self._oprot.writeMessageEnd()
1545 
    self._oprot.trans.flush()
1546 
 
1547 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1548 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1549 
    if mtype == TMessageType.EXCEPTION:
1550 
      x = TApplicationException()
1551 
      x.read(self._iprot)
1552 
      self._iprot.readMessageEnd()
1553 
      raise x
1554 
    result = getAffiliatesByMasterAffiliate_result()
1555 
    result.read(self._iprot)
1556 
    self._iprot.readMessageEnd()
1557 
    if result.success != None:
1558 
      return result.success
1559 
    if result.utx != None:
1560 
      raise result.utx
1561 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1562 
 
1563 
  def createTracker(self, affiliateId):
1564 
    """
1565 
    Parameters:
1566 
     - affiliateId
1567 
    """
1568 
    self.send_createTracker(affiliateId)
1569 
    return self.recv_createTracker()
1570 
 
1571 
  def send_createTracker(self, affiliateId):
1572 
    self._oprot.writeMessageBegin('createTracker', TMessageType.CALL, self._seqid)
1573 
    args = createTracker_args()
1574 
    args.affiliateId = affiliateId
1575 
    args.write(self._oprot)
1576 
    self._oprot.writeMessageEnd()
1577 
    self._oprot.trans.flush()
1578 
 
1579 
  def recv_createTracker(self, ):
1580 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1581 
    if mtype == TMessageType.EXCEPTION:
1582 
      x = TApplicationException()
1583 
      x.read(self._iprot)
1584 
      self._iprot.readMessageEnd()
1585 
      raise x
1586 
    result = createTracker_result()
1587 
    result.read(self._iprot)
1588 
    self._iprot.readMessageEnd()
1589 
    if result.success != None:
1590 
      return result.success
1591 
    if result.utx != None:
1592 
      raise result.utx
1593 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTracker failed: unknown result");
1594 
 
1595 
  def getTrackerById(self, trackerId):
1596 
    """
1597 
    Parameters:
1598 
     - trackerId
1599 
    """
1600 
    self.send_getTrackerById(trackerId)
1601 
    return self.recv_getTrackerById()
1602 
 
1603 
  def send_getTrackerById(self, trackerId):
1604 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1605 
    args = getTrackerById_args()
1606 
    args.trackerId = trackerId
1607 
    args.write(self._oprot)
1608 
    self._oprot.writeMessageEnd()
1609 
    self._oprot.trans.flush()
1610 
 
1611 
  def recv_getTrackerById(self, ):
1612 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1613 
    if mtype == TMessageType.EXCEPTION:
1614 
      x = TApplicationException()
1615 
      x.read(self._iprot)
1616 
      self._iprot.readMessageEnd()
1617 
      raise x
1618 
    result = getTrackerById_result()
1619 
    result.read(self._iprot)
1620 
    self._iprot.readMessageEnd()
1621 
    if result.success != None:
1622 
      return result.success
1623 
    if result.utx != None:
1624 
      raise result.utx
1625 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1626 
 
1627 
  def getTrackersByAffiliate(self, affiliateId):
1628 
    """
1629 
    Parameters:
1630 
     - affiliateId
1631 
    """
1632 
    self.send_getTrackersByAffiliate(affiliateId)
1633 
    return self.recv_getTrackersByAffiliate()
1634 
 
1635 
  def send_getTrackersByAffiliate(self, affiliateId):
1636 
    self._oprot.writeMessageBegin('getTrackersByAffiliate', TMessageType.CALL, self._seqid)
1637 
    args = getTrackersByAffiliate_args()
1638 
    args.affiliateId = affiliateId
1639 
    args.write(self._oprot)
1640 
    self._oprot.writeMessageEnd()
1641 
    self._oprot.trans.flush()
1642 
 
1643 
  def recv_getTrackersByAffiliate(self, ):
1644 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1645 
    if mtype == TMessageType.EXCEPTION:
1646 
      x = TApplicationException()
1647 
      x.read(self._iprot)
1648 
      self._iprot.readMessageEnd()
1649 
      raise x
1650 
    result = getTrackersByAffiliate_result()
1651 
    result.read(self._iprot)
1652 
    self._iprot.readMessageEnd()
1653 
    if result.success != None:
1654 
      return result.success
1655 
    if result.utx != None:
1656 
      raise result.utx
1657 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackersByAffiliate failed: unknown result");
1658 
 
1659 
  def addTrackLog(self, trackerId, userId, event, url, data):
1660 
    """
1661 
    Parameters:
1662 
     - trackerId
1663 
     - userId
1664 
     - event
1665 
     - url
1666 
     - data
1667 
    """
1668 
    self.send_addTrackLog(trackerId, userId, event, url, data)
1669 
    return self.recv_addTrackLog()
1670 
 
1671 
  def send_addTrackLog(self, trackerId, userId, event, url, data):
1672 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1673 
    args = addTrackLog_args()
1674 
    args.trackerId = trackerId
1675 
    args.userId = userId
1676 
    args.event = event
1677 
    args.url = url
1678 
    args.data = data
1679 
    args.write(self._oprot)
1680 
    self._oprot.writeMessageEnd()
1681 
    self._oprot.trans.flush()
1682 
 
1683 
  def recv_addTrackLog(self, ):
1684 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1685 
    if mtype == TMessageType.EXCEPTION:
1686 
      x = TApplicationException()
1687 
      x.read(self._iprot)
1688 
      self._iprot.readMessageEnd()
1689 
      raise x
1690 
    result = addTrackLog_result()
1691 
    result.read(self._iprot)
1692 
    self._iprot.readMessageEnd()
1693 
    if result.success != None:
1694 
      return result.success
1695 
    if result.utx != None:
1696 
      raise result.utx
1697 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1698 
 
1699 
  def getTrackLogById(self, id):
1700 
    """
1701 
    Parameters:
1702 
     - id
1703 
    """
1704 
    self.send_getTrackLogById(id)
1705 
    return self.recv_getTrackLogById()
1706 
 
1707 
  def send_getTrackLogById(self, id):
1708 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1709 
    args = getTrackLogById_args()
1710 
    args.id = id
1711 
    args.write(self._oprot)
1712 
    self._oprot.writeMessageEnd()
1713 
    self._oprot.trans.flush()
1714 
 
1715 
  def recv_getTrackLogById(self, ):
1716 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1717 
    if mtype == TMessageType.EXCEPTION:
1718 
      x = TApplicationException()
1719 
      x.read(self._iprot)
1720 
      self._iprot.readMessageEnd()
1721 
      raise x
1722 
    result = getTrackLogById_result()
1723 
    result.read(self._iprot)
1724 
    self._iprot.readMessageEnd()
1725 
    if result.success != None:
1726 
      return result.success
1727 
    if result.utx != None:
1728 
      raise result.utx
1729 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1730 
 
1731 
  def getTrackLogsByTracker(self, trackerId):
1732 
    """
1733 
    Parameters:
1734 
     - trackerId
1735 
    """
1736 
    self.send_getTrackLogsByTracker(trackerId)
1737 
    return self.recv_getTrackLogsByTracker()
1738 
 
1739 
  def send_getTrackLogsByTracker(self, trackerId):
1740 
    self._oprot.writeMessageBegin('getTrackLogsByTracker', TMessageType.CALL, self._seqid)
1741 
    args = getTrackLogsByTracker_args()
1742 
    args.trackerId = trackerId
1743 
    args.write(self._oprot)
1744 
    self._oprot.writeMessageEnd()
1745 
    self._oprot.trans.flush()
1746 
 
1747 
  def recv_getTrackLogsByTracker(self, ):
1748 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1749 
    if mtype == TMessageType.EXCEPTION:
1750 
      x = TApplicationException()
1751 
      x.read(self._iprot)
1752 
      self._iprot.readMessageEnd()
1753 
      raise x
1754 
    result = getTrackLogsByTracker_result()
1755 
    result.read(self._iprot)
1756 
    self._iprot.readMessageEnd()
1757 
    if result.success != None:
1758 
      return result.success
1759 
    if result.utx != None:
1760 
      raise result.utx
1761 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByTracker failed: unknown result");
1762 
 
1763 
  def getTrackLogsByUser(self, userId):
1764 
    """
1765 
    Parameters:
1766 
     - userId
1767 
    """
1768 
    self.send_getTrackLogsByUser(userId)
1769 
    return self.recv_getTrackLogsByUser()
1770 
 
1771 
  def send_getTrackLogsByUser(self, userId):
1772 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
1773 
    args = getTrackLogsByUser_args()
1774 
    args.userId = userId
1775 
    args.write(self._oprot)
1776 
    self._oprot.writeMessageEnd()
1777 
    self._oprot.trans.flush()
1778 
 
1779 
  def recv_getTrackLogsByUser(self, ):
1780 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1781 
    if mtype == TMessageType.EXCEPTION:
1782 
      x = TApplicationException()
1783 
      x.read(self._iprot)
1784 
      self._iprot.readMessageEnd()
1785 
      raise x
1786 
    result = getTrackLogsByUser_result()
1787 
    result.read(self._iprot)
1788 
    self._iprot.readMessageEnd()
1789 
    if result.success != None:
1790 
      return result.success
1791 
    if result.utx != None:
1792 
      raise result.utx
1793 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
1794 
 
1795 
  def getTrackLogs(self, trackerId, userId, event, url):
1796 
    """
1797 
    Parameters:
1798 
     - trackerId
1799 
     - userId
1800 
     - event
1801 
     - url
1802 
    """
1803 
    self.send_getTrackLogs(trackerId, userId, event, url)
1804 
    return self.recv_getTrackLogs()
1805 
 
1806 
  def send_getTrackLogs(self, trackerId, userId, event, url):
1807 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
1808 
    args = getTrackLogs_args()
1809 
    args.trackerId = trackerId
1810 
    args.userId = userId
1811 
    args.event = event
1812 
    args.url = url
1813 
    args.write(self._oprot)
1814 
    self._oprot.writeMessageEnd()
1815 
    self._oprot.trans.flush()
1816 
 
1817 
  def recv_getTrackLogs(self, ):
1818 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1819 
    if mtype == TMessageType.EXCEPTION:
1820 
      x = TApplicationException()
1821 
      x.read(self._iprot)
1822 
      self._iprot.readMessageEnd()
1823 
      raise x
1824 
    result = getTrackLogs_result()
1825 
    result.read(self._iprot)
1826 
    self._iprot.readMessageEnd()
1827 
    if result.success != None:
1828 
      return result.success
1829 
    if result.utx != None:
1830 
      raise result.utx
1831 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
1832 
 
559 chandransh 1833 
  def createCart(self, userId):
94 ashish 1834 
    """
1835 
    Parameters:
559 chandransh 1836 
     - userId
94 ashish 1837 
    """
559 chandransh 1838 
    self.send_createCart(userId)
1839 
    return self.recv_createCart()
94 ashish 1840 
 
559 chandransh 1841 
  def send_createCart(self, userId):
1842 
    self._oprot.writeMessageBegin('createCart', TMessageType.CALL, self._seqid)
1843 
    args = createCart_args()
1844 
    args.userId = userId
94 ashish 1845 
    args.write(self._oprot)
1846 
    self._oprot.writeMessageEnd()
1847 
    self._oprot.trans.flush()
1848 
 
559 chandransh 1849 
  def recv_createCart(self, ):
94 ashish 1850 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1851 
    if mtype == TMessageType.EXCEPTION:
1852 
      x = TApplicationException()
1853 
      x.read(self._iprot)
1854 
      self._iprot.readMessageEnd()
1855 
      raise x
559 chandransh 1856 
    result = createCart_result()
94 ashish 1857 
    result.read(self._iprot)
1858 
    self._iprot.readMessageEnd()
1859 
    if result.success != None:
1860 
      return result.success
559 chandransh 1861 
    if result.scx != None:
1862 
      raise result.scx
1863 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createCart failed: unknown result");
94 ashish 1864 
 
559 chandransh 1865 
  def getCurrentCart(self, userId):
94 ashish 1866 
    """
1867 
    Parameters:
559 chandransh 1868 
     - userId
94 ashish 1869 
    """
559 chandransh 1870 
    self.send_getCurrentCart(userId)
1871 
    return self.recv_getCurrentCart()
94 ashish 1872 
 
559 chandransh 1873 
  def send_getCurrentCart(self, userId):
1874 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
1875 
    args = getCurrentCart_args()
1876 
    args.userId = userId
94 ashish 1877 
    args.write(self._oprot)
1878 
    self._oprot.writeMessageEnd()
1879 
    self._oprot.trans.flush()
1880 
 
559 chandransh 1881 
  def recv_getCurrentCart(self, ):
94 ashish 1882 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1883 
    if mtype == TMessageType.EXCEPTION:
1884 
      x = TApplicationException()
1885 
      x.read(self._iprot)
1886 
      self._iprot.readMessageEnd()
1887 
      raise x
559 chandransh 1888 
    result = getCurrentCart_result()
94 ashish 1889 
    result.read(self._iprot)
1890 
    self._iprot.readMessageEnd()
1891 
    if result.success != None:
1892 
      return result.success
559 chandransh 1893 
    if result.scx != None:
1894 
      raise result.scx
1895 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 1896 
 
559 chandransh 1897 
  def getCart(self, cartId):
94 ashish 1898 
    """
1899 
    Parameters:
559 chandransh 1900 
     - cartId
94 ashish 1901 
    """
559 chandransh 1902 
    self.send_getCart(cartId)
1903 
    return self.recv_getCart()
94 ashish 1904 
 
559 chandransh 1905 
  def send_getCart(self, cartId):
1906 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
1907 
    args = getCart_args()
1908 
    args.cartId = cartId
94 ashish 1909 
    args.write(self._oprot)
1910 
    self._oprot.writeMessageEnd()
1911 
    self._oprot.trans.flush()
1912 
 
559 chandransh 1913 
  def recv_getCart(self, ):
94 ashish 1914 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1915 
    if mtype == TMessageType.EXCEPTION:
1916 
      x = TApplicationException()
1917 
      x.read(self._iprot)
1918 
      self._iprot.readMessageEnd()
1919 
      raise x
559 chandransh 1920 
    result = getCart_result()
94 ashish 1921 
    result.read(self._iprot)
1922 
    self._iprot.readMessageEnd()
1923 
    if result.success != None:
1924 
      return result.success
559 chandransh 1925 
    if result.scx != None:
1926 
      raise result.scx
1927 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 1928 
 
559 chandransh 1929 
  def getCartsForUser(self, userId, status):
94 ashish 1930 
    """
1931 
    Parameters:
559 chandransh 1932 
     - userId
1933 
     - status
94 ashish 1934 
    """
559 chandransh 1935 
    self.send_getCartsForUser(userId, status)
1936 
    return self.recv_getCartsForUser()
94 ashish 1937 
 
559 chandransh 1938 
  def send_getCartsForUser(self, userId, status):
1939 
    self._oprot.writeMessageBegin('getCartsForUser', TMessageType.CALL, self._seqid)
1940 
    args = getCartsForUser_args()
1941 
    args.userId = userId
1942 
    args.status = status
94 ashish 1943 
    args.write(self._oprot)
1944 
    self._oprot.writeMessageEnd()
1945 
    self._oprot.trans.flush()
1946 
 
559 chandransh 1947 
  def recv_getCartsForUser(self, ):
94 ashish 1948 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1949 
    if mtype == TMessageType.EXCEPTION:
1950 
      x = TApplicationException()
1951 
      x.read(self._iprot)
1952 
      self._iprot.readMessageEnd()
1953 
      raise x
559 chandransh 1954 
    result = getCartsForUser_result()
94 ashish 1955 
    result.read(self._iprot)
1956 
    self._iprot.readMessageEnd()
1957 
    if result.success != None:
1958 
      return result.success
559 chandransh 1959 
    if result.scx != None:
1960 
      raise result.scx
1961 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsForUser failed: unknown result");
94 ashish 1962 
 
559 chandransh 1963 
  def getCartsByStatus(self, status):
94 ashish 1964 
    """
1965 
    Parameters:
559 chandransh 1966 
     - status
94 ashish 1967 
    """
559 chandransh 1968 
    self.send_getCartsByStatus(status)
1969 
    return self.recv_getCartsByStatus()
94 ashish 1970 
 
559 chandransh 1971 
  def send_getCartsByStatus(self, status):
1972 
    self._oprot.writeMessageBegin('getCartsByStatus', TMessageType.CALL, self._seqid)
1973 
    args = getCartsByStatus_args()
1974 
    args.status = status
94 ashish 1975 
    args.write(self._oprot)
1976 
    self._oprot.writeMessageEnd()
1977 
    self._oprot.trans.flush()
1978 
 
559 chandransh 1979 
  def recv_getCartsByStatus(self, ):
94 ashish 1980 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1981 
    if mtype == TMessageType.EXCEPTION:
1982 
      x = TApplicationException()
1983 
      x.read(self._iprot)
1984 
      self._iprot.readMessageEnd()
1985 
      raise x
559 chandransh 1986 
    result = getCartsByStatus_result()
94 ashish 1987 
    result.read(self._iprot)
1988 
    self._iprot.readMessageEnd()
1989 
    if result.success != None:
1990 
      return result.success
559 chandransh 1991 
    if result.scx != None:
1992 
      raise result.scx
1993 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByStatus failed: unknown result");
94 ashish 1994 
 
559 chandransh 1995 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 1996 
    """
1997 
    Parameters:
559 chandransh 1998 
     - from_time
1999 
     - to_time
2000 
     - status
94 ashish 2001 
    """
559 chandransh 2002 
    self.send_getCartsByTime(from_time, to_time, status)
2003 
    return self.recv_getCartsByTime()
94 ashish 2004 
 
559 chandransh 2005 
  def send_getCartsByTime(self, from_time, to_time, status):
2006 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2007 
    args = getCartsByTime_args()
2008 
    args.from_time = from_time
2009 
    args.to_time = to_time
2010 
    args.status = status
94 ashish 2011 
    args.write(self._oprot)
2012 
    self._oprot.writeMessageEnd()
2013 
    self._oprot.trans.flush()
2014 
 
559 chandransh 2015 
  def recv_getCartsByTime(self, ):
94 ashish 2016 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2017 
    if mtype == TMessageType.EXCEPTION:
2018 
      x = TApplicationException()
2019 
      x.read(self._iprot)
2020 
      self._iprot.readMessageEnd()
2021 
      raise x
559 chandransh 2022 
    result = getCartsByTime_result()
94 ashish 2023 
    result.read(self._iprot)
2024 
    self._iprot.readMessageEnd()
2025 
    if result.success != None:
2026 
      return result.success
559 chandransh 2027 
    if result.scx != None:
2028 
      raise result.scx
2029 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2030 
 
559 chandransh 2031 
  def changeCartStatus(self, cartId, status):
130 ashish 2032 
    """
2033 
    Parameters:
559 chandransh 2034 
     - cartId
2035 
     - status
130 ashish 2036 
    """
559 chandransh 2037 
    self.send_changeCartStatus(cartId, status)
2038 
    self.recv_changeCartStatus()
94 ashish 2039 
 
559 chandransh 2040 
  def send_changeCartStatus(self, cartId, status):
2041 
    self._oprot.writeMessageBegin('changeCartStatus', TMessageType.CALL, self._seqid)
2042 
    args = changeCartStatus_args()
2043 
    args.cartId = cartId
2044 
    args.status = status
130 ashish 2045 
    args.write(self._oprot)
2046 
    self._oprot.writeMessageEnd()
2047 
    self._oprot.trans.flush()
2048 
 
559 chandransh 2049 
  def recv_changeCartStatus(self, ):
130 ashish 2050 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2051 
    if mtype == TMessageType.EXCEPTION:
2052 
      x = TApplicationException()
2053 
      x.read(self._iprot)
2054 
      self._iprot.readMessageEnd()
2055 
      raise x
559 chandransh 2056 
    result = changeCartStatus_result()
130 ashish 2057 
    result.read(self._iprot)
2058 
    self._iprot.readMessageEnd()
559 chandransh 2059 
    if result.scx != None:
2060 
      raise result.scx
2061 
    return
2062 
 
2063 
  def addItemToCart(self, cartId, itemId, quantity):
2064 
    """
2065 
    Parameters:
2066 
     - cartId
2067 
     - itemId
2068 
     - quantity
2069 
    """
2070 
    self.send_addItemToCart(cartId, itemId, quantity)
2071 
    self.recv_addItemToCart()
2072 
 
2073 
  def send_addItemToCart(self, cartId, itemId, quantity):
2074 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2075 
    args = addItemToCart_args()
2076 
    args.cartId = cartId
2077 
    args.itemId = itemId
2078 
    args.quantity = quantity
2079 
    args.write(self._oprot)
2080 
    self._oprot.writeMessageEnd()
2081 
    self._oprot.trans.flush()
2082 
 
2083 
  def recv_addItemToCart(self, ):
2084 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2085 
    if mtype == TMessageType.EXCEPTION:
2086 
      x = TApplicationException()
2087 
      x.read(self._iprot)
2088 
      self._iprot.readMessageEnd()
2089 
      raise x
2090 
    result = addItemToCart_result()
2091 
    result.read(self._iprot)
2092 
    self._iprot.readMessageEnd()
2093 
    if result.scx != None:
2094 
      raise result.scx
2095 
    return
2096 
 
2097 
  def deleteItemFromCart(self, cartId, itemId):
2098 
    """
2099 
    Parameters:
2100 
     - cartId
2101 
     - itemId
2102 
    """
2103 
    self.send_deleteItemFromCart(cartId, itemId)
2104 
    self.recv_deleteItemFromCart()
2105 
 
2106 
  def send_deleteItemFromCart(self, cartId, itemId):
2107 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2108 
    args = deleteItemFromCart_args()
2109 
    args.cartId = cartId
2110 
    args.itemId = itemId
2111 
    args.write(self._oprot)
2112 
    self._oprot.writeMessageEnd()
2113 
    self._oprot.trans.flush()
2114 
 
2115 
  def recv_deleteItemFromCart(self, ):
2116 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2117 
    if mtype == TMessageType.EXCEPTION:
2118 
      x = TApplicationException()
2119 
      x.read(self._iprot)
2120 
      self._iprot.readMessageEnd()
2121 
      raise x
2122 
    result = deleteItemFromCart_result()
2123 
    result.read(self._iprot)
2124 
    self._iprot.readMessageEnd()
2125 
    if result.scx != None:
2126 
      raise result.scx
2127 
    return
2128 
 
2129 
  def changeQuantity(self, cartId, itemId, quantity):
2130 
    """
2131 
    Parameters:
2132 
     - cartId
2133 
     - itemId
2134 
     - quantity
2135 
    """
2136 
    self.send_changeQuantity(cartId, itemId, quantity)
2137 
    self.recv_changeQuantity()
2138 
 
2139 
  def send_changeQuantity(self, cartId, itemId, quantity):
2140 
    self._oprot.writeMessageBegin('changeQuantity', TMessageType.CALL, self._seqid)
2141 
    args = changeQuantity_args()
2142 
    args.cartId = cartId
2143 
    args.itemId = itemId
2144 
    args.quantity = quantity
2145 
    args.write(self._oprot)
2146 
    self._oprot.writeMessageEnd()
2147 
    self._oprot.trans.flush()
2148 
 
2149 
  def recv_changeQuantity(self, ):
2150 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2151 
    if mtype == TMessageType.EXCEPTION:
2152 
      x = TApplicationException()
2153 
      x.read(self._iprot)
2154 
      self._iprot.readMessageEnd()
2155 
      raise x
2156 
    result = changeQuantity_result()
2157 
    result.read(self._iprot)
2158 
    self._iprot.readMessageEnd()
2159 
    if result.scx != None:
2160 
      raise result.scx
2161 
    return
2162 
 
2163 
  def changeItemStatus(self, cartId, itemId, status):
2164 
    """
2165 
    Parameters:
2166 
     - cartId
2167 
     - itemId
2168 
     - status
2169 
    """
2170 
    self.send_changeItemStatus(cartId, itemId, status)
2171 
    self.recv_changeItemStatus()
2172 
 
2173 
  def send_changeItemStatus(self, cartId, itemId, status):
2174 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
2175 
    args = changeItemStatus_args()
2176 
    args.cartId = cartId
2177 
    args.itemId = itemId
2178 
    args.status = status
2179 
    args.write(self._oprot)
2180 
    self._oprot.writeMessageEnd()
2181 
    self._oprot.trans.flush()
2182 
 
2183 
  def recv_changeItemStatus(self, ):
2184 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2185 
    if mtype == TMessageType.EXCEPTION:
2186 
      x = TApplicationException()
2187 
      x.read(self._iprot)
2188 
      self._iprot.readMessageEnd()
2189 
      raise x
2190 
    result = changeItemStatus_result()
2191 
    result.read(self._iprot)
2192 
    self._iprot.readMessageEnd()
2193 
    if result.scx != None:
2194 
      raise result.scx
2195 
    return
2196 
 
2197 
  def addAddressToCart(self, cartId, addressId):
2198 
    """
2199 
    Parameters:
2200 
     - cartId
2201 
     - addressId
2202 
    """
2203 
    self.send_addAddressToCart(cartId, addressId)
2204 
    self.recv_addAddressToCart()
2205 
 
2206 
  def send_addAddressToCart(self, cartId, addressId):
2207 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2208 
    args = addAddressToCart_args()
2209 
    args.cartId = cartId
2210 
    args.addressId = addressId
2211 
    args.write(self._oprot)
2212 
    self._oprot.writeMessageEnd()
2213 
    self._oprot.trans.flush()
2214 
 
2215 
  def recv_addAddressToCart(self, ):
2216 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2217 
    if mtype == TMessageType.EXCEPTION:
2218 
      x = TApplicationException()
2219 
      x.read(self._iprot)
2220 
      self._iprot.readMessageEnd()
2221 
      raise x
2222 
    result = addAddressToCart_result()
2223 
    result.read(self._iprot)
2224 
    self._iprot.readMessageEnd()
575 chandransh 2225 
    if result.scx != None:
2226 
      raise result.scx
559 chandransh 2227 
    return
2228 
 
690 chandransh 2229 
  def createOrders(self, cartId):
559 chandransh 2230 
    """
690 chandransh 2231 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
2232 
 
559 chandransh 2233 
    Parameters:
2234 
     - cartId
2235 
    """
690 chandransh 2236 
    self.send_createOrders(cartId)
2237 
    return self.recv_createOrders()
559 chandransh 2238 
 
690 chandransh 2239 
  def send_createOrders(self, cartId):
2240 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2241 
    args = createOrders_args()
559 chandransh 2242 
    args.cartId = cartId
2243 
    args.write(self._oprot)
2244 
    self._oprot.writeMessageEnd()
2245 
    self._oprot.trans.flush()
2246 
 
690 chandransh 2247 
  def recv_createOrders(self, ):
559 chandransh 2248 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2249 
    if mtype == TMessageType.EXCEPTION:
2250 
      x = TApplicationException()
2251 
      x.read(self._iprot)
2252 
      self._iprot.readMessageEnd()
2253 
      raise x
690 chandransh 2254 
    result = createOrders_result()
559 chandransh 2255 
    result.read(self._iprot)
2256 
    self._iprot.readMessageEnd()
130 ashish 2257 
    if result.success != None:
2258 
      return result.success
559 chandransh 2259 
    if result.scx != None:
2260 
      raise result.scx
690 chandransh 2261 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2262 
 
559 chandransh 2263 
  def validateCart(self, cartId):
130 ashish 2264 
    """
690 chandransh 2265 
    Validates that:
2266 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2267 
    2. All of the lines in the cart are active items.
690 chandransh 2268 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2269 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 2270 
 
130 ashish 2271 
    Parameters:
559 chandransh 2272 
     - cartId
130 ashish 2273 
    """
559 chandransh 2274 
    self.send_validateCart(cartId)
2275 
    return self.recv_validateCart()
130 ashish 2276 
 
559 chandransh 2277 
  def send_validateCart(self, cartId):
2278 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2279 
    args = validateCart_args()
2280 
    args.cartId = cartId
130 ashish 2281 
    args.write(self._oprot)
2282 
    self._oprot.writeMessageEnd()
2283 
    self._oprot.trans.flush()
2284 
 
559 chandransh 2285 
  def recv_validateCart(self, ):
130 ashish 2286 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2287 
    if mtype == TMessageType.EXCEPTION:
2288 
      x = TApplicationException()
2289 
      x.read(self._iprot)
2290 
      self._iprot.readMessageEnd()
2291 
      raise x
559 chandransh 2292 
    result = validateCart_result()
130 ashish 2293 
    result.read(self._iprot)
2294 
    self._iprot.readMessageEnd()
2295 
    if result.success != None:
2296 
      return result.success
575 chandransh 2297 
    if result.scex != None:
2298 
      raise result.scex
559 chandransh 2299 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2300 
 
690 chandransh 2301 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2302 
    """
690 chandransh 2303 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
2304 
 
575 chandransh 2305 
    Parameters:
690 chandransh 2306 
     - fromCartId
2307 
     - toCartId
2308 
    """
2309 
    self.send_mergeCart(fromCartId, toCartId)
2310 
    self.recv_mergeCart()
2311 
 
2312 
  def send_mergeCart(self, fromCartId, toCartId):
2313 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2314 
    args = mergeCart_args()
2315 
    args.fromCartId = fromCartId
2316 
    args.toCartId = toCartId
2317 
    args.write(self._oprot)
2318 
    self._oprot.writeMessageEnd()
2319 
    self._oprot.trans.flush()
2320 
 
2321 
  def recv_mergeCart(self, ):
2322 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2323 
    if mtype == TMessageType.EXCEPTION:
2324 
      x = TApplicationException()
2325 
      x.read(self._iprot)
2326 
      self._iprot.readMessageEnd()
2327 
      raise x
2328 
    result = mergeCart_result()
2329 
    result.read(self._iprot)
2330 
    self._iprot.readMessageEnd()
2331 
    return
2332 
 
2333 
  def checkOut(self, cartId):
2334 
    """
2335 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
2336 
 
2337 
    Parameters:
575 chandransh 2338 
     - cartId
2339 
    """
690 chandransh 2340 
    self.send_checkOut(cartId)
2341 
    return self.recv_checkOut()
575 chandransh 2342 
 
690 chandransh 2343 
  def send_checkOut(self, cartId):
2344 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2345 
    args = checkOut_args()
575 chandransh 2346 
    args.cartId = cartId
2347 
    args.write(self._oprot)
2348 
    self._oprot.writeMessageEnd()
2349 
    self._oprot.trans.flush()
2350 
 
690 chandransh 2351 
  def recv_checkOut(self, ):
575 chandransh 2352 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2353 
    if mtype == TMessageType.EXCEPTION:
2354 
      x = TApplicationException()
2355 
      x.read(self._iprot)
2356 
      self._iprot.readMessageEnd()
2357 
      raise x
690 chandransh 2358 
    result = checkOut_result()
575 chandransh 2359 
    result.read(self._iprot)
2360 
    self._iprot.readMessageEnd()
2361 
    if result.success != None:
2362 
      return result.success
2363 
    if result.scex != None:
2364 
      raise result.scex
690 chandransh 2365 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2366 
 
690 chandransh 2367 
  def resetCart(self, cartId, items):
559 chandransh 2368 
    """
690 chandransh 2369 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2370 
    This methods removes the specified quantiry of the specified item from the cart.
2371 
 
559 chandransh 2372 
    Parameters:
690 chandransh 2373 
     - cartId
2374 
     - items
559 chandransh 2375 
    """
690 chandransh 2376 
    self.send_resetCart(cartId, items)
2377 
    return self.recv_resetCart()
130 ashish 2378 
 
690 chandransh 2379 
  def send_resetCart(self, cartId, items):
2380 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2381 
    args = resetCart_args()
2382 
    args.cartId = cartId
2383 
    args.items = items
559 chandransh 2384 
    args.write(self._oprot)
2385 
    self._oprot.writeMessageEnd()
2386 
    self._oprot.trans.flush()
2387 
 
690 chandransh 2388 
  def recv_resetCart(self, ):
559 chandransh 2389 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2390 
    if mtype == TMessageType.EXCEPTION:
2391 
      x = TApplicationException()
2392 
      x.read(self._iprot)
2393 
      self._iprot.readMessageEnd()
2394 
      raise x
690 chandransh 2395 
    result = resetCart_result()
559 chandransh 2396 
    result.read(self._iprot)
2397 
    self._iprot.readMessageEnd()
690 chandransh 2398 
    if result.success != None:
2399 
      return result.success
2400 
    if result.scex != None:
2401 
      raise result.scex
2402 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2403 
 
772 rajveer 2404 
  def getMyResearch(self, userId):
559 chandransh 2405 
    """
772 rajveer 2406 
    Widgets
2407 
 
559 chandransh 2408 
    Parameters:
2409 
     - userId
2410 
    """
772 rajveer 2411 
    self.send_getMyResearch(userId)
559 chandransh 2412 
    return self.recv_getMyResearch()
2413 
 
772 rajveer 2414 
  def send_getMyResearch(self, userId):
559 chandransh 2415 
    self._oprot.writeMessageBegin('getMyResearch', TMessageType.CALL, self._seqid)
2416 
    args = getMyResearch_args()
772 rajveer 2417 
    args.userId = userId
559 chandransh 2418 
    args.write(self._oprot)
2419 
    self._oprot.writeMessageEnd()
2420 
    self._oprot.trans.flush()
2421 
 
2422 
  def recv_getMyResearch(self, ):
2423 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2424 
    if mtype == TMessageType.EXCEPTION:
2425 
      x = TApplicationException()
2426 
      x.read(self._iprot)
2427 
      self._iprot.readMessageEnd()
2428 
      raise x
2429 
    result = getMyResearch_result()
2430 
    result.read(self._iprot)
2431 
    self._iprot.readMessageEnd()
2432 
    if result.success != None:
2433 
      return result.success
2434 
    if result.scx != None:
2435 
      raise result.scx
2436 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearch failed: unknown result");
2437 
 
772 rajveer 2438 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2439 
    """
2440 
    Parameters:
772 rajveer 2441 
     - userId
2442 
     - itemId
559 chandransh 2443 
    """
772 rajveer 2444 
    self.send_updateMyResearch(userId, itemId)
559 chandransh 2445 
    return self.recv_updateMyResearch()
2446 
 
772 rajveer 2447 
  def send_updateMyResearch(self, userId, itemId):
559 chandransh 2448 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2449 
    args = updateMyResearch_args()
772 rajveer 2450 
    args.userId = userId
2451 
    args.itemId = itemId
559 chandransh 2452 
    args.write(self._oprot)
2453 
    self._oprot.writeMessageEnd()
2454 
    self._oprot.trans.flush()
2455 
 
2456 
  def recv_updateMyResearch(self, ):
2457 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2458 
    if mtype == TMessageType.EXCEPTION:
2459 
      x = TApplicationException()
2460 
      x.read(self._iprot)
2461 
      self._iprot.readMessageEnd()
2462 
      raise x
2463 
    result = updateMyResearch_result()
2464 
    result.read(self._iprot)
2465 
    self._iprot.readMessageEnd()
2466 
    if result.success != None:
2467 
      return result.success
2468 
    if result.scx != None:
2469 
      raise result.scx
2470 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
2471 
 
772 rajveer 2472 
  def deleteItemFromMyResearch(self, userId, itemId):
559 chandransh 2473 
    """
2474 
    Parameters:
772 rajveer 2475 
     - userId
2476 
     - itemId
559 chandransh 2477 
    """
772 rajveer 2478 
    self.send_deleteItemFromMyResearch(userId, itemId)
559 chandransh 2479 
    self.recv_deleteItemFromMyResearch()
2480 
 
772 rajveer 2481 
  def send_deleteItemFromMyResearch(self, userId, itemId):
559 chandransh 2482 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2483 
    args = deleteItemFromMyResearch_args()
772 rajveer 2484 
    args.userId = userId
2485 
    args.itemId = itemId
559 chandransh 2486 
    args.write(self._oprot)
2487 
    self._oprot.writeMessageEnd()
2488 
    self._oprot.trans.flush()
2489 
 
2490 
  def recv_deleteItemFromMyResearch(self, ):
2491 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2492 
    if mtype == TMessageType.EXCEPTION:
2493 
      x = TApplicationException()
2494 
      x.read(self._iprot)
2495 
      self._iprot.readMessageEnd()
2496 
      raise x
2497 
    result = deleteItemFromMyResearch_result()
2498 
    result.read(self._iprot)
2499 
    self._iprot.readMessageEnd()
2500 
    if result.scx != None:
2501 
      raise result.scx
2502 
    return
2503 
 
772 rajveer 2504 
  def updateBrowseHistory(self, userId, itemId):
559 chandransh 2505 
    """
2506 
    Parameters:
772 rajveer 2507 
     - userId
2508 
     - itemId
559 chandransh 2509 
    """
772 rajveer 2510 
    self.send_updateBrowseHistory(userId, itemId)
2511 
    self.recv_updateBrowseHistory()
559 chandransh 2512 
 
772 rajveer 2513 
  def send_updateBrowseHistory(self, userId, itemId):
2514 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2515 
    args = updateBrowseHistory_args()
2516 
    args.userId = userId
2517 
    args.itemId = itemId
559 chandransh 2518 
    args.write(self._oprot)
2519 
    self._oprot.writeMessageEnd()
2520 
    self._oprot.trans.flush()
2521 
 
772 rajveer 2522 
  def recv_updateBrowseHistory(self, ):
559 chandransh 2523 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2524 
    if mtype == TMessageType.EXCEPTION:
2525 
      x = TApplicationException()
2526 
      x.read(self._iprot)
2527 
      self._iprot.readMessageEnd()
2528 
      raise x
772 rajveer 2529 
    result = updateBrowseHistory_result()
559 chandransh 2530 
    result.read(self._iprot)
2531 
    self._iprot.readMessageEnd()
2532 
    return
2533 
 
772 rajveer 2534 
  def getBrowseHistory(self, userId):
559 chandransh 2535 
    """
2536 
    Parameters:
772 rajveer 2537 
     - userId
559 chandransh 2538 
    """
772 rajveer 2539 
    self.send_getBrowseHistory(userId)
2540 
    return self.recv_getBrowseHistory()
559 chandransh 2541 
 
772 rajveer 2542 
  def send_getBrowseHistory(self, userId):
2543 
    self._oprot.writeMessageBegin('getBrowseHistory', TMessageType.CALL, self._seqid)
2544 
    args = getBrowseHistory_args()
2545 
    args.userId = userId
559 chandransh 2546 
    args.write(self._oprot)
2547 
    self._oprot.writeMessageEnd()
2548 
    self._oprot.trans.flush()
2549 
 
772 rajveer 2550 
  def recv_getBrowseHistory(self, ):
559 chandransh 2551 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2552 
    if mtype == TMessageType.EXCEPTION:
2553 
      x = TApplicationException()
2554 
      x.read(self._iprot)
2555 
      self._iprot.readMessageEnd()
2556 
      raise x
772 rajveer 2557 
    result = getBrowseHistory_result()
559 chandransh 2558 
    result.read(self._iprot)
2559 
    self._iprot.readMessageEnd()
2560 
    if result.success != None:
2561 
      return result.success
2562 
    if result.scx != None:
2563 
      raise result.scx
772 rajveer 2564 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistory failed: unknown result");
559 chandransh 2565 
 
772 rajveer 2566 
  def mergeBrowseHistory(self, fromUserId, toUserId):
559 chandransh 2567 
    """
2568 
    Parameters:
772 rajveer 2569 
     - fromUserId
2570 
     - toUserId
559 chandransh 2571 
    """
772 rajveer 2572 
    self.send_mergeBrowseHistory(fromUserId, toUserId)
2573 
    self.recv_mergeBrowseHistory()
559 chandransh 2574 
 
772 rajveer 2575 
  def send_mergeBrowseHistory(self, fromUserId, toUserId):
2576 
    self._oprot.writeMessageBegin('mergeBrowseHistory', TMessageType.CALL, self._seqid)
2577 
    args = mergeBrowseHistory_args()
2578 
    args.fromUserId = fromUserId
2579 
    args.toUserId = toUserId
559 chandransh 2580 
    args.write(self._oprot)
2581 
    self._oprot.writeMessageEnd()
2582 
    self._oprot.trans.flush()
2583 
 
772 rajveer 2584 
  def recv_mergeBrowseHistory(self, ):
559 chandransh 2585 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2586 
    if mtype == TMessageType.EXCEPTION:
2587 
      x = TApplicationException()
2588 
      x.read(self._iprot)
2589 
      self._iprot.readMessageEnd()
2590 
      raise x
772 rajveer 2591 
    result = mergeBrowseHistory_result()
559 chandransh 2592 
    result.read(self._iprot)
2593 
    self._iprot.readMessageEnd()
2594 
    return
2595 
 
1596 ankur.sing 2596 
  def getUserCount(self, userType):
2597 
    """
2598 
    Returns number of registered users.
2599 
    If userType = null, then it returns count of all users, including anonymous
2600 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2601 
    If userType = UserType.USER, then it returns count of non-anonymous users only
2602 
 
2603 
    Parameters:
2604 
     - userType
2605 
    """
2606 
    self.send_getUserCount(userType)
2607 
    return self.recv_getUserCount()
559 chandransh 2608 
 
1596 ankur.sing 2609 
  def send_getUserCount(self, userType):
2610 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2611 
    args = getUserCount_args()
2612 
    args.userType = userType
2613 
    args.write(self._oprot)
2614 
    self._oprot.writeMessageEnd()
2615 
    self._oprot.trans.flush()
2616 
 
2617 
  def recv_getUserCount(self, ):
2618 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2619 
    if mtype == TMessageType.EXCEPTION:
2620 
      x = TApplicationException()
2621 
      x.read(self._iprot)
2622 
      self._iprot.readMessageEnd()
2623 
      raise x
2624 
    result = getUserCount_result()
2625 
    result.read(self._iprot)
2626 
    self._iprot.readMessageEnd()
2627 
    if result.success != None:
2628 
      return result.success
2629 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
2630 
 
1673 ankur.sing 2631 
  def getAllUsers(self, userType):
2632 
    """
2633 
    Returns list of users of type userType. If userType is null, then returns all the users.
2634 
 
2635 
    Parameters:
2636 
     - userType
2637 
    """
2638 
    self.send_getAllUsers(userType)
2639 
    return self.recv_getAllUsers()
1596 ankur.sing 2640 
 
1673 ankur.sing 2641 
  def send_getAllUsers(self, userType):
2642 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2643 
    args = getAllUsers_args()
2644 
    args.userType = userType
2645 
    args.write(self._oprot)
2646 
    self._oprot.writeMessageEnd()
2647 
    self._oprot.trans.flush()
2648 
 
2649 
  def recv_getAllUsers(self, ):
2650 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2651 
    if mtype == TMessageType.EXCEPTION:
2652 
      x = TApplicationException()
2653 
      x.read(self._iprot)
2654 
      self._iprot.readMessageEnd()
2655 
      raise x
2656 
    result = getAllUsers_result()
2657 
    result.read(self._iprot)
2658 
    self._iprot.readMessageEnd()
2659 
    if result.success != None:
2660 
      return result.success
2661 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
2662 
 
2663 
 
94 ashish 2664 
class Processor(Iface, TProcessor):
2665 
  def __init__(self, handler):
2666 
    self._handler = handler
2667 
    self._processMap = {}
765 rajveer 2668 
    self._processMap["closeSession"] = Processor.process_closeSession
559 chandransh 2669 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
2670 
    self._processMap["getUserById"] = Processor.process_getUserById
1491 vikas 2671 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
559 chandransh 2672 
    self._processMap["createUser"] = Processor.process_createUser
2673 
    self._processMap["updateUser"] = Processor.process_updateUser
2674 
    self._processMap["deleteUser"] = Processor.process_deleteUser
2675 
    self._processMap["getUserState"] = Processor.process_getUserState
122 ashish 2676 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 2677 
    self._processMap["userExists"] = Processor.process_userExists
2678 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
2679 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
2680 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
2681 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 2682 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 2683 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 2684 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 2685 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
2686 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 2687 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 2688 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 2689 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
2690 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
2691 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
1845 vikas 2692 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
2693 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
2694 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
2695 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
2696 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
2697 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
2698 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
2699 
    self._processMap["createTracker"] = Processor.process_createTracker
2700 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
2701 
    self._processMap["getTrackersByAffiliate"] = Processor.process_getTrackersByAffiliate
2702 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
2703 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
2704 
    self._processMap["getTrackLogsByTracker"] = Processor.process_getTrackLogsByTracker
2705 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
2706 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 2707 
    self._processMap["createCart"] = Processor.process_createCart
2708 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
2709 
    self._processMap["getCart"] = Processor.process_getCart
2710 
    self._processMap["getCartsForUser"] = Processor.process_getCartsForUser
2711 
    self._processMap["getCartsByStatus"] = Processor.process_getCartsByStatus
2712 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
2713 
    self._processMap["changeCartStatus"] = Processor.process_changeCartStatus
2714 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
2715 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
2716 
    self._processMap["changeQuantity"] = Processor.process_changeQuantity
2717 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
2718 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
690 chandransh 2719 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 2720 
    self._processMap["validateCart"] = Processor.process_validateCart
2721 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 2722 
    self._processMap["checkOut"] = Processor.process_checkOut
2723 
    self._processMap["resetCart"] = Processor.process_resetCart
559 chandransh 2724 
    self._processMap["getMyResearch"] = Processor.process_getMyResearch
2725 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
2726 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
2727 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
2728 
    self._processMap["getBrowseHistory"] = Processor.process_getBrowseHistory
772 rajveer 2729 
    self._processMap["mergeBrowseHistory"] = Processor.process_mergeBrowseHistory
1596 ankur.sing 2730 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 2731 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
94 ashish 2732 
 
2733 
  def process(self, iprot, oprot):
2734 
    (name, type, seqid) = iprot.readMessageBegin()
2735 
    if name not in self._processMap:
2736 
      iprot.skip(TType.STRUCT)
2737 
      iprot.readMessageEnd()
2738 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
2739 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
2740 
      x.write(oprot)
2741 
      oprot.writeMessageEnd()
2742 
      oprot.trans.flush()
2743 
      return
2744 
    else:
2745 
      self._processMap[name](self, seqid, iprot, oprot)
2746 
    return True
2747 
 
765 rajveer 2748 
  def process_closeSession(self, seqid, iprot, oprot):
2749 
    args = closeSession_args()
2750 
    args.read(iprot)
2751 
    iprot.readMessageEnd()
2752 
    result = closeSession_result()
2753 
    self._handler.closeSession()
2754 
    oprot.writeMessageBegin("closeSession", TMessageType.REPLY, seqid)
2755 
    result.write(oprot)
2756 
    oprot.writeMessageEnd()
2757 
    oprot.trans.flush()
2758 
 
559 chandransh 2759 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
2760 
    args = createAnonymousUser_args()
94 ashish 2761 
    args.read(iprot)
2762 
    iprot.readMessageEnd()
559 chandransh 2763 
    result = createAnonymousUser_result()
94 ashish 2764 
    try:
559 chandransh 2765 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
2766 
    except UserContextException, ucex:
2767 
      result.ucex = ucex
2768 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 2769 
    result.write(oprot)
2770 
    oprot.writeMessageEnd()
2771 
    oprot.trans.flush()
2772 
 
559 chandransh 2773 
  def process_getUserById(self, seqid, iprot, oprot):
2774 
    args = getUserById_args()
94 ashish 2775 
    args.read(iprot)
2776 
    iprot.readMessageEnd()
559 chandransh 2777 
    result = getUserById_result()
94 ashish 2778 
    try:
559 chandransh 2779 
      result.success = self._handler.getUserById(args.userId)
2780 
    except UserContextException, ucex:
2781 
      result.ucex = ucex
2782 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 2783 
    result.write(oprot)
2784 
    oprot.writeMessageEnd()
2785 
    oprot.trans.flush()
2786 
 
1491 vikas 2787 
  def process_getUserByEmail(self, seqid, iprot, oprot):
2788 
    args = getUserByEmail_args()
2789 
    args.read(iprot)
2790 
    iprot.readMessageEnd()
2791 
    result = getUserByEmail_result()
2792 
    try:
2793 
      result.success = self._handler.getUserByEmail(args.email)
2794 
    except UserContextException, ucex:
2795 
      result.ucex = ucex
2796 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
2797 
    result.write(oprot)
2798 
    oprot.writeMessageEnd()
2799 
    oprot.trans.flush()
2800 
 
559 chandransh 2801 
  def process_createUser(self, seqid, iprot, oprot):
2802 
    args = createUser_args()
94 ashish 2803 
    args.read(iprot)
2804 
    iprot.readMessageEnd()
559 chandransh 2805 
    result = createUser_result()
94 ashish 2806 
    try:
559 chandransh 2807 
      result.success = self._handler.createUser(args.user)
2808 
    except UserContextException, ucex:
2809 
      result.ucex = ucex
2810 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 2811 
    result.write(oprot)
2812 
    oprot.writeMessageEnd()
2813 
    oprot.trans.flush()
2814 
 
559 chandransh 2815 
  def process_updateUser(self, seqid, iprot, oprot):
2816 
    args = updateUser_args()
94 ashish 2817 
    args.read(iprot)
2818 
    iprot.readMessageEnd()
559 chandransh 2819 
    result = updateUser_result()
94 ashish 2820 
    try:
559 chandransh 2821 
      result.success = self._handler.updateUser(args.user)
2822 
    except UserContextException, ucex:
2823 
      result.ucex = ucex
2824 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 2825 
    result.write(oprot)
2826 
    oprot.writeMessageEnd()
2827 
    oprot.trans.flush()
2828 
 
559 chandransh 2829 
  def process_deleteUser(self, seqid, iprot, oprot):
2830 
    args = deleteUser_args()
94 ashish 2831 
    args.read(iprot)
2832 
    iprot.readMessageEnd()
559 chandransh 2833 
    result = deleteUser_result()
94 ashish 2834 
    try:
559 chandransh 2835 
      result.success = self._handler.deleteUser(args.userId)
2836 
    except UserContextException, ucex:
2837 
      result.ucex = ucex
2838 
    oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
94 ashish 2839 
    result.write(oprot)
2840 
    oprot.writeMessageEnd()
2841 
    oprot.trans.flush()
2842 
 
559 chandransh 2843 
  def process_getUserState(self, seqid, iprot, oprot):
2844 
    args = getUserState_args()
94 ashish 2845 
    args.read(iprot)
2846 
    iprot.readMessageEnd()
559 chandransh 2847 
    result = getUserState_result()
94 ashish 2848 
    try:
559 chandransh 2849 
      result.success = self._handler.getUserState(args.userId)
2850 
    except UserContextException, ucex:
2851 
      result.ucex = ucex
2852 
    oprot.writeMessageBegin("getUserState", TMessageType.REPLY, seqid)
94 ashish 2853 
    result.write(oprot)
2854 
    oprot.writeMessageEnd()
2855 
    oprot.trans.flush()
2856 
 
122 ashish 2857 
  def process_authenticateUser(self, seqid, iprot, oprot):
2858 
    args = authenticateUser_args()
2859 
    args.read(iprot)
2860 
    iprot.readMessageEnd()
2861 
    result = authenticateUser_result()
2862 
    try:
559 chandransh 2863 
      result.success = self._handler.authenticateUser(args.email, args.password)
2864 
    except AuthenticationException, auex:
2865 
      result.auex = auex
122 ashish 2866 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
2867 
    result.write(oprot)
2868 
    oprot.writeMessageEnd()
2869 
    oprot.trans.flush()
2870 
 
94 ashish 2871 
  def process_userExists(self, seqid, iprot, oprot):
2872 
    args = userExists_args()
2873 
    args.read(iprot)
2874 
    iprot.readMessageEnd()
2875 
    result = userExists_result()
2876 
    try:
2877 
      result.success = self._handler.userExists(args.email)
2878 
    except UserContextException, ucx:
2879 
      result.ucx = ucx
2880 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
2881 
    result.write(oprot)
2882 
    oprot.writeMessageEnd()
2883 
    oprot.trans.flush()
2884 
 
2885 
  def process_addAddressForUser(self, seqid, iprot, oprot):
2886 
    args = addAddressForUser_args()
2887 
    args.read(iprot)
2888 
    iprot.readMessageEnd()
2889 
    result = addAddressForUser_result()
2890 
    try:
567 rajveer 2891 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 2892 
    except UserContextException, ucx:
2893 
      result.ucx = ucx
2894 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
2895 
    result.write(oprot)
2896 
    oprot.writeMessageEnd()
2897 
    oprot.trans.flush()
2898 
 
2899 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
2900 
    args = removeAddressForUser_args()
2901 
    args.read(iprot)
2902 
    iprot.readMessageEnd()
2903 
    result = removeAddressForUser_result()
2904 
    try:
2905 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
2906 
    except UserContextException, ucx:
2907 
      result.ucx = ucx
2908 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
2909 
    result.write(oprot)
2910 
    oprot.writeMessageEnd()
2911 
    oprot.trans.flush()
2912 
 
2913 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
2914 
    args = setUserAsLoggedIn_args()
2915 
    args.read(iprot)
2916 
    iprot.readMessageEnd()
2917 
    result = setUserAsLoggedIn_result()
2918 
    try:
2919 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
2920 
    except UserContextException, ucx:
2921 
      result.ucx = ucx
2922 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
2923 
    result.write(oprot)
2924 
    oprot.writeMessageEnd()
2925 
    oprot.trans.flush()
2926 
 
2927 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
2928 
    args = setUserAsLoggedOut_args()
2929 
    args.read(iprot)
2930 
    iprot.readMessageEnd()
2931 
    result = setUserAsLoggedOut_result()
2932 
    try:
2933 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
2934 
    except UserContextException, ucx:
2935 
      result.ucx = ucx
2936 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
2937 
    result.write(oprot)
2938 
    oprot.writeMessageEnd()
2939 
    oprot.trans.flush()
2940 
 
504 rajveer 2941 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
2942 
    args = setDefaultAddress_args()
2943 
    args.read(iprot)
2944 
    iprot.readMessageEnd()
2945 
    result = setDefaultAddress_result()
2946 
    try:
2947 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
2948 
    except UserContextException, ucx:
2949 
      result.ucx = ucx
2950 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
2951 
    result.write(oprot)
2952 
    oprot.writeMessageEnd()
2953 
    oprot.trans.flush()
2954 
 
94 ashish 2955 
  def process_updatePassword(self, seqid, iprot, oprot):
2956 
    args = updatePassword_args()
2957 
    args.read(iprot)
2958 
    iprot.readMessageEnd()
2959 
    result = updatePassword_result()
2960 
    try:
594 rajveer 2961 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 2962 
    except UserContextException, ucx:
2963 
      result.ucx = ucx
2964 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
2965 
    result.write(oprot)
2966 
    oprot.writeMessageEnd()
2967 
    oprot.trans.flush()
2968 
 
581 rajveer 2969 
  def process_forgotPassword(self, seqid, iprot, oprot):
2970 
    args = forgotPassword_args()
2971 
    args.read(iprot)
2972 
    iprot.readMessageEnd()
2973 
    result = forgotPassword_result()
2974 
    try:
884 rajveer 2975 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 2976 
    except UserContextException, ucx:
2977 
      result.ucx = ucx
2978 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
2979 
    result.write(oprot)
2980 
    oprot.writeMessageEnd()
2981 
    oprot.trans.flush()
2982 
 
594 rajveer 2983 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
2984 
    args = getAllAddressesForUser_args()
2985 
    args.read(iprot)
2986 
    iprot.readMessageEnd()
2987 
    result = getAllAddressesForUser_result()
2988 
    try:
2989 
      result.success = self._handler.getAllAddressesForUser(args.userId)
2990 
    except UserContextException, ucx:
2991 
      result.ucx = ucx
2992 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
2993 
    result.write(oprot)
2994 
    oprot.writeMessageEnd()
2995 
    oprot.trans.flush()
2996 
 
2997 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
2998 
    args = getDefaultAddressId_args()
2999 
    args.read(iprot)
3000 
    iprot.readMessageEnd()
3001 
    result = getDefaultAddressId_result()
3002 
    try:
3003 
      result.success = self._handler.getDefaultAddressId(args.userId)
3004 
    except UserContextException, ucx:
3005 
      result.ucx = ucx
3006 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
3007 
    result.write(oprot)
3008 
    oprot.writeMessageEnd()
3009 
    oprot.trans.flush()
3010 
 
785 rajveer 3011 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
3012 
    args = getDefaultPincode_args()
3013 
    args.read(iprot)
3014 
    iprot.readMessageEnd()
3015 
    result = getDefaultPincode_result()
3016 
    try:
3017 
      result.success = self._handler.getDefaultPincode(args.userId)
3018 
    except UserContextException, ucx:
3019 
      result.ucx = ucx
3020 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
3021 
    result.write(oprot)
3022 
    oprot.writeMessageEnd()
3023 
    oprot.trans.flush()
3024 
 
1274 varun.gupt 3025 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
3026 
    args = saveUserCommunication_args()
3027 
    args.read(iprot)
3028 
    iprot.readMessageEnd()
3029 
    result = saveUserCommunication_result()
3030 
    try:
3031 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
3032 
    except UserCommunicationException, ucx:
3033 
      result.ucx = ucx
3034 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
3035 
    result.write(oprot)
3036 
    oprot.writeMessageEnd()
3037 
    oprot.trans.flush()
3038 
 
1590 varun.gupt 3039 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
3040 
    args = getUserCommunicationById_args()
3041 
    args.read(iprot)
3042 
    iprot.readMessageEnd()
3043 
    result = getUserCommunicationById_result()
3044 
    try:
3045 
      result.success = self._handler.getUserCommunicationById(args.id)
3046 
    except UserCommunicationException, ucx:
3047 
      result.ucx = ucx
3048 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
3049 
    result.write(oprot)
3050 
    oprot.writeMessageEnd()
3051 
    oprot.trans.flush()
3052 
 
3053 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
3054 
    args = getUserCommunicationByUser_args()
3055 
    args.read(iprot)
3056 
    iprot.readMessageEnd()
3057 
    result = getUserCommunicationByUser_result()
3058 
    try:
3059 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
3060 
    except UserCommunicationException, ucx:
3061 
      result.ucx = ucx
3062 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
3063 
    result.write(oprot)
3064 
    oprot.writeMessageEnd()
3065 
    oprot.trans.flush()
3066 
 
3067 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
3068 
    args = getAllUserCommunications_args()
3069 
    args.read(iprot)
3070 
    iprot.readMessageEnd()
3071 
    result = getAllUserCommunications_result()
3072 
    try:
3073 
      result.success = self._handler.getAllUserCommunications()
3074 
    except UserCommunicationException, ucx:
3075 
      result.ucx = ucx
3076 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
3077 
    result.write(oprot)
3078 
    oprot.writeMessageEnd()
3079 
    oprot.trans.flush()
3080 
 
1845 vikas 3081 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
3082 
    args = createMasterAffiliate_args()
3083 
    args.read(iprot)
3084 
    iprot.readMessageEnd()
3085 
    result = createMasterAffiliate_result()
3086 
    try:
3087 
      result.success = self._handler.createMasterAffiliate(args.name)
3088 
    except UserTrackerException, utx:
3089 
      result.utx = utx
3090 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
3091 
    result.write(oprot)
3092 
    oprot.writeMessageEnd()
3093 
    oprot.trans.flush()
3094 
 
3095 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
3096 
    args = getMasterAffiliateById_args()
3097 
    args.read(iprot)
3098 
    iprot.readMessageEnd()
3099 
    result = getMasterAffiliateById_result()
3100 
    try:
3101 
      result.success = self._handler.getMasterAffiliateById(args.id)
3102 
    except UserTrackerException, utx:
3103 
      result.utx = utx
3104 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
3105 
    result.write(oprot)
3106 
    oprot.writeMessageEnd()
3107 
    oprot.trans.flush()
3108 
 
3109 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
3110 
    args = getMasterAffiliateByName_args()
3111 
    args.read(iprot)
3112 
    iprot.readMessageEnd()
3113 
    result = getMasterAffiliateByName_result()
3114 
    try:
3115 
      result.success = self._handler.getMasterAffiliateByName(args.name)
3116 
    except UserTrackerException, utx:
3117 
      result.utx = utx
3118 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
3119 
    result.write(oprot)
3120 
    oprot.writeMessageEnd()
3121 
    oprot.trans.flush()
3122 
 
3123 
  def process_createAffiliate(self, seqid, iprot, oprot):
3124 
    args = createAffiliate_args()
3125 
    args.read(iprot)
3126 
    iprot.readMessageEnd()
3127 
    result = createAffiliate_result()
3128 
    try:
3129 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId)
3130 
    except UserTrackerException, utx:
3131 
      result.utx = utx
3132 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
3133 
    result.write(oprot)
3134 
    oprot.writeMessageEnd()
3135 
    oprot.trans.flush()
3136 
 
3137 
  def process_getAffiliateById(self, seqid, iprot, oprot):
3138 
    args = getAffiliateById_args()
3139 
    args.read(iprot)
3140 
    iprot.readMessageEnd()
3141 
    result = getAffiliateById_result()
3142 
    try:
3143 
      result.success = self._handler.getAffiliateById(args.id)
3144 
    except UserTrackerException, utx:
3145 
      result.utx = utx
3146 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
3147 
    result.write(oprot)
3148 
    oprot.writeMessageEnd()
3149 
    oprot.trans.flush()
3150 
 
3151 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
3152 
    args = getAffiliateByName_args()
3153 
    args.read(iprot)
3154 
    iprot.readMessageEnd()
3155 
    result = getAffiliateByName_result()
3156 
    try:
3157 
      result.success = self._handler.getAffiliateByName(args.name)
3158 
    except UserTrackerException, utx:
3159 
      result.utx = utx
3160 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
3161 
    result.write(oprot)
3162 
    oprot.writeMessageEnd()
3163 
    oprot.trans.flush()
3164 
 
3165 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
3166 
    args = getAffiliatesByMasterAffiliate_args()
3167 
    args.read(iprot)
3168 
    iprot.readMessageEnd()
3169 
    result = getAffiliatesByMasterAffiliate_result()
3170 
    try:
3171 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
3172 
    except UserTrackerException, utx:
3173 
      result.utx = utx
3174 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
3175 
    result.write(oprot)
3176 
    oprot.writeMessageEnd()
3177 
    oprot.trans.flush()
3178 
 
3179 
  def process_createTracker(self, seqid, iprot, oprot):
3180 
    args = createTracker_args()
3181 
    args.read(iprot)
3182 
    iprot.readMessageEnd()
3183 
    result = createTracker_result()
3184 
    try:
3185 
      result.success = self._handler.createTracker(args.affiliateId)
3186 
    except UserTrackerException, utx:
3187 
      result.utx = utx
3188 
    oprot.writeMessageBegin("createTracker", TMessageType.REPLY, seqid)
3189 
    result.write(oprot)
3190 
    oprot.writeMessageEnd()
3191 
    oprot.trans.flush()
3192 
 
3193 
  def process_getTrackerById(self, seqid, iprot, oprot):
3194 
    args = getTrackerById_args()
3195 
    args.read(iprot)
3196 
    iprot.readMessageEnd()
3197 
    result = getTrackerById_result()
3198 
    try:
3199 
      result.success = self._handler.getTrackerById(args.trackerId)
3200 
    except UserTrackerException, utx:
3201 
      result.utx = utx
3202 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
3203 
    result.write(oprot)
3204 
    oprot.writeMessageEnd()
3205 
    oprot.trans.flush()
3206 
 
3207 
  def process_getTrackersByAffiliate(self, seqid, iprot, oprot):
3208 
    args = getTrackersByAffiliate_args()
3209 
    args.read(iprot)
3210 
    iprot.readMessageEnd()
3211 
    result = getTrackersByAffiliate_result()
3212 
    try:
3213 
      result.success = self._handler.getTrackersByAffiliate(args.affiliateId)
3214 
    except UserTrackerException, utx:
3215 
      result.utx = utx
3216 
    oprot.writeMessageBegin("getTrackersByAffiliate", TMessageType.REPLY, seqid)
3217 
    result.write(oprot)
3218 
    oprot.writeMessageEnd()
3219 
    oprot.trans.flush()
3220 
 
3221 
  def process_addTrackLog(self, seqid, iprot, oprot):
3222 
    args = addTrackLog_args()
3223 
    args.read(iprot)
3224 
    iprot.readMessageEnd()
3225 
    result = addTrackLog_result()
3226 
    try:
3227 
      result.success = self._handler.addTrackLog(args.trackerId, args.userId, args.event, args.url, args.data)
3228 
    except UserTrackerException, utx:
3229 
      result.utx = utx
3230 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
3231 
    result.write(oprot)
3232 
    oprot.writeMessageEnd()
3233 
    oprot.trans.flush()
3234 
 
3235 
  def process_getTrackLogById(self, seqid, iprot, oprot):
3236 
    args = getTrackLogById_args()
3237 
    args.read(iprot)
3238 
    iprot.readMessageEnd()
3239 
    result = getTrackLogById_result()
3240 
    try:
3241 
      result.success = self._handler.getTrackLogById(args.id)
3242 
    except UserTrackerException, utx:
3243 
      result.utx = utx
3244 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
3245 
    result.write(oprot)
3246 
    oprot.writeMessageEnd()
3247 
    oprot.trans.flush()
3248 
 
3249 
  def process_getTrackLogsByTracker(self, seqid, iprot, oprot):
3250 
    args = getTrackLogsByTracker_args()
3251 
    args.read(iprot)
3252 
    iprot.readMessageEnd()
3253 
    result = getTrackLogsByTracker_result()
3254 
    try:
3255 
      result.success = self._handler.getTrackLogsByTracker(args.trackerId)
3256 
    except UserTrackerException, utx:
3257 
      result.utx = utx
3258 
    oprot.writeMessageBegin("getTrackLogsByTracker", TMessageType.REPLY, seqid)
3259 
    result.write(oprot)
3260 
    oprot.writeMessageEnd()
3261 
    oprot.trans.flush()
3262 
 
3263 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
3264 
    args = getTrackLogsByUser_args()
3265 
    args.read(iprot)
3266 
    iprot.readMessageEnd()
3267 
    result = getTrackLogsByUser_result()
3268 
    try:
3269 
      result.success = self._handler.getTrackLogsByUser(args.userId)
3270 
    except UserTrackerException, utx:
3271 
      result.utx = utx
3272 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
3273 
    result.write(oprot)
3274 
    oprot.writeMessageEnd()
3275 
    oprot.trans.flush()
3276 
 
3277 
  def process_getTrackLogs(self, seqid, iprot, oprot):
3278 
    args = getTrackLogs_args()
3279 
    args.read(iprot)
3280 
    iprot.readMessageEnd()
3281 
    result = getTrackLogs_result()
3282 
    try:
3283 
      result.success = self._handler.getTrackLogs(args.trackerId, args.userId, args.event, args.url)
3284 
    except UserTrackerException, utx:
3285 
      result.utx = utx
3286 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
3287 
    result.write(oprot)
3288 
    oprot.writeMessageEnd()
3289 
    oprot.trans.flush()
3290 
 
559 chandransh 3291 
  def process_createCart(self, seqid, iprot, oprot):
3292 
    args = createCart_args()
94 ashish 3293 
    args.read(iprot)
3294 
    iprot.readMessageEnd()
559 chandransh 3295 
    result = createCart_result()
94 ashish 3296 
    try:
559 chandransh 3297 
      result.success = self._handler.createCart(args.userId)
3298 
    except ShoppingCartException, scx:
3299 
      result.scx = scx
3300 
    oprot.writeMessageBegin("createCart", TMessageType.REPLY, seqid)
94 ashish 3301 
    result.write(oprot)
3302 
    oprot.writeMessageEnd()
3303 
    oprot.trans.flush()
3304 
 
559 chandransh 3305 
  def process_getCurrentCart(self, seqid, iprot, oprot):
3306 
    args = getCurrentCart_args()
94 ashish 3307 
    args.read(iprot)
3308 
    iprot.readMessageEnd()
559 chandransh 3309 
    result = getCurrentCart_result()
94 ashish 3310 
    try:
559 chandransh 3311 
      result.success = self._handler.getCurrentCart(args.userId)
3312 
    except ShoppingCartException, scx:
3313 
      result.scx = scx
3314 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 3315 
    result.write(oprot)
3316 
    oprot.writeMessageEnd()
3317 
    oprot.trans.flush()
3318 
 
559 chandransh 3319 
  def process_getCart(self, seqid, iprot, oprot):
3320 
    args = getCart_args()
94 ashish 3321 
    args.read(iprot)
3322 
    iprot.readMessageEnd()
559 chandransh 3323 
    result = getCart_result()
94 ashish 3324 
    try:
559 chandransh 3325 
      result.success = self._handler.getCart(args.cartId)
3326 
    except ShoppingCartException, scx:
3327 
      result.scx = scx
3328 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 3329 
    result.write(oprot)
3330 
    oprot.writeMessageEnd()
3331 
    oprot.trans.flush()
3332 
 
559 chandransh 3333 
  def process_getCartsForUser(self, seqid, iprot, oprot):
3334 
    args = getCartsForUser_args()
94 ashish 3335 
    args.read(iprot)
3336 
    iprot.readMessageEnd()
559 chandransh 3337 
    result = getCartsForUser_result()
94 ashish 3338 
    try:
559 chandransh 3339 
      result.success = self._handler.getCartsForUser(args.userId, args.status)
3340 
    except ShoppingCartException, scx:
3341 
      result.scx = scx
3342 
    oprot.writeMessageBegin("getCartsForUser", TMessageType.REPLY, seqid)
94 ashish 3343 
    result.write(oprot)
3344 
    oprot.writeMessageEnd()
3345 
    oprot.trans.flush()
3346 
 
559 chandransh 3347 
  def process_getCartsByStatus(self, seqid, iprot, oprot):
3348 
    args = getCartsByStatus_args()
94 ashish 3349 
    args.read(iprot)
3350 
    iprot.readMessageEnd()
559 chandransh 3351 
    result = getCartsByStatus_result()
94 ashish 3352 
    try:
559 chandransh 3353 
      result.success = self._handler.getCartsByStatus(args.status)
3354 
    except ShoppingCartException, scx:
3355 
      result.scx = scx
3356 
    oprot.writeMessageBegin("getCartsByStatus", TMessageType.REPLY, seqid)
94 ashish 3357 
    result.write(oprot)
3358 
    oprot.writeMessageEnd()
3359 
    oprot.trans.flush()
3360 
 
559 chandransh 3361 
  def process_getCartsByTime(self, seqid, iprot, oprot):
3362 
    args = getCartsByTime_args()
94 ashish 3363 
    args.read(iprot)
3364 
    iprot.readMessageEnd()
559 chandransh 3365 
    result = getCartsByTime_result()
94 ashish 3366 
    try:
559 chandransh 3367 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
3368 
    except ShoppingCartException, scx:
3369 
      result.scx = scx
3370 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 3371 
    result.write(oprot)
3372 
    oprot.writeMessageEnd()
3373 
    oprot.trans.flush()
3374 
 
559 chandransh 3375 
  def process_changeCartStatus(self, seqid, iprot, oprot):
3376 
    args = changeCartStatus_args()
130 ashish 3377 
    args.read(iprot)
3378 
    iprot.readMessageEnd()
559 chandransh 3379 
    result = changeCartStatus_result()
130 ashish 3380 
    try:
559 chandransh 3381 
      self._handler.changeCartStatus(args.cartId, args.status)
3382 
    except ShoppingCartException, scx:
3383 
      result.scx = scx
3384 
    oprot.writeMessageBegin("changeCartStatus", TMessageType.REPLY, seqid)
130 ashish 3385 
    result.write(oprot)
3386 
    oprot.writeMessageEnd()
3387 
    oprot.trans.flush()
94 ashish 3388 
 
559 chandransh 3389 
  def process_addItemToCart(self, seqid, iprot, oprot):
3390 
    args = addItemToCart_args()
130 ashish 3391 
    args.read(iprot)
3392 
    iprot.readMessageEnd()
559 chandransh 3393 
    result = addItemToCart_result()
130 ashish 3394 
    try:
559 chandransh 3395 
      self._handler.addItemToCart(args.cartId, args.itemId, args.quantity)
3396 
    except ShoppingCartException, scx:
3397 
      result.scx = scx
3398 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 3399 
    result.write(oprot)
3400 
    oprot.writeMessageEnd()
3401 
    oprot.trans.flush()
3402 
 
559 chandransh 3403 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
3404 
    args = deleteItemFromCart_args()
3405 
    args.read(iprot)
3406 
    iprot.readMessageEnd()
3407 
    result = deleteItemFromCart_result()
3408 
    try:
3409 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
3410 
    except ShoppingCartException, scx:
3411 
      result.scx = scx
3412 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
3413 
    result.write(oprot)
3414 
    oprot.writeMessageEnd()
3415 
    oprot.trans.flush()
130 ashish 3416 
 
559 chandransh 3417 
  def process_changeQuantity(self, seqid, iprot, oprot):
3418 
    args = changeQuantity_args()
3419 
    args.read(iprot)
3420 
    iprot.readMessageEnd()
3421 
    result = changeQuantity_result()
3422 
    try:
3423 
      self._handler.changeQuantity(args.cartId, args.itemId, args.quantity)
3424 
    except ShoppingCartException, scx:
3425 
      result.scx = scx
3426 
    oprot.writeMessageBegin("changeQuantity", TMessageType.REPLY, seqid)
3427 
    result.write(oprot)
3428 
    oprot.writeMessageEnd()
3429 
    oprot.trans.flush()
3430 
 
3431 
  def process_changeItemStatus(self, seqid, iprot, oprot):
3432 
    args = changeItemStatus_args()
3433 
    args.read(iprot)
3434 
    iprot.readMessageEnd()
3435 
    result = changeItemStatus_result()
3436 
    try:
3437 
      self._handler.changeItemStatus(args.cartId, args.itemId, args.status)
3438 
    except ShoppingCartException, scx:
3439 
      result.scx = scx
3440 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
3441 
    result.write(oprot)
3442 
    oprot.writeMessageEnd()
3443 
    oprot.trans.flush()
3444 
 
3445 
  def process_addAddressToCart(self, seqid, iprot, oprot):
3446 
    args = addAddressToCart_args()
3447 
    args.read(iprot)
3448 
    iprot.readMessageEnd()
3449 
    result = addAddressToCart_result()
575 chandransh 3450 
    try:
3451 
      self._handler.addAddressToCart(args.cartId, args.addressId)
3452 
    except ShoppingCartException, scx:
3453 
      result.scx = scx
559 chandransh 3454 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
3455 
    result.write(oprot)
3456 
    oprot.writeMessageEnd()
3457 
    oprot.trans.flush()
3458 
 
690 chandransh 3459 
  def process_createOrders(self, seqid, iprot, oprot):
3460 
    args = createOrders_args()
559 chandransh 3461 
    args.read(iprot)
3462 
    iprot.readMessageEnd()
690 chandransh 3463 
    result = createOrders_result()
559 chandransh 3464 
    try:
690 chandransh 3465 
      result.success = self._handler.createOrders(args.cartId)
559 chandransh 3466 
    except ShoppingCartException, scx:
3467 
      result.scx = scx
690 chandransh 3468 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 3469 
    result.write(oprot)
3470 
    oprot.writeMessageEnd()
3471 
    oprot.trans.flush()
3472 
 
3473 
  def process_validateCart(self, seqid, iprot, oprot):
3474 
    args = validateCart_args()
3475 
    args.read(iprot)
3476 
    iprot.readMessageEnd()
3477 
    result = validateCart_result()
575 chandransh 3478 
    try:
3479 
      result.success = self._handler.validateCart(args.cartId)
3480 
    except ShoppingCartException, scex:
3481 
      result.scex = scex
559 chandransh 3482 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
3483 
    result.write(oprot)
3484 
    oprot.writeMessageEnd()
3485 
    oprot.trans.flush()
3486 
 
690 chandransh 3487 
  def process_mergeCart(self, seqid, iprot, oprot):
3488 
    args = mergeCart_args()
575 chandransh 3489 
    args.read(iprot)
3490 
    iprot.readMessageEnd()
690 chandransh 3491 
    result = mergeCart_result()
3492 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
3493 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
3494 
    result.write(oprot)
3495 
    oprot.writeMessageEnd()
3496 
    oprot.trans.flush()
3497 
 
3498 
  def process_checkOut(self, seqid, iprot, oprot):
3499 
    args = checkOut_args()
3500 
    args.read(iprot)
3501 
    iprot.readMessageEnd()
3502 
    result = checkOut_result()
575 chandransh 3503 
    try:
690 chandransh 3504 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 3505 
    except ShoppingCartException, scex:
3506 
      result.scex = scex
690 chandransh 3507 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 3508 
    result.write(oprot)
3509 
    oprot.writeMessageEnd()
3510 
    oprot.trans.flush()
3511 
 
690 chandransh 3512 
  def process_resetCart(self, seqid, iprot, oprot):
3513 
    args = resetCart_args()
559 chandransh 3514 
    args.read(iprot)
3515 
    iprot.readMessageEnd()
690 chandransh 3516 
    result = resetCart_result()
3517 
    try:
3518 
      result.success = self._handler.resetCart(args.cartId, args.items)
3519 
    except ShoppingCartException, scex:
3520 
      result.scex = scex
3521 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 3522 
    result.write(oprot)
3523 
    oprot.writeMessageEnd()
3524 
    oprot.trans.flush()
3525 
 
3526 
  def process_getMyResearch(self, seqid, iprot, oprot):
3527 
    args = getMyResearch_args()
3528 
    args.read(iprot)
3529 
    iprot.readMessageEnd()
3530 
    result = getMyResearch_result()
3531 
    try:
772 rajveer 3532 
      result.success = self._handler.getMyResearch(args.userId)
559 chandransh 3533 
    except WidgetException, scx:
3534 
      result.scx = scx
3535 
    oprot.writeMessageBegin("getMyResearch", TMessageType.REPLY, seqid)
3536 
    result.write(oprot)
3537 
    oprot.writeMessageEnd()
3538 
    oprot.trans.flush()
3539 
 
3540 
  def process_updateMyResearch(self, seqid, iprot, oprot):
3541 
    args = updateMyResearch_args()
3542 
    args.read(iprot)
3543 
    iprot.readMessageEnd()
3544 
    result = updateMyResearch_result()
3545 
    try:
772 rajveer 3546 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
559 chandransh 3547 
    except WidgetException, scx:
3548 
      result.scx = scx
3549 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
3550 
    result.write(oprot)
3551 
    oprot.writeMessageEnd()
3552 
    oprot.trans.flush()
3553 
 
3554 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
3555 
    args = deleteItemFromMyResearch_args()
3556 
    args.read(iprot)
3557 
    iprot.readMessageEnd()
3558 
    result = deleteItemFromMyResearch_result()
3559 
    try:
772 rajveer 3560 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
559 chandransh 3561 
    except WidgetException, scx:
3562 
      result.scx = scx
3563 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
3564 
    result.write(oprot)
3565 
    oprot.writeMessageEnd()
3566 
    oprot.trans.flush()
3567 
 
3568 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
3569 
    args = updateBrowseHistory_args()
3570 
    args.read(iprot)
3571 
    iprot.readMessageEnd()
3572 
    result = updateBrowseHistory_result()
772 rajveer 3573 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
559 chandransh 3574 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
3575 
    result.write(oprot)
3576 
    oprot.writeMessageEnd()
3577 
    oprot.trans.flush()
3578 
 
3579 
  def process_getBrowseHistory(self, seqid, iprot, oprot):
3580 
    args = getBrowseHistory_args()
3581 
    args.read(iprot)
3582 
    iprot.readMessageEnd()
3583 
    result = getBrowseHistory_result()
3584 
    try:
772 rajveer 3585 
      result.success = self._handler.getBrowseHistory(args.userId)
559 chandransh 3586 
    except WidgetException, scx:
3587 
      result.scx = scx
3588 
    oprot.writeMessageBegin("getBrowseHistory", TMessageType.REPLY, seqid)
3589 
    result.write(oprot)
3590 
    oprot.writeMessageEnd()
3591 
    oprot.trans.flush()
3592 
 
772 rajveer 3593 
  def process_mergeBrowseHistory(self, seqid, iprot, oprot):
3594 
    args = mergeBrowseHistory_args()
3595 
    args.read(iprot)
3596 
    iprot.readMessageEnd()
3597 
    result = mergeBrowseHistory_result()
3598 
    self._handler.mergeBrowseHistory(args.fromUserId, args.toUserId)
3599 
    oprot.writeMessageBegin("mergeBrowseHistory", TMessageType.REPLY, seqid)
3600 
    result.write(oprot)
3601 
    oprot.writeMessageEnd()
3602 
    oprot.trans.flush()
559 chandransh 3603 
 
1596 ankur.sing 3604 
  def process_getUserCount(self, seqid, iprot, oprot):
3605 
    args = getUserCount_args()
3606 
    args.read(iprot)
3607 
    iprot.readMessageEnd()
3608 
    result = getUserCount_result()
3609 
    result.success = self._handler.getUserCount(args.userType)
3610 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
3611 
    result.write(oprot)
3612 
    oprot.writeMessageEnd()
3613 
    oprot.trans.flush()
772 rajveer 3614 
 
1673 ankur.sing 3615 
  def process_getAllUsers(self, seqid, iprot, oprot):
3616 
    args = getAllUsers_args()
3617 
    args.read(iprot)
3618 
    iprot.readMessageEnd()
3619 
    result = getAllUsers_result()
3620 
    result.success = self._handler.getAllUsers(args.userType)
3621 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
3622 
    result.write(oprot)
3623 
    oprot.writeMessageEnd()
3624 
    oprot.trans.flush()
1596 ankur.sing 3625 
 
1673 ankur.sing 3626 
 
94 ashish 3627 
# HELPER FUNCTIONS AND STRUCTURES
3628 
 
765 rajveer 3629 
class closeSession_args:
3630 
 
3631 
  thrift_spec = (
3632 
  )
3633 
 
3634 
  def read(self, iprot):
3635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3637 
      return
3638 
    iprot.readStructBegin()
3639 
    while True:
3640 
      (fname, ftype, fid) = iprot.readFieldBegin()
3641 
      if ftype == TType.STOP:
3642 
        break
3643 
      else:
3644 
        iprot.skip(ftype)
3645 
      iprot.readFieldEnd()
3646 
    iprot.readStructEnd()
3647 
 
3648 
  def write(self, oprot):
3649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3651 
      return
3652 
    oprot.writeStructBegin('closeSession_args')
3653 
    oprot.writeFieldStop()
3654 
    oprot.writeStructEnd()
3655 
 
3656 
  def __repr__(self):
3657 
    L = ['%s=%r' % (key, value)
3658 
      for key, value in self.__dict__.iteritems()]
3659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3660 
 
3661 
  def __eq__(self, other):
3662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3663 
 
3664 
  def __ne__(self, other):
3665 
    return not (self == other)
3666 
 
3667 
class closeSession_result:
3668 
 
3669 
  thrift_spec = (
3670 
  )
3671 
 
3672 
  def read(self, iprot):
3673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3675 
      return
3676 
    iprot.readStructBegin()
3677 
    while True:
3678 
      (fname, ftype, fid) = iprot.readFieldBegin()
3679 
      if ftype == TType.STOP:
3680 
        break
3681 
      else:
3682 
        iprot.skip(ftype)
3683 
      iprot.readFieldEnd()
3684 
    iprot.readStructEnd()
3685 
 
3686 
  def write(self, oprot):
3687 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3688 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3689 
      return
3690 
    oprot.writeStructBegin('closeSession_result')
3691 
    oprot.writeFieldStop()
3692 
    oprot.writeStructEnd()
3693 
 
3694 
  def __repr__(self):
3695 
    L = ['%s=%r' % (key, value)
3696 
      for key, value in self.__dict__.iteritems()]
3697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3698 
 
3699 
  def __eq__(self, other):
3700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3701 
 
3702 
  def __ne__(self, other):
3703 
    return not (self == other)
3704 
 
559 chandransh 3705 
class createAnonymousUser_args:
94 ashish 3706 
  """
3707 
  Attributes:
559 chandransh 3708 
   - jsessionId
94 ashish 3709 
  """
3710 
 
3711 
  thrift_spec = (
3712 
    None, # 0
559 chandransh 3713 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 3714 
  )
3715 
 
559 chandransh 3716 
  def __init__(self, jsessionId=None,):
3717 
    self.jsessionId = jsessionId
94 ashish 3718 
 
3719 
  def read(self, iprot):
3720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3722 
      return
3723 
    iprot.readStructBegin()
3724 
    while True:
3725 
      (fname, ftype, fid) = iprot.readFieldBegin()
3726 
      if ftype == TType.STOP:
3727 
        break
3728 
      if fid == 1:
559 chandransh 3729 
        if ftype == TType.STRING:
3730 
          self.jsessionId = iprot.readString();
94 ashish 3731 
        else:
3732 
          iprot.skip(ftype)
3733 
      else:
3734 
        iprot.skip(ftype)
3735 
      iprot.readFieldEnd()
3736 
    iprot.readStructEnd()
3737 
 
3738 
  def write(self, oprot):
3739 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3740 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3741 
      return
559 chandransh 3742 
    oprot.writeStructBegin('createAnonymousUser_args')
3743 
    if self.jsessionId != None:
3744 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
3745 
      oprot.writeString(self.jsessionId)
94 ashish 3746 
      oprot.writeFieldEnd()
3747 
    oprot.writeFieldStop()
3748 
    oprot.writeStructEnd()
3749 
 
3750 
  def __repr__(self):
3751 
    L = ['%s=%r' % (key, value)
3752 
      for key, value in self.__dict__.iteritems()]
3753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3754 
 
3755 
  def __eq__(self, other):
3756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3757 
 
3758 
  def __ne__(self, other):
3759 
    return not (self == other)
3760 
 
559 chandransh 3761 
class createAnonymousUser_result:
94 ashish 3762 
  """
3763 
  Attributes:
3764 
   - success
559 chandransh 3765 
   - ucex
94 ashish 3766 
  """
3767 
 
3768 
  thrift_spec = (
559 chandransh 3769 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
3770 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 3771 
  )
3772 
 
559 chandransh 3773 
  def __init__(self, success=None, ucex=None,):
94 ashish 3774 
    self.success = success
559 chandransh 3775 
    self.ucex = ucex
94 ashish 3776 
 
3777 
  def read(self, iprot):
3778 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3779 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3780 
      return
3781 
    iprot.readStructBegin()
3782 
    while True:
3783 
      (fname, ftype, fid) = iprot.readFieldBegin()
3784 
      if ftype == TType.STOP:
3785 
        break
3786 
      if fid == 0:
3787 
        if ftype == TType.STRUCT:
559 chandransh 3788 
          self.success = User()
94 ashish 3789 
          self.success.read(iprot)
3790 
        else:
3791 
          iprot.skip(ftype)
3792 
      elif fid == 1:
3793 
        if ftype == TType.STRUCT:
559 chandransh 3794 
          self.ucex = UserContextException()
3795 
          self.ucex.read(iprot)
94 ashish 3796 
        else:
3797 
          iprot.skip(ftype)
3798 
      else:
3799 
        iprot.skip(ftype)
3800 
      iprot.readFieldEnd()
3801 
    iprot.readStructEnd()
3802 
 
3803 
  def write(self, oprot):
3804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3806 
      return
559 chandransh 3807 
    oprot.writeStructBegin('createAnonymousUser_result')
94 ashish 3808 
    if self.success != None:
3809 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3810 
      self.success.write(oprot)
3811 
      oprot.writeFieldEnd()
559 chandransh 3812 
    if self.ucex != None:
3813 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
3814 
      self.ucex.write(oprot)
94 ashish 3815 
      oprot.writeFieldEnd()
3816 
    oprot.writeFieldStop()
3817 
    oprot.writeStructEnd()
3818 
 
3819 
  def __repr__(self):
3820 
    L = ['%s=%r' % (key, value)
3821 
      for key, value in self.__dict__.iteritems()]
3822 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3823 
 
3824 
  def __eq__(self, other):
3825 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3826 
 
3827 
  def __ne__(self, other):
3828 
    return not (self == other)
3829 
 
559 chandransh 3830 
class getUserById_args:
94 ashish 3831 
  """
3832 
  Attributes:
3833 
   - userId
3834 
  """
3835 
 
3836 
  thrift_spec = (
3837 
    None, # 0
3838 
    (1, TType.I64, 'userId', None, None, ), # 1
3839 
  )
3840 
 
559 chandransh 3841 
  def __init__(self, userId=None,):
94 ashish 3842 
    self.userId = userId
3843 
 
3844 
  def read(self, iprot):
3845 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3846 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3847 
      return
3848 
    iprot.readStructBegin()
3849 
    while True:
3850 
      (fname, ftype, fid) = iprot.readFieldBegin()
3851 
      if ftype == TType.STOP:
3852 
        break
3853 
      if fid == 1:
3854 
        if ftype == TType.I64:
3855 
          self.userId = iprot.readI64();
3856 
        else:
3857 
          iprot.skip(ftype)
3858 
      else:
3859 
        iprot.skip(ftype)
3860 
      iprot.readFieldEnd()
3861 
    iprot.readStructEnd()
3862 
 
3863 
  def write(self, oprot):
3864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3866 
      return
559 chandransh 3867 
    oprot.writeStructBegin('getUserById_args')
94 ashish 3868 
    if self.userId != None:
3869 
      oprot.writeFieldBegin('userId', TType.I64, 1)
3870 
      oprot.writeI64(self.userId)
3871 
      oprot.writeFieldEnd()
3872 
    oprot.writeFieldStop()
3873 
    oprot.writeStructEnd()
3874 
 
3875 
  def __repr__(self):
3876 
    L = ['%s=%r' % (key, value)
3877 
      for key, value in self.__dict__.iteritems()]
3878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3879 
 
3880 
  def __eq__(self, other):
3881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3882 
 
3883 
  def __ne__(self, other):
3884 
    return not (self == other)
3885 
 
559 chandransh 3886 
class getUserById_result:
94 ashish 3887 
  """
3888 
  Attributes:
3889 
   - success
559 chandransh 3890 
   - ucex
94 ashish 3891 
  """
3892 
 
3893 
  thrift_spec = (
559 chandransh 3894 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
3895 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 3896 
  )
3897 
 
559 chandransh 3898 
  def __init__(self, success=None, ucex=None,):
94 ashish 3899 
    self.success = success
559 chandransh 3900 
    self.ucex = ucex
94 ashish 3901 
 
3902 
  def read(self, iprot):
3903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3905 
      return
3906 
    iprot.readStructBegin()
3907 
    while True:
3908 
      (fname, ftype, fid) = iprot.readFieldBegin()
3909 
      if ftype == TType.STOP:
3910 
        break
3911 
      if fid == 0:
3912 
        if ftype == TType.STRUCT:
559 chandransh 3913 
          self.success = User()
94 ashish 3914 
          self.success.read(iprot)
3915 
        else:
3916 
          iprot.skip(ftype)
3917 
      elif fid == 1:
3918 
        if ftype == TType.STRUCT:
559 chandransh 3919 
          self.ucex = UserContextException()
3920 
          self.ucex.read(iprot)
94 ashish 3921 
        else:
3922 
          iprot.skip(ftype)
3923 
      else:
3924 
        iprot.skip(ftype)
3925 
      iprot.readFieldEnd()
3926 
    iprot.readStructEnd()
3927 
 
3928 
  def write(self, oprot):
3929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3931 
      return
559 chandransh 3932 
    oprot.writeStructBegin('getUserById_result')
94 ashish 3933 
    if self.success != None:
3934 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3935 
      self.success.write(oprot)
3936 
      oprot.writeFieldEnd()
559 chandransh 3937 
    if self.ucex != None:
3938 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
3939 
      self.ucex.write(oprot)
94 ashish 3940 
      oprot.writeFieldEnd()
3941 
    oprot.writeFieldStop()
3942 
    oprot.writeStructEnd()
3943 
 
3944 
  def __repr__(self):
3945 
    L = ['%s=%r' % (key, value)
3946 
      for key, value in self.__dict__.iteritems()]
3947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3948 
 
3949 
  def __eq__(self, other):
3950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3951 
 
3952 
  def __ne__(self, other):
3953 
    return not (self == other)
3954 
 
1491 vikas 3955 
class getUserByEmail_args:
3956 
  """
3957 
  Attributes:
3958 
   - email
3959 
  """
3960 
 
3961 
  thrift_spec = (
3962 
    None, # 0
3963 
    (1, TType.STRING, 'email', None, None, ), # 1
3964 
  )
3965 
 
3966 
  def __init__(self, email=None,):
3967 
    self.email = email
3968 
 
3969 
  def read(self, iprot):
3970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3972 
      return
3973 
    iprot.readStructBegin()
3974 
    while True:
3975 
      (fname, ftype, fid) = iprot.readFieldBegin()
3976 
      if ftype == TType.STOP:
3977 
        break
3978 
      if fid == 1:
3979 
        if ftype == TType.STRING:
3980 
          self.email = iprot.readString();
3981 
        else:
3982 
          iprot.skip(ftype)
3983 
      else:
3984 
        iprot.skip(ftype)
3985 
      iprot.readFieldEnd()
3986 
    iprot.readStructEnd()
3987 
 
3988 
  def write(self, oprot):
3989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3991 
      return
3992 
    oprot.writeStructBegin('getUserByEmail_args')
3993 
    if self.email != None:
3994 
      oprot.writeFieldBegin('email', TType.STRING, 1)
3995 
      oprot.writeString(self.email)
3996 
      oprot.writeFieldEnd()
3997 
    oprot.writeFieldStop()
3998 
    oprot.writeStructEnd()
3999 
 
4000 
  def __repr__(self):
4001 
    L = ['%s=%r' % (key, value)
4002 
      for key, value in self.__dict__.iteritems()]
4003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4004 
 
4005 
  def __eq__(self, other):
4006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4007 
 
4008 
  def __ne__(self, other):
4009 
    return not (self == other)
4010 
 
4011 
class getUserByEmail_result:
4012 
  """
4013 
  Attributes:
4014 
   - success
4015 
   - ucex
4016 
  """
4017 
 
4018 
  thrift_spec = (
4019 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4020 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4021 
  )
4022 
 
4023 
  def __init__(self, success=None, ucex=None,):
4024 
    self.success = success
4025 
    self.ucex = ucex
4026 
 
4027 
  def read(self, iprot):
4028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4030 
      return
4031 
    iprot.readStructBegin()
4032 
    while True:
4033 
      (fname, ftype, fid) = iprot.readFieldBegin()
4034 
      if ftype == TType.STOP:
4035 
        break
4036 
      if fid == 0:
4037 
        if ftype == TType.STRUCT:
4038 
          self.success = User()
4039 
          self.success.read(iprot)
4040 
        else:
4041 
          iprot.skip(ftype)
4042 
      elif fid == 1:
4043 
        if ftype == TType.STRUCT:
4044 
          self.ucex = UserContextException()
4045 
          self.ucex.read(iprot)
4046 
        else:
4047 
          iprot.skip(ftype)
4048 
      else:
4049 
        iprot.skip(ftype)
4050 
      iprot.readFieldEnd()
4051 
    iprot.readStructEnd()
4052 
 
4053 
  def write(self, oprot):
4054 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4055 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4056 
      return
4057 
    oprot.writeStructBegin('getUserByEmail_result')
4058 
    if self.success != None:
4059 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4060 
      self.success.write(oprot)
4061 
      oprot.writeFieldEnd()
4062 
    if self.ucex != None:
4063 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4064 
      self.ucex.write(oprot)
4065 
      oprot.writeFieldEnd()
4066 
    oprot.writeFieldStop()
4067 
    oprot.writeStructEnd()
4068 
 
4069 
  def __repr__(self):
4070 
    L = ['%s=%r' % (key, value)
4071 
      for key, value in self.__dict__.iteritems()]
4072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4073 
 
4074 
  def __eq__(self, other):
4075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4076 
 
4077 
  def __ne__(self, other):
4078 
    return not (self == other)
4079 
 
559 chandransh 4080 
class createUser_args:
94 ashish 4081 
  """
4082 
  Attributes:
559 chandransh 4083 
   - user
94 ashish 4084 
  """
4085 
 
4086 
  thrift_spec = (
4087 
    None, # 0
559 chandransh 4088 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4089 
  )
4090 
 
559 chandransh 4091 
  def __init__(self, user=None,):
4092 
    self.user = user
94 ashish 4093 
 
4094 
  def read(self, iprot):
4095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4097 
      return
4098 
    iprot.readStructBegin()
4099 
    while True:
4100 
      (fname, ftype, fid) = iprot.readFieldBegin()
4101 
      if ftype == TType.STOP:
4102 
        break
4103 
      if fid == 1:
559 chandransh 4104 
        if ftype == TType.STRUCT:
4105 
          self.user = User()
4106 
          self.user.read(iprot)
94 ashish 4107 
        else:
4108 
          iprot.skip(ftype)
4109 
      else:
4110 
        iprot.skip(ftype)
4111 
      iprot.readFieldEnd()
4112 
    iprot.readStructEnd()
4113 
 
4114 
  def write(self, oprot):
4115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4117 
      return
559 chandransh 4118 
    oprot.writeStructBegin('createUser_args')
4119 
    if self.user != None:
4120 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4121 
      self.user.write(oprot)
94 ashish 4122 
      oprot.writeFieldEnd()
4123 
    oprot.writeFieldStop()
4124 
    oprot.writeStructEnd()
4125 
 
4126 
  def __repr__(self):
4127 
    L = ['%s=%r' % (key, value)
4128 
      for key, value in self.__dict__.iteritems()]
4129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4130 
 
4131 
  def __eq__(self, other):
4132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4133 
 
4134 
  def __ne__(self, other):
4135 
    return not (self == other)
4136 
 
559 chandransh 4137 
class createUser_result:
94 ashish 4138 
  """
4139 
  Attributes:
4140 
   - success
559 chandransh 4141 
   - ucex
94 ashish 4142 
  """
4143 
 
4144 
  thrift_spec = (
559 chandransh 4145 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4146 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4147 
  )
4148 
 
559 chandransh 4149 
  def __init__(self, success=None, ucex=None,):
94 ashish 4150 
    self.success = success
559 chandransh 4151 
    self.ucex = ucex
94 ashish 4152 
 
4153 
  def read(self, iprot):
4154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4156 
      return
4157 
    iprot.readStructBegin()
4158 
    while True:
4159 
      (fname, ftype, fid) = iprot.readFieldBegin()
4160 
      if ftype == TType.STOP:
4161 
        break
4162 
      if fid == 0:
4163 
        if ftype == TType.STRUCT:
559 chandransh 4164 
          self.success = User()
94 ashish 4165 
          self.success.read(iprot)
4166 
        else:
4167 
          iprot.skip(ftype)
4168 
      elif fid == 1:
4169 
        if ftype == TType.STRUCT:
559 chandransh 4170 
          self.ucex = UserContextException()
4171 
          self.ucex.read(iprot)
94 ashish 4172 
        else:
4173 
          iprot.skip(ftype)
4174 
      else:
4175 
        iprot.skip(ftype)
4176 
      iprot.readFieldEnd()
4177 
    iprot.readStructEnd()
4178 
 
4179 
  def write(self, oprot):
4180 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4181 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4182 
      return
559 chandransh 4183 
    oprot.writeStructBegin('createUser_result')
94 ashish 4184 
    if self.success != None:
4185 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4186 
      self.success.write(oprot)
4187 
      oprot.writeFieldEnd()
559 chandransh 4188 
    if self.ucex != None:
4189 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4190 
      self.ucex.write(oprot)
94 ashish 4191 
      oprot.writeFieldEnd()
4192 
    oprot.writeFieldStop()
4193 
    oprot.writeStructEnd()
4194 
 
4195 
  def __repr__(self):
4196 
    L = ['%s=%r' % (key, value)
4197 
      for key, value in self.__dict__.iteritems()]
4198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4199 
 
4200 
  def __eq__(self, other):
4201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4202 
 
4203 
  def __ne__(self, other):
4204 
    return not (self == other)
4205 
 
559 chandransh 4206 
class updateUser_args:
94 ashish 4207 
  """
4208 
  Attributes:
559 chandransh 4209 
   - user
94 ashish 4210 
  """
4211 
 
4212 
  thrift_spec = (
4213 
    None, # 0
559 chandransh 4214 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4215 
  )
4216 
 
559 chandransh 4217 
  def __init__(self, user=None,):
4218 
    self.user = user
94 ashish 4219 
 
4220 
  def read(self, iprot):
4221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4223 
      return
4224 
    iprot.readStructBegin()
4225 
    while True:
4226 
      (fname, ftype, fid) = iprot.readFieldBegin()
4227 
      if ftype == TType.STOP:
4228 
        break
4229 
      if fid == 1:
559 chandransh 4230 
        if ftype == TType.STRUCT:
4231 
          self.user = User()
4232 
          self.user.read(iprot)
94 ashish 4233 
        else:
4234 
          iprot.skip(ftype)
4235 
      else:
4236 
        iprot.skip(ftype)
4237 
      iprot.readFieldEnd()
4238 
    iprot.readStructEnd()
4239 
 
4240 
  def write(self, oprot):
4241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4243 
      return
559 chandransh 4244 
    oprot.writeStructBegin('updateUser_args')
4245 
    if self.user != None:
4246 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4247 
      self.user.write(oprot)
94 ashish 4248 
      oprot.writeFieldEnd()
4249 
    oprot.writeFieldStop()
4250 
    oprot.writeStructEnd()
4251 
 
4252 
  def __repr__(self):
4253 
    L = ['%s=%r' % (key, value)
4254 
      for key, value in self.__dict__.iteritems()]
4255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4256 
 
4257 
  def __eq__(self, other):
4258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4259 
 
4260 
  def __ne__(self, other):
4261 
    return not (self == other)
4262 
 
559 chandransh 4263 
class updateUser_result:
94 ashish 4264 
  """
4265 
  Attributes:
4266 
   - success
559 chandransh 4267 
   - ucex
94 ashish 4268 
  """
4269 
 
4270 
  thrift_spec = (
559 chandransh 4271 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4272 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4273 
  )
4274 
 
559 chandransh 4275 
  def __init__(self, success=None, ucex=None,):
94 ashish 4276 
    self.success = success
559 chandransh 4277 
    self.ucex = ucex
94 ashish 4278 
 
4279 
  def read(self, iprot):
4280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4282 
      return
4283 
    iprot.readStructBegin()
4284 
    while True:
4285 
      (fname, ftype, fid) = iprot.readFieldBegin()
4286 
      if ftype == TType.STOP:
4287 
        break
4288 
      if fid == 0:
4289 
        if ftype == TType.STRUCT:
559 chandransh 4290 
          self.success = User()
94 ashish 4291 
          self.success.read(iprot)
4292 
        else:
4293 
          iprot.skip(ftype)
4294 
      elif fid == 1:
4295 
        if ftype == TType.STRUCT:
559 chandransh 4296 
          self.ucex = UserContextException()
4297 
          self.ucex.read(iprot)
94 ashish 4298 
        else:
4299 
          iprot.skip(ftype)
4300 
      else:
4301 
        iprot.skip(ftype)
4302 
      iprot.readFieldEnd()
4303 
    iprot.readStructEnd()
4304 
 
4305 
  def write(self, oprot):
4306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4308 
      return
559 chandransh 4309 
    oprot.writeStructBegin('updateUser_result')
94 ashish 4310 
    if self.success != None:
4311 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4312 
      self.success.write(oprot)
4313 
      oprot.writeFieldEnd()
559 chandransh 4314 
    if self.ucex != None:
4315 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4316 
      self.ucex.write(oprot)
94 ashish 4317 
      oprot.writeFieldEnd()
4318 
    oprot.writeFieldStop()
4319 
    oprot.writeStructEnd()
4320 
 
4321 
  def __repr__(self):
4322 
    L = ['%s=%r' % (key, value)
4323 
      for key, value in self.__dict__.iteritems()]
4324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4325 
 
4326 
  def __eq__(self, other):
4327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4328 
 
4329 
  def __ne__(self, other):
4330 
    return not (self == other)
4331 
 
559 chandransh 4332 
class deleteUser_args:
94 ashish 4333 
  """
4334 
  Attributes:
4335 
   - userId
4336 
  """
4337 
 
4338 
  thrift_spec = (
4339 
    None, # 0
4340 
    (1, TType.I64, 'userId', None, None, ), # 1
4341 
  )
4342 
 
559 chandransh 4343 
  def __init__(self, userId=None,):
94 ashish 4344 
    self.userId = userId
4345 
 
4346 
  def read(self, iprot):
4347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4349 
      return
4350 
    iprot.readStructBegin()
4351 
    while True:
4352 
      (fname, ftype, fid) = iprot.readFieldBegin()
4353 
      if ftype == TType.STOP:
4354 
        break
4355 
      if fid == 1:
4356 
        if ftype == TType.I64:
4357 
          self.userId = iprot.readI64();
4358 
        else:
4359 
          iprot.skip(ftype)
4360 
      else:
4361 
        iprot.skip(ftype)
4362 
      iprot.readFieldEnd()
4363 
    iprot.readStructEnd()
4364 
 
4365 
  def write(self, oprot):
4366 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4367 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4368 
      return
559 chandransh 4369 
    oprot.writeStructBegin('deleteUser_args')
94 ashish 4370 
    if self.userId != None:
4371 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4372 
      oprot.writeI64(self.userId)
4373 
      oprot.writeFieldEnd()
4374 
    oprot.writeFieldStop()
4375 
    oprot.writeStructEnd()
4376 
 
4377 
  def __repr__(self):
4378 
    L = ['%s=%r' % (key, value)
4379 
      for key, value in self.__dict__.iteritems()]
4380 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4381 
 
4382 
  def __eq__(self, other):
4383 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4384 
 
4385 
  def __ne__(self, other):
4386 
    return not (self == other)
4387 
 
559 chandransh 4388 
class deleteUser_result:
94 ashish 4389 
  """
4390 
  Attributes:
4391 
   - success
559 chandransh 4392 
   - ucex
94 ashish 4393 
  """
4394 
 
4395 
  thrift_spec = (
559 chandransh 4396 
    (0, TType.BOOL, 'success', None, None, ), # 0
4397 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4398 
  )
4399 
 
559 chandransh 4400 
  def __init__(self, success=None, ucex=None,):
94 ashish 4401 
    self.success = success
559 chandransh 4402 
    self.ucex = ucex
94 ashish 4403 
 
4404 
  def read(self, iprot):
4405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4407 
      return
4408 
    iprot.readStructBegin()
4409 
    while True:
4410 
      (fname, ftype, fid) = iprot.readFieldBegin()
4411 
      if ftype == TType.STOP:
4412 
        break
4413 
      if fid == 0:
559 chandransh 4414 
        if ftype == TType.BOOL:
4415 
          self.success = iprot.readBool();
94 ashish 4416 
        else:
4417 
          iprot.skip(ftype)
4418 
      elif fid == 1:
4419 
        if ftype == TType.STRUCT:
559 chandransh 4420 
          self.ucex = UserContextException()
4421 
          self.ucex.read(iprot)
94 ashish 4422 
        else:
4423 
          iprot.skip(ftype)
4424 
      else:
4425 
        iprot.skip(ftype)
4426 
      iprot.readFieldEnd()
4427 
    iprot.readStructEnd()
4428 
 
4429 
  def write(self, oprot):
4430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4432 
      return
559 chandransh 4433 
    oprot.writeStructBegin('deleteUser_result')
94 ashish 4434 
    if self.success != None:
559 chandransh 4435 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4436 
      oprot.writeBool(self.success)
94 ashish 4437 
      oprot.writeFieldEnd()
559 chandransh 4438 
    if self.ucex != None:
4439 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4440 
      self.ucex.write(oprot)
94 ashish 4441 
      oprot.writeFieldEnd()
4442 
    oprot.writeFieldStop()
4443 
    oprot.writeStructEnd()
4444 
 
4445 
  def __repr__(self):
4446 
    L = ['%s=%r' % (key, value)
4447 
      for key, value in self.__dict__.iteritems()]
4448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4449 
 
4450 
  def __eq__(self, other):
4451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4452 
 
4453 
  def __ne__(self, other):
4454 
    return not (self == other)
4455 
 
559 chandransh 4456 
class getUserState_args:
94 ashish 4457 
  """
4458 
  Attributes:
4459 
   - userId
4460 
  """
4461 
 
4462 
  thrift_spec = (
4463 
    None, # 0
4464 
    (1, TType.I64, 'userId', None, None, ), # 1
4465 
  )
4466 
 
559 chandransh 4467 
  def __init__(self, userId=None,):
94 ashish 4468 
    self.userId = userId
4469 
 
4470 
  def read(self, iprot):
4471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4473 
      return
4474 
    iprot.readStructBegin()
4475 
    while True:
4476 
      (fname, ftype, fid) = iprot.readFieldBegin()
4477 
      if ftype == TType.STOP:
4478 
        break
4479 
      if fid == 1:
4480 
        if ftype == TType.I64:
4481 
          self.userId = iprot.readI64();
4482 
        else:
4483 
          iprot.skip(ftype)
4484 
      else:
4485 
        iprot.skip(ftype)
4486 
      iprot.readFieldEnd()
4487 
    iprot.readStructEnd()
4488 
 
4489 
  def write(self, oprot):
4490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4492 
      return
559 chandransh 4493 
    oprot.writeStructBegin('getUserState_args')
94 ashish 4494 
    if self.userId != None:
4495 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4496 
      oprot.writeI64(self.userId)
4497 
      oprot.writeFieldEnd()
4498 
    oprot.writeFieldStop()
4499 
    oprot.writeStructEnd()
4500 
 
4501 
  def __repr__(self):
4502 
    L = ['%s=%r' % (key, value)
4503 
      for key, value in self.__dict__.iteritems()]
4504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4505 
 
4506 
  def __eq__(self, other):
4507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4508 
 
4509 
  def __ne__(self, other):
4510 
    return not (self == other)
4511 
 
559 chandransh 4512 
class getUserState_result:
94 ashish 4513 
  """
4514 
  Attributes:
4515 
   - success
559 chandransh 4516 
   - ucex
94 ashish 4517 
  """
4518 
 
4519 
  thrift_spec = (
559 chandransh 4520 
    (0, TType.STRUCT, 'success', (UserState, UserState.thrift_spec), None, ), # 0
4521 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4522 
  )
4523 
 
559 chandransh 4524 
  def __init__(self, success=None, ucex=None,):
94 ashish 4525 
    self.success = success
559 chandransh 4526 
    self.ucex = ucex
94 ashish 4527 
 
4528 
  def read(self, iprot):
4529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4531 
      return
4532 
    iprot.readStructBegin()
4533 
    while True:
4534 
      (fname, ftype, fid) = iprot.readFieldBegin()
4535 
      if ftype == TType.STOP:
4536 
        break
4537 
      if fid == 0:
4538 
        if ftype == TType.STRUCT:
559 chandransh 4539 
          self.success = UserState()
94 ashish 4540 
          self.success.read(iprot)
4541 
        else:
4542 
          iprot.skip(ftype)
4543 
      elif fid == 1:
4544 
        if ftype == TType.STRUCT:
559 chandransh 4545 
          self.ucex = UserContextException()
4546 
          self.ucex.read(iprot)
94 ashish 4547 
        else:
4548 
          iprot.skip(ftype)
4549 
      else:
4550 
        iprot.skip(ftype)
4551 
      iprot.readFieldEnd()
4552 
    iprot.readStructEnd()
4553 
 
4554 
  def write(self, oprot):
4555 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4556 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4557 
      return
559 chandransh 4558 
    oprot.writeStructBegin('getUserState_result')
94 ashish 4559 
    if self.success != None:
4560 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4561 
      self.success.write(oprot)
4562 
      oprot.writeFieldEnd()
559 chandransh 4563 
    if self.ucex != None:
4564 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4565 
      self.ucex.write(oprot)
94 ashish 4566 
      oprot.writeFieldEnd()
4567 
    oprot.writeFieldStop()
4568 
    oprot.writeStructEnd()
4569 
 
4570 
  def __repr__(self):
4571 
    L = ['%s=%r' % (key, value)
4572 
      for key, value in self.__dict__.iteritems()]
4573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4574 
 
4575 
  def __eq__(self, other):
4576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4577 
 
4578 
  def __ne__(self, other):
4579 
    return not (self == other)
4580 
 
559 chandransh 4581 
class authenticateUser_args:
94 ashish 4582 
  """
4583 
  Attributes:
4584 
   - email
4585 
   - password
4586 
  """
4587 
 
4588 
  thrift_spec = (
4589 
    None, # 0
4590 
    (1, TType.STRING, 'email', None, None, ), # 1
4591 
    (2, TType.STRING, 'password', None, None, ), # 2
4592 
  )
4593 
 
4594 
  def __init__(self, email=None, password=None,):
4595 
    self.email = email
4596 
    self.password = password
4597 
 
4598 
  def read(self, iprot):
4599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4601 
      return
4602 
    iprot.readStructBegin()
4603 
    while True:
4604 
      (fname, ftype, fid) = iprot.readFieldBegin()
4605 
      if ftype == TType.STOP:
4606 
        break
4607 
      if fid == 1:
4608 
        if ftype == TType.STRING:
4609 
          self.email = iprot.readString();
4610 
        else:
4611 
          iprot.skip(ftype)
4612 
      elif fid == 2:
4613 
        if ftype == TType.STRING:
4614 
          self.password = iprot.readString();
4615 
        else:
4616 
          iprot.skip(ftype)
4617 
      else:
4618 
        iprot.skip(ftype)
4619 
      iprot.readFieldEnd()
4620 
    iprot.readStructEnd()
4621 
 
4622 
  def write(self, oprot):
4623 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4624 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4625 
      return
559 chandransh 4626 
    oprot.writeStructBegin('authenticateUser_args')
94 ashish 4627 
    if self.email != None:
4628 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4629 
      oprot.writeString(self.email)
4630 
      oprot.writeFieldEnd()
4631 
    if self.password != None:
4632 
      oprot.writeFieldBegin('password', TType.STRING, 2)
4633 
      oprot.writeString(self.password)
4634 
      oprot.writeFieldEnd()
4635 
    oprot.writeFieldStop()
4636 
    oprot.writeStructEnd()
4637 
 
4638 
  def __repr__(self):
4639 
    L = ['%s=%r' % (key, value)
4640 
      for key, value in self.__dict__.iteritems()]
4641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4642 
 
4643 
  def __eq__(self, other):
4644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4645 
 
4646 
  def __ne__(self, other):
4647 
    return not (self == other)
4648 
 
559 chandransh 4649 
class authenticateUser_result:
94 ashish 4650 
  """
4651 
  Attributes:
4652 
   - success
559 chandransh 4653 
   - auex
94 ashish 4654 
  """
4655 
 
4656 
  thrift_spec = (
559 chandransh 4657 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4658 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 4659 
  )
4660 
 
559 chandransh 4661 
  def __init__(self, success=None, auex=None,):
94 ashish 4662 
    self.success = success
559 chandransh 4663 
    self.auex = auex
94 ashish 4664 
 
4665 
  def read(self, iprot):
4666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4668 
      return
4669 
    iprot.readStructBegin()
4670 
    while True:
4671 
      (fname, ftype, fid) = iprot.readFieldBegin()
4672 
      if ftype == TType.STOP:
4673 
        break
4674 
      if fid == 0:
4675 
        if ftype == TType.STRUCT:
559 chandransh 4676 
          self.success = User()
94 ashish 4677 
          self.success.read(iprot)
4678 
        else:
4679 
          iprot.skip(ftype)
4680 
      elif fid == 1:
4681 
        if ftype == TType.STRUCT:
559 chandransh 4682 
          self.auex = AuthenticationException()
4683 
          self.auex.read(iprot)
94 ashish 4684 
        else:
4685 
          iprot.skip(ftype)
4686 
      else:
4687 
        iprot.skip(ftype)
4688 
      iprot.readFieldEnd()
4689 
    iprot.readStructEnd()
4690 
 
4691 
  def write(self, oprot):
4692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4694 
      return
559 chandransh 4695 
    oprot.writeStructBegin('authenticateUser_result')
94 ashish 4696 
    if self.success != None:
4697 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4698 
      self.success.write(oprot)
4699 
      oprot.writeFieldEnd()
559 chandransh 4700 
    if self.auex != None:
4701 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
4702 
      self.auex.write(oprot)
94 ashish 4703 
      oprot.writeFieldEnd()
4704 
    oprot.writeFieldStop()
4705 
    oprot.writeStructEnd()
4706 
 
4707 
  def __repr__(self):
4708 
    L = ['%s=%r' % (key, value)
4709 
      for key, value in self.__dict__.iteritems()]
4710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4711 
 
4712 
  def __eq__(self, other):
4713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4714 
 
4715 
  def __ne__(self, other):
4716 
    return not (self == other)
4717 
 
559 chandransh 4718 
class userExists_args:
122 ashish 4719 
  """
4720 
  Attributes:
559 chandransh 4721 
   - email
122 ashish 4722 
  """
4723 
 
4724 
  thrift_spec = (
4725 
    None, # 0
559 chandransh 4726 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 4727 
  )
4728 
 
559 chandransh 4729 
  def __init__(self, email=None,):
4730 
    self.email = email
122 ashish 4731 
 
4732 
  def read(self, iprot):
4733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4735 
      return
4736 
    iprot.readStructBegin()
4737 
    while True:
4738 
      (fname, ftype, fid) = iprot.readFieldBegin()
4739 
      if ftype == TType.STOP:
4740 
        break
4741 
      if fid == 1:
4742 
        if ftype == TType.STRING:
559 chandransh 4743 
          self.email = iprot.readString();
122 ashish 4744 
        else:
4745 
          iprot.skip(ftype)
559 chandransh 4746 
      else:
4747 
        iprot.skip(ftype)
4748 
      iprot.readFieldEnd()
4749 
    iprot.readStructEnd()
4750 
 
4751 
  def write(self, oprot):
4752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4754 
      return
4755 
    oprot.writeStructBegin('userExists_args')
4756 
    if self.email != None:
4757 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4758 
      oprot.writeString(self.email)
4759 
      oprot.writeFieldEnd()
4760 
    oprot.writeFieldStop()
4761 
    oprot.writeStructEnd()
4762 
 
4763 
  def __repr__(self):
4764 
    L = ['%s=%r' % (key, value)
4765 
      for key, value in self.__dict__.iteritems()]
4766 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4767 
 
4768 
  def __eq__(self, other):
4769 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4770 
 
4771 
  def __ne__(self, other):
4772 
    return not (self == other)
4773 
 
4774 
class userExists_result:
4775 
  """
4776 
  Attributes:
4777 
   - success
4778 
   - ucx
4779 
  """
4780 
 
4781 
  thrift_spec = (
4782 
    (0, TType.BOOL, 'success', None, None, ), # 0
4783 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4784 
  )
4785 
 
4786 
  def __init__(self, success=None, ucx=None,):
4787 
    self.success = success
4788 
    self.ucx = ucx
4789 
 
4790 
  def read(self, iprot):
4791 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4792 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4793 
      return
4794 
    iprot.readStructBegin()
4795 
    while True:
4796 
      (fname, ftype, fid) = iprot.readFieldBegin()
4797 
      if ftype == TType.STOP:
4798 
        break
4799 
      if fid == 0:
4800 
        if ftype == TType.BOOL:
4801 
          self.success = iprot.readBool();
4802 
        else:
4803 
          iprot.skip(ftype)
4804 
      elif fid == 1:
4805 
        if ftype == TType.STRUCT:
4806 
          self.ucx = UserContextException()
4807 
          self.ucx.read(iprot)
4808 
        else:
4809 
          iprot.skip(ftype)
4810 
      else:
4811 
        iprot.skip(ftype)
4812 
      iprot.readFieldEnd()
4813 
    iprot.readStructEnd()
4814 
 
4815 
  def write(self, oprot):
4816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4818 
      return
4819 
    oprot.writeStructBegin('userExists_result')
4820 
    if self.success != None:
4821 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4822 
      oprot.writeBool(self.success)
4823 
      oprot.writeFieldEnd()
4824 
    if self.ucx != None:
4825 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4826 
      self.ucx.write(oprot)
4827 
      oprot.writeFieldEnd()
4828 
    oprot.writeFieldStop()
4829 
    oprot.writeStructEnd()
4830 
 
4831 
  def __repr__(self):
4832 
    L = ['%s=%r' % (key, value)
4833 
      for key, value in self.__dict__.iteritems()]
4834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4835 
 
4836 
  def __eq__(self, other):
4837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4838 
 
4839 
  def __ne__(self, other):
4840 
    return not (self == other)
4841 
 
4842 
class addAddressForUser_args:
4843 
  """
4844 
  Attributes:
4845 
   - userId
4846 
   - address
4847 
   - setDefault
4848 
  """
4849 
 
4850 
  thrift_spec = (
4851 
    None, # 0
4852 
    (1, TType.I64, 'userId', None, None, ), # 1
4853 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 4854 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 4855 
  )
4856 
 
567 rajveer 4857 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 4858 
    self.userId = userId
4859 
    self.address = address
4860 
    self.setDefault = setDefault
4861 
 
4862 
  def read(self, iprot):
4863 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4864 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4865 
      return
4866 
    iprot.readStructBegin()
4867 
    while True:
4868 
      (fname, ftype, fid) = iprot.readFieldBegin()
4869 
      if ftype == TType.STOP:
4870 
        break
4871 
      if fid == 1:
4872 
        if ftype == TType.I64:
4873 
          self.userId = iprot.readI64();
4874 
        else:
4875 
          iprot.skip(ftype)
122 ashish 4876 
      elif fid == 2:
559 chandransh 4877 
        if ftype == TType.STRUCT:
4878 
          self.address = Address()
4879 
          self.address.read(iprot)
122 ashish 4880 
        else:
4881 
          iprot.skip(ftype)
4882 
      elif fid == 3:
4883 
        if ftype == TType.BOOL:
559 chandransh 4884 
          self.setDefault = iprot.readBool();
122 ashish 4885 
        else:
4886 
          iprot.skip(ftype)
4887 
      else:
4888 
        iprot.skip(ftype)
4889 
      iprot.readFieldEnd()
4890 
    iprot.readStructEnd()
4891 
 
4892 
  def write(self, oprot):
4893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4895 
      return
559 chandransh 4896 
    oprot.writeStructBegin('addAddressForUser_args')
4897 
    if self.userId != None:
4898 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4899 
      oprot.writeI64(self.userId)
122 ashish 4900 
      oprot.writeFieldEnd()
559 chandransh 4901 
    if self.address != None:
4902 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
4903 
      self.address.write(oprot)
122 ashish 4904 
      oprot.writeFieldEnd()
559 chandransh 4905 
    if self.setDefault != None:
567 rajveer 4906 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 4907 
      oprot.writeBool(self.setDefault)
4908 
      oprot.writeFieldEnd()
122 ashish 4909 
    oprot.writeFieldStop()
4910 
    oprot.writeStructEnd()
4911 
 
4912 
  def __repr__(self):
4913 
    L = ['%s=%r' % (key, value)
4914 
      for key, value in self.__dict__.iteritems()]
4915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4916 
 
4917 
  def __eq__(self, other):
4918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4919 
 
4920 
  def __ne__(self, other):
4921 
    return not (self == other)
4922 
 
559 chandransh 4923 
class addAddressForUser_result:
122 ashish 4924 
  """
4925 
  Attributes:
4926 
   - success
559 chandransh 4927 
   - ucx
122 ashish 4928 
  """
4929 
 
4930 
  thrift_spec = (
567 rajveer 4931 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 4932 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 4933 
  )
4934 
 
559 chandransh 4935 
  def __init__(self, success=None, ucx=None,):
122 ashish 4936 
    self.success = success
559 chandransh 4937 
    self.ucx = ucx
122 ashish 4938 
 
4939 
  def read(self, iprot):
4940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4942 
      return
4943 
    iprot.readStructBegin()
4944 
    while True:
4945 
      (fname, ftype, fid) = iprot.readFieldBegin()
4946 
      if ftype == TType.STOP:
4947 
        break
4948 
      if fid == 0:
567 rajveer 4949 
        if ftype == TType.I64:
4950 
          self.success = iprot.readI64();
122 ashish 4951 
        else:
4952 
          iprot.skip(ftype)
4953 
      elif fid == 1:
4954 
        if ftype == TType.STRUCT:
559 chandransh 4955 
          self.ucx = UserContextException()
4956 
          self.ucx.read(iprot)
122 ashish 4957 
        else:
4958 
          iprot.skip(ftype)
4959 
      else:
4960 
        iprot.skip(ftype)
4961 
      iprot.readFieldEnd()
4962 
    iprot.readStructEnd()
4963 
 
4964 
  def write(self, oprot):
4965 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4966 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4967 
      return
559 chandransh 4968 
    oprot.writeStructBegin('addAddressForUser_result')
122 ashish 4969 
    if self.success != None:
567 rajveer 4970 
      oprot.writeFieldBegin('success', TType.I64, 0)
4971 
      oprot.writeI64(self.success)
122 ashish 4972 
      oprot.writeFieldEnd()
559 chandransh 4973 
    if self.ucx != None:
4974 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4975 
      self.ucx.write(oprot)
122 ashish 4976 
      oprot.writeFieldEnd()
4977 
    oprot.writeFieldStop()
4978 
    oprot.writeStructEnd()
4979 
 
4980 
  def __repr__(self):
4981 
    L = ['%s=%r' % (key, value)
4982 
      for key, value in self.__dict__.iteritems()]
4983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4984 
 
4985 
  def __eq__(self, other):
4986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4987 
 
4988 
  def __ne__(self, other):
4989 
    return not (self == other)
4990 
 
559 chandransh 4991 
class removeAddressForUser_args:
94 ashish 4992 
  """
4993 
  Attributes:
559 chandransh 4994 
   - userid
4995 
   - addressId
94 ashish 4996 
  """
4997 
 
4998 
  thrift_spec = (
4999 
    None, # 0
559 chandransh 5000 
    (1, TType.I64, 'userid', None, None, ), # 1
5001 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 5002 
  )
5003 
 
559 chandransh 5004 
  def __init__(self, userid=None, addressId=None,):
5005 
    self.userid = userid
5006 
    self.addressId = addressId
94 ashish 5007 
 
5008 
  def read(self, iprot):
5009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5011 
      return
5012 
    iprot.readStructBegin()
5013 
    while True:
5014 
      (fname, ftype, fid) = iprot.readFieldBegin()
5015 
      if ftype == TType.STOP:
5016 
        break
5017 
      if fid == 1:
559 chandransh 5018 
        if ftype == TType.I64:
5019 
          self.userid = iprot.readI64();
94 ashish 5020 
        else:
5021 
          iprot.skip(ftype)
559 chandransh 5022 
      elif fid == 2:
5023 
        if ftype == TType.I64:
5024 
          self.addressId = iprot.readI64();
5025 
        else:
5026 
          iprot.skip(ftype)
94 ashish 5027 
      else:
5028 
        iprot.skip(ftype)
5029 
      iprot.readFieldEnd()
5030 
    iprot.readStructEnd()
5031 
 
5032 
  def write(self, oprot):
5033 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5034 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5035 
      return
559 chandransh 5036 
    oprot.writeStructBegin('removeAddressForUser_args')
5037 
    if self.userid != None:
5038 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5039 
      oprot.writeI64(self.userid)
94 ashish 5040 
      oprot.writeFieldEnd()
559 chandransh 5041 
    if self.addressId != None:
5042 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5043 
      oprot.writeI64(self.addressId)
5044 
      oprot.writeFieldEnd()
94 ashish 5045 
    oprot.writeFieldStop()
5046 
    oprot.writeStructEnd()
5047 
 
5048 
  def __repr__(self):
5049 
    L = ['%s=%r' % (key, value)
5050 
      for key, value in self.__dict__.iteritems()]
5051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5052 
 
5053 
  def __eq__(self, other):
5054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5055 
 
5056 
  def __ne__(self, other):
5057 
    return not (self == other)
5058 
 
559 chandransh 5059 
class removeAddressForUser_result:
94 ashish 5060 
  """
5061 
  Attributes:
5062 
   - success
5063 
   - ucx
5064 
  """
5065 
 
5066 
  thrift_spec = (
5067 
    (0, TType.BOOL, 'success', None, None, ), # 0
5068 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5069 
  )
5070 
 
5071 
  def __init__(self, success=None, ucx=None,):
5072 
    self.success = success
5073 
    self.ucx = ucx
5074 
 
5075 
  def read(self, iprot):
5076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5078 
      return
5079 
    iprot.readStructBegin()
5080 
    while True:
5081 
      (fname, ftype, fid) = iprot.readFieldBegin()
5082 
      if ftype == TType.STOP:
5083 
        break
5084 
      if fid == 0:
5085 
        if ftype == TType.BOOL:
5086 
          self.success = iprot.readBool();
5087 
        else:
5088 
          iprot.skip(ftype)
5089 
      elif fid == 1:
5090 
        if ftype == TType.STRUCT:
5091 
          self.ucx = UserContextException()
5092 
          self.ucx.read(iprot)
5093 
        else:
5094 
          iprot.skip(ftype)
5095 
      else:
5096 
        iprot.skip(ftype)
5097 
      iprot.readFieldEnd()
5098 
    iprot.readStructEnd()
5099 
 
5100 
  def write(self, oprot):
5101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5103 
      return
559 chandransh 5104 
    oprot.writeStructBegin('removeAddressForUser_result')
94 ashish 5105 
    if self.success != None:
5106 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5107 
      oprot.writeBool(self.success)
5108 
      oprot.writeFieldEnd()
5109 
    if self.ucx != None:
5110 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5111 
      self.ucx.write(oprot)
5112 
      oprot.writeFieldEnd()
5113 
    oprot.writeFieldStop()
5114 
    oprot.writeStructEnd()
5115 
 
5116 
  def __repr__(self):
5117 
    L = ['%s=%r' % (key, value)
5118 
      for key, value in self.__dict__.iteritems()]
5119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5120 
 
5121 
  def __eq__(self, other):
5122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5123 
 
5124 
  def __ne__(self, other):
5125 
    return not (self == other)
5126 
 
559 chandransh 5127 
class setUserAsLoggedIn_args:
94 ashish 5128 
  """
5129 
  Attributes:
559 chandransh 5130 
   - userId
94 ashish 5131 
   - timestamp
5132 
  """
5133 
 
5134 
  thrift_spec = (
5135 
    None, # 0
559 chandransh 5136 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 5137 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5138 
  )
5139 
 
559 chandransh 5140 
  def __init__(self, userId=None, timestamp=None,):
5141 
    self.userId = userId
94 ashish 5142 
    self.timestamp = timestamp
5143 
 
5144 
  def read(self, iprot):
5145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5147 
      return
5148 
    iprot.readStructBegin()
5149 
    while True:
5150 
      (fname, ftype, fid) = iprot.readFieldBegin()
5151 
      if ftype == TType.STOP:
5152 
        break
5153 
      if fid == 1:
559 chandransh 5154 
        if ftype == TType.I64:
5155 
          self.userId = iprot.readI64();
94 ashish 5156 
        else:
5157 
          iprot.skip(ftype)
5158 
      elif fid == 2:
5159 
        if ftype == TType.I64:
5160 
          self.timestamp = iprot.readI64();
5161 
        else:
5162 
          iprot.skip(ftype)
5163 
      else:
5164 
        iprot.skip(ftype)
5165 
      iprot.readFieldEnd()
5166 
    iprot.readStructEnd()
5167 
 
5168 
  def write(self, oprot):
5169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5171 
      return
559 chandransh 5172 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
5173 
    if self.userId != None:
5174 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5175 
      oprot.writeI64(self.userId)
94 ashish 5176 
      oprot.writeFieldEnd()
5177 
    if self.timestamp != None:
5178 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5179 
      oprot.writeI64(self.timestamp)
5180 
      oprot.writeFieldEnd()
5181 
    oprot.writeFieldStop()
5182 
    oprot.writeStructEnd()
5183 
 
5184 
  def __repr__(self):
5185 
    L = ['%s=%r' % (key, value)
5186 
      for key, value in self.__dict__.iteritems()]
5187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5188 
 
5189 
  def __eq__(self, other):
5190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5191 
 
5192 
  def __ne__(self, other):
5193 
    return not (self == other)
5194 
 
559 chandransh 5195 
class setUserAsLoggedIn_result:
94 ashish 5196 
  """
5197 
  Attributes:
5198 
   - success
5199 
   - ucx
5200 
  """
5201 
 
5202 
  thrift_spec = (
5203 
    (0, TType.BOOL, 'success', None, None, ), # 0
5204 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5205 
  )
5206 
 
5207 
  def __init__(self, success=None, ucx=None,):
5208 
    self.success = success
5209 
    self.ucx = ucx
5210 
 
5211 
  def read(self, iprot):
5212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5214 
      return
5215 
    iprot.readStructBegin()
5216 
    while True:
5217 
      (fname, ftype, fid) = iprot.readFieldBegin()
5218 
      if ftype == TType.STOP:
5219 
        break
5220 
      if fid == 0:
5221 
        if ftype == TType.BOOL:
5222 
          self.success = iprot.readBool();
5223 
        else:
5224 
          iprot.skip(ftype)
5225 
      elif fid == 1:
5226 
        if ftype == TType.STRUCT:
5227 
          self.ucx = UserContextException()
5228 
          self.ucx.read(iprot)
5229 
        else:
5230 
          iprot.skip(ftype)
5231 
      else:
5232 
        iprot.skip(ftype)
5233 
      iprot.readFieldEnd()
5234 
    iprot.readStructEnd()
5235 
 
5236 
  def write(self, oprot):
5237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5239 
      return
559 chandransh 5240 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
94 ashish 5241 
    if self.success != None:
5242 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5243 
      oprot.writeBool(self.success)
5244 
      oprot.writeFieldEnd()
5245 
    if self.ucx != None:
5246 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5247 
      self.ucx.write(oprot)
5248 
      oprot.writeFieldEnd()
5249 
    oprot.writeFieldStop()
5250 
    oprot.writeStructEnd()
5251 
 
5252 
  def __repr__(self):
5253 
    L = ['%s=%r' % (key, value)
5254 
      for key, value in self.__dict__.iteritems()]
5255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5256 
 
5257 
  def __eq__(self, other):
5258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5259 
 
5260 
  def __ne__(self, other):
5261 
    return not (self == other)
5262 
 
559 chandransh 5263 
class setUserAsLoggedOut_args:
94 ashish 5264 
  """
5265 
  Attributes:
5266 
   - userid
5267 
   - timestamp
5268 
  """
5269 
 
5270 
  thrift_spec = (
5271 
    None, # 0
559 chandransh 5272 
    (1, TType.I64, 'userid', None, None, ), # 1
5273 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 5274 
  )
5275 
 
559 chandransh 5276 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 5277 
    self.userid = userid
5278 
    self.timestamp = timestamp
5279 
 
5280 
  def read(self, iprot):
5281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5283 
      return
5284 
    iprot.readStructBegin()
5285 
    while True:
5286 
      (fname, ftype, fid) = iprot.readFieldBegin()
5287 
      if ftype == TType.STOP:
5288 
        break
5289 
      if fid == 1:
5290 
        if ftype == TType.I64:
5291 
          self.userid = iprot.readI64();
5292 
        else:
5293 
          iprot.skip(ftype)
559 chandransh 5294 
      elif fid == 2:
94 ashish 5295 
        if ftype == TType.I64:
5296 
          self.timestamp = iprot.readI64();
5297 
        else:
5298 
          iprot.skip(ftype)
5299 
      else:
5300 
        iprot.skip(ftype)
5301 
      iprot.readFieldEnd()
5302 
    iprot.readStructEnd()
5303 
 
5304 
  def write(self, oprot):
5305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5307 
      return
559 chandransh 5308 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
94 ashish 5309 
    if self.userid != None:
559 chandransh 5310 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 5311 
      oprot.writeI64(self.userid)
5312 
      oprot.writeFieldEnd()
5313 
    if self.timestamp != None:
559 chandransh 5314 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 5315 
      oprot.writeI64(self.timestamp)
5316 
      oprot.writeFieldEnd()
5317 
    oprot.writeFieldStop()
5318 
    oprot.writeStructEnd()
5319 
 
5320 
  def __repr__(self):
5321 
    L = ['%s=%r' % (key, value)
5322 
      for key, value in self.__dict__.iteritems()]
5323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5324 
 
5325 
  def __eq__(self, other):
5326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5327 
 
5328 
  def __ne__(self, other):
5329 
    return not (self == other)
5330 
 
559 chandransh 5331 
class setUserAsLoggedOut_result:
94 ashish 5332 
  """
5333 
  Attributes:
5334 
   - success
5335 
   - ucx
5336 
  """
5337 
 
5338 
  thrift_spec = (
5339 
    (0, TType.BOOL, 'success', None, None, ), # 0
5340 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5341 
  )
5342 
 
5343 
  def __init__(self, success=None, ucx=None,):
5344 
    self.success = success
5345 
    self.ucx = ucx
5346 
 
5347 
  def read(self, iprot):
5348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5350 
      return
5351 
    iprot.readStructBegin()
5352 
    while True:
5353 
      (fname, ftype, fid) = iprot.readFieldBegin()
5354 
      if ftype == TType.STOP:
5355 
        break
5356 
      if fid == 0:
5357 
        if ftype == TType.BOOL:
5358 
          self.success = iprot.readBool();
5359 
        else:
5360 
          iprot.skip(ftype)
5361 
      elif fid == 1:
5362 
        if ftype == TType.STRUCT:
5363 
          self.ucx = UserContextException()
5364 
          self.ucx.read(iprot)
5365 
        else:
5366 
          iprot.skip(ftype)
5367 
      else:
5368 
        iprot.skip(ftype)
5369 
      iprot.readFieldEnd()
5370 
    iprot.readStructEnd()
5371 
 
5372 
  def write(self, oprot):
5373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5375 
      return
559 chandransh 5376 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
94 ashish 5377 
    if self.success != None:
5378 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5379 
      oprot.writeBool(self.success)
5380 
      oprot.writeFieldEnd()
5381 
    if self.ucx != None:
5382 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5383 
      self.ucx.write(oprot)
5384 
      oprot.writeFieldEnd()
5385 
    oprot.writeFieldStop()
5386 
    oprot.writeStructEnd()
5387 
 
5388 
  def __repr__(self):
5389 
    L = ['%s=%r' % (key, value)
5390 
      for key, value in self.__dict__.iteritems()]
5391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5392 
 
5393 
  def __eq__(self, other):
5394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5395 
 
5396 
  def __ne__(self, other):
5397 
    return not (self == other)
5398 
 
559 chandransh 5399 
class setDefaultAddress_args:
94 ashish 5400 
  """
5401 
  Attributes:
5402 
   - userid
5403 
   - addressId
5404 
  """
5405 
 
5406 
  thrift_spec = (
5407 
    None, # 0
5408 
    (1, TType.I64, 'userid', None, None, ), # 1
5409 
    (2, TType.I64, 'addressId', None, None, ), # 2
5410 
  )
5411 
 
5412 
  def __init__(self, userid=None, addressId=None,):
5413 
    self.userid = userid
5414 
    self.addressId = addressId
5415 
 
5416 
  def read(self, iprot):
5417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5419 
      return
5420 
    iprot.readStructBegin()
5421 
    while True:
5422 
      (fname, ftype, fid) = iprot.readFieldBegin()
5423 
      if ftype == TType.STOP:
5424 
        break
5425 
      if fid == 1:
5426 
        if ftype == TType.I64:
5427 
          self.userid = iprot.readI64();
5428 
        else:
5429 
          iprot.skip(ftype)
5430 
      elif fid == 2:
5431 
        if ftype == TType.I64:
5432 
          self.addressId = iprot.readI64();
5433 
        else:
5434 
          iprot.skip(ftype)
5435 
      else:
5436 
        iprot.skip(ftype)
5437 
      iprot.readFieldEnd()
5438 
    iprot.readStructEnd()
5439 
 
5440 
  def write(self, oprot):
5441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5443 
      return
559 chandransh 5444 
    oprot.writeStructBegin('setDefaultAddress_args')
94 ashish 5445 
    if self.userid != None:
5446 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5447 
      oprot.writeI64(self.userid)
5448 
      oprot.writeFieldEnd()
5449 
    if self.addressId != None:
5450 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5451 
      oprot.writeI64(self.addressId)
5452 
      oprot.writeFieldEnd()
5453 
    oprot.writeFieldStop()
5454 
    oprot.writeStructEnd()
5455 
 
5456 
  def __repr__(self):
5457 
    L = ['%s=%r' % (key, value)
5458 
      for key, value in self.__dict__.iteritems()]
5459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5460 
 
5461 
  def __eq__(self, other):
5462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5463 
 
5464 
  def __ne__(self, other):
5465 
    return not (self == other)
5466 
 
559 chandransh 5467 
class setDefaultAddress_result:
94 ashish 5468 
  """
5469 
  Attributes:
5470 
   - success
5471 
   - ucx
5472 
  """
5473 
 
5474 
  thrift_spec = (
5475 
    (0, TType.BOOL, 'success', None, None, ), # 0
5476 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5477 
  )
5478 
 
5479 
  def __init__(self, success=None, ucx=None,):
5480 
    self.success = success
5481 
    self.ucx = ucx
5482 
 
5483 
  def read(self, iprot):
5484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5486 
      return
5487 
    iprot.readStructBegin()
5488 
    while True:
5489 
      (fname, ftype, fid) = iprot.readFieldBegin()
5490 
      if ftype == TType.STOP:
5491 
        break
5492 
      if fid == 0:
5493 
        if ftype == TType.BOOL:
5494 
          self.success = iprot.readBool();
5495 
        else:
5496 
          iprot.skip(ftype)
5497 
      elif fid == 1:
5498 
        if ftype == TType.STRUCT:
5499 
          self.ucx = UserContextException()
5500 
          self.ucx.read(iprot)
5501 
        else:
5502 
          iprot.skip(ftype)
5503 
      else:
5504 
        iprot.skip(ftype)
5505 
      iprot.readFieldEnd()
5506 
    iprot.readStructEnd()
5507 
 
5508 
  def write(self, oprot):
5509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5511 
      return
559 chandransh 5512 
    oprot.writeStructBegin('setDefaultAddress_result')
94 ashish 5513 
    if self.success != None:
5514 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5515 
      oprot.writeBool(self.success)
5516 
      oprot.writeFieldEnd()
5517 
    if self.ucx != None:
5518 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5519 
      self.ucx.write(oprot)
5520 
      oprot.writeFieldEnd()
5521 
    oprot.writeFieldStop()
5522 
    oprot.writeStructEnd()
5523 
 
5524 
  def __repr__(self):
5525 
    L = ['%s=%r' % (key, value)
5526 
      for key, value in self.__dict__.iteritems()]
5527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5528 
 
5529 
  def __eq__(self, other):
5530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5531 
 
5532 
  def __ne__(self, other):
5533 
    return not (self == other)
5534 
 
559 chandransh 5535 
class updatePassword_args:
94 ashish 5536 
  """
5537 
  Attributes:
559 chandransh 5538 
   - userid
594 rajveer 5539 
   - oldPassword
5540 
   - newPassword
94 ashish 5541 
  """
5542 
 
5543 
  thrift_spec = (
5544 
    None, # 0
559 chandransh 5545 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 5546 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
5547 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 5548 
  )
5549 
 
594 rajveer 5550 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 5551 
    self.userid = userid
594 rajveer 5552 
    self.oldPassword = oldPassword
5553 
    self.newPassword = newPassword
94 ashish 5554 
 
5555 
  def read(self, iprot):
5556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5558 
      return
5559 
    iprot.readStructBegin()
5560 
    while True:
5561 
      (fname, ftype, fid) = iprot.readFieldBegin()
5562 
      if ftype == TType.STOP:
5563 
        break
5564 
      if fid == 1:
5565 
        if ftype == TType.I64:
559 chandransh 5566 
          self.userid = iprot.readI64();
94 ashish 5567 
        else:
5568 
          iprot.skip(ftype)
5569 
      elif fid == 2:
559 chandransh 5570 
        if ftype == TType.STRING:
594 rajveer 5571 
          self.oldPassword = iprot.readString();
94 ashish 5572 
        else:
5573 
          iprot.skip(ftype)
594 rajveer 5574 
      elif fid == 3:
5575 
        if ftype == TType.STRING:
5576 
          self.newPassword = iprot.readString();
5577 
        else:
5578 
          iprot.skip(ftype)
94 ashish 5579 
      else:
5580 
        iprot.skip(ftype)
5581 
      iprot.readFieldEnd()
5582 
    iprot.readStructEnd()
5583 
 
5584 
  def write(self, oprot):
5585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5587 
      return
559 chandransh 5588 
    oprot.writeStructBegin('updatePassword_args')
5589 
    if self.userid != None:
5590 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5591 
      oprot.writeI64(self.userid)
94 ashish 5592 
      oprot.writeFieldEnd()
594 rajveer 5593 
    if self.oldPassword != None:
5594 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
5595 
      oprot.writeString(self.oldPassword)
94 ashish 5596 
      oprot.writeFieldEnd()
594 rajveer 5597 
    if self.newPassword != None:
5598 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
5599 
      oprot.writeString(self.newPassword)
5600 
      oprot.writeFieldEnd()
94 ashish 5601 
    oprot.writeFieldStop()
5602 
    oprot.writeStructEnd()
5603 
 
5604 
  def __repr__(self):
5605 
    L = ['%s=%r' % (key, value)
5606 
      for key, value in self.__dict__.iteritems()]
5607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5608 
 
5609 
  def __eq__(self, other):
5610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5611 
 
5612 
  def __ne__(self, other):
5613 
    return not (self == other)
5614 
 
559 chandransh 5615 
class updatePassword_result:
94 ashish 5616 
  """
5617 
  Attributes:
5618 
   - success
5619 
   - ucx
5620 
  """
5621 
 
5622 
  thrift_spec = (
5623 
    (0, TType.BOOL, 'success', None, None, ), # 0
5624 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5625 
  )
5626 
 
5627 
  def __init__(self, success=None, ucx=None,):
5628 
    self.success = success
5629 
    self.ucx = ucx
5630 
 
5631 
  def read(self, iprot):
5632 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5633 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5634 
      return
5635 
    iprot.readStructBegin()
5636 
    while True:
5637 
      (fname, ftype, fid) = iprot.readFieldBegin()
5638 
      if ftype == TType.STOP:
5639 
        break
5640 
      if fid == 0:
5641 
        if ftype == TType.BOOL:
5642 
          self.success = iprot.readBool();
5643 
        else:
5644 
          iprot.skip(ftype)
5645 
      elif fid == 1:
5646 
        if ftype == TType.STRUCT:
5647 
          self.ucx = UserContextException()
5648 
          self.ucx.read(iprot)
5649 
        else:
5650 
          iprot.skip(ftype)
5651 
      else:
5652 
        iprot.skip(ftype)
5653 
      iprot.readFieldEnd()
5654 
    iprot.readStructEnd()
5655 
 
5656 
  def write(self, oprot):
5657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5659 
      return
559 chandransh 5660 
    oprot.writeStructBegin('updatePassword_result')
94 ashish 5661 
    if self.success != None:
5662 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5663 
      oprot.writeBool(self.success)
5664 
      oprot.writeFieldEnd()
5665 
    if self.ucx != None:
5666 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5667 
      self.ucx.write(oprot)
5668 
      oprot.writeFieldEnd()
5669 
    oprot.writeFieldStop()
5670 
    oprot.writeStructEnd()
5671 
 
5672 
  def __repr__(self):
5673 
    L = ['%s=%r' % (key, value)
5674 
      for key, value in self.__dict__.iteritems()]
5675 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5676 
 
5677 
  def __eq__(self, other):
5678 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5679 
 
5680 
  def __ne__(self, other):
5681 
    return not (self == other)
5682 
 
581 rajveer 5683 
class forgotPassword_args:
5684 
  """
5685 
  Attributes:
5686 
   - email
884 rajveer 5687 
   - newPassword
581 rajveer 5688 
  """
5689 
 
5690 
  thrift_spec = (
5691 
    None, # 0
5692 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 5693 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 5694 
  )
5695 
 
884 rajveer 5696 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 5697 
    self.email = email
884 rajveer 5698 
    self.newPassword = newPassword
581 rajveer 5699 
 
5700 
  def read(self, iprot):
5701 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5702 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5703 
      return
5704 
    iprot.readStructBegin()
5705 
    while True:
5706 
      (fname, ftype, fid) = iprot.readFieldBegin()
5707 
      if ftype == TType.STOP:
5708 
        break
5709 
      if fid == 1:
5710 
        if ftype == TType.STRING:
5711 
          self.email = iprot.readString();
5712 
        else:
5713 
          iprot.skip(ftype)
884 rajveer 5714 
      elif fid == 2:
5715 
        if ftype == TType.STRING:
5716 
          self.newPassword = iprot.readString();
5717 
        else:
5718 
          iprot.skip(ftype)
581 rajveer 5719 
      else:
5720 
        iprot.skip(ftype)
5721 
      iprot.readFieldEnd()
5722 
    iprot.readStructEnd()
5723 
 
5724 
  def write(self, oprot):
5725 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5726 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5727 
      return
5728 
    oprot.writeStructBegin('forgotPassword_args')
5729 
    if self.email != None:
5730 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5731 
      oprot.writeString(self.email)
5732 
      oprot.writeFieldEnd()
884 rajveer 5733 
    if self.newPassword != None:
5734 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
5735 
      oprot.writeString(self.newPassword)
5736 
      oprot.writeFieldEnd()
581 rajveer 5737 
    oprot.writeFieldStop()
5738 
    oprot.writeStructEnd()
5739 
 
5740 
  def __repr__(self):
5741 
    L = ['%s=%r' % (key, value)
5742 
      for key, value in self.__dict__.iteritems()]
5743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5744 
 
5745 
  def __eq__(self, other):
5746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5747 
 
5748 
  def __ne__(self, other):
5749 
    return not (self == other)
5750 
 
5751 
class forgotPassword_result:
5752 
  """
5753 
  Attributes:
5754 
   - success
5755 
   - ucx
5756 
  """
5757 
 
5758 
  thrift_spec = (
5759 
    (0, TType.BOOL, 'success', None, None, ), # 0
5760 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5761 
  )
5762 
 
5763 
  def __init__(self, success=None, ucx=None,):
5764 
    self.success = success
5765 
    self.ucx = ucx
5766 
 
5767 
  def read(self, iprot):
5768 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5769 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5770 
      return
5771 
    iprot.readStructBegin()
5772 
    while True:
5773 
      (fname, ftype, fid) = iprot.readFieldBegin()
5774 
      if ftype == TType.STOP:
5775 
        break
5776 
      if fid == 0:
5777 
        if ftype == TType.BOOL:
5778 
          self.success = iprot.readBool();
5779 
        else:
5780 
          iprot.skip(ftype)
5781 
      elif fid == 1:
5782 
        if ftype == TType.STRUCT:
5783 
          self.ucx = UserContextException()
5784 
          self.ucx.read(iprot)
5785 
        else:
5786 
          iprot.skip(ftype)
5787 
      else:
5788 
        iprot.skip(ftype)
5789 
      iprot.readFieldEnd()
5790 
    iprot.readStructEnd()
5791 
 
5792 
  def write(self, oprot):
5793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5795 
      return
5796 
    oprot.writeStructBegin('forgotPassword_result')
5797 
    if self.success != None:
5798 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5799 
      oprot.writeBool(self.success)
5800 
      oprot.writeFieldEnd()
5801 
    if self.ucx != None:
5802 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5803 
      self.ucx.write(oprot)
5804 
      oprot.writeFieldEnd()
5805 
    oprot.writeFieldStop()
5806 
    oprot.writeStructEnd()
5807 
 
5808 
  def __repr__(self):
5809 
    L = ['%s=%r' % (key, value)
5810 
      for key, value in self.__dict__.iteritems()]
5811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5812 
 
5813 
  def __eq__(self, other):
5814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5815 
 
5816 
  def __ne__(self, other):
5817 
    return not (self == other)
5818 
 
594 rajveer 5819 
class getAllAddressesForUser_args:
5820 
  """
5821 
  Attributes:
5822 
   - userId
5823 
  """
5824 
 
5825 
  thrift_spec = (
5826 
    None, # 0
5827 
    (1, TType.I64, 'userId', None, None, ), # 1
5828 
  )
5829 
 
5830 
  def __init__(self, userId=None,):
5831 
    self.userId = userId
5832 
 
5833 
  def read(self, iprot):
5834 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5835 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5836 
      return
5837 
    iprot.readStructBegin()
5838 
    while True:
5839 
      (fname, ftype, fid) = iprot.readFieldBegin()
5840 
      if ftype == TType.STOP:
5841 
        break
5842 
      if fid == 1:
5843 
        if ftype == TType.I64:
5844 
          self.userId = iprot.readI64();
5845 
        else:
5846 
          iprot.skip(ftype)
5847 
      else:
5848 
        iprot.skip(ftype)
5849 
      iprot.readFieldEnd()
5850 
    iprot.readStructEnd()
5851 
 
5852 
  def write(self, oprot):
5853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5855 
      return
5856 
    oprot.writeStructBegin('getAllAddressesForUser_args')
5857 
    if self.userId != None:
5858 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5859 
      oprot.writeI64(self.userId)
5860 
      oprot.writeFieldEnd()
5861 
    oprot.writeFieldStop()
5862 
    oprot.writeStructEnd()
5863 
 
5864 
  def __repr__(self):
5865 
    L = ['%s=%r' % (key, value)
5866 
      for key, value in self.__dict__.iteritems()]
5867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5868 
 
5869 
  def __eq__(self, other):
5870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5871 
 
5872 
  def __ne__(self, other):
5873 
    return not (self == other)
5874 
 
5875 
class getAllAddressesForUser_result:
5876 
  """
5877 
  Attributes:
5878 
   - success
5879 
   - ucx
5880 
  """
5881 
 
5882 
  thrift_spec = (
5883 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
5884 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5885 
  )
5886 
 
5887 
  def __init__(self, success=None, ucx=None,):
5888 
    self.success = success
5889 
    self.ucx = ucx
5890 
 
5891 
  def read(self, iprot):
5892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5894 
      return
5895 
    iprot.readStructBegin()
5896 
    while True:
5897 
      (fname, ftype, fid) = iprot.readFieldBegin()
5898 
      if ftype == TType.STOP:
5899 
        break
5900 
      if fid == 0:
5901 
        if ftype == TType.LIST:
5902 
          self.success = []
772 rajveer 5903 
          (_etype31, _size28) = iprot.readListBegin()
5904 
          for _i32 in xrange(_size28):
5905 
            _elem33 = Address()
5906 
            _elem33.read(iprot)
5907 
            self.success.append(_elem33)
594 rajveer 5908 
          iprot.readListEnd()
5909 
        else:
5910 
          iprot.skip(ftype)
5911 
      elif fid == 1:
5912 
        if ftype == TType.STRUCT:
5913 
          self.ucx = UserContextException()
5914 
          self.ucx.read(iprot)
5915 
        else:
5916 
          iprot.skip(ftype)
5917 
      else:
5918 
        iprot.skip(ftype)
5919 
      iprot.readFieldEnd()
5920 
    iprot.readStructEnd()
5921 
 
5922 
  def write(self, oprot):
5923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5925 
      return
5926 
    oprot.writeStructBegin('getAllAddressesForUser_result')
5927 
    if self.success != None:
5928 
      oprot.writeFieldBegin('success', TType.LIST, 0)
5929 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
772 rajveer 5930 
      for iter34 in self.success:
5931 
        iter34.write(oprot)
594 rajveer 5932 
      oprot.writeListEnd()
5933 
      oprot.writeFieldEnd()
5934 
    if self.ucx != None:
5935 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5936 
      self.ucx.write(oprot)
5937 
      oprot.writeFieldEnd()
5938 
    oprot.writeFieldStop()
5939 
    oprot.writeStructEnd()
5940 
 
5941 
  def __repr__(self):
5942 
    L = ['%s=%r' % (key, value)
5943 
      for key, value in self.__dict__.iteritems()]
5944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5945 
 
5946 
  def __eq__(self, other):
5947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5948 
 
5949 
  def __ne__(self, other):
5950 
    return not (self == other)
5951 
 
5952 
class getDefaultAddressId_args:
5953 
  """
5954 
  Attributes:
5955 
   - userId
5956 
  """
5957 
 
5958 
  thrift_spec = (
5959 
    None, # 0
5960 
    (1, TType.I64, 'userId', None, None, ), # 1
5961 
  )
5962 
 
5963 
  def __init__(self, userId=None,):
5964 
    self.userId = userId
5965 
 
5966 
  def read(self, iprot):
5967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5969 
      return
5970 
    iprot.readStructBegin()
5971 
    while True:
5972 
      (fname, ftype, fid) = iprot.readFieldBegin()
5973 
      if ftype == TType.STOP:
5974 
        break
5975 
      if fid == 1:
5976 
        if ftype == TType.I64:
5977 
          self.userId = iprot.readI64();
5978 
        else:
5979 
          iprot.skip(ftype)
5980 
      else:
5981 
        iprot.skip(ftype)
5982 
      iprot.readFieldEnd()
5983 
    iprot.readStructEnd()
5984 
 
5985 
  def write(self, oprot):
5986 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5987 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5988 
      return
5989 
    oprot.writeStructBegin('getDefaultAddressId_args')
5990 
    if self.userId != None:
5991 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5992 
      oprot.writeI64(self.userId)
5993 
      oprot.writeFieldEnd()
5994 
    oprot.writeFieldStop()
5995 
    oprot.writeStructEnd()
5996 
 
5997 
  def __repr__(self):
5998 
    L = ['%s=%r' % (key, value)
5999 
      for key, value in self.__dict__.iteritems()]
6000 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6001 
 
6002 
  def __eq__(self, other):
6003 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6004 
 
6005 
  def __ne__(self, other):
6006 
    return not (self == other)
6007 
 
6008 
class getDefaultAddressId_result:
6009 
  """
6010 
  Attributes:
6011 
   - success
6012 
   - ucx
6013 
  """
6014 
 
6015 
  thrift_spec = (
6016 
    (0, TType.I64, 'success', None, None, ), # 0
6017 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6018 
  )
6019 
 
6020 
  def __init__(self, success=None, ucx=None,):
6021 
    self.success = success
6022 
    self.ucx = ucx
6023 
 
6024 
  def read(self, iprot):
6025 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6026 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6027 
      return
6028 
    iprot.readStructBegin()
6029 
    while True:
6030 
      (fname, ftype, fid) = iprot.readFieldBegin()
6031 
      if ftype == TType.STOP:
6032 
        break
6033 
      if fid == 0:
6034 
        if ftype == TType.I64:
6035 
          self.success = iprot.readI64();
6036 
        else:
6037 
          iprot.skip(ftype)
6038 
      elif fid == 1:
6039 
        if ftype == TType.STRUCT:
6040 
          self.ucx = UserContextException()
6041 
          self.ucx.read(iprot)
6042 
        else:
6043 
          iprot.skip(ftype)
6044 
      else:
6045 
        iprot.skip(ftype)
6046 
      iprot.readFieldEnd()
6047 
    iprot.readStructEnd()
6048 
 
6049 
  def write(self, oprot):
6050 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6051 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6052 
      return
6053 
    oprot.writeStructBegin('getDefaultAddressId_result')
6054 
    if self.success != None:
6055 
      oprot.writeFieldBegin('success', TType.I64, 0)
6056 
      oprot.writeI64(self.success)
6057 
      oprot.writeFieldEnd()
6058 
    if self.ucx != None:
6059 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6060 
      self.ucx.write(oprot)
6061 
      oprot.writeFieldEnd()
6062 
    oprot.writeFieldStop()
6063 
    oprot.writeStructEnd()
6064 
 
6065 
  def __repr__(self):
6066 
    L = ['%s=%r' % (key, value)
6067 
      for key, value in self.__dict__.iteritems()]
6068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6069 
 
6070 
  def __eq__(self, other):
6071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6072 
 
6073 
  def __ne__(self, other):
6074 
    return not (self == other)
6075 
 
785 rajveer 6076 
class getDefaultPincode_args:
6077 
  """
6078 
  Attributes:
6079 
   - userId
6080 
  """
6081 
 
6082 
  thrift_spec = (
6083 
    None, # 0
6084 
    (1, TType.I64, 'userId', None, None, ), # 1
6085 
  )
6086 
 
6087 
  def __init__(self, userId=None,):
6088 
    self.userId = userId
6089 
 
6090 
  def read(self, iprot):
6091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6093 
      return
6094 
    iprot.readStructBegin()
6095 
    while True:
6096 
      (fname, ftype, fid) = iprot.readFieldBegin()
6097 
      if ftype == TType.STOP:
6098 
        break
6099 
      if fid == 1:
6100 
        if ftype == TType.I64:
6101 
          self.userId = iprot.readI64();
6102 
        else:
6103 
          iprot.skip(ftype)
6104 
      else:
6105 
        iprot.skip(ftype)
6106 
      iprot.readFieldEnd()
6107 
    iprot.readStructEnd()
6108 
 
6109 
  def write(self, oprot):
6110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6112 
      return
6113 
    oprot.writeStructBegin('getDefaultPincode_args')
6114 
    if self.userId != None:
6115 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6116 
      oprot.writeI64(self.userId)
6117 
      oprot.writeFieldEnd()
6118 
    oprot.writeFieldStop()
6119 
    oprot.writeStructEnd()
6120 
 
6121 
  def __repr__(self):
6122 
    L = ['%s=%r' % (key, value)
6123 
      for key, value in self.__dict__.iteritems()]
6124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6125 
 
6126 
  def __eq__(self, other):
6127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6128 
 
6129 
  def __ne__(self, other):
6130 
    return not (self == other)
6131 
 
6132 
class getDefaultPincode_result:
6133 
  """
6134 
  Attributes:
6135 
   - success
6136 
   - ucx
6137 
  """
6138 
 
6139 
  thrift_spec = (
6140 
    (0, TType.STRING, 'success', None, None, ), # 0
6141 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6142 
  )
6143 
 
6144 
  def __init__(self, success=None, ucx=None,):
6145 
    self.success = success
6146 
    self.ucx = ucx
6147 
 
6148 
  def read(self, iprot):
6149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6151 
      return
6152 
    iprot.readStructBegin()
6153 
    while True:
6154 
      (fname, ftype, fid) = iprot.readFieldBegin()
6155 
      if ftype == TType.STOP:
6156 
        break
6157 
      if fid == 0:
6158 
        if ftype == TType.STRING:
6159 
          self.success = iprot.readString();
6160 
        else:
6161 
          iprot.skip(ftype)
6162 
      elif fid == 1:
6163 
        if ftype == TType.STRUCT:
6164 
          self.ucx = UserContextException()
6165 
          self.ucx.read(iprot)
6166 
        else:
6167 
          iprot.skip(ftype)
6168 
      else:
6169 
        iprot.skip(ftype)
6170 
      iprot.readFieldEnd()
6171 
    iprot.readStructEnd()
6172 
 
6173 
  def write(self, oprot):
6174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6176 
      return
6177 
    oprot.writeStructBegin('getDefaultPincode_result')
6178 
    if self.success != None:
6179 
      oprot.writeFieldBegin('success', TType.STRING, 0)
6180 
      oprot.writeString(self.success)
6181 
      oprot.writeFieldEnd()
6182 
    if self.ucx != None:
6183 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6184 
      self.ucx.write(oprot)
6185 
      oprot.writeFieldEnd()
6186 
    oprot.writeFieldStop()
6187 
    oprot.writeStructEnd()
6188 
 
6189 
  def __repr__(self):
6190 
    L = ['%s=%r' % (key, value)
6191 
      for key, value in self.__dict__.iteritems()]
6192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6193 
 
6194 
  def __eq__(self, other):
6195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6196 
 
6197 
  def __ne__(self, other):
6198 
    return not (self == other)
6199 
 
1274 varun.gupt 6200 
class saveUserCommunication_args:
6201 
  """
6202 
  Attributes:
6203 
   - userId
6204 
   - replyTo
6205 
   - communicationType
6206 
   - orderId
6207 
   - airwaybillNo
6208 
   - productName
6209 
   - subject
6210 
   - message
6211 
  """
6212 
 
6213 
  thrift_spec = (
6214 
    None, # 0
6215 
    (1, TType.I64, 'userId', None, None, ), # 1
6216 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
6217 
    (3, TType.I64, 'communicationType', None, None, ), # 3
6218 
    (4, TType.I64, 'orderId', None, None, ), # 4
6219 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
6220 
    (6, TType.STRING, 'productName', None, None, ), # 6
6221 
    (7, TType.STRING, 'subject', None, None, ), # 7
6222 
    (8, TType.STRING, 'message', None, None, ), # 8
6223 
  )
6224 
 
6225 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
6226 
    self.userId = userId
6227 
    self.replyTo = replyTo
6228 
    self.communicationType = communicationType
6229 
    self.orderId = orderId
6230 
    self.airwaybillNo = airwaybillNo
6231 
    self.productName = productName
6232 
    self.subject = subject
6233 
    self.message = message
6234 
 
6235 
  def read(self, iprot):
6236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6238 
      return
6239 
    iprot.readStructBegin()
6240 
    while True:
6241 
      (fname, ftype, fid) = iprot.readFieldBegin()
6242 
      if ftype == TType.STOP:
6243 
        break
6244 
      if fid == 1:
6245 
        if ftype == TType.I64:
6246 
          self.userId = iprot.readI64();
6247 
        else:
6248 
          iprot.skip(ftype)
6249 
      elif fid == 2:
6250 
        if ftype == TType.STRING:
6251 
          self.replyTo = iprot.readString();
6252 
        else:
6253 
          iprot.skip(ftype)
6254 
      elif fid == 3:
6255 
        if ftype == TType.I64:
6256 
          self.communicationType = iprot.readI64();
6257 
        else:
6258 
          iprot.skip(ftype)
6259 
      elif fid == 4:
6260 
        if ftype == TType.I64:
6261 
          self.orderId = iprot.readI64();
6262 
        else:
6263 
          iprot.skip(ftype)
6264 
      elif fid == 5:
6265 
        if ftype == TType.STRING:
6266 
          self.airwaybillNo = iprot.readString();
6267 
        else:
6268 
          iprot.skip(ftype)
6269 
      elif fid == 6:
6270 
        if ftype == TType.STRING:
6271 
          self.productName = iprot.readString();
6272 
        else:
6273 
          iprot.skip(ftype)
6274 
      elif fid == 7:
6275 
        if ftype == TType.STRING:
6276 
          self.subject = iprot.readString();
6277 
        else:
6278 
          iprot.skip(ftype)
6279 
      elif fid == 8:
6280 
        if ftype == TType.STRING:
6281 
          self.message = iprot.readString();
6282 
        else:
6283 
          iprot.skip(ftype)
6284 
      else:
6285 
        iprot.skip(ftype)
6286 
      iprot.readFieldEnd()
6287 
    iprot.readStructEnd()
6288 
 
6289 
  def write(self, oprot):
6290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6292 
      return
6293 
    oprot.writeStructBegin('saveUserCommunication_args')
6294 
    if self.userId != None:
6295 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6296 
      oprot.writeI64(self.userId)
6297 
      oprot.writeFieldEnd()
6298 
    if self.replyTo != None:
6299 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
6300 
      oprot.writeString(self.replyTo)
6301 
      oprot.writeFieldEnd()
6302 
    if self.communicationType != None:
6303 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
6304 
      oprot.writeI64(self.communicationType)
6305 
      oprot.writeFieldEnd()
6306 
    if self.orderId != None:
6307 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
6308 
      oprot.writeI64(self.orderId)
6309 
      oprot.writeFieldEnd()
6310 
    if self.airwaybillNo != None:
6311 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
6312 
      oprot.writeString(self.airwaybillNo)
6313 
      oprot.writeFieldEnd()
6314 
    if self.productName != None:
6315 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
6316 
      oprot.writeString(self.productName)
6317 
      oprot.writeFieldEnd()
6318 
    if self.subject != None:
6319 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
6320 
      oprot.writeString(self.subject)
6321 
      oprot.writeFieldEnd()
6322 
    if self.message != None:
6323 
      oprot.writeFieldBegin('message', TType.STRING, 8)
6324 
      oprot.writeString(self.message)
6325 
      oprot.writeFieldEnd()
6326 
    oprot.writeFieldStop()
6327 
    oprot.writeStructEnd()
6328 
 
6329 
  def __repr__(self):
6330 
    L = ['%s=%r' % (key, value)
6331 
      for key, value in self.__dict__.iteritems()]
6332 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6333 
 
6334 
  def __eq__(self, other):
6335 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6336 
 
6337 
  def __ne__(self, other):
6338 
    return not (self == other)
6339 
 
6340 
class saveUserCommunication_result:
6341 
  """
6342 
  Attributes:
6343 
   - success
6344 
   - ucx
6345 
  """
6346 
 
6347 
  thrift_spec = (
6348 
    (0, TType.BOOL, 'success', None, None, ), # 0
6349 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6350 
  )
6351 
 
6352 
  def __init__(self, success=None, ucx=None,):
6353 
    self.success = success
6354 
    self.ucx = ucx
6355 
 
6356 
  def read(self, iprot):
6357 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6358 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6359 
      return
6360 
    iprot.readStructBegin()
6361 
    while True:
6362 
      (fname, ftype, fid) = iprot.readFieldBegin()
6363 
      if ftype == TType.STOP:
6364 
        break
6365 
      if fid == 0:
6366 
        if ftype == TType.BOOL:
6367 
          self.success = iprot.readBool();
6368 
        else:
6369 
          iprot.skip(ftype)
6370 
      elif fid == 1:
6371 
        if ftype == TType.STRUCT:
6372 
          self.ucx = UserCommunicationException()
6373 
          self.ucx.read(iprot)
6374 
        else:
6375 
          iprot.skip(ftype)
6376 
      else:
6377 
        iprot.skip(ftype)
6378 
      iprot.readFieldEnd()
6379 
    iprot.readStructEnd()
6380 
 
6381 
  def write(self, oprot):
6382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6384 
      return
6385 
    oprot.writeStructBegin('saveUserCommunication_result')
6386 
    if self.success != None:
6387 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6388 
      oprot.writeBool(self.success)
6389 
      oprot.writeFieldEnd()
6390 
    if self.ucx != None:
6391 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6392 
      self.ucx.write(oprot)
6393 
      oprot.writeFieldEnd()
6394 
    oprot.writeFieldStop()
6395 
    oprot.writeStructEnd()
6396 
 
6397 
  def __repr__(self):
6398 
    L = ['%s=%r' % (key, value)
6399 
      for key, value in self.__dict__.iteritems()]
6400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6401 
 
6402 
  def __eq__(self, other):
6403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6404 
 
6405 
  def __ne__(self, other):
6406 
    return not (self == other)
6407 
 
1590 varun.gupt 6408 
class getUserCommunicationById_args:
6409 
  """
6410 
  Attributes:
6411 
   - id
6412 
  """
6413 
 
6414 
  thrift_spec = (
6415 
    None, # 0
6416 
    (1, TType.I64, 'id', None, None, ), # 1
6417 
  )
6418 
 
6419 
  def __init__(self, id=None,):
6420 
    self.id = id
6421 
 
6422 
  def read(self, iprot):
6423 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6424 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6425 
      return
6426 
    iprot.readStructBegin()
6427 
    while True:
6428 
      (fname, ftype, fid) = iprot.readFieldBegin()
6429 
      if ftype == TType.STOP:
6430 
        break
6431 
      if fid == 1:
6432 
        if ftype == TType.I64:
6433 
          self.id = iprot.readI64();
6434 
        else:
6435 
          iprot.skip(ftype)
6436 
      else:
6437 
        iprot.skip(ftype)
6438 
      iprot.readFieldEnd()
6439 
    iprot.readStructEnd()
6440 
 
6441 
  def write(self, oprot):
6442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6444 
      return
6445 
    oprot.writeStructBegin('getUserCommunicationById_args')
6446 
    if self.id != None:
6447 
      oprot.writeFieldBegin('id', TType.I64, 1)
6448 
      oprot.writeI64(self.id)
6449 
      oprot.writeFieldEnd()
6450 
    oprot.writeFieldStop()
6451 
    oprot.writeStructEnd()
6452 
 
6453 
  def __repr__(self):
6454 
    L = ['%s=%r' % (key, value)
6455 
      for key, value in self.__dict__.iteritems()]
6456 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6457 
 
6458 
  def __eq__(self, other):
6459 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6460 
 
6461 
  def __ne__(self, other):
6462 
    return not (self == other)
6463 
 
6464 
class getUserCommunicationById_result:
6465 
  """
6466 
  Attributes:
6467 
   - success
6468 
   - ucx
6469 
  """
6470 
 
6471 
  thrift_spec = (
6472 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
6473 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6474 
  )
6475 
 
6476 
  def __init__(self, success=None, ucx=None,):
6477 
    self.success = success
6478 
    self.ucx = ucx
6479 
 
6480 
  def read(self, iprot):
6481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6483 
      return
6484 
    iprot.readStructBegin()
6485 
    while True:
6486 
      (fname, ftype, fid) = iprot.readFieldBegin()
6487 
      if ftype == TType.STOP:
6488 
        break
6489 
      if fid == 0:
6490 
        if ftype == TType.STRUCT:
6491 
          self.success = UserCommunication()
6492 
          self.success.read(iprot)
6493 
        else:
6494 
          iprot.skip(ftype)
6495 
      elif fid == 1:
6496 
        if ftype == TType.STRUCT:
6497 
          self.ucx = UserCommunicationException()
6498 
          self.ucx.read(iprot)
6499 
        else:
6500 
          iprot.skip(ftype)
6501 
      else:
6502 
        iprot.skip(ftype)
6503 
      iprot.readFieldEnd()
6504 
    iprot.readStructEnd()
6505 
 
6506 
  def write(self, oprot):
6507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6509 
      return
6510 
    oprot.writeStructBegin('getUserCommunicationById_result')
6511 
    if self.success != None:
6512 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6513 
      self.success.write(oprot)
6514 
      oprot.writeFieldEnd()
6515 
    if self.ucx != None:
6516 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6517 
      self.ucx.write(oprot)
6518 
      oprot.writeFieldEnd()
6519 
    oprot.writeFieldStop()
6520 
    oprot.writeStructEnd()
6521 
 
6522 
  def __repr__(self):
6523 
    L = ['%s=%r' % (key, value)
6524 
      for key, value in self.__dict__.iteritems()]
6525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6526 
 
6527 
  def __eq__(self, other):
6528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6529 
 
6530 
  def __ne__(self, other):
6531 
    return not (self == other)
6532 
 
6533 
class getUserCommunicationByUser_args:
6534 
  """
6535 
  Attributes:
6536 
   - userId
6537 
  """
6538 
 
6539 
  thrift_spec = (
6540 
    None, # 0
6541 
    (1, TType.I64, 'userId', None, None, ), # 1
6542 
  )
6543 
 
6544 
  def __init__(self, userId=None,):
6545 
    self.userId = userId
6546 
 
6547 
  def read(self, iprot):
6548 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6549 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6550 
      return
6551 
    iprot.readStructBegin()
6552 
    while True:
6553 
      (fname, ftype, fid) = iprot.readFieldBegin()
6554 
      if ftype == TType.STOP:
6555 
        break
6556 
      if fid == 1:
6557 
        if ftype == TType.I64:
6558 
          self.userId = iprot.readI64();
6559 
        else:
6560 
          iprot.skip(ftype)
6561 
      else:
6562 
        iprot.skip(ftype)
6563 
      iprot.readFieldEnd()
6564 
    iprot.readStructEnd()
6565 
 
6566 
  def write(self, oprot):
6567 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6568 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6569 
      return
6570 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
6571 
    if self.userId != None:
6572 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6573 
      oprot.writeI64(self.userId)
6574 
      oprot.writeFieldEnd()
6575 
    oprot.writeFieldStop()
6576 
    oprot.writeStructEnd()
6577 
 
6578 
  def __repr__(self):
6579 
    L = ['%s=%r' % (key, value)
6580 
      for key, value in self.__dict__.iteritems()]
6581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6582 
 
6583 
  def __eq__(self, other):
6584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6585 
 
6586 
  def __ne__(self, other):
6587 
    return not (self == other)
6588 
 
6589 
class getUserCommunicationByUser_result:
6590 
  """
6591 
  Attributes:
6592 
   - success
6593 
   - ucx
6594 
  """
6595 
 
6596 
  thrift_spec = (
6597 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
6598 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6599 
  )
6600 
 
6601 
  def __init__(self, success=None, ucx=None,):
6602 
    self.success = success
6603 
    self.ucx = ucx
6604 
 
6605 
  def read(self, iprot):
6606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6608 
      return
6609 
    iprot.readStructBegin()
6610 
    while True:
6611 
      (fname, ftype, fid) = iprot.readFieldBegin()
6612 
      if ftype == TType.STOP:
6613 
        break
6614 
      if fid == 0:
6615 
        if ftype == TType.LIST:
6616 
          self.success = []
6617 
          (_etype38, _size35) = iprot.readListBegin()
6618 
          for _i39 in xrange(_size35):
6619 
            _elem40 = UserCommunication()
6620 
            _elem40.read(iprot)
6621 
            self.success.append(_elem40)
6622 
          iprot.readListEnd()
6623 
        else:
6624 
          iprot.skip(ftype)
6625 
      elif fid == 1:
6626 
        if ftype == TType.STRUCT:
6627 
          self.ucx = UserCommunicationException()
6628 
          self.ucx.read(iprot)
6629 
        else:
6630 
          iprot.skip(ftype)
6631 
      else:
6632 
        iprot.skip(ftype)
6633 
      iprot.readFieldEnd()
6634 
    iprot.readStructEnd()
6635 
 
6636 
  def write(self, oprot):
6637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6639 
      return
6640 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
6641 
    if self.success != None:
6642 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6643 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6644 
      for iter41 in self.success:
6645 
        iter41.write(oprot)
6646 
      oprot.writeListEnd()
6647 
      oprot.writeFieldEnd()
6648 
    if self.ucx != None:
6649 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6650 
      self.ucx.write(oprot)
6651 
      oprot.writeFieldEnd()
6652 
    oprot.writeFieldStop()
6653 
    oprot.writeStructEnd()
6654 
 
6655 
  def __repr__(self):
6656 
    L = ['%s=%r' % (key, value)
6657 
      for key, value in self.__dict__.iteritems()]
6658 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6659 
 
6660 
  def __eq__(self, other):
6661 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6662 
 
6663 
  def __ne__(self, other):
6664 
    return not (self == other)
6665 
 
6666 
class getAllUserCommunications_args:
6667 
 
6668 
  thrift_spec = (
6669 
  )
6670 
 
6671 
  def read(self, iprot):
6672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6674 
      return
6675 
    iprot.readStructBegin()
6676 
    while True:
6677 
      (fname, ftype, fid) = iprot.readFieldBegin()
6678 
      if ftype == TType.STOP:
6679 
        break
6680 
      else:
6681 
        iprot.skip(ftype)
6682 
      iprot.readFieldEnd()
6683 
    iprot.readStructEnd()
6684 
 
6685 
  def write(self, oprot):
6686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6688 
      return
6689 
    oprot.writeStructBegin('getAllUserCommunications_args')
6690 
    oprot.writeFieldStop()
6691 
    oprot.writeStructEnd()
6692 
 
6693 
  def __repr__(self):
6694 
    L = ['%s=%r' % (key, value)
6695 
      for key, value in self.__dict__.iteritems()]
6696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6697 
 
6698 
  def __eq__(self, other):
6699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6700 
 
6701 
  def __ne__(self, other):
6702 
    return not (self == other)
6703 
 
6704 
class getAllUserCommunications_result:
6705 
  """
6706 
  Attributes:
6707 
   - success
6708 
   - ucx
6709 
  """
6710 
 
6711 
  thrift_spec = (
6712 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
6713 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6714 
  )
6715 
 
6716 
  def __init__(self, success=None, ucx=None,):
6717 
    self.success = success
6718 
    self.ucx = ucx
6719 
 
6720 
  def read(self, iprot):
6721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6723 
      return
6724 
    iprot.readStructBegin()
6725 
    while True:
6726 
      (fname, ftype, fid) = iprot.readFieldBegin()
6727 
      if ftype == TType.STOP:
6728 
        break
6729 
      if fid == 0:
6730 
        if ftype == TType.LIST:
6731 
          self.success = []
6732 
          (_etype45, _size42) = iprot.readListBegin()
6733 
          for _i46 in xrange(_size42):
6734 
            _elem47 = UserCommunication()
6735 
            _elem47.read(iprot)
6736 
            self.success.append(_elem47)
6737 
          iprot.readListEnd()
6738 
        else:
6739 
          iprot.skip(ftype)
6740 
      elif fid == 1:
6741 
        if ftype == TType.STRUCT:
6742 
          self.ucx = UserCommunicationException()
6743 
          self.ucx.read(iprot)
6744 
        else:
6745 
          iprot.skip(ftype)
6746 
      else:
6747 
        iprot.skip(ftype)
6748 
      iprot.readFieldEnd()
6749 
    iprot.readStructEnd()
6750 
 
6751 
  def write(self, oprot):
6752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6754 
      return
6755 
    oprot.writeStructBegin('getAllUserCommunications_result')
6756 
    if self.success != None:
6757 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6758 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6759 
      for iter48 in self.success:
6760 
        iter48.write(oprot)
6761 
      oprot.writeListEnd()
6762 
      oprot.writeFieldEnd()
6763 
    if self.ucx != None:
6764 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6765 
      self.ucx.write(oprot)
6766 
      oprot.writeFieldEnd()
6767 
    oprot.writeFieldStop()
6768 
    oprot.writeStructEnd()
6769 
 
6770 
  def __repr__(self):
6771 
    L = ['%s=%r' % (key, value)
6772 
      for key, value in self.__dict__.iteritems()]
6773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6774 
 
6775 
  def __eq__(self, other):
6776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6777 
 
6778 
  def __ne__(self, other):
6779 
    return not (self == other)
6780 
 
1845 vikas 6781 
class createMasterAffiliate_args:
6782 
  """
6783 
  Attributes:
6784 
   - name
6785 
  """
6786 
 
6787 
  thrift_spec = (
6788 
    None, # 0
6789 
    (1, TType.STRING, 'name', None, None, ), # 1
6790 
  )
6791 
 
6792 
  def __init__(self, name=None,):
6793 
    self.name = name
6794 
 
6795 
  def read(self, iprot):
6796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6798 
      return
6799 
    iprot.readStructBegin()
6800 
    while True:
6801 
      (fname, ftype, fid) = iprot.readFieldBegin()
6802 
      if ftype == TType.STOP:
6803 
        break
6804 
      if fid == 1:
6805 
        if ftype == TType.STRING:
6806 
          self.name = iprot.readString();
6807 
        else:
6808 
          iprot.skip(ftype)
6809 
      else:
6810 
        iprot.skip(ftype)
6811 
      iprot.readFieldEnd()
6812 
    iprot.readStructEnd()
6813 
 
6814 
  def write(self, oprot):
6815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6817 
      return
6818 
    oprot.writeStructBegin('createMasterAffiliate_args')
6819 
    if self.name != None:
6820 
      oprot.writeFieldBegin('name', TType.STRING, 1)
6821 
      oprot.writeString(self.name)
6822 
      oprot.writeFieldEnd()
6823 
    oprot.writeFieldStop()
6824 
    oprot.writeStructEnd()
6825 
 
6826 
  def __repr__(self):
6827 
    L = ['%s=%r' % (key, value)
6828 
      for key, value in self.__dict__.iteritems()]
6829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6830 
 
6831 
  def __eq__(self, other):
6832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6833 
 
6834 
  def __ne__(self, other):
6835 
    return not (self == other)
6836 
 
6837 
class createMasterAffiliate_result:
6838 
  """
6839 
  Attributes:
6840 
   - success
6841 
   - utx
6842 
  """
6843 
 
6844 
  thrift_spec = (
6845 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
6846 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
6847 
  )
6848 
 
6849 
  def __init__(self, success=None, utx=None,):
6850 
    self.success = success
6851 
    self.utx = utx
6852 
 
6853 
  def read(self, iprot):
6854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6856 
      return
6857 
    iprot.readStructBegin()
6858 
    while True:
6859 
      (fname, ftype, fid) = iprot.readFieldBegin()
6860 
      if ftype == TType.STOP:
6861 
        break
6862 
      if fid == 0:
6863 
        if ftype == TType.STRUCT:
6864 
          self.success = MasterAffiliate()
6865 
          self.success.read(iprot)
6866 
        else:
6867 
          iprot.skip(ftype)
6868 
      elif fid == 1:
6869 
        if ftype == TType.STRUCT:
6870 
          self.utx = UserTrackerException()
6871 
          self.utx.read(iprot)
6872 
        else:
6873 
          iprot.skip(ftype)
6874 
      else:
6875 
        iprot.skip(ftype)
6876 
      iprot.readFieldEnd()
6877 
    iprot.readStructEnd()
6878 
 
6879 
  def write(self, oprot):
6880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6882 
      return
6883 
    oprot.writeStructBegin('createMasterAffiliate_result')
6884 
    if self.success != None:
6885 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6886 
      self.success.write(oprot)
6887 
      oprot.writeFieldEnd()
6888 
    if self.utx != None:
6889 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
6890 
      self.utx.write(oprot)
6891 
      oprot.writeFieldEnd()
6892 
    oprot.writeFieldStop()
6893 
    oprot.writeStructEnd()
6894 
 
6895 
  def __repr__(self):
6896 
    L = ['%s=%r' % (key, value)
6897 
      for key, value in self.__dict__.iteritems()]
6898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6899 
 
6900 
  def __eq__(self, other):
6901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6902 
 
6903 
  def __ne__(self, other):
6904 
    return not (self == other)
6905 
 
6906 
class getMasterAffiliateById_args:
6907 
  """
6908 
  Attributes:
6909 
   - id
6910 
  """
6911 
 
6912 
  thrift_spec = (
6913 
    None, # 0
6914 
    (1, TType.I64, 'id', None, None, ), # 1
6915 
  )
6916 
 
6917 
  def __init__(self, id=None,):
6918 
    self.id = id
6919 
 
6920 
  def read(self, iprot):
6921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6923 
      return
6924 
    iprot.readStructBegin()
6925 
    while True:
6926 
      (fname, ftype, fid) = iprot.readFieldBegin()
6927 
      if ftype == TType.STOP:
6928 
        break
6929 
      if fid == 1:
6930 
        if ftype == TType.I64:
6931 
          self.id = iprot.readI64();
6932 
        else:
6933 
          iprot.skip(ftype)
6934 
      else:
6935 
        iprot.skip(ftype)
6936 
      iprot.readFieldEnd()
6937 
    iprot.readStructEnd()
6938 
 
6939 
  def write(self, oprot):
6940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6942 
      return
6943 
    oprot.writeStructBegin('getMasterAffiliateById_args')
6944 
    if self.id != None:
6945 
      oprot.writeFieldBegin('id', TType.I64, 1)
6946 
      oprot.writeI64(self.id)
6947 
      oprot.writeFieldEnd()
6948 
    oprot.writeFieldStop()
6949 
    oprot.writeStructEnd()
6950 
 
6951 
  def __repr__(self):
6952 
    L = ['%s=%r' % (key, value)
6953 
      for key, value in self.__dict__.iteritems()]
6954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6955 
 
6956 
  def __eq__(self, other):
6957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6958 
 
6959 
  def __ne__(self, other):
6960 
    return not (self == other)
6961 
 
6962 
class getMasterAffiliateById_result:
6963 
  """
6964 
  Attributes:
6965 
   - success
6966 
   - utx
6967 
  """
6968 
 
6969 
  thrift_spec = (
6970 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
6971 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
6972 
  )
6973 
 
6974 
  def __init__(self, success=None, utx=None,):
6975 
    self.success = success
6976 
    self.utx = utx
6977 
 
6978 
  def read(self, iprot):
6979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6981 
      return
6982 
    iprot.readStructBegin()
6983 
    while True:
6984 
      (fname, ftype, fid) = iprot.readFieldBegin()
6985 
      if ftype == TType.STOP:
6986 
        break
6987 
      if fid == 0:
6988 
        if ftype == TType.STRUCT:
6989 
          self.success = MasterAffiliate()
6990 
          self.success.read(iprot)
6991 
        else:
6992 
          iprot.skip(ftype)
6993 
      elif fid == 1:
6994 
        if ftype == TType.STRUCT:
6995 
          self.utx = UserTrackerException()
6996 
          self.utx.read(iprot)
6997 
        else:
6998 
          iprot.skip(ftype)
6999 
      else:
7000 
        iprot.skip(ftype)
7001 
      iprot.readFieldEnd()
7002 
    iprot.readStructEnd()
7003 
 
7004 
  def write(self, oprot):
7005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7007 
      return
7008 
    oprot.writeStructBegin('getMasterAffiliateById_result')
7009 
    if self.success != None:
7010 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7011 
      self.success.write(oprot)
7012 
      oprot.writeFieldEnd()
7013 
    if self.utx != None:
7014 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7015 
      self.utx.write(oprot)
7016 
      oprot.writeFieldEnd()
7017 
    oprot.writeFieldStop()
7018 
    oprot.writeStructEnd()
7019 
 
7020 
  def __repr__(self):
7021 
    L = ['%s=%r' % (key, value)
7022 
      for key, value in self.__dict__.iteritems()]
7023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7024 
 
7025 
  def __eq__(self, other):
7026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7027 
 
7028 
  def __ne__(self, other):
7029 
    return not (self == other)
7030 
 
7031 
class getMasterAffiliateByName_args:
7032 
  """
7033 
  Attributes:
7034 
   - name
7035 
  """
7036 
 
7037 
  thrift_spec = (
7038 
    None, # 0
7039 
    (1, TType.STRING, 'name', None, None, ), # 1
7040 
  )
7041 
 
7042 
  def __init__(self, name=None,):
7043 
    self.name = name
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)
7059 
      else:
7060 
        iprot.skip(ftype)
7061 
      iprot.readFieldEnd()
7062 
    iprot.readStructEnd()
7063 
 
7064 
  def write(self, oprot):
7065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7067 
      return
7068 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
7069 
    if self.name != None:
7070 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7071 
      oprot.writeString(self.name)
7072 
      oprot.writeFieldEnd()
7073 
    oprot.writeFieldStop()
7074 
    oprot.writeStructEnd()
7075 
 
7076 
  def __repr__(self):
7077 
    L = ['%s=%r' % (key, value)
7078 
      for key, value in self.__dict__.iteritems()]
7079 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7080 
 
7081 
  def __eq__(self, other):
7082 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7083 
 
7084 
  def __ne__(self, other):
7085 
    return not (self == other)
7086 
 
7087 
class getMasterAffiliateByName_result:
7088 
  """
7089 
  Attributes:
7090 
   - success
7091 
   - utx
7092 
  """
7093 
 
7094 
  thrift_spec = (
7095 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
7096 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7097 
  )
7098 
 
7099 
  def __init__(self, success=None, utx=None,):
7100 
    self.success = success
7101 
    self.utx = utx
7102 
 
7103 
  def read(self, iprot):
7104 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7105 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7106 
      return
7107 
    iprot.readStructBegin()
7108 
    while True:
7109 
      (fname, ftype, fid) = iprot.readFieldBegin()
7110 
      if ftype == TType.STOP:
7111 
        break
7112 
      if fid == 0:
7113 
        if ftype == TType.STRUCT:
7114 
          self.success = MasterAffiliate()
7115 
          self.success.read(iprot)
7116 
        else:
7117 
          iprot.skip(ftype)
7118 
      elif fid == 1:
7119 
        if ftype == TType.STRUCT:
7120 
          self.utx = UserTrackerException()
7121 
          self.utx.read(iprot)
7122 
        else:
7123 
          iprot.skip(ftype)
7124 
      else:
7125 
        iprot.skip(ftype)
7126 
      iprot.readFieldEnd()
7127 
    iprot.readStructEnd()
7128 
 
7129 
  def write(self, oprot):
7130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7132 
      return
7133 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
7134 
    if self.success != None:
7135 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7136 
      self.success.write(oprot)
7137 
      oprot.writeFieldEnd()
7138 
    if self.utx != None:
7139 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7140 
      self.utx.write(oprot)
7141 
      oprot.writeFieldEnd()
7142 
    oprot.writeFieldStop()
7143 
    oprot.writeStructEnd()
7144 
 
7145 
  def __repr__(self):
7146 
    L = ['%s=%r' % (key, value)
7147 
      for key, value in self.__dict__.iteritems()]
7148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7149 
 
7150 
  def __eq__(self, other):
7151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7152 
 
7153 
  def __ne__(self, other):
7154 
    return not (self == other)
7155 
 
7156 
class createAffiliate_args:
7157 
  """
7158 
  Attributes:
7159 
   - name
7160 
   - url
7161 
   - masterAffiliateId
7162 
  """
7163 
 
7164 
  thrift_spec = (
7165 
    None, # 0
7166 
    (1, TType.STRING, 'name', None, None, ), # 1
7167 
    (2, TType.STRING, 'url', None, None, ), # 2
7168 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
7169 
  )
7170 
 
7171 
  def __init__(self, name=None, url=None, masterAffiliateId=None,):
7172 
    self.name = name
7173 
    self.url = url
7174 
    self.masterAffiliateId = masterAffiliateId
7175 
 
7176 
  def read(self, iprot):
7177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7179 
      return
7180 
    iprot.readStructBegin()
7181 
    while True:
7182 
      (fname, ftype, fid) = iprot.readFieldBegin()
7183 
      if ftype == TType.STOP:
7184 
        break
7185 
      if fid == 1:
7186 
        if ftype == TType.STRING:
7187 
          self.name = iprot.readString();
7188 
        else:
7189 
          iprot.skip(ftype)
7190 
      elif fid == 2:
7191 
        if ftype == TType.STRING:
7192 
          self.url = iprot.readString();
7193 
        else:
7194 
          iprot.skip(ftype)
7195 
      elif fid == 3:
7196 
        if ftype == TType.I64:
7197 
          self.masterAffiliateId = iprot.readI64();
7198 
        else:
7199 
          iprot.skip(ftype)
7200 
      else:
7201 
        iprot.skip(ftype)
7202 
      iprot.readFieldEnd()
7203 
    iprot.readStructEnd()
7204 
 
7205 
  def write(self, oprot):
7206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7208 
      return
7209 
    oprot.writeStructBegin('createAffiliate_args')
7210 
    if self.name != None:
7211 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7212 
      oprot.writeString(self.name)
7213 
      oprot.writeFieldEnd()
7214 
    if self.url != None:
7215 
      oprot.writeFieldBegin('url', TType.STRING, 2)
7216 
      oprot.writeString(self.url)
7217 
      oprot.writeFieldEnd()
7218 
    if self.masterAffiliateId != None:
7219 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
7220 
      oprot.writeI64(self.masterAffiliateId)
7221 
      oprot.writeFieldEnd()
7222 
    oprot.writeFieldStop()
7223 
    oprot.writeStructEnd()
7224 
 
7225 
  def __repr__(self):
7226 
    L = ['%s=%r' % (key, value)
7227 
      for key, value in self.__dict__.iteritems()]
7228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7229 
 
7230 
  def __eq__(self, other):
7231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7232 
 
7233 
  def __ne__(self, other):
7234 
    return not (self == other)
7235 
 
7236 
class createAffiliate_result:
7237 
  """
7238 
  Attributes:
7239 
   - success
7240 
   - utx
7241 
  """
7242 
 
7243 
  thrift_spec = (
7244 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
7245 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7246 
  )
7247 
 
7248 
  def __init__(self, success=None, utx=None,):
7249 
    self.success = success
7250 
    self.utx = utx
7251 
 
7252 
  def read(self, iprot):
7253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7255 
      return
7256 
    iprot.readStructBegin()
7257 
    while True:
7258 
      (fname, ftype, fid) = iprot.readFieldBegin()
7259 
      if ftype == TType.STOP:
7260 
        break
7261 
      if fid == 0:
7262 
        if ftype == TType.STRUCT:
7263 
          self.success = Affiliate()
7264 
          self.success.read(iprot)
7265 
        else:
7266 
          iprot.skip(ftype)
7267 
      elif fid == 1:
7268 
        if ftype == TType.STRUCT:
7269 
          self.utx = UserTrackerException()
7270 
          self.utx.read(iprot)
7271 
        else:
7272 
          iprot.skip(ftype)
7273 
      else:
7274 
        iprot.skip(ftype)
7275 
      iprot.readFieldEnd()
7276 
    iprot.readStructEnd()
7277 
 
7278 
  def write(self, oprot):
7279 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7280 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7281 
      return
7282 
    oprot.writeStructBegin('createAffiliate_result')
7283 
    if self.success != None:
7284 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7285 
      self.success.write(oprot)
7286 
      oprot.writeFieldEnd()
7287 
    if self.utx != None:
7288 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7289 
      self.utx.write(oprot)
7290 
      oprot.writeFieldEnd()
7291 
    oprot.writeFieldStop()
7292 
    oprot.writeStructEnd()
7293 
 
7294 
  def __repr__(self):
7295 
    L = ['%s=%r' % (key, value)
7296 
      for key, value in self.__dict__.iteritems()]
7297 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7298 
 
7299 
  def __eq__(self, other):
7300 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7301 
 
7302 
  def __ne__(self, other):
7303 
    return not (self == other)
7304 
 
7305 
class getAffiliateById_args:
7306 
  """
7307 
  Attributes:
7308 
   - id
7309 
  """
7310 
 
7311 
  thrift_spec = (
7312 
    None, # 0
7313 
    (1, TType.I64, 'id', None, None, ), # 1
7314 
  )
7315 
 
7316 
  def __init__(self, id=None,):
7317 
    self.id = id
7318 
 
7319 
  def read(self, iprot):
7320 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7321 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7322 
      return
7323 
    iprot.readStructBegin()
7324 
    while True:
7325 
      (fname, ftype, fid) = iprot.readFieldBegin()
7326 
      if ftype == TType.STOP:
7327 
        break
7328 
      if fid == 1:
7329 
        if ftype == TType.I64:
7330 
          self.id = iprot.readI64();
7331 
        else:
7332 
          iprot.skip(ftype)
7333 
      else:
7334 
        iprot.skip(ftype)
7335 
      iprot.readFieldEnd()
7336 
    iprot.readStructEnd()
7337 
 
7338 
  def write(self, oprot):
7339 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7340 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7341 
      return
7342 
    oprot.writeStructBegin('getAffiliateById_args')
7343 
    if self.id != None:
7344 
      oprot.writeFieldBegin('id', TType.I64, 1)
7345 
      oprot.writeI64(self.id)
7346 
      oprot.writeFieldEnd()
7347 
    oprot.writeFieldStop()
7348 
    oprot.writeStructEnd()
7349 
 
7350 
  def __repr__(self):
7351 
    L = ['%s=%r' % (key, value)
7352 
      for key, value in self.__dict__.iteritems()]
7353 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7354 
 
7355 
  def __eq__(self, other):
7356 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7357 
 
7358 
  def __ne__(self, other):
7359 
    return not (self == other)
7360 
 
7361 
class getAffiliateById_result:
7362 
  """
7363 
  Attributes:
7364 
   - success
7365 
   - utx
7366 
  """
7367 
 
7368 
  thrift_spec = (
7369 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
7370 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7371 
  )
7372 
 
7373 
  def __init__(self, success=None, utx=None,):
7374 
    self.success = success
7375 
    self.utx = utx
7376 
 
7377 
  def read(self, iprot):
7378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7380 
      return
7381 
    iprot.readStructBegin()
7382 
    while True:
7383 
      (fname, ftype, fid) = iprot.readFieldBegin()
7384 
      if ftype == TType.STOP:
7385 
        break
7386 
      if fid == 0:
7387 
        if ftype == TType.STRUCT:
7388 
          self.success = Affiliate()
7389 
          self.success.read(iprot)
7390 
        else:
7391 
          iprot.skip(ftype)
7392 
      elif fid == 1:
7393 
        if ftype == TType.STRUCT:
7394 
          self.utx = UserTrackerException()
7395 
          self.utx.read(iprot)
7396 
        else:
7397 
          iprot.skip(ftype)
7398 
      else:
7399 
        iprot.skip(ftype)
7400 
      iprot.readFieldEnd()
7401 
    iprot.readStructEnd()
7402 
 
7403 
  def write(self, oprot):
7404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7406 
      return
7407 
    oprot.writeStructBegin('getAffiliateById_result')
7408 
    if self.success != None:
7409 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7410 
      self.success.write(oprot)
7411 
      oprot.writeFieldEnd()
7412 
    if self.utx != None:
7413 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7414 
      self.utx.write(oprot)
7415 
      oprot.writeFieldEnd()
7416 
    oprot.writeFieldStop()
7417 
    oprot.writeStructEnd()
7418 
 
7419 
  def __repr__(self):
7420 
    L = ['%s=%r' % (key, value)
7421 
      for key, value in self.__dict__.iteritems()]
7422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7423 
 
7424 
  def __eq__(self, other):
7425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7426 
 
7427 
  def __ne__(self, other):
7428 
    return not (self == other)
7429 
 
7430 
class getAffiliateByName_args:
7431 
  """
7432 
  Attributes:
7433 
   - name
7434 
  """
7435 
 
7436 
  thrift_spec = (
7437 
    None, # 0
7438 
    (1, TType.STRING, 'name', None, None, ), # 1
7439 
  )
7440 
 
7441 
  def __init__(self, name=None,):
7442 
    self.name = name
7443 
 
7444 
  def read(self, iprot):
7445 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7446 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7447 
      return
7448 
    iprot.readStructBegin()
7449 
    while True:
7450 
      (fname, ftype, fid) = iprot.readFieldBegin()
7451 
      if ftype == TType.STOP:
7452 
        break
7453 
      if fid == 1:
7454 
        if ftype == TType.STRING:
7455 
          self.name = iprot.readString();
7456 
        else:
7457 
          iprot.skip(ftype)
7458 
      else:
7459 
        iprot.skip(ftype)
7460 
      iprot.readFieldEnd()
7461 
    iprot.readStructEnd()
7462 
 
7463 
  def write(self, oprot):
7464 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7465 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7466 
      return
7467 
    oprot.writeStructBegin('getAffiliateByName_args')
7468 
    if self.name != None:
7469 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7470 
      oprot.writeString(self.name)
7471 
      oprot.writeFieldEnd()
7472 
    oprot.writeFieldStop()
7473 
    oprot.writeStructEnd()
7474 
 
7475 
  def __repr__(self):
7476 
    L = ['%s=%r' % (key, value)
7477 
      for key, value in self.__dict__.iteritems()]
7478 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7479 
 
7480 
  def __eq__(self, other):
7481 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7482 
 
7483 
  def __ne__(self, other):
7484 
    return not (self == other)
7485 
 
7486 
class getAffiliateByName_result:
7487 
  """
7488 
  Attributes:
7489 
   - success
7490 
   - utx
7491 
  """
7492 
 
7493 
  thrift_spec = (
7494 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
7495 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7496 
  )
7497 
 
7498 
  def __init__(self, success=None, utx=None,):
7499 
    self.success = success
7500 
    self.utx = utx
7501 
 
7502 
  def read(self, iprot):
7503 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7504 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7505 
      return
7506 
    iprot.readStructBegin()
7507 
    while True:
7508 
      (fname, ftype, fid) = iprot.readFieldBegin()
7509 
      if ftype == TType.STOP:
7510 
        break
7511 
      if fid == 0:
7512 
        if ftype == TType.STRUCT:
7513 
          self.success = Affiliate()
7514 
          self.success.read(iprot)
7515 
        else:
7516 
          iprot.skip(ftype)
7517 
      elif fid == 1:
7518 
        if ftype == TType.STRUCT:
7519 
          self.utx = UserTrackerException()
7520 
          self.utx.read(iprot)
7521 
        else:
7522 
          iprot.skip(ftype)
7523 
      else:
7524 
        iprot.skip(ftype)
7525 
      iprot.readFieldEnd()
7526 
    iprot.readStructEnd()
7527 
 
7528 
  def write(self, oprot):
7529 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7530 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7531 
      return
7532 
    oprot.writeStructBegin('getAffiliateByName_result')
7533 
    if self.success != None:
7534 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7535 
      self.success.write(oprot)
7536 
      oprot.writeFieldEnd()
7537 
    if self.utx != None:
7538 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7539 
      self.utx.write(oprot)
7540 
      oprot.writeFieldEnd()
7541 
    oprot.writeFieldStop()
7542 
    oprot.writeStructEnd()
7543 
 
7544 
  def __repr__(self):
7545 
    L = ['%s=%r' % (key, value)
7546 
      for key, value in self.__dict__.iteritems()]
7547 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7548 
 
7549 
  def __eq__(self, other):
7550 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7551 
 
7552 
  def __ne__(self, other):
7553 
    return not (self == other)
7554 
 
7555 
class getAffiliatesByMasterAffiliate_args:
7556 
  """
7557 
  Attributes:
7558 
   - id
7559 
  """
7560 
 
7561 
  thrift_spec = (
7562 
    None, # 0
7563 
    (1, TType.I64, 'id', None, None, ), # 1
7564 
  )
7565 
 
7566 
  def __init__(self, id=None,):
7567 
    self.id = id
7568 
 
7569 
  def read(self, iprot):
7570 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7571 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7572 
      return
7573 
    iprot.readStructBegin()
7574 
    while True:
7575 
      (fname, ftype, fid) = iprot.readFieldBegin()
7576 
      if ftype == TType.STOP:
7577 
        break
7578 
      if fid == 1:
7579 
        if ftype == TType.I64:
7580 
          self.id = iprot.readI64();
7581 
        else:
7582 
          iprot.skip(ftype)
7583 
      else:
7584 
        iprot.skip(ftype)
7585 
      iprot.readFieldEnd()
7586 
    iprot.readStructEnd()
7587 
 
7588 
  def write(self, oprot):
7589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7591 
      return
7592 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
7593 
    if self.id != None:
7594 
      oprot.writeFieldBegin('id', TType.I64, 1)
7595 
      oprot.writeI64(self.id)
7596 
      oprot.writeFieldEnd()
7597 
    oprot.writeFieldStop()
7598 
    oprot.writeStructEnd()
7599 
 
7600 
  def __repr__(self):
7601 
    L = ['%s=%r' % (key, value)
7602 
      for key, value in self.__dict__.iteritems()]
7603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7604 
 
7605 
  def __eq__(self, other):
7606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7607 
 
7608 
  def __ne__(self, other):
7609 
    return not (self == other)
7610 
 
7611 
class getAffiliatesByMasterAffiliate_result:
7612 
  """
7613 
  Attributes:
7614 
   - success
7615 
   - utx
7616 
  """
7617 
 
7618 
  thrift_spec = (
7619 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
7620 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7621 
  )
7622 
 
7623 
  def __init__(self, success=None, utx=None,):
7624 
    self.success = success
7625 
    self.utx = utx
7626 
 
7627 
  def read(self, iprot):
7628 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7629 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7630 
      return
7631 
    iprot.readStructBegin()
7632 
    while True:
7633 
      (fname, ftype, fid) = iprot.readFieldBegin()
7634 
      if ftype == TType.STOP:
7635 
        break
7636 
      if fid == 0:
7637 
        if ftype == TType.LIST:
7638 
          self.success = []
7639 
          (_etype52, _size49) = iprot.readListBegin()
7640 
          for _i53 in xrange(_size49):
7641 
            _elem54 = Affiliate()
7642 
            _elem54.read(iprot)
7643 
            self.success.append(_elem54)
7644 
          iprot.readListEnd()
7645 
        else:
7646 
          iprot.skip(ftype)
7647 
      elif fid == 1:
7648 
        if ftype == TType.STRUCT:
7649 
          self.utx = UserTrackerException()
7650 
          self.utx.read(iprot)
7651 
        else:
7652 
          iprot.skip(ftype)
7653 
      else:
7654 
        iprot.skip(ftype)
7655 
      iprot.readFieldEnd()
7656 
    iprot.readStructEnd()
7657 
 
7658 
  def write(self, oprot):
7659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7661 
      return
7662 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
7663 
    if self.success != None:
7664 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7665 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7666 
      for iter55 in self.success:
7667 
        iter55.write(oprot)
7668 
      oprot.writeListEnd()
7669 
      oprot.writeFieldEnd()
7670 
    if self.utx != None:
7671 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7672 
      self.utx.write(oprot)
7673 
      oprot.writeFieldEnd()
7674 
    oprot.writeFieldStop()
7675 
    oprot.writeStructEnd()
7676 
 
7677 
  def __repr__(self):
7678 
    L = ['%s=%r' % (key, value)
7679 
      for key, value in self.__dict__.iteritems()]
7680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7681 
 
7682 
  def __eq__(self, other):
7683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7684 
 
7685 
  def __ne__(self, other):
7686 
    return not (self == other)
7687 
 
7688 
class createTracker_args:
7689 
  """
7690 
  Attributes:
7691 
   - affiliateId
7692 
  """
7693 
 
7694 
  thrift_spec = (
7695 
    None, # 0
7696 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
7697 
  )
7698 
 
7699 
  def __init__(self, affiliateId=None,):
7700 
    self.affiliateId = affiliateId
7701 
 
7702 
  def read(self, iprot):
7703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7705 
      return
7706 
    iprot.readStructBegin()
7707 
    while True:
7708 
      (fname, ftype, fid) = iprot.readFieldBegin()
7709 
      if ftype == TType.STOP:
7710 
        break
7711 
      if fid == 1:
7712 
        if ftype == TType.I64:
7713 
          self.affiliateId = iprot.readI64();
7714 
        else:
7715 
          iprot.skip(ftype)
7716 
      else:
7717 
        iprot.skip(ftype)
7718 
      iprot.readFieldEnd()
7719 
    iprot.readStructEnd()
7720 
 
7721 
  def write(self, oprot):
7722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7724 
      return
7725 
    oprot.writeStructBegin('createTracker_args')
7726 
    if self.affiliateId != None:
7727 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
7728 
      oprot.writeI64(self.affiliateId)
7729 
      oprot.writeFieldEnd()
7730 
    oprot.writeFieldStop()
7731 
    oprot.writeStructEnd()
7732 
 
7733 
  def __repr__(self):
7734 
    L = ['%s=%r' % (key, value)
7735 
      for key, value in self.__dict__.iteritems()]
7736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7737 
 
7738 
  def __eq__(self, other):
7739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7740 
 
7741 
  def __ne__(self, other):
7742 
    return not (self == other)
7743 
 
7744 
class createTracker_result:
7745 
  """
7746 
  Attributes:
7747 
   - success
7748 
   - utx
7749 
  """
7750 
 
7751 
  thrift_spec = (
7752 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
7753 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7754 
  )
7755 
 
7756 
  def __init__(self, success=None, utx=None,):
7757 
    self.success = success
7758 
    self.utx = utx
7759 
 
7760 
  def read(self, iprot):
7761 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7762 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7763 
      return
7764 
    iprot.readStructBegin()
7765 
    while True:
7766 
      (fname, ftype, fid) = iprot.readFieldBegin()
7767 
      if ftype == TType.STOP:
7768 
        break
7769 
      if fid == 0:
7770 
        if ftype == TType.STRUCT:
7771 
          self.success = Tracker()
7772 
          self.success.read(iprot)
7773 
        else:
7774 
          iprot.skip(ftype)
7775 
      elif fid == 1:
7776 
        if ftype == TType.STRUCT:
7777 
          self.utx = UserTrackerException()
7778 
          self.utx.read(iprot)
7779 
        else:
7780 
          iprot.skip(ftype)
7781 
      else:
7782 
        iprot.skip(ftype)
7783 
      iprot.readFieldEnd()
7784 
    iprot.readStructEnd()
7785 
 
7786 
  def write(self, oprot):
7787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7789 
      return
7790 
    oprot.writeStructBegin('createTracker_result')
7791 
    if self.success != None:
7792 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7793 
      self.success.write(oprot)
7794 
      oprot.writeFieldEnd()
7795 
    if self.utx != None:
7796 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7797 
      self.utx.write(oprot)
7798 
      oprot.writeFieldEnd()
7799 
    oprot.writeFieldStop()
7800 
    oprot.writeStructEnd()
7801 
 
7802 
  def __repr__(self):
7803 
    L = ['%s=%r' % (key, value)
7804 
      for key, value in self.__dict__.iteritems()]
7805 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7806 
 
7807 
  def __eq__(self, other):
7808 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7809 
 
7810 
  def __ne__(self, other):
7811 
    return not (self == other)
7812 
 
7813 
class getTrackerById_args:
7814 
  """
7815 
  Attributes:
7816 
   - trackerId
7817 
  """
7818 
 
7819 
  thrift_spec = (
7820 
    None, # 0
7821 
    (1, TType.I64, 'trackerId', None, None, ), # 1
7822 
  )
7823 
 
7824 
  def __init__(self, trackerId=None,):
7825 
    self.trackerId = trackerId
7826 
 
7827 
  def read(self, iprot):
7828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7830 
      return
7831 
    iprot.readStructBegin()
7832 
    while True:
7833 
      (fname, ftype, fid) = iprot.readFieldBegin()
7834 
      if ftype == TType.STOP:
7835 
        break
7836 
      if fid == 1:
7837 
        if ftype == TType.I64:
7838 
          self.trackerId = iprot.readI64();
7839 
        else:
7840 
          iprot.skip(ftype)
7841 
      else:
7842 
        iprot.skip(ftype)
7843 
      iprot.readFieldEnd()
7844 
    iprot.readStructEnd()
7845 
 
7846 
  def write(self, oprot):
7847 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7848 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7849 
      return
7850 
    oprot.writeStructBegin('getTrackerById_args')
7851 
    if self.trackerId != None:
7852 
      oprot.writeFieldBegin('trackerId', TType.I64, 1)
7853 
      oprot.writeI64(self.trackerId)
7854 
      oprot.writeFieldEnd()
7855 
    oprot.writeFieldStop()
7856 
    oprot.writeStructEnd()
7857 
 
7858 
  def __repr__(self):
7859 
    L = ['%s=%r' % (key, value)
7860 
      for key, value in self.__dict__.iteritems()]
7861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7862 
 
7863 
  def __eq__(self, other):
7864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7865 
 
7866 
  def __ne__(self, other):
7867 
    return not (self == other)
7868 
 
7869 
class getTrackerById_result:
7870 
  """
7871 
  Attributes:
7872 
   - success
7873 
   - utx
7874 
  """
7875 
 
7876 
  thrift_spec = (
7877 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
7878 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7879 
  )
7880 
 
7881 
  def __init__(self, success=None, utx=None,):
7882 
    self.success = success
7883 
    self.utx = utx
7884 
 
7885 
  def read(self, iprot):
7886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7888 
      return
7889 
    iprot.readStructBegin()
7890 
    while True:
7891 
      (fname, ftype, fid) = iprot.readFieldBegin()
7892 
      if ftype == TType.STOP:
7893 
        break
7894 
      if fid == 0:
7895 
        if ftype == TType.STRUCT:
7896 
          self.success = Tracker()
7897 
          self.success.read(iprot)
7898 
        else:
7899 
          iprot.skip(ftype)
7900 
      elif fid == 1:
7901 
        if ftype == TType.STRUCT:
7902 
          self.utx = UserTrackerException()
7903 
          self.utx.read(iprot)
7904 
        else:
7905 
          iprot.skip(ftype)
7906 
      else:
7907 
        iprot.skip(ftype)
7908 
      iprot.readFieldEnd()
7909 
    iprot.readStructEnd()
7910 
 
7911 
  def write(self, oprot):
7912 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7913 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7914 
      return
7915 
    oprot.writeStructBegin('getTrackerById_result')
7916 
    if self.success != None:
7917 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7918 
      self.success.write(oprot)
7919 
      oprot.writeFieldEnd()
7920 
    if self.utx != None:
7921 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7922 
      self.utx.write(oprot)
7923 
      oprot.writeFieldEnd()
7924 
    oprot.writeFieldStop()
7925 
    oprot.writeStructEnd()
7926 
 
7927 
  def __repr__(self):
7928 
    L = ['%s=%r' % (key, value)
7929 
      for key, value in self.__dict__.iteritems()]
7930 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7931 
 
7932 
  def __eq__(self, other):
7933 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7934 
 
7935 
  def __ne__(self, other):
7936 
    return not (self == other)
7937 
 
7938 
class getTrackersByAffiliate_args:
7939 
  """
7940 
  Attributes:
7941 
   - affiliateId
7942 
  """
7943 
 
7944 
  thrift_spec = (
7945 
    None, # 0
7946 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
7947 
  )
7948 
 
7949 
  def __init__(self, affiliateId=None,):
7950 
    self.affiliateId = affiliateId
7951 
 
7952 
  def read(self, iprot):
7953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7955 
      return
7956 
    iprot.readStructBegin()
7957 
    while True:
7958 
      (fname, ftype, fid) = iprot.readFieldBegin()
7959 
      if ftype == TType.STOP:
7960 
        break
7961 
      if fid == 1:
7962 
        if ftype == TType.I64:
7963 
          self.affiliateId = iprot.readI64();
7964 
        else:
7965 
          iprot.skip(ftype)
7966 
      else:
7967 
        iprot.skip(ftype)
7968 
      iprot.readFieldEnd()
7969 
    iprot.readStructEnd()
7970 
 
7971 
  def write(self, oprot):
7972 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7973 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7974 
      return
7975 
    oprot.writeStructBegin('getTrackersByAffiliate_args')
7976 
    if self.affiliateId != None:
7977 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
7978 
      oprot.writeI64(self.affiliateId)
7979 
      oprot.writeFieldEnd()
7980 
    oprot.writeFieldStop()
7981 
    oprot.writeStructEnd()
7982 
 
7983 
  def __repr__(self):
7984 
    L = ['%s=%r' % (key, value)
7985 
      for key, value in self.__dict__.iteritems()]
7986 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7987 
 
7988 
  def __eq__(self, other):
7989 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7990 
 
7991 
  def __ne__(self, other):
7992 
    return not (self == other)
7993 
 
7994 
class getTrackersByAffiliate_result:
7995 
  """
7996 
  Attributes:
7997 
   - success
7998 
   - utx
7999 
  """
8000 
 
8001 
  thrift_spec = (
8002 
    (0, TType.LIST, 'success', (TType.STRUCT,(Tracker, Tracker.thrift_spec)), None, ), # 0
8003 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8004 
  )
8005 
 
8006 
  def __init__(self, success=None, utx=None,):
8007 
    self.success = success
8008 
    self.utx = utx
8009 
 
8010 
  def read(self, iprot):
8011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8013 
      return
8014 
    iprot.readStructBegin()
8015 
    while True:
8016 
      (fname, ftype, fid) = iprot.readFieldBegin()
8017 
      if ftype == TType.STOP:
8018 
        break
8019 
      if fid == 0:
8020 
        if ftype == TType.LIST:
8021 
          self.success = []
8022 
          (_etype59, _size56) = iprot.readListBegin()
8023 
          for _i60 in xrange(_size56):
8024 
            _elem61 = Tracker()
8025 
            _elem61.read(iprot)
8026 
            self.success.append(_elem61)
8027 
          iprot.readListEnd()
8028 
        else:
8029 
          iprot.skip(ftype)
8030 
      elif fid == 1:
8031 
        if ftype == TType.STRUCT:
8032 
          self.utx = UserTrackerException()
8033 
          self.utx.read(iprot)
8034 
        else:
8035 
          iprot.skip(ftype)
8036 
      else:
8037 
        iprot.skip(ftype)
8038 
      iprot.readFieldEnd()
8039 
    iprot.readStructEnd()
8040 
 
8041 
  def write(self, oprot):
8042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8044 
      return
8045 
    oprot.writeStructBegin('getTrackersByAffiliate_result')
8046 
    if self.success != None:
8047 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8048 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8049 
      for iter62 in self.success:
8050 
        iter62.write(oprot)
8051 
      oprot.writeListEnd()
8052 
      oprot.writeFieldEnd()
8053 
    if self.utx != None:
8054 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8055 
      self.utx.write(oprot)
8056 
      oprot.writeFieldEnd()
8057 
    oprot.writeFieldStop()
8058 
    oprot.writeStructEnd()
8059 
 
8060 
  def __repr__(self):
8061 
    L = ['%s=%r' % (key, value)
8062 
      for key, value in self.__dict__.iteritems()]
8063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8064 
 
8065 
  def __eq__(self, other):
8066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8067 
 
8068 
  def __ne__(self, other):
8069 
    return not (self == other)
8070 
 
8071 
class addTrackLog_args:
8072 
  """
8073 
  Attributes:
8074 
   - trackerId
8075 
   - userId
8076 
   - event
8077 
   - url
8078 
   - data
8079 
  """
8080 
 
8081 
  thrift_spec = (
8082 
    None, # 0
8083 
    (1, TType.I64, 'trackerId', None, None, ), # 1
8084 
    (2, TType.I64, 'userId', None, None, ), # 2
8085 
    (3, TType.STRING, 'event', None, None, ), # 3
8086 
    (4, TType.STRING, 'url', None, None, ), # 4
8087 
    (5, TType.STRING, 'data', None, None, ), # 5
8088 
  )
8089 
 
8090 
  def __init__(self, trackerId=None, userId=None, event=None, url=None, data=None,):
8091 
    self.trackerId = trackerId
8092 
    self.userId = userId
8093 
    self.event = event
8094 
    self.url = url
8095 
    self.data = data
8096 
 
8097 
  def read(self, iprot):
8098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8100 
      return
8101 
    iprot.readStructBegin()
8102 
    while True:
8103 
      (fname, ftype, fid) = iprot.readFieldBegin()
8104 
      if ftype == TType.STOP:
8105 
        break
8106 
      if fid == 1:
8107 
        if ftype == TType.I64:
8108 
          self.trackerId = iprot.readI64();
8109 
        else:
8110 
          iprot.skip(ftype)
8111 
      elif fid == 2:
8112 
        if ftype == TType.I64:
8113 
          self.userId = iprot.readI64();
8114 
        else:
8115 
          iprot.skip(ftype)
8116 
      elif fid == 3:
8117 
        if ftype == TType.STRING:
8118 
          self.event = iprot.readString();
8119 
        else:
8120 
          iprot.skip(ftype)
8121 
      elif fid == 4:
8122 
        if ftype == TType.STRING:
8123 
          self.url = iprot.readString();
8124 
        else:
8125 
          iprot.skip(ftype)
8126 
      elif fid == 5:
8127 
        if ftype == TType.STRING:
8128 
          self.data = iprot.readString();
8129 
        else:
8130 
          iprot.skip(ftype)
8131 
      else:
8132 
        iprot.skip(ftype)
8133 
      iprot.readFieldEnd()
8134 
    iprot.readStructEnd()
8135 
 
8136 
  def write(self, oprot):
8137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8139 
      return
8140 
    oprot.writeStructBegin('addTrackLog_args')
8141 
    if self.trackerId != None:
8142 
      oprot.writeFieldBegin('trackerId', TType.I64, 1)
8143 
      oprot.writeI64(self.trackerId)
8144 
      oprot.writeFieldEnd()
8145 
    if self.userId != None:
8146 
      oprot.writeFieldBegin('userId', TType.I64, 2)
8147 
      oprot.writeI64(self.userId)
8148 
      oprot.writeFieldEnd()
8149 
    if self.event != None:
8150 
      oprot.writeFieldBegin('event', TType.STRING, 3)
8151 
      oprot.writeString(self.event)
8152 
      oprot.writeFieldEnd()
8153 
    if self.url != None:
8154 
      oprot.writeFieldBegin('url', TType.STRING, 4)
8155 
      oprot.writeString(self.url)
8156 
      oprot.writeFieldEnd()
8157 
    if self.data != None:
8158 
      oprot.writeFieldBegin('data', TType.STRING, 5)
8159 
      oprot.writeString(self.data)
8160 
      oprot.writeFieldEnd()
8161 
    oprot.writeFieldStop()
8162 
    oprot.writeStructEnd()
8163 
 
8164 
  def __repr__(self):
8165 
    L = ['%s=%r' % (key, value)
8166 
      for key, value in self.__dict__.iteritems()]
8167 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8168 
 
8169 
  def __eq__(self, other):
8170 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8171 
 
8172 
  def __ne__(self, other):
8173 
    return not (self == other)
8174 
 
8175 
class addTrackLog_result:
8176 
  """
8177 
  Attributes:
8178 
   - success
8179 
   - utx
8180 
  """
8181 
 
8182 
  thrift_spec = (
8183 
    (0, TType.I64, 'success', None, None, ), # 0
8184 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8185 
  )
8186 
 
8187 
  def __init__(self, success=None, utx=None,):
8188 
    self.success = success
8189 
    self.utx = utx
8190 
 
8191 
  def read(self, iprot):
8192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8194 
      return
8195 
    iprot.readStructBegin()
8196 
    while True:
8197 
      (fname, ftype, fid) = iprot.readFieldBegin()
8198 
      if ftype == TType.STOP:
8199 
        break
8200 
      if fid == 0:
8201 
        if ftype == TType.I64:
8202 
          self.success = iprot.readI64();
8203 
        else:
8204 
          iprot.skip(ftype)
8205 
      elif fid == 1:
8206 
        if ftype == TType.STRUCT:
8207 
          self.utx = UserTrackerException()
8208 
          self.utx.read(iprot)
8209 
        else:
8210 
          iprot.skip(ftype)
8211 
      else:
8212 
        iprot.skip(ftype)
8213 
      iprot.readFieldEnd()
8214 
    iprot.readStructEnd()
8215 
 
8216 
  def write(self, oprot):
8217 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8218 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8219 
      return
8220 
    oprot.writeStructBegin('addTrackLog_result')
8221 
    if self.success != None:
8222 
      oprot.writeFieldBegin('success', TType.I64, 0)
8223 
      oprot.writeI64(self.success)
8224 
      oprot.writeFieldEnd()
8225 
    if self.utx != None:
8226 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8227 
      self.utx.write(oprot)
8228 
      oprot.writeFieldEnd()
8229 
    oprot.writeFieldStop()
8230 
    oprot.writeStructEnd()
8231 
 
8232 
  def __repr__(self):
8233 
    L = ['%s=%r' % (key, value)
8234 
      for key, value in self.__dict__.iteritems()]
8235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8236 
 
8237 
  def __eq__(self, other):
8238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8239 
 
8240 
  def __ne__(self, other):
8241 
    return not (self == other)
8242 
 
8243 
class getTrackLogById_args:
8244 
  """
8245 
  Attributes:
8246 
   - id
8247 
  """
8248 
 
8249 
  thrift_spec = (
8250 
    None, # 0
8251 
    (1, TType.I64, 'id', None, None, ), # 1
8252 
  )
8253 
 
8254 
  def __init__(self, id=None,):
8255 
    self.id = id
8256 
 
8257 
  def read(self, iprot):
8258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8260 
      return
8261 
    iprot.readStructBegin()
8262 
    while True:
8263 
      (fname, ftype, fid) = iprot.readFieldBegin()
8264 
      if ftype == TType.STOP:
8265 
        break
8266 
      if fid == 1:
8267 
        if ftype == TType.I64:
8268 
          self.id = iprot.readI64();
8269 
        else:
8270 
          iprot.skip(ftype)
8271 
      else:
8272 
        iprot.skip(ftype)
8273 
      iprot.readFieldEnd()
8274 
    iprot.readStructEnd()
8275 
 
8276 
  def write(self, oprot):
8277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8279 
      return
8280 
    oprot.writeStructBegin('getTrackLogById_args')
8281 
    if self.id != None:
8282 
      oprot.writeFieldBegin('id', TType.I64, 1)
8283 
      oprot.writeI64(self.id)
8284 
      oprot.writeFieldEnd()
8285 
    oprot.writeFieldStop()
8286 
    oprot.writeStructEnd()
8287 
 
8288 
  def __repr__(self):
8289 
    L = ['%s=%r' % (key, value)
8290 
      for key, value in self.__dict__.iteritems()]
8291 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8292 
 
8293 
  def __eq__(self, other):
8294 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8295 
 
8296 
  def __ne__(self, other):
8297 
    return not (self == other)
8298 
 
8299 
class getTrackLogById_result:
8300 
  """
8301 
  Attributes:
8302 
   - success
8303 
   - utx
8304 
  """
8305 
 
8306 
  thrift_spec = (
8307 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
8308 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8309 
  )
8310 
 
8311 
  def __init__(self, success=None, utx=None,):
8312 
    self.success = success
8313 
    self.utx = utx
8314 
 
8315 
  def read(self, iprot):
8316 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8317 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8318 
      return
8319 
    iprot.readStructBegin()
8320 
    while True:
8321 
      (fname, ftype, fid) = iprot.readFieldBegin()
8322 
      if ftype == TType.STOP:
8323 
        break
8324 
      if fid == 0:
8325 
        if ftype == TType.STRUCT:
8326 
          self.success = TrackLog()
8327 
          self.success.read(iprot)
8328 
        else:
8329 
          iprot.skip(ftype)
8330 
      elif fid == 1:
8331 
        if ftype == TType.STRUCT:
8332 
          self.utx = UserTrackerException()
8333 
          self.utx.read(iprot)
8334 
        else:
8335 
          iprot.skip(ftype)
8336 
      else:
8337 
        iprot.skip(ftype)
8338 
      iprot.readFieldEnd()
8339 
    iprot.readStructEnd()
8340 
 
8341 
  def write(self, oprot):
8342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8344 
      return
8345 
    oprot.writeStructBegin('getTrackLogById_result')
8346 
    if self.success != None:
8347 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8348 
      self.success.write(oprot)
8349 
      oprot.writeFieldEnd()
8350 
    if self.utx != None:
8351 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8352 
      self.utx.write(oprot)
8353 
      oprot.writeFieldEnd()
8354 
    oprot.writeFieldStop()
8355 
    oprot.writeStructEnd()
8356 
 
8357 
  def __repr__(self):
8358 
    L = ['%s=%r' % (key, value)
8359 
      for key, value in self.__dict__.iteritems()]
8360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8361 
 
8362 
  def __eq__(self, other):
8363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8364 
 
8365 
  def __ne__(self, other):
8366 
    return not (self == other)
8367 
 
8368 
class getTrackLogsByTracker_args:
8369 
  """
8370 
  Attributes:
8371 
   - trackerId
8372 
  """
8373 
 
8374 
  thrift_spec = (
8375 
    None, # 0
8376 
    (1, TType.I64, 'trackerId', None, None, ), # 1
8377 
  )
8378 
 
8379 
  def __init__(self, trackerId=None,):
8380 
    self.trackerId = trackerId
8381 
 
8382 
  def read(self, iprot):
8383 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8384 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8385 
      return
8386 
    iprot.readStructBegin()
8387 
    while True:
8388 
      (fname, ftype, fid) = iprot.readFieldBegin()
8389 
      if ftype == TType.STOP:
8390 
        break
8391 
      if fid == 1:
8392 
        if ftype == TType.I64:
8393 
          self.trackerId = iprot.readI64();
8394 
        else:
8395 
          iprot.skip(ftype)
8396 
      else:
8397 
        iprot.skip(ftype)
8398 
      iprot.readFieldEnd()
8399 
    iprot.readStructEnd()
8400 
 
8401 
  def write(self, oprot):
8402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8404 
      return
8405 
    oprot.writeStructBegin('getTrackLogsByTracker_args')
8406 
    if self.trackerId != None:
8407 
      oprot.writeFieldBegin('trackerId', TType.I64, 1)
8408 
      oprot.writeI64(self.trackerId)
8409 
      oprot.writeFieldEnd()
8410 
    oprot.writeFieldStop()
8411 
    oprot.writeStructEnd()
8412 
 
8413 
  def __repr__(self):
8414 
    L = ['%s=%r' % (key, value)
8415 
      for key, value in self.__dict__.iteritems()]
8416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8417 
 
8418 
  def __eq__(self, other):
8419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8420 
 
8421 
  def __ne__(self, other):
8422 
    return not (self == other)
8423 
 
8424 
class getTrackLogsByTracker_result:
8425 
  """
8426 
  Attributes:
8427 
   - success
8428 
   - utx
8429 
  """
8430 
 
8431 
  thrift_spec = (
8432 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
8433 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8434 
  )
8435 
 
8436 
  def __init__(self, success=None, utx=None,):
8437 
    self.success = success
8438 
    self.utx = utx
8439 
 
8440 
  def read(self, iprot):
8441 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8442 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8443 
      return
8444 
    iprot.readStructBegin()
8445 
    while True:
8446 
      (fname, ftype, fid) = iprot.readFieldBegin()
8447 
      if ftype == TType.STOP:
8448 
        break
8449 
      if fid == 0:
8450 
        if ftype == TType.LIST:
8451 
          self.success = []
8452 
          (_etype66, _size63) = iprot.readListBegin()
8453 
          for _i67 in xrange(_size63):
8454 
            _elem68 = TrackLog()
8455 
            _elem68.read(iprot)
8456 
            self.success.append(_elem68)
8457 
          iprot.readListEnd()
8458 
        else:
8459 
          iprot.skip(ftype)
8460 
      elif fid == 1:
8461 
        if ftype == TType.STRUCT:
8462 
          self.utx = UserTrackerException()
8463 
          self.utx.read(iprot)
8464 
        else:
8465 
          iprot.skip(ftype)
8466 
      else:
8467 
        iprot.skip(ftype)
8468 
      iprot.readFieldEnd()
8469 
    iprot.readStructEnd()
8470 
 
8471 
  def write(self, oprot):
8472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8474 
      return
8475 
    oprot.writeStructBegin('getTrackLogsByTracker_result')
8476 
    if self.success != None:
8477 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8478 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8479 
      for iter69 in self.success:
8480 
        iter69.write(oprot)
8481 
      oprot.writeListEnd()
8482 
      oprot.writeFieldEnd()
8483 
    if self.utx != None:
8484 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8485 
      self.utx.write(oprot)
8486 
      oprot.writeFieldEnd()
8487 
    oprot.writeFieldStop()
8488 
    oprot.writeStructEnd()
8489 
 
8490 
  def __repr__(self):
8491 
    L = ['%s=%r' % (key, value)
8492 
      for key, value in self.__dict__.iteritems()]
8493 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8494 
 
8495 
  def __eq__(self, other):
8496 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8497 
 
8498 
  def __ne__(self, other):
8499 
    return not (self == other)
8500 
 
8501 
class getTrackLogsByUser_args:
8502 
  """
8503 
  Attributes:
8504 
   - userId
8505 
  """
8506 
 
8507 
  thrift_spec = (
8508 
    None, # 0
8509 
    (1, TType.I64, 'userId', None, None, ), # 1
8510 
  )
8511 
 
8512 
  def __init__(self, userId=None,):
8513 
    self.userId = userId
8514 
 
8515 
  def read(self, iprot):
8516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8518 
      return
8519 
    iprot.readStructBegin()
8520 
    while True:
8521 
      (fname, ftype, fid) = iprot.readFieldBegin()
8522 
      if ftype == TType.STOP:
8523 
        break
8524 
      if fid == 1:
8525 
        if ftype == TType.I64:
8526 
          self.userId = iprot.readI64();
8527 
        else:
8528 
          iprot.skip(ftype)
8529 
      else:
8530 
        iprot.skip(ftype)
8531 
      iprot.readFieldEnd()
8532 
    iprot.readStructEnd()
8533 
 
8534 
  def write(self, oprot):
8535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8537 
      return
8538 
    oprot.writeStructBegin('getTrackLogsByUser_args')
8539 
    if self.userId != None:
8540 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8541 
      oprot.writeI64(self.userId)
8542 
      oprot.writeFieldEnd()
8543 
    oprot.writeFieldStop()
8544 
    oprot.writeStructEnd()
8545 
 
8546 
  def __repr__(self):
8547 
    L = ['%s=%r' % (key, value)
8548 
      for key, value in self.__dict__.iteritems()]
8549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8550 
 
8551 
  def __eq__(self, other):
8552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8553 
 
8554 
  def __ne__(self, other):
8555 
    return not (self == other)
8556 
 
8557 
class getTrackLogsByUser_result:
8558 
  """
8559 
  Attributes:
8560 
   - success
8561 
   - utx
8562 
  """
8563 
 
8564 
  thrift_spec = (
8565 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
8566 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8567 
  )
8568 
 
8569 
  def __init__(self, success=None, utx=None,):
8570 
    self.success = success
8571 
    self.utx = utx
8572 
 
8573 
  def read(self, iprot):
8574 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8575 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8576 
      return
8577 
    iprot.readStructBegin()
8578 
    while True:
8579 
      (fname, ftype, fid) = iprot.readFieldBegin()
8580 
      if ftype == TType.STOP:
8581 
        break
8582 
      if fid == 0:
8583 
        if ftype == TType.LIST:
8584 
          self.success = []
8585 
          (_etype73, _size70) = iprot.readListBegin()
8586 
          for _i74 in xrange(_size70):
8587 
            _elem75 = TrackLog()
8588 
            _elem75.read(iprot)
8589 
            self.success.append(_elem75)
8590 
          iprot.readListEnd()
8591 
        else:
8592 
          iprot.skip(ftype)
8593 
      elif fid == 1:
8594 
        if ftype == TType.STRUCT:
8595 
          self.utx = UserTrackerException()
8596 
          self.utx.read(iprot)
8597 
        else:
8598 
          iprot.skip(ftype)
8599 
      else:
8600 
        iprot.skip(ftype)
8601 
      iprot.readFieldEnd()
8602 
    iprot.readStructEnd()
8603 
 
8604 
  def write(self, oprot):
8605 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8606 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8607 
      return
8608 
    oprot.writeStructBegin('getTrackLogsByUser_result')
8609 
    if self.success != None:
8610 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8611 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8612 
      for iter76 in self.success:
8613 
        iter76.write(oprot)
8614 
      oprot.writeListEnd()
8615 
      oprot.writeFieldEnd()
8616 
    if self.utx != None:
8617 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8618 
      self.utx.write(oprot)
8619 
      oprot.writeFieldEnd()
8620 
    oprot.writeFieldStop()
8621 
    oprot.writeStructEnd()
8622 
 
8623 
  def __repr__(self):
8624 
    L = ['%s=%r' % (key, value)
8625 
      for key, value in self.__dict__.iteritems()]
8626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8627 
 
8628 
  def __eq__(self, other):
8629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8630 
 
8631 
  def __ne__(self, other):
8632 
    return not (self == other)
8633 
 
8634 
class getTrackLogs_args:
8635 
  """
8636 
  Attributes:
8637 
   - trackerId
8638 
   - userId
8639 
   - event
8640 
   - url
8641 
  """
8642 
 
8643 
  thrift_spec = (
8644 
    None, # 0
8645 
    (1, TType.I64, 'trackerId', None, None, ), # 1
8646 
    (2, TType.I64, 'userId', None, None, ), # 2
8647 
    (3, TType.STRING, 'event', None, None, ), # 3
8648 
    (4, TType.STRING, 'url', None, None, ), # 4
8649 
  )
8650 
 
8651 
  def __init__(self, trackerId=None, userId=None, event=None, url=None,):
8652 
    self.trackerId = trackerId
8653 
    self.userId = userId
8654 
    self.event = event
8655 
    self.url = url
8656 
 
8657 
  def read(self, iprot):
8658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8660 
      return
8661 
    iprot.readStructBegin()
8662 
    while True:
8663 
      (fname, ftype, fid) = iprot.readFieldBegin()
8664 
      if ftype == TType.STOP:
8665 
        break
8666 
      if fid == 1:
8667 
        if ftype == TType.I64:
8668 
          self.trackerId = iprot.readI64();
8669 
        else:
8670 
          iprot.skip(ftype)
8671 
      elif fid == 2:
8672 
        if ftype == TType.I64:
8673 
          self.userId = iprot.readI64();
8674 
        else:
8675 
          iprot.skip(ftype)
8676 
      elif fid == 3:
8677 
        if ftype == TType.STRING:
8678 
          self.event = iprot.readString();
8679 
        else:
8680 
          iprot.skip(ftype)
8681 
      elif fid == 4:
8682 
        if ftype == TType.STRING:
8683 
          self.url = iprot.readString();
8684 
        else:
8685 
          iprot.skip(ftype)
8686 
      else:
8687 
        iprot.skip(ftype)
8688 
      iprot.readFieldEnd()
8689 
    iprot.readStructEnd()
8690 
 
8691 
  def write(self, oprot):
8692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8694 
      return
8695 
    oprot.writeStructBegin('getTrackLogs_args')
8696 
    if self.trackerId != None:
8697 
      oprot.writeFieldBegin('trackerId', TType.I64, 1)
8698 
      oprot.writeI64(self.trackerId)
8699 
      oprot.writeFieldEnd()
8700 
    if self.userId != None:
8701 
      oprot.writeFieldBegin('userId', TType.I64, 2)
8702 
      oprot.writeI64(self.userId)
8703 
      oprot.writeFieldEnd()
8704 
    if self.event != None:
8705 
      oprot.writeFieldBegin('event', TType.STRING, 3)
8706 
      oprot.writeString(self.event)
8707 
      oprot.writeFieldEnd()
8708 
    if self.url != None:
8709 
      oprot.writeFieldBegin('url', TType.STRING, 4)
8710 
      oprot.writeString(self.url)
8711 
      oprot.writeFieldEnd()
8712 
    oprot.writeFieldStop()
8713 
    oprot.writeStructEnd()
8714 
 
8715 
  def __repr__(self):
8716 
    L = ['%s=%r' % (key, value)
8717 
      for key, value in self.__dict__.iteritems()]
8718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8719 
 
8720 
  def __eq__(self, other):
8721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8722 
 
8723 
  def __ne__(self, other):
8724 
    return not (self == other)
8725 
 
8726 
class getTrackLogs_result:
8727 
  """
8728 
  Attributes:
8729 
   - success
8730 
   - utx
8731 
  """
8732 
 
8733 
  thrift_spec = (
8734 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
8735 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8736 
  )
8737 
 
8738 
  def __init__(self, success=None, utx=None,):
8739 
    self.success = success
8740 
    self.utx = utx
8741 
 
8742 
  def read(self, iprot):
8743 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8744 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8745 
      return
8746 
    iprot.readStructBegin()
8747 
    while True:
8748 
      (fname, ftype, fid) = iprot.readFieldBegin()
8749 
      if ftype == TType.STOP:
8750 
        break
8751 
      if fid == 0:
8752 
        if ftype == TType.LIST:
8753 
          self.success = []
8754 
          (_etype80, _size77) = iprot.readListBegin()
8755 
          for _i81 in xrange(_size77):
8756 
            _elem82 = TrackLog()
8757 
            _elem82.read(iprot)
8758 
            self.success.append(_elem82)
8759 
          iprot.readListEnd()
8760 
        else:
8761 
          iprot.skip(ftype)
8762 
      elif fid == 1:
8763 
        if ftype == TType.STRUCT:
8764 
          self.utx = UserTrackerException()
8765 
          self.utx.read(iprot)
8766 
        else:
8767 
          iprot.skip(ftype)
8768 
      else:
8769 
        iprot.skip(ftype)
8770 
      iprot.readFieldEnd()
8771 
    iprot.readStructEnd()
8772 
 
8773 
  def write(self, oprot):
8774 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8775 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8776 
      return
8777 
    oprot.writeStructBegin('getTrackLogs_result')
8778 
    if self.success != None:
8779 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8780 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8781 
      for iter83 in self.success:
8782 
        iter83.write(oprot)
8783 
      oprot.writeListEnd()
8784 
      oprot.writeFieldEnd()
8785 
    if self.utx != None:
8786 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8787 
      self.utx.write(oprot)
8788 
      oprot.writeFieldEnd()
8789 
    oprot.writeFieldStop()
8790 
    oprot.writeStructEnd()
8791 
 
8792 
  def __repr__(self):
8793 
    L = ['%s=%r' % (key, value)
8794 
      for key, value in self.__dict__.iteritems()]
8795 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8796 
 
8797 
  def __eq__(self, other):
8798 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8799 
 
8800 
  def __ne__(self, other):
8801 
    return not (self == other)
8802 
 
559 chandransh 8803 
class createCart_args:
94 ashish 8804 
  """
8805 
  Attributes:
559 chandransh 8806 
   - userId
94 ashish 8807 
  """
8808 
 
8809 
  thrift_spec = (
8810 
    None, # 0
559 chandransh 8811 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 8812 
  )
8813 
 
559 chandransh 8814 
  def __init__(self, userId=None,):
8815 
    self.userId = userId
94 ashish 8816 
 
8817 
  def read(self, iprot):
8818 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8819 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8820 
      return
8821 
    iprot.readStructBegin()
8822 
    while True:
8823 
      (fname, ftype, fid) = iprot.readFieldBegin()
8824 
      if ftype == TType.STOP:
8825 
        break
8826 
      if fid == 1:
8827 
        if ftype == TType.I64:
559 chandransh 8828 
          self.userId = iprot.readI64();
94 ashish 8829 
        else:
8830 
          iprot.skip(ftype)
559 chandransh 8831 
      else:
8832 
        iprot.skip(ftype)
8833 
      iprot.readFieldEnd()
8834 
    iprot.readStructEnd()
8835 
 
8836 
  def write(self, oprot):
8837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8839 
      return
8840 
    oprot.writeStructBegin('createCart_args')
8841 
    if self.userId != None:
8842 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8843 
      oprot.writeI64(self.userId)
8844 
      oprot.writeFieldEnd()
8845 
    oprot.writeFieldStop()
8846 
    oprot.writeStructEnd()
8847 
 
8848 
  def __repr__(self):
8849 
    L = ['%s=%r' % (key, value)
8850 
      for key, value in self.__dict__.iteritems()]
8851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8852 
 
8853 
  def __eq__(self, other):
8854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8855 
 
8856 
  def __ne__(self, other):
8857 
    return not (self == other)
8858 
 
8859 
class createCart_result:
8860 
  """
8861 
  Attributes:
8862 
   - success
8863 
   - scx
8864 
  """
8865 
 
8866 
  thrift_spec = (
8867 
    (0, TType.I64, 'success', None, None, ), # 0
8868 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
8869 
  )
8870 
 
8871 
  def __init__(self, success=None, scx=None,):
8872 
    self.success = success
8873 
    self.scx = scx
8874 
 
8875 
  def read(self, iprot):
8876 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8877 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8878 
      return
8879 
    iprot.readStructBegin()
8880 
    while True:
8881 
      (fname, ftype, fid) = iprot.readFieldBegin()
8882 
      if ftype == TType.STOP:
8883 
        break
8884 
      if fid == 0:
94 ashish 8885 
        if ftype == TType.I64:
559 chandransh 8886 
          self.success = iprot.readI64();
94 ashish 8887 
        else:
8888 
          iprot.skip(ftype)
559 chandransh 8889 
      elif fid == 1:
8890 
        if ftype == TType.STRUCT:
8891 
          self.scx = ShoppingCartException()
8892 
          self.scx.read(iprot)
8893 
        else:
8894 
          iprot.skip(ftype)
94 ashish 8895 
      else:
8896 
        iprot.skip(ftype)
8897 
      iprot.readFieldEnd()
8898 
    iprot.readStructEnd()
8899 
 
8900 
  def write(self, oprot):
8901 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8902 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8903 
      return
559 chandransh 8904 
    oprot.writeStructBegin('createCart_result')
8905 
    if self.success != None:
8906 
      oprot.writeFieldBegin('success', TType.I64, 0)
8907 
      oprot.writeI64(self.success)
94 ashish 8908 
      oprot.writeFieldEnd()
559 chandransh 8909 
    if self.scx != None:
8910 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
8911 
      self.scx.write(oprot)
94 ashish 8912 
      oprot.writeFieldEnd()
8913 
    oprot.writeFieldStop()
8914 
    oprot.writeStructEnd()
8915 
 
8916 
  def __repr__(self):
8917 
    L = ['%s=%r' % (key, value)
8918 
      for key, value in self.__dict__.iteritems()]
8919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8920 
 
8921 
  def __eq__(self, other):
8922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8923 
 
8924 
  def __ne__(self, other):
8925 
    return not (self == other)
8926 
 
559 chandransh 8927 
class getCurrentCart_args:
94 ashish 8928 
  """
8929 
  Attributes:
559 chandransh 8930 
   - userId
8931 
  """
8932 
 
8933 
  thrift_spec = (
8934 
    None, # 0
8935 
    (1, TType.I64, 'userId', None, None, ), # 1
8936 
  )
8937 
 
8938 
  def __init__(self, userId=None,):
8939 
    self.userId = userId
8940 
 
8941 
  def read(self, iprot):
8942 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8943 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8944 
      return
8945 
    iprot.readStructBegin()
8946 
    while True:
8947 
      (fname, ftype, fid) = iprot.readFieldBegin()
8948 
      if ftype == TType.STOP:
8949 
        break
8950 
      if fid == 1:
8951 
        if ftype == TType.I64:
8952 
          self.userId = iprot.readI64();
8953 
        else:
8954 
          iprot.skip(ftype)
8955 
      else:
8956 
        iprot.skip(ftype)
8957 
      iprot.readFieldEnd()
8958 
    iprot.readStructEnd()
8959 
 
8960 
  def write(self, oprot):
8961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8963 
      return
8964 
    oprot.writeStructBegin('getCurrentCart_args')
8965 
    if self.userId != None:
8966 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8967 
      oprot.writeI64(self.userId)
8968 
      oprot.writeFieldEnd()
8969 
    oprot.writeFieldStop()
8970 
    oprot.writeStructEnd()
8971 
 
8972 
  def __repr__(self):
8973 
    L = ['%s=%r' % (key, value)
8974 
      for key, value in self.__dict__.iteritems()]
8975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8976 
 
8977 
  def __eq__(self, other):
8978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8979 
 
8980 
  def __ne__(self, other):
8981 
    return not (self == other)
8982 
 
8983 
class getCurrentCart_result:
8984 
  """
8985 
  Attributes:
94 ashish 8986 
   - success
559 chandransh 8987 
   - scx
94 ashish 8988 
  """
8989 
 
8990 
  thrift_spec = (
559 chandransh 8991 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
8992 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 8993 
  )
8994 
 
559 chandransh 8995 
  def __init__(self, success=None, scx=None,):
94 ashish 8996 
    self.success = success
559 chandransh 8997 
    self.scx = scx
94 ashish 8998 
 
8999 
  def read(self, iprot):
9000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9002 
      return
9003 
    iprot.readStructBegin()
9004 
    while True:
9005 
      (fname, ftype, fid) = iprot.readFieldBegin()
9006 
      if ftype == TType.STOP:
9007 
        break
9008 
      if fid == 0:
559 chandransh 9009 
        if ftype == TType.STRUCT:
9010 
          self.success = Cart()
9011 
          self.success.read(iprot)
94 ashish 9012 
        else:
9013 
          iprot.skip(ftype)
9014 
      elif fid == 1:
9015 
        if ftype == TType.STRUCT:
559 chandransh 9016 
          self.scx = ShoppingCartException()
9017 
          self.scx.read(iprot)
94 ashish 9018 
        else:
9019 
          iprot.skip(ftype)
9020 
      else:
9021 
        iprot.skip(ftype)
9022 
      iprot.readFieldEnd()
9023 
    iprot.readStructEnd()
9024 
 
9025 
  def write(self, oprot):
9026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9028 
      return
559 chandransh 9029 
    oprot.writeStructBegin('getCurrentCart_result')
94 ashish 9030 
    if self.success != None:
559 chandransh 9031 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9032 
      self.success.write(oprot)
94 ashish 9033 
      oprot.writeFieldEnd()
559 chandransh 9034 
    if self.scx != None:
9035 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9036 
      self.scx.write(oprot)
94 ashish 9037 
      oprot.writeFieldEnd()
9038 
    oprot.writeFieldStop()
9039 
    oprot.writeStructEnd()
9040 
 
9041 
  def __repr__(self):
9042 
    L = ['%s=%r' % (key, value)
9043 
      for key, value in self.__dict__.iteritems()]
9044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9045 
 
9046 
  def __eq__(self, other):
9047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9048 
 
9049 
  def __ne__(self, other):
9050 
    return not (self == other)
9051 
 
559 chandransh 9052 
class getCart_args:
504 rajveer 9053 
  """
9054 
  Attributes:
559 chandransh 9055 
   - cartId
504 rajveer 9056 
  """
9057 
 
9058 
  thrift_spec = (
9059 
    None, # 0
559 chandransh 9060 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 9061 
  )
9062 
 
559 chandransh 9063 
  def __init__(self, cartId=None,):
9064 
    self.cartId = cartId
504 rajveer 9065 
 
9066 
  def read(self, iprot):
9067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9069 
      return
9070 
    iprot.readStructBegin()
9071 
    while True:
9072 
      (fname, ftype, fid) = iprot.readFieldBegin()
9073 
      if ftype == TType.STOP:
9074 
        break
9075 
      if fid == 1:
9076 
        if ftype == TType.I64:
559 chandransh 9077 
          self.cartId = iprot.readI64();
504 rajveer 9078 
        else:
9079 
          iprot.skip(ftype)
9080 
      else:
9081 
        iprot.skip(ftype)
9082 
      iprot.readFieldEnd()
9083 
    iprot.readStructEnd()
9084 
 
9085 
  def write(self, oprot):
9086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9088 
      return
559 chandransh 9089 
    oprot.writeStructBegin('getCart_args')
9090 
    if self.cartId != None:
9091 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9092 
      oprot.writeI64(self.cartId)
504 rajveer 9093 
      oprot.writeFieldEnd()
9094 
    oprot.writeFieldStop()
9095 
    oprot.writeStructEnd()
9096 
 
9097 
  def __repr__(self):
9098 
    L = ['%s=%r' % (key, value)
9099 
      for key, value in self.__dict__.iteritems()]
9100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9101 
 
9102 
  def __eq__(self, other):
9103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9104 
 
9105 
  def __ne__(self, other):
9106 
    return not (self == other)
9107 
 
559 chandransh 9108 
class getCart_result:
504 rajveer 9109 
  """
9110 
  Attributes:
9111 
   - success
559 chandransh 9112 
   - scx
504 rajveer 9113 
  """
9114 
 
9115 
  thrift_spec = (
559 chandransh 9116 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9117 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 9118 
  )
9119 
 
559 chandransh 9120 
  def __init__(self, success=None, scx=None,):
504 rajveer 9121 
    self.success = success
559 chandransh 9122 
    self.scx = scx
504 rajveer 9123 
 
9124 
  def read(self, iprot):
9125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9127 
      return
9128 
    iprot.readStructBegin()
9129 
    while True:
9130 
      (fname, ftype, fid) = iprot.readFieldBegin()
9131 
      if ftype == TType.STOP:
9132 
        break
9133 
      if fid == 0:
559 chandransh 9134 
        if ftype == TType.STRUCT:
9135 
          self.success = Cart()
9136 
          self.success.read(iprot)
504 rajveer 9137 
        else:
9138 
          iprot.skip(ftype)
9139 
      elif fid == 1:
9140 
        if ftype == TType.STRUCT:
559 chandransh 9141 
          self.scx = ShoppingCartException()
9142 
          self.scx.read(iprot)
504 rajveer 9143 
        else:
9144 
          iprot.skip(ftype)
9145 
      else:
9146 
        iprot.skip(ftype)
9147 
      iprot.readFieldEnd()
9148 
    iprot.readStructEnd()
9149 
 
9150 
  def write(self, oprot):
9151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9153 
      return
559 chandransh 9154 
    oprot.writeStructBegin('getCart_result')
504 rajveer 9155 
    if self.success != None:
559 chandransh 9156 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9157 
      self.success.write(oprot)
504 rajveer 9158 
      oprot.writeFieldEnd()
559 chandransh 9159 
    if self.scx != None:
9160 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9161 
      self.scx.write(oprot)
504 rajveer 9162 
      oprot.writeFieldEnd()
9163 
    oprot.writeFieldStop()
9164 
    oprot.writeStructEnd()
9165 
 
9166 
  def __repr__(self):
9167 
    L = ['%s=%r' % (key, value)
9168 
      for key, value in self.__dict__.iteritems()]
9169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9170 
 
9171 
  def __eq__(self, other):
9172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9173 
 
9174 
  def __ne__(self, other):
9175 
    return not (self == other)
9176 
 
559 chandransh 9177 
class getCartsForUser_args:
94 ashish 9178 
  """
9179 
  Attributes:
559 chandransh 9180 
   - userId
9181 
   - status
94 ashish 9182 
  """
9183 
 
9184 
  thrift_spec = (
9185 
    None, # 0
559 chandransh 9186 
    (1, TType.I64, 'userId', None, None, ), # 1
9187 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 9188 
  )
9189 
 
559 chandransh 9190 
  def __init__(self, userId=None, status=None,):
9191 
    self.userId = userId
9192 
    self.status = status
94 ashish 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.userId = iprot.readI64();
94 ashish 9206 
        else:
9207 
          iprot.skip(ftype)
9208 
      elif fid == 2:
559 chandransh 9209 
        if ftype == TType.I32:
9210 
          self.status = iprot.readI32();
94 ashish 9211 
        else:
9212 
          iprot.skip(ftype)
9213 
      else:
9214 
        iprot.skip(ftype)
9215 
      iprot.readFieldEnd()
9216 
    iprot.readStructEnd()
9217 
 
9218 
  def write(self, oprot):
9219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9221 
      return
559 chandransh 9222 
    oprot.writeStructBegin('getCartsForUser_args')
9223 
    if self.userId != None:
9224 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9225 
      oprot.writeI64(self.userId)
94 ashish 9226 
      oprot.writeFieldEnd()
559 chandransh 9227 
    if self.status != None:
9228 
      oprot.writeFieldBegin('status', TType.I32, 2)
9229 
      oprot.writeI32(self.status)
94 ashish 9230 
      oprot.writeFieldEnd()
9231 
    oprot.writeFieldStop()
9232 
    oprot.writeStructEnd()
9233 
 
9234 
  def __repr__(self):
9235 
    L = ['%s=%r' % (key, value)
9236 
      for key, value in self.__dict__.iteritems()]
9237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9238 
 
9239 
  def __eq__(self, other):
9240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9241 
 
9242 
  def __ne__(self, other):
9243 
    return not (self == other)
9244 
 
559 chandransh 9245 
class getCartsForUser_result:
94 ashish 9246 
  """
9247 
  Attributes:
9248 
   - success
559 chandransh 9249 
   - scx
94 ashish 9250 
  """
9251 
 
9252 
  thrift_spec = (
559 chandransh 9253 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9254 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9255 
  )
9256 
 
559 chandransh 9257 
  def __init__(self, success=None, scx=None,):
94 ashish 9258 
    self.success = success
559 chandransh 9259 
    self.scx = scx
94 ashish 9260 
 
9261 
  def read(self, iprot):
9262 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9263 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9264 
      return
9265 
    iprot.readStructBegin()
9266 
    while True:
9267 
      (fname, ftype, fid) = iprot.readFieldBegin()
9268 
      if ftype == TType.STOP:
9269 
        break
9270 
      if fid == 0:
559 chandransh 9271 
        if ftype == TType.LIST:
9272 
          self.success = []
1845 vikas 9273 
          (_etype87, _size84) = iprot.readListBegin()
9274 
          for _i88 in xrange(_size84):
9275 
            _elem89 = Cart()
9276 
            _elem89.read(iprot)
9277 
            self.success.append(_elem89)
559 chandransh 9278 
          iprot.readListEnd()
94 ashish 9279 
        else:
9280 
          iprot.skip(ftype)
9281 
      elif fid == 1:
9282 
        if ftype == TType.STRUCT:
559 chandransh 9283 
          self.scx = ShoppingCartException()
9284 
          self.scx.read(iprot)
94 ashish 9285 
        else:
9286 
          iprot.skip(ftype)
9287 
      else:
9288 
        iprot.skip(ftype)
9289 
      iprot.readFieldEnd()
9290 
    iprot.readStructEnd()
9291 
 
9292 
  def write(self, oprot):
9293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9295 
      return
559 chandransh 9296 
    oprot.writeStructBegin('getCartsForUser_result')
94 ashish 9297 
    if self.success != None:
559 chandransh 9298 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9299 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1845 vikas 9300 
      for iter90 in self.success:
9301 
        iter90.write(oprot)
559 chandransh 9302 
      oprot.writeListEnd()
94 ashish 9303 
      oprot.writeFieldEnd()
559 chandransh 9304 
    if self.scx != None:
9305 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9306 
      self.scx.write(oprot)
94 ashish 9307 
      oprot.writeFieldEnd()
9308 
    oprot.writeFieldStop()
9309 
    oprot.writeStructEnd()
9310 
 
9311 
  def __repr__(self):
9312 
    L = ['%s=%r' % (key, value)
9313 
      for key, value in self.__dict__.iteritems()]
9314 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9315 
 
9316 
  def __eq__(self, other):
9317 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9318 
 
9319 
  def __ne__(self, other):
9320 
    return not (self == other)
9321 
 
559 chandransh 9322 
class getCartsByStatus_args:
94 ashish 9323 
  """
9324 
  Attributes:
559 chandransh 9325 
   - status
94 ashish 9326 
  """
9327 
 
9328 
  thrift_spec = (
9329 
    None, # 0
559 chandransh 9330 
    (1, TType.I32, 'status', None, None, ), # 1
94 ashish 9331 
  )
9332 
 
559 chandransh 9333 
  def __init__(self, status=None,):
9334 
    self.status = status
94 ashish 9335 
 
9336 
  def read(self, iprot):
9337 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9338 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9339 
      return
9340 
    iprot.readStructBegin()
9341 
    while True:
9342 
      (fname, ftype, fid) = iprot.readFieldBegin()
9343 
      if ftype == TType.STOP:
9344 
        break
9345 
      if fid == 1:
559 chandransh 9346 
        if ftype == TType.I32:
9347 
          self.status = iprot.readI32();
9348 
        else:
9349 
          iprot.skip(ftype)
9350 
      else:
9351 
        iprot.skip(ftype)
9352 
      iprot.readFieldEnd()
9353 
    iprot.readStructEnd()
9354 
 
9355 
  def write(self, oprot):
9356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9358 
      return
9359 
    oprot.writeStructBegin('getCartsByStatus_args')
9360 
    if self.status != None:
9361 
      oprot.writeFieldBegin('status', TType.I32, 1)
9362 
      oprot.writeI32(self.status)
9363 
      oprot.writeFieldEnd()
9364 
    oprot.writeFieldStop()
9365 
    oprot.writeStructEnd()
9366 
 
9367 
  def __repr__(self):
9368 
    L = ['%s=%r' % (key, value)
9369 
      for key, value in self.__dict__.iteritems()]
9370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9371 
 
9372 
  def __eq__(self, other):
9373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9374 
 
9375 
  def __ne__(self, other):
9376 
    return not (self == other)
9377 
 
9378 
class getCartsByStatus_result:
9379 
  """
9380 
  Attributes:
9381 
   - success
9382 
   - scx
9383 
  """
9384 
 
9385 
  thrift_spec = (
9386 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9387 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9388 
  )
9389 
 
9390 
  def __init__(self, success=None, scx=None,):
9391 
    self.success = success
9392 
    self.scx = scx
9393 
 
9394 
  def read(self, iprot):
9395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9397 
      return
9398 
    iprot.readStructBegin()
9399 
    while True:
9400 
      (fname, ftype, fid) = iprot.readFieldBegin()
9401 
      if ftype == TType.STOP:
9402 
        break
9403 
      if fid == 0:
9404 
        if ftype == TType.LIST:
9405 
          self.success = []
1845 vikas 9406 
          (_etype94, _size91) = iprot.readListBegin()
9407 
          for _i95 in xrange(_size91):
9408 
            _elem96 = Cart()
9409 
            _elem96.read(iprot)
9410 
            self.success.append(_elem96)
559 chandransh 9411 
          iprot.readListEnd()
9412 
        else:
9413 
          iprot.skip(ftype)
9414 
      elif fid == 1:
9415 
        if ftype == TType.STRUCT:
9416 
          self.scx = ShoppingCartException()
9417 
          self.scx.read(iprot)
9418 
        else:
9419 
          iprot.skip(ftype)
9420 
      else:
9421 
        iprot.skip(ftype)
9422 
      iprot.readFieldEnd()
9423 
    iprot.readStructEnd()
9424 
 
9425 
  def write(self, oprot):
9426 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9427 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9428 
      return
9429 
    oprot.writeStructBegin('getCartsByStatus_result')
9430 
    if self.success != None:
9431 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9432 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1845 vikas 9433 
      for iter97 in self.success:
9434 
        iter97.write(oprot)
559 chandransh 9435 
      oprot.writeListEnd()
9436 
      oprot.writeFieldEnd()
9437 
    if self.scx != None:
9438 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9439 
      self.scx.write(oprot)
9440 
      oprot.writeFieldEnd()
9441 
    oprot.writeFieldStop()
9442 
    oprot.writeStructEnd()
9443 
 
9444 
  def __repr__(self):
9445 
    L = ['%s=%r' % (key, value)
9446 
      for key, value in self.__dict__.iteritems()]
9447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9448 
 
9449 
  def __eq__(self, other):
9450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9451 
 
9452 
  def __ne__(self, other):
9453 
    return not (self == other)
9454 
 
9455 
class getCartsByTime_args:
9456 
  """
9457 
  Attributes:
9458 
   - from_time
9459 
   - to_time
9460 
   - status
9461 
  """
9462 
 
9463 
  thrift_spec = (
9464 
    None, # 0
9465 
    (1, TType.I64, 'from_time', None, None, ), # 1
9466 
    (2, TType.I64, 'to_time', None, None, ), # 2
9467 
    (3, TType.I32, 'status', None, None, ), # 3
9468 
  )
9469 
 
9470 
  def __init__(self, from_time=None, to_time=None, status=None,):
9471 
    self.from_time = from_time
9472 
    self.to_time = to_time
9473 
    self.status = status
9474 
 
9475 
  def read(self, iprot):
9476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9478 
      return
9479 
    iprot.readStructBegin()
9480 
    while True:
9481 
      (fname, ftype, fid) = iprot.readFieldBegin()
9482 
      if ftype == TType.STOP:
9483 
        break
9484 
      if fid == 1:
94 ashish 9485 
        if ftype == TType.I64:
559 chandransh 9486 
          self.from_time = iprot.readI64();
94 ashish 9487 
        else:
9488 
          iprot.skip(ftype)
122 ashish 9489 
      elif fid == 2:
559 chandransh 9490 
        if ftype == TType.I64:
9491 
          self.to_time = iprot.readI64();
122 ashish 9492 
        else:
9493 
          iprot.skip(ftype)
559 chandransh 9494 
      elif fid == 3:
9495 
        if ftype == TType.I32:
9496 
          self.status = iprot.readI32();
9497 
        else:
9498 
          iprot.skip(ftype)
94 ashish 9499 
      else:
9500 
        iprot.skip(ftype)
9501 
      iprot.readFieldEnd()
9502 
    iprot.readStructEnd()
9503 
 
9504 
  def write(self, oprot):
9505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9507 
      return
559 chandransh 9508 
    oprot.writeStructBegin('getCartsByTime_args')
9509 
    if self.from_time != None:
9510 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
9511 
      oprot.writeI64(self.from_time)
94 ashish 9512 
      oprot.writeFieldEnd()
559 chandransh 9513 
    if self.to_time != None:
9514 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
9515 
      oprot.writeI64(self.to_time)
122 ashish 9516 
      oprot.writeFieldEnd()
559 chandransh 9517 
    if self.status != None:
9518 
      oprot.writeFieldBegin('status', TType.I32, 3)
9519 
      oprot.writeI32(self.status)
9520 
      oprot.writeFieldEnd()
94 ashish 9521 
    oprot.writeFieldStop()
9522 
    oprot.writeStructEnd()
9523 
 
9524 
  def __repr__(self):
9525 
    L = ['%s=%r' % (key, value)
9526 
      for key, value in self.__dict__.iteritems()]
9527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9528 
 
9529 
  def __eq__(self, other):
9530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9531 
 
9532 
  def __ne__(self, other):
9533 
    return not (self == other)
9534 
 
559 chandransh 9535 
class getCartsByTime_result:
94 ashish 9536 
  """
9537 
  Attributes:
9538 
   - success
559 chandransh 9539 
   - scx
94 ashish 9540 
  """
9541 
 
9542 
  thrift_spec = (
559 chandransh 9543 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9544 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9545 
  )
9546 
 
559 chandransh 9547 
  def __init__(self, success=None, scx=None,):
94 ashish 9548 
    self.success = success
559 chandransh 9549 
    self.scx = scx
94 ashish 9550 
 
9551 
  def read(self, iprot):
9552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9554 
      return
9555 
    iprot.readStructBegin()
9556 
    while True:
9557 
      (fname, ftype, fid) = iprot.readFieldBegin()
9558 
      if ftype == TType.STOP:
9559 
        break
9560 
      if fid == 0:
559 chandransh 9561 
        if ftype == TType.LIST:
9562 
          self.success = []
1845 vikas 9563 
          (_etype101, _size98) = iprot.readListBegin()
9564 
          for _i102 in xrange(_size98):
9565 
            _elem103 = Cart()
9566 
            _elem103.read(iprot)
9567 
            self.success.append(_elem103)
559 chandransh 9568 
          iprot.readListEnd()
94 ashish 9569 
        else:
9570 
          iprot.skip(ftype)
9571 
      elif fid == 1:
9572 
        if ftype == TType.STRUCT:
559 chandransh 9573 
          self.scx = ShoppingCartException()
9574 
          self.scx.read(iprot)
94 ashish 9575 
        else:
9576 
          iprot.skip(ftype)
9577 
      else:
9578 
        iprot.skip(ftype)
9579 
      iprot.readFieldEnd()
9580 
    iprot.readStructEnd()
9581 
 
9582 
  def write(self, oprot):
9583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9585 
      return
559 chandransh 9586 
    oprot.writeStructBegin('getCartsByTime_result')
94 ashish 9587 
    if self.success != None:
559 chandransh 9588 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9589 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1845 vikas 9590 
      for iter104 in self.success:
9591 
        iter104.write(oprot)
559 chandransh 9592 
      oprot.writeListEnd()
94 ashish 9593 
      oprot.writeFieldEnd()
559 chandransh 9594 
    if self.scx != None:
9595 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9596 
      self.scx.write(oprot)
94 ashish 9597 
      oprot.writeFieldEnd()
9598 
    oprot.writeFieldStop()
9599 
    oprot.writeStructEnd()
9600 
 
9601 
  def __repr__(self):
9602 
    L = ['%s=%r' % (key, value)
9603 
      for key, value in self.__dict__.iteritems()]
9604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9605 
 
9606 
  def __eq__(self, other):
9607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9608 
 
9609 
  def __ne__(self, other):
9610 
    return not (self == other)
9611 
 
559 chandransh 9612 
class changeCartStatus_args:
94 ashish 9613 
  """
9614 
  Attributes:
559 chandransh 9615 
   - cartId
9616 
   - status
94 ashish 9617 
  """
9618 
 
9619 
  thrift_spec = (
9620 
    None, # 0
559 chandransh 9621 
    (1, TType.I64, 'cartId', None, None, ), # 1
9622 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 9623 
  )
9624 
 
559 chandransh 9625 
  def __init__(self, cartId=None, status=None,):
9626 
    self.cartId = cartId
9627 
    self.status = status
94 ashish 9628 
 
9629 
  def read(self, iprot):
9630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9632 
      return
9633 
    iprot.readStructBegin()
9634 
    while True:
9635 
      (fname, ftype, fid) = iprot.readFieldBegin()
9636 
      if ftype == TType.STOP:
9637 
        break
9638 
      if fid == 1:
9639 
        if ftype == TType.I64:
559 chandransh 9640 
          self.cartId = iprot.readI64();
94 ashish 9641 
        else:
9642 
          iprot.skip(ftype)
559 chandransh 9643 
      elif fid == 2:
9644 
        if ftype == TType.I32:
9645 
          self.status = iprot.readI32();
9646 
        else:
9647 
          iprot.skip(ftype)
94 ashish 9648 
      else:
9649 
        iprot.skip(ftype)
9650 
      iprot.readFieldEnd()
9651 
    iprot.readStructEnd()
9652 
 
9653 
  def write(self, oprot):
9654 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9655 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9656 
      return
559 chandransh 9657 
    oprot.writeStructBegin('changeCartStatus_args')
9658 
    if self.cartId != None:
9659 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9660 
      oprot.writeI64(self.cartId)
94 ashish 9661 
      oprot.writeFieldEnd()
559 chandransh 9662 
    if self.status != None:
9663 
      oprot.writeFieldBegin('status', TType.I32, 2)
9664 
      oprot.writeI32(self.status)
9665 
      oprot.writeFieldEnd()
94 ashish 9666 
    oprot.writeFieldStop()
9667 
    oprot.writeStructEnd()
9668 
 
9669 
  def __repr__(self):
9670 
    L = ['%s=%r' % (key, value)
9671 
      for key, value in self.__dict__.iteritems()]
9672 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9673 
 
9674 
  def __eq__(self, other):
9675 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9676 
 
9677 
  def __ne__(self, other):
9678 
    return not (self == other)
9679 
 
559 chandransh 9680 
class changeCartStatus_result:
94 ashish 9681 
  """
9682 
  Attributes:
559 chandransh 9683 
   - scx
9684 
  """
9685 
 
9686 
  thrift_spec = (
9687 
    None, # 0
9688 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9689 
  )
9690 
 
9691 
  def __init__(self, scx=None,):
9692 
    self.scx = scx
9693 
 
9694 
  def read(self, iprot):
9695 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9696 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9697 
      return
9698 
    iprot.readStructBegin()
9699 
    while True:
9700 
      (fname, ftype, fid) = iprot.readFieldBegin()
9701 
      if ftype == TType.STOP:
9702 
        break
9703 
      if fid == 1:
9704 
        if ftype == TType.STRUCT:
9705 
          self.scx = ShoppingCartException()
9706 
          self.scx.read(iprot)
9707 
        else:
9708 
          iprot.skip(ftype)
9709 
      else:
9710 
        iprot.skip(ftype)
9711 
      iprot.readFieldEnd()
9712 
    iprot.readStructEnd()
9713 
 
9714 
  def write(self, oprot):
9715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9717 
      return
9718 
    oprot.writeStructBegin('changeCartStatus_result')
9719 
    if self.scx != None:
9720 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9721 
      self.scx.write(oprot)
9722 
      oprot.writeFieldEnd()
9723 
    oprot.writeFieldStop()
9724 
    oprot.writeStructEnd()
9725 
 
9726 
  def __repr__(self):
9727 
    L = ['%s=%r' % (key, value)
9728 
      for key, value in self.__dict__.iteritems()]
9729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9730 
 
9731 
  def __eq__(self, other):
9732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9733 
 
9734 
  def __ne__(self, other):
9735 
    return not (self == other)
9736 
 
9737 
class addItemToCart_args:
9738 
  """
9739 
  Attributes:
9740 
   - cartId
9741 
   - itemId
9742 
   - quantity
9743 
  """
9744 
 
9745 
  thrift_spec = (
9746 
    None, # 0
9747 
    (1, TType.I64, 'cartId', None, None, ), # 1
9748 
    (2, TType.I64, 'itemId', None, None, ), # 2
9749 
    (3, TType.I64, 'quantity', None, None, ), # 3
9750 
  )
9751 
 
9752 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
9753 
    self.cartId = cartId
9754 
    self.itemId = itemId
9755 
    self.quantity = quantity
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:
9768 
          self.cartId = iprot.readI64();
9769 
        else:
9770 
          iprot.skip(ftype)
9771 
      elif fid == 2:
9772 
        if ftype == TType.I64:
9773 
          self.itemId = iprot.readI64();
9774 
        else:
9775 
          iprot.skip(ftype)
9776 
      elif fid == 3:
9777 
        if ftype == TType.I64:
9778 
          self.quantity = iprot.readI64();
9779 
        else:
9780 
          iprot.skip(ftype)
9781 
      else:
9782 
        iprot.skip(ftype)
9783 
      iprot.readFieldEnd()
9784 
    iprot.readStructEnd()
9785 
 
9786 
  def write(self, oprot):
9787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9789 
      return
9790 
    oprot.writeStructBegin('addItemToCart_args')
9791 
    if self.cartId != None:
9792 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9793 
      oprot.writeI64(self.cartId)
9794 
      oprot.writeFieldEnd()
9795 
    if self.itemId != None:
9796 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
9797 
      oprot.writeI64(self.itemId)
9798 
      oprot.writeFieldEnd()
9799 
    if self.quantity != None:
9800 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
9801 
      oprot.writeI64(self.quantity)
9802 
      oprot.writeFieldEnd()
9803 
    oprot.writeFieldStop()
9804 
    oprot.writeStructEnd()
9805 
 
9806 
  def __repr__(self):
9807 
    L = ['%s=%r' % (key, value)
9808 
      for key, value in self.__dict__.iteritems()]
9809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9810 
 
9811 
  def __eq__(self, other):
9812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9813 
 
9814 
  def __ne__(self, other):
9815 
    return not (self == other)
9816 
 
9817 
class addItemToCart_result:
9818 
  """
9819 
  Attributes:
9820 
   - scx
9821 
  """
9822 
 
9823 
  thrift_spec = (
9824 
    None, # 0
9825 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9826 
  )
9827 
 
9828 
  def __init__(self, scx=None,):
9829 
    self.scx = scx
9830 
 
9831 
  def read(self, iprot):
9832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9834 
      return
9835 
    iprot.readStructBegin()
9836 
    while True:
9837 
      (fname, ftype, fid) = iprot.readFieldBegin()
9838 
      if ftype == TType.STOP:
9839 
        break
9840 
      if fid == 1:
9841 
        if ftype == TType.STRUCT:
9842 
          self.scx = ShoppingCartException()
9843 
          self.scx.read(iprot)
9844 
        else:
9845 
          iprot.skip(ftype)
9846 
      else:
9847 
        iprot.skip(ftype)
9848 
      iprot.readFieldEnd()
9849 
    iprot.readStructEnd()
9850 
 
9851 
  def write(self, oprot):
9852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9854 
      return
9855 
    oprot.writeStructBegin('addItemToCart_result')
9856 
    if self.scx != None:
9857 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9858 
      self.scx.write(oprot)
9859 
      oprot.writeFieldEnd()
9860 
    oprot.writeFieldStop()
9861 
    oprot.writeStructEnd()
9862 
 
9863 
  def __repr__(self):
9864 
    L = ['%s=%r' % (key, value)
9865 
      for key, value in self.__dict__.iteritems()]
9866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9867 
 
9868 
  def __eq__(self, other):
9869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9870 
 
9871 
  def __ne__(self, other):
9872 
    return not (self == other)
9873 
 
9874 
class deleteItemFromCart_args:
9875 
  """
9876 
  Attributes:
9877 
   - cartId
9878 
   - itemId
9879 
  """
9880 
 
9881 
  thrift_spec = (
9882 
    None, # 0
9883 
    (1, TType.I64, 'cartId', None, None, ), # 1
9884 
    (2, TType.I64, 'itemId', None, None, ), # 2
9885 
  )
9886 
 
9887 
  def __init__(self, cartId=None, itemId=None,):
9888 
    self.cartId = cartId
9889 
    self.itemId = itemId
9890 
 
9891 
  def read(self, iprot):
9892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9894 
      return
9895 
    iprot.readStructBegin()
9896 
    while True:
9897 
      (fname, ftype, fid) = iprot.readFieldBegin()
9898 
      if ftype == TType.STOP:
9899 
        break
9900 
      if fid == 1:
9901 
        if ftype == TType.I64:
9902 
          self.cartId = iprot.readI64();
9903 
        else:
9904 
          iprot.skip(ftype)
9905 
      elif fid == 2:
9906 
        if ftype == TType.I64:
9907 
          self.itemId = iprot.readI64();
9908 
        else:
9909 
          iprot.skip(ftype)
9910 
      else:
9911 
        iprot.skip(ftype)
9912 
      iprot.readFieldEnd()
9913 
    iprot.readStructEnd()
9914 
 
9915 
  def write(self, oprot):
9916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9918 
      return
9919 
    oprot.writeStructBegin('deleteItemFromCart_args')
9920 
    if self.cartId != None:
9921 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9922 
      oprot.writeI64(self.cartId)
9923 
      oprot.writeFieldEnd()
9924 
    if self.itemId != None:
9925 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
9926 
      oprot.writeI64(self.itemId)
9927 
      oprot.writeFieldEnd()
9928 
    oprot.writeFieldStop()
9929 
    oprot.writeStructEnd()
9930 
 
9931 
  def __repr__(self):
9932 
    L = ['%s=%r' % (key, value)
9933 
      for key, value in self.__dict__.iteritems()]
9934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9935 
 
9936 
  def __eq__(self, other):
9937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9938 
 
9939 
  def __ne__(self, other):
9940 
    return not (self == other)
9941 
 
9942 
class deleteItemFromCart_result:
9943 
  """
9944 
  Attributes:
9945 
   - scx
9946 
  """
9947 
 
9948 
  thrift_spec = (
9949 
    None, # 0
9950 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9951 
  )
9952 
 
9953 
  def __init__(self, scx=None,):
9954 
    self.scx = scx
9955 
 
9956 
  def read(self, iprot):
9957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9959 
      return
9960 
    iprot.readStructBegin()
9961 
    while True:
9962 
      (fname, ftype, fid) = iprot.readFieldBegin()
9963 
      if ftype == TType.STOP:
9964 
        break
9965 
      if fid == 1:
9966 
        if ftype == TType.STRUCT:
9967 
          self.scx = ShoppingCartException()
9968 
          self.scx.read(iprot)
9969 
        else:
9970 
          iprot.skip(ftype)
9971 
      else:
9972 
        iprot.skip(ftype)
9973 
      iprot.readFieldEnd()
9974 
    iprot.readStructEnd()
9975 
 
9976 
  def write(self, oprot):
9977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9979 
      return
9980 
    oprot.writeStructBegin('deleteItemFromCart_result')
9981 
    if self.scx != None:
9982 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9983 
      self.scx.write(oprot)
9984 
      oprot.writeFieldEnd()
9985 
    oprot.writeFieldStop()
9986 
    oprot.writeStructEnd()
9987 
 
9988 
  def __repr__(self):
9989 
    L = ['%s=%r' % (key, value)
9990 
      for key, value in self.__dict__.iteritems()]
9991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9992 
 
9993 
  def __eq__(self, other):
9994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9995 
 
9996 
  def __ne__(self, other):
9997 
    return not (self == other)
9998 
 
9999 
class changeQuantity_args:
10000 
  """
10001 
  Attributes:
10002 
   - cartId
10003 
   - itemId
10004 
   - quantity
10005 
  """
10006 
 
10007 
  thrift_spec = (
10008 
    None, # 0
10009 
    (1, TType.I64, 'cartId', None, None, ), # 1
10010 
    (2, TType.I64, 'itemId', None, None, ), # 2
10011 
    (3, TType.I64, 'quantity', None, None, ), # 3
10012 
  )
10013 
 
10014 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
10015 
    self.cartId = cartId
10016 
    self.itemId = itemId
10017 
    self.quantity = quantity
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 
      elif fid == 3:
10039 
        if ftype == TType.I64:
10040 
          self.quantity = iprot.readI64();
10041 
        else:
10042 
          iprot.skip(ftype)
10043 
      else:
10044 
        iprot.skip(ftype)
10045 
      iprot.readFieldEnd()
10046 
    iprot.readStructEnd()
10047 
 
10048 
  def write(self, oprot):
10049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10051 
      return
10052 
    oprot.writeStructBegin('changeQuantity_args')
10053 
    if self.cartId != None:
10054 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10055 
      oprot.writeI64(self.cartId)
10056 
      oprot.writeFieldEnd()
10057 
    if self.itemId != None:
10058 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10059 
      oprot.writeI64(self.itemId)
10060 
      oprot.writeFieldEnd()
10061 
    if self.quantity != None:
10062 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10063 
      oprot.writeI64(self.quantity)
10064 
      oprot.writeFieldEnd()
10065 
    oprot.writeFieldStop()
10066 
    oprot.writeStructEnd()
10067 
 
10068 
  def __repr__(self):
10069 
    L = ['%s=%r' % (key, value)
10070 
      for key, value in self.__dict__.iteritems()]
10071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10072 
 
10073 
  def __eq__(self, other):
10074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10075 
 
10076 
  def __ne__(self, other):
10077 
    return not (self == other)
10078 
 
10079 
class changeQuantity_result:
10080 
  """
10081 
  Attributes:
10082 
   - scx
10083 
  """
10084 
 
10085 
  thrift_spec = (
10086 
    None, # 0
10087 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10088 
  )
10089 
 
10090 
  def __init__(self, scx=None,):
10091 
    self.scx = scx
10092 
 
10093 
  def read(self, iprot):
10094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10096 
      return
10097 
    iprot.readStructBegin()
10098 
    while True:
10099 
      (fname, ftype, fid) = iprot.readFieldBegin()
10100 
      if ftype == TType.STOP:
10101 
        break
10102 
      if fid == 1:
10103 
        if ftype == TType.STRUCT:
10104 
          self.scx = ShoppingCartException()
10105 
          self.scx.read(iprot)
10106 
        else:
10107 
          iprot.skip(ftype)
10108 
      else:
10109 
        iprot.skip(ftype)
10110 
      iprot.readFieldEnd()
10111 
    iprot.readStructEnd()
10112 
 
10113 
  def write(self, oprot):
10114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10116 
      return
10117 
    oprot.writeStructBegin('changeQuantity_result')
10118 
    if self.scx != None:
10119 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10120 
      self.scx.write(oprot)
10121 
      oprot.writeFieldEnd()
10122 
    oprot.writeFieldStop()
10123 
    oprot.writeStructEnd()
10124 
 
10125 
  def __repr__(self):
10126 
    L = ['%s=%r' % (key, value)
10127 
      for key, value in self.__dict__.iteritems()]
10128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10129 
 
10130 
  def __eq__(self, other):
10131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10132 
 
10133 
  def __ne__(self, other):
10134 
    return not (self == other)
10135 
 
10136 
class changeItemStatus_args:
10137 
  """
10138 
  Attributes:
10139 
   - cartId
10140 
   - itemId
10141 
   - status
10142 
  """
10143 
 
10144 
  thrift_spec = (
10145 
    None, # 0
10146 
    (1, TType.I64, 'cartId', None, None, ), # 1
10147 
    (2, TType.I64, 'itemId', None, None, ), # 2
10148 
    (3, TType.I32, 'status', None, None, ), # 3
10149 
  )
10150 
 
10151 
  def __init__(self, cartId=None, itemId=None, status=None,):
10152 
    self.cartId = cartId
10153 
    self.itemId = itemId
10154 
    self.status = status
10155 
 
10156 
  def read(self, iprot):
10157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10159 
      return
10160 
    iprot.readStructBegin()
10161 
    while True:
10162 
      (fname, ftype, fid) = iprot.readFieldBegin()
10163 
      if ftype == TType.STOP:
10164 
        break
10165 
      if fid == 1:
10166 
        if ftype == TType.I64:
10167 
          self.cartId = iprot.readI64();
10168 
        else:
10169 
          iprot.skip(ftype)
10170 
      elif fid == 2:
10171 
        if ftype == TType.I64:
10172 
          self.itemId = iprot.readI64();
10173 
        else:
10174 
          iprot.skip(ftype)
10175 
      elif fid == 3:
10176 
        if ftype == TType.I32:
10177 
          self.status = iprot.readI32();
10178 
        else:
10179 
          iprot.skip(ftype)
10180 
      else:
10181 
        iprot.skip(ftype)
10182 
      iprot.readFieldEnd()
10183 
    iprot.readStructEnd()
10184 
 
10185 
  def write(self, oprot):
10186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10188 
      return
10189 
    oprot.writeStructBegin('changeItemStatus_args')
10190 
    if self.cartId != None:
10191 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10192 
      oprot.writeI64(self.cartId)
10193 
      oprot.writeFieldEnd()
10194 
    if self.itemId != None:
10195 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10196 
      oprot.writeI64(self.itemId)
10197 
      oprot.writeFieldEnd()
10198 
    if self.status != None:
10199 
      oprot.writeFieldBegin('status', TType.I32, 3)
10200 
      oprot.writeI32(self.status)
10201 
      oprot.writeFieldEnd()
10202 
    oprot.writeFieldStop()
10203 
    oprot.writeStructEnd()
10204 
 
10205 
  def __repr__(self):
10206 
    L = ['%s=%r' % (key, value)
10207 
      for key, value in self.__dict__.iteritems()]
10208 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10209 
 
10210 
  def __eq__(self, other):
10211 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10212 
 
10213 
  def __ne__(self, other):
10214 
    return not (self == other)
10215 
 
10216 
class changeItemStatus_result:
10217 
  """
10218 
  Attributes:
10219 
   - scx
10220 
  """
10221 
 
10222 
  thrift_spec = (
10223 
    None, # 0
10224 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10225 
  )
10226 
 
10227 
  def __init__(self, scx=None,):
10228 
    self.scx = scx
10229 
 
10230 
  def read(self, iprot):
10231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10233 
      return
10234 
    iprot.readStructBegin()
10235 
    while True:
10236 
      (fname, ftype, fid) = iprot.readFieldBegin()
10237 
      if ftype == TType.STOP:
10238 
        break
10239 
      if fid == 1:
10240 
        if ftype == TType.STRUCT:
10241 
          self.scx = ShoppingCartException()
10242 
          self.scx.read(iprot)
10243 
        else:
10244 
          iprot.skip(ftype)
10245 
      else:
10246 
        iprot.skip(ftype)
10247 
      iprot.readFieldEnd()
10248 
    iprot.readStructEnd()
10249 
 
10250 
  def write(self, oprot):
10251 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10252 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10253 
      return
10254 
    oprot.writeStructBegin('changeItemStatus_result')
10255 
    if self.scx != None:
10256 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10257 
      self.scx.write(oprot)
10258 
      oprot.writeFieldEnd()
10259 
    oprot.writeFieldStop()
10260 
    oprot.writeStructEnd()
10261 
 
10262 
  def __repr__(self):
10263 
    L = ['%s=%r' % (key, value)
10264 
      for key, value in self.__dict__.iteritems()]
10265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10266 
 
10267 
  def __eq__(self, other):
10268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10269 
 
10270 
  def __ne__(self, other):
10271 
    return not (self == other)
10272 
 
10273 
class addAddressToCart_args:
10274 
  """
10275 
  Attributes:
10276 
   - cartId
10277 
   - addressId
10278 
  """
10279 
 
10280 
  thrift_spec = (
10281 
    None, # 0
10282 
    (1, TType.I64, 'cartId', None, None, ), # 1
10283 
    (2, TType.I64, 'addressId', None, None, ), # 2
10284 
  )
10285 
 
10286 
  def __init__(self, cartId=None, addressId=None,):
10287 
    self.cartId = cartId
10288 
    self.addressId = addressId
10289 
 
10290 
  def read(self, iprot):
10291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10293 
      return
10294 
    iprot.readStructBegin()
10295 
    while True:
10296 
      (fname, ftype, fid) = iprot.readFieldBegin()
10297 
      if ftype == TType.STOP:
10298 
        break
10299 
      if fid == 1:
10300 
        if ftype == TType.I64:
10301 
          self.cartId = iprot.readI64();
10302 
        else:
10303 
          iprot.skip(ftype)
10304 
      elif fid == 2:
10305 
        if ftype == TType.I64:
10306 
          self.addressId = iprot.readI64();
10307 
        else:
10308 
          iprot.skip(ftype)
10309 
      else:
10310 
        iprot.skip(ftype)
10311 
      iprot.readFieldEnd()
10312 
    iprot.readStructEnd()
10313 
 
10314 
  def write(self, oprot):
10315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10317 
      return
10318 
    oprot.writeStructBegin('addAddressToCart_args')
10319 
    if self.cartId != None:
10320 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10321 
      oprot.writeI64(self.cartId)
10322 
      oprot.writeFieldEnd()
10323 
    if self.addressId != None:
10324 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
10325 
      oprot.writeI64(self.addressId)
10326 
      oprot.writeFieldEnd()
10327 
    oprot.writeFieldStop()
10328 
    oprot.writeStructEnd()
10329 
 
10330 
  def __repr__(self):
10331 
    L = ['%s=%r' % (key, value)
10332 
      for key, value in self.__dict__.iteritems()]
10333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10334 
 
10335 
  def __eq__(self, other):
10336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10337 
 
10338 
  def __ne__(self, other):
10339 
    return not (self == other)
10340 
 
10341 
class addAddressToCart_result:
575 chandransh 10342 
  """
10343 
  Attributes:
10344 
   - scx
10345 
  """
559 chandransh 10346 
 
10347 
  thrift_spec = (
575 chandransh 10348 
    None, # 0
10349 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 10350 
  )
10351 
 
575 chandransh 10352 
  def __init__(self, scx=None,):
10353 
    self.scx = scx
10354 
 
559 chandransh 10355 
  def read(self, iprot):
10356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10358 
      return
10359 
    iprot.readStructBegin()
10360 
    while True:
10361 
      (fname, ftype, fid) = iprot.readFieldBegin()
10362 
      if ftype == TType.STOP:
10363 
        break
575 chandransh 10364 
      if fid == 1:
10365 
        if ftype == TType.STRUCT:
10366 
          self.scx = ShoppingCartException()
10367 
          self.scx.read(iprot)
10368 
        else:
10369 
          iprot.skip(ftype)
559 chandransh 10370 
      else:
10371 
        iprot.skip(ftype)
10372 
      iprot.readFieldEnd()
10373 
    iprot.readStructEnd()
10374 
 
10375 
  def write(self, oprot):
10376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10378 
      return
10379 
    oprot.writeStructBegin('addAddressToCart_result')
575 chandransh 10380 
    if self.scx != None:
10381 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10382 
      self.scx.write(oprot)
10383 
      oprot.writeFieldEnd()
559 chandransh 10384 
    oprot.writeFieldStop()
10385 
    oprot.writeStructEnd()
10386 
 
10387 
  def __repr__(self):
10388 
    L = ['%s=%r' % (key, value)
10389 
      for key, value in self.__dict__.iteritems()]
10390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10391 
 
10392 
  def __eq__(self, other):
10393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10394 
 
10395 
  def __ne__(self, other):
10396 
    return not (self == other)
10397 
 
690 chandransh 10398 
class createOrders_args:
559 chandransh 10399 
  """
10400 
  Attributes:
10401 
   - cartId
10402 
  """
10403 
 
10404 
  thrift_spec = (
10405 
    None, # 0
10406 
    (1, TType.I64, 'cartId', None, None, ), # 1
10407 
  )
10408 
 
10409 
  def __init__(self, cartId=None,):
10410 
    self.cartId = cartId
10411 
 
10412 
  def read(self, iprot):
10413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10415 
      return
10416 
    iprot.readStructBegin()
10417 
    while True:
10418 
      (fname, ftype, fid) = iprot.readFieldBegin()
10419 
      if ftype == TType.STOP:
10420 
        break
10421 
      if fid == 1:
10422 
        if ftype == TType.I64:
10423 
          self.cartId = iprot.readI64();
10424 
        else:
10425 
          iprot.skip(ftype)
10426 
      else:
10427 
        iprot.skip(ftype)
10428 
      iprot.readFieldEnd()
10429 
    iprot.readStructEnd()
10430 
 
10431 
  def write(self, oprot):
10432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10434 
      return
690 chandransh 10435 
    oprot.writeStructBegin('createOrders_args')
559 chandransh 10436 
    if self.cartId != None:
10437 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10438 
      oprot.writeI64(self.cartId)
10439 
      oprot.writeFieldEnd()
10440 
    oprot.writeFieldStop()
10441 
    oprot.writeStructEnd()
10442 
 
10443 
  def __repr__(self):
10444 
    L = ['%s=%r' % (key, value)
10445 
      for key, value in self.__dict__.iteritems()]
10446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10447 
 
10448 
  def __eq__(self, other):
10449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10450 
 
10451 
  def __ne__(self, other):
10452 
    return not (self == other)
10453 
 
690 chandransh 10454 
class createOrders_result:
559 chandransh 10455 
  """
10456 
  Attributes:
94 ashish 10457 
   - success
559 chandransh 10458 
   - scx
94 ashish 10459 
  """
10460 
 
10461 
  thrift_spec = (
575 chandransh 10462 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 10463 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10464 
  )
10465 
 
559 chandransh 10466 
  def __init__(self, success=None, scx=None,):
94 ashish 10467 
    self.success = success
559 chandransh 10468 
    self.scx = scx
94 ashish 10469 
 
10470 
  def read(self, iprot):
10471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10473 
      return
10474 
    iprot.readStructBegin()
10475 
    while True:
10476 
      (fname, ftype, fid) = iprot.readFieldBegin()
10477 
      if ftype == TType.STOP:
10478 
        break
10479 
      if fid == 0:
575 chandransh 10480 
        if ftype == TType.I64:
10481 
          self.success = iprot.readI64();
94 ashish 10482 
        else:
10483 
          iprot.skip(ftype)
10484 
      elif fid == 1:
10485 
        if ftype == TType.STRUCT:
559 chandransh 10486 
          self.scx = ShoppingCartException()
10487 
          self.scx.read(iprot)
94 ashish 10488 
        else:
10489 
          iprot.skip(ftype)
10490 
      else:
10491 
        iprot.skip(ftype)
10492 
      iprot.readFieldEnd()
10493 
    iprot.readStructEnd()
10494 
 
10495 
  def write(self, oprot):
10496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10498 
      return
690 chandransh 10499 
    oprot.writeStructBegin('createOrders_result')
94 ashish 10500 
    if self.success != None:
575 chandransh 10501 
      oprot.writeFieldBegin('success', TType.I64, 0)
10502 
      oprot.writeI64(self.success)
94 ashish 10503 
      oprot.writeFieldEnd()
559 chandransh 10504 
    if self.scx != None:
10505 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10506 
      self.scx.write(oprot)
94 ashish 10507 
      oprot.writeFieldEnd()
10508 
    oprot.writeFieldStop()
10509 
    oprot.writeStructEnd()
10510 
 
10511 
  def __repr__(self):
10512 
    L = ['%s=%r' % (key, value)
10513 
      for key, value in self.__dict__.iteritems()]
10514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10515 
 
10516 
  def __eq__(self, other):
10517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10518 
 
10519 
  def __ne__(self, other):
10520 
    return not (self == other)
10521 
 
559 chandransh 10522 
class validateCart_args:
94 ashish 10523 
  """
10524 
  Attributes:
559 chandransh 10525 
   - cartId
94 ashish 10526 
  """
10527 
 
10528 
  thrift_spec = (
10529 
    None, # 0
559 chandransh 10530 
    (1, TType.I64, 'cartId', None, None, ), # 1
94 ashish 10531 
  )
10532 
 
559 chandransh 10533 
  def __init__(self, cartId=None,):
10534 
    self.cartId = cartId
94 ashish 10535 
 
10536 
  def read(self, iprot):
10537 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10538 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10539 
      return
10540 
    iprot.readStructBegin()
10541 
    while True:
10542 
      (fname, ftype, fid) = iprot.readFieldBegin()
10543 
      if ftype == TType.STOP:
10544 
        break
10545 
      if fid == 1:
10546 
        if ftype == TType.I64:
559 chandransh 10547 
          self.cartId = iprot.readI64();
94 ashish 10548 
        else:
10549 
          iprot.skip(ftype)
10550 
      else:
10551 
        iprot.skip(ftype)
10552 
      iprot.readFieldEnd()
10553 
    iprot.readStructEnd()
10554 
 
10555 
  def write(self, oprot):
10556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10558 
      return
559 chandransh 10559 
    oprot.writeStructBegin('validateCart_args')
10560 
    if self.cartId != None:
10561 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10562 
      oprot.writeI64(self.cartId)
94 ashish 10563 
      oprot.writeFieldEnd()
10564 
    oprot.writeFieldStop()
10565 
    oprot.writeStructEnd()
10566 
 
10567 
  def __repr__(self):
10568 
    L = ['%s=%r' % (key, value)
10569 
      for key, value in self.__dict__.iteritems()]
10570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10571 
 
10572 
  def __eq__(self, other):
10573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10574 
 
10575 
  def __ne__(self, other):
10576 
    return not (self == other)
10577 
 
559 chandransh 10578 
class validateCart_result:
94 ashish 10579 
  """
10580 
  Attributes:
10581 
   - success
575 chandransh 10582 
   - scex
94 ashish 10583 
  """
10584 
 
10585 
  thrift_spec = (
1466 ankur.sing 10586 
    (0, TType.STRING, 'success', None, None, ), # 0
575 chandransh 10587 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10588 
  )
10589 
 
575 chandransh 10590 
  def __init__(self, success=None, scex=None,):
94 ashish 10591 
    self.success = success
575 chandransh 10592 
    self.scex = scex
94 ashish 10593 
 
10594 
  def read(self, iprot):
10595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10597 
      return
10598 
    iprot.readStructBegin()
10599 
    while True:
10600 
      (fname, ftype, fid) = iprot.readFieldBegin()
10601 
      if ftype == TType.STOP:
10602 
        break
10603 
      if fid == 0:
1466 ankur.sing 10604 
        if ftype == TType.STRING:
10605 
          self.success = iprot.readString();
94 ashish 10606 
        else:
10607 
          iprot.skip(ftype)
575 chandransh 10608 
      elif fid == 1:
10609 
        if ftype == TType.STRUCT:
10610 
          self.scex = ShoppingCartException()
10611 
          self.scex.read(iprot)
10612 
        else:
10613 
          iprot.skip(ftype)
94 ashish 10614 
      else:
10615 
        iprot.skip(ftype)
10616 
      iprot.readFieldEnd()
10617 
    iprot.readStructEnd()
10618 
 
10619 
  def write(self, oprot):
10620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10622 
      return
559 chandransh 10623 
    oprot.writeStructBegin('validateCart_result')
94 ashish 10624 
    if self.success != None:
1466 ankur.sing 10625 
      oprot.writeFieldBegin('success', TType.STRING, 0)
10626 
      oprot.writeString(self.success)
94 ashish 10627 
      oprot.writeFieldEnd()
575 chandransh 10628 
    if self.scex != None:
10629 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
10630 
      self.scex.write(oprot)
10631 
      oprot.writeFieldEnd()
559 chandransh 10632 
    oprot.writeFieldStop()
10633 
    oprot.writeStructEnd()
10634 
 
10635 
  def __repr__(self):
10636 
    L = ['%s=%r' % (key, value)
10637 
      for key, value in self.__dict__.iteritems()]
10638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10639 
 
10640 
  def __eq__(self, other):
10641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10642 
 
10643 
  def __ne__(self, other):
10644 
    return not (self == other)
10645 
 
690 chandransh 10646 
class mergeCart_args:
575 chandransh 10647 
  """
10648 
  Attributes:
690 chandransh 10649 
   - fromCartId
10650 
   - toCartId
10651 
  """
10652 
 
10653 
  thrift_spec = (
10654 
    None, # 0
10655 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
10656 
    (2, TType.I64, 'toCartId', None, None, ), # 2
10657 
  )
10658 
 
10659 
  def __init__(self, fromCartId=None, toCartId=None,):
10660 
    self.fromCartId = fromCartId
10661 
    self.toCartId = toCartId
10662 
 
10663 
  def read(self, iprot):
10664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10666 
      return
10667 
    iprot.readStructBegin()
10668 
    while True:
10669 
      (fname, ftype, fid) = iprot.readFieldBegin()
10670 
      if ftype == TType.STOP:
10671 
        break
10672 
      if fid == 1:
10673 
        if ftype == TType.I64:
10674 
          self.fromCartId = iprot.readI64();
10675 
        else:
10676 
          iprot.skip(ftype)
10677 
      elif fid == 2:
10678 
        if ftype == TType.I64:
10679 
          self.toCartId = iprot.readI64();
10680 
        else:
10681 
          iprot.skip(ftype)
10682 
      else:
10683 
        iprot.skip(ftype)
10684 
      iprot.readFieldEnd()
10685 
    iprot.readStructEnd()
10686 
 
10687 
  def write(self, oprot):
10688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10690 
      return
10691 
    oprot.writeStructBegin('mergeCart_args')
10692 
    if self.fromCartId != None:
10693 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
10694 
      oprot.writeI64(self.fromCartId)
10695 
      oprot.writeFieldEnd()
10696 
    if self.toCartId != None:
10697 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
10698 
      oprot.writeI64(self.toCartId)
10699 
      oprot.writeFieldEnd()
10700 
    oprot.writeFieldStop()
10701 
    oprot.writeStructEnd()
10702 
 
10703 
  def __repr__(self):
10704 
    L = ['%s=%r' % (key, value)
10705 
      for key, value in self.__dict__.iteritems()]
10706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10707 
 
10708 
  def __eq__(self, other):
10709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10710 
 
10711 
  def __ne__(self, other):
10712 
    return not (self == other)
10713 
 
10714 
class mergeCart_result:
10715 
 
10716 
  thrift_spec = (
10717 
  )
10718 
 
10719 
  def read(self, iprot):
10720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10722 
      return
10723 
    iprot.readStructBegin()
10724 
    while True:
10725 
      (fname, ftype, fid) = iprot.readFieldBegin()
10726 
      if ftype == TType.STOP:
10727 
        break
10728 
      else:
10729 
        iprot.skip(ftype)
10730 
      iprot.readFieldEnd()
10731 
    iprot.readStructEnd()
10732 
 
10733 
  def write(self, oprot):
10734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10736 
      return
10737 
    oprot.writeStructBegin('mergeCart_result')
10738 
    oprot.writeFieldStop()
10739 
    oprot.writeStructEnd()
10740 
 
10741 
  def __repr__(self):
10742 
    L = ['%s=%r' % (key, value)
10743 
      for key, value in self.__dict__.iteritems()]
10744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10745 
 
10746 
  def __eq__(self, other):
10747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10748 
 
10749 
  def __ne__(self, other):
10750 
    return not (self == other)
10751 
 
10752 
class checkOut_args:
10753 
  """
10754 
  Attributes:
575 chandransh 10755 
   - cartId
10756 
  """
10757 
 
10758 
  thrift_spec = (
10759 
    None, # 0
10760 
    (1, TType.I64, 'cartId', None, None, ), # 1
10761 
  )
10762 
 
10763 
  def __init__(self, cartId=None,):
10764 
    self.cartId = cartId
10765 
 
10766 
  def read(self, iprot):
10767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10769 
      return
10770 
    iprot.readStructBegin()
10771 
    while True:
10772 
      (fname, ftype, fid) = iprot.readFieldBegin()
10773 
      if ftype == TType.STOP:
10774 
        break
10775 
      if fid == 1:
10776 
        if ftype == TType.I64:
10777 
          self.cartId = iprot.readI64();
10778 
        else:
10779 
          iprot.skip(ftype)
10780 
      else:
10781 
        iprot.skip(ftype)
10782 
      iprot.readFieldEnd()
10783 
    iprot.readStructEnd()
10784 
 
10785 
  def write(self, oprot):
10786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10788 
      return
690 chandransh 10789 
    oprot.writeStructBegin('checkOut_args')
575 chandransh 10790 
    if self.cartId != None:
10791 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10792 
      oprot.writeI64(self.cartId)
10793 
      oprot.writeFieldEnd()
10794 
    oprot.writeFieldStop()
10795 
    oprot.writeStructEnd()
10796 
 
10797 
  def __repr__(self):
10798 
    L = ['%s=%r' % (key, value)
10799 
      for key, value in self.__dict__.iteritems()]
10800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10801 
 
10802 
  def __eq__(self, other):
10803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10804 
 
10805 
  def __ne__(self, other):
10806 
    return not (self == other)
10807 
 
690 chandransh 10808 
class checkOut_result:
575 chandransh 10809 
  """
10810 
  Attributes:
10811 
   - success
10812 
   - scex
10813 
  """
10814 
 
10815 
  thrift_spec = (
10816 
    (0, TType.BOOL, 'success', None, None, ), # 0
10817 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10818 
  )
10819 
 
10820 
  def __init__(self, success=None, scex=None,):
10821 
    self.success = success
10822 
    self.scex = scex
10823 
 
10824 
  def read(self, iprot):
10825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10827 
      return
10828 
    iprot.readStructBegin()
10829 
    while True:
10830 
      (fname, ftype, fid) = iprot.readFieldBegin()
10831 
      if ftype == TType.STOP:
10832 
        break
10833 
      if fid == 0:
10834 
        if ftype == TType.BOOL:
10835 
          self.success = iprot.readBool();
10836 
        else:
10837 
          iprot.skip(ftype)
10838 
      elif fid == 1:
10839 
        if ftype == TType.STRUCT:
10840 
          self.scex = ShoppingCartException()
10841 
          self.scex.read(iprot)
10842 
        else:
10843 
          iprot.skip(ftype)
10844 
      else:
10845 
        iprot.skip(ftype)
10846 
      iprot.readFieldEnd()
10847 
    iprot.readStructEnd()
10848 
 
10849 
  def write(self, oprot):
10850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10852 
      return
690 chandransh 10853 
    oprot.writeStructBegin('checkOut_result')
575 chandransh 10854 
    if self.success != None:
10855 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
10856 
      oprot.writeBool(self.success)
10857 
      oprot.writeFieldEnd()
10858 
    if self.scex != None:
10859 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
10860 
      self.scex.write(oprot)
10861 
      oprot.writeFieldEnd()
10862 
    oprot.writeFieldStop()
10863 
    oprot.writeStructEnd()
10864 
 
10865 
  def __repr__(self):
10866 
    L = ['%s=%r' % (key, value)
10867 
      for key, value in self.__dict__.iteritems()]
10868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10869 
 
10870 
  def __eq__(self, other):
10871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10872 
 
10873 
  def __ne__(self, other):
10874 
    return not (self == other)
10875 
 
690 chandransh 10876 
class resetCart_args:
559 chandransh 10877 
  """
10878 
  Attributes:
690 chandransh 10879 
   - cartId
10880 
   - items
559 chandransh 10881 
  """
10882 
 
10883 
  thrift_spec = (
10884 
    None, # 0
690 chandransh 10885 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 10886 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 10887 
  )
10888 
 
690 chandransh 10889 
  def __init__(self, cartId=None, items=None,):
10890 
    self.cartId = cartId
10891 
    self.items = items
559 chandransh 10892 
 
10893 
  def read(self, iprot):
10894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10896 
      return
10897 
    iprot.readStructBegin()
10898 
    while True:
10899 
      (fname, ftype, fid) = iprot.readFieldBegin()
10900 
      if ftype == TType.STOP:
10901 
        break
10902 
      if fid == 1:
10903 
        if ftype == TType.I64:
690 chandransh 10904 
          self.cartId = iprot.readI64();
559 chandransh 10905 
        else:
10906 
          iprot.skip(ftype)
10907 
      elif fid == 2:
690 chandransh 10908 
        if ftype == TType.MAP:
10909 
          self.items = {}
1845 vikas 10910 
          (_ktype106, _vtype107, _size105 ) = iprot.readMapBegin()
10911 
          for _i109 in xrange(_size105):
10912 
            _key110 = iprot.readI64();
10913 
            _val111 = iprot.readDouble();
10914 
            self.items[_key110] = _val111
690 chandransh 10915 
          iprot.readMapEnd()
559 chandransh 10916 
        else:
10917 
          iprot.skip(ftype)
10918 
      else:
10919 
        iprot.skip(ftype)
10920 
      iprot.readFieldEnd()
10921 
    iprot.readStructEnd()
10922 
 
10923 
  def write(self, oprot):
10924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10926 
      return
690 chandransh 10927 
    oprot.writeStructBegin('resetCart_args')
10928 
    if self.cartId != None:
10929 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10930 
      oprot.writeI64(self.cartId)
94 ashish 10931 
      oprot.writeFieldEnd()
690 chandransh 10932 
    if self.items != None:
10933 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 10934 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
1845 vikas 10935 
      for kiter112,viter113 in self.items.items():
10936 
        oprot.writeI64(kiter112)
10937 
        oprot.writeDouble(viter113)
690 chandransh 10938 
      oprot.writeMapEnd()
559 chandransh 10939 
      oprot.writeFieldEnd()
94 ashish 10940 
    oprot.writeFieldStop()
10941 
    oprot.writeStructEnd()
10942 
 
10943 
  def __repr__(self):
10944 
    L = ['%s=%r' % (key, value)
10945 
      for key, value in self.__dict__.iteritems()]
10946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10947 
 
10948 
  def __eq__(self, other):
10949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10950 
 
10951 
  def __ne__(self, other):
10952 
    return not (self == other)
10953 
 
690 chandransh 10954 
class resetCart_result:
10955 
  """
10956 
  Attributes:
10957 
   - success
10958 
   - scex
10959 
  """
559 chandransh 10960 
 
10961 
  thrift_spec = (
690 chandransh 10962 
    (0, TType.BOOL, 'success', None, None, ), # 0
10963 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 10964 
  )
10965 
 
690 chandransh 10966 
  def __init__(self, success=None, scex=None,):
10967 
    self.success = success
10968 
    self.scex = scex
10969 
 
559 chandransh 10970 
  def read(self, iprot):
10971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10973 
      return
10974 
    iprot.readStructBegin()
10975 
    while True:
10976 
      (fname, ftype, fid) = iprot.readFieldBegin()
10977 
      if ftype == TType.STOP:
10978 
        break
690 chandransh 10979 
      if fid == 0:
10980 
        if ftype == TType.BOOL:
10981 
          self.success = iprot.readBool();
10982 
        else:
10983 
          iprot.skip(ftype)
10984 
      elif fid == 1:
10985 
        if ftype == TType.STRUCT:
10986 
          self.scex = ShoppingCartException()
10987 
          self.scex.read(iprot)
10988 
        else:
10989 
          iprot.skip(ftype)
559 chandransh 10990 
      else:
10991 
        iprot.skip(ftype)
10992 
      iprot.readFieldEnd()
10993 
    iprot.readStructEnd()
10994 
 
10995 
  def write(self, oprot):
10996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10998 
      return
690 chandransh 10999 
    oprot.writeStructBegin('resetCart_result')
11000 
    if self.success != None:
11001 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11002 
      oprot.writeBool(self.success)
11003 
      oprot.writeFieldEnd()
11004 
    if self.scex != None:
11005 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11006 
      self.scex.write(oprot)
11007 
      oprot.writeFieldEnd()
559 chandransh 11008 
    oprot.writeFieldStop()
11009 
    oprot.writeStructEnd()
11010 
 
11011 
  def __repr__(self):
11012 
    L = ['%s=%r' % (key, value)
11013 
      for key, value in self.__dict__.iteritems()]
11014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11015 
 
11016 
  def __eq__(self, other):
11017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11018 
 
11019 
  def __ne__(self, other):
11020 
    return not (self == other)
11021 
 
772 rajveer 11022 
class getMyResearch_args:
94 ashish 11023 
  """
11024 
  Attributes:
559 chandransh 11025 
   - userId
11026 
  """
11027 
 
11028 
  thrift_spec = (
11029 
    None, # 0
772 rajveer 11030 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 11031 
  )
11032 
 
772 rajveer 11033 
  def __init__(self, userId=None,):
559 chandransh 11034 
    self.userId = userId
11035 
 
11036 
  def read(self, iprot):
11037 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11038 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11039 
      return
11040 
    iprot.readStructBegin()
11041 
    while True:
11042 
      (fname, ftype, fid) = iprot.readFieldBegin()
11043 
      if ftype == TType.STOP:
11044 
        break
11045 
      if fid == 1:
11046 
        if ftype == TType.I64:
11047 
          self.userId = iprot.readI64();
11048 
        else:
11049 
          iprot.skip(ftype)
11050 
      else:
11051 
        iprot.skip(ftype)
11052 
      iprot.readFieldEnd()
11053 
    iprot.readStructEnd()
11054 
 
11055 
  def write(self, oprot):
11056 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11057 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11058 
      return
772 rajveer 11059 
    oprot.writeStructBegin('getMyResearch_args')
559 chandransh 11060 
    if self.userId != None:
772 rajveer 11061 
      oprot.writeFieldBegin('userId', TType.I64, 1)
559 chandransh 11062 
      oprot.writeI64(self.userId)
11063 
      oprot.writeFieldEnd()
11064 
    oprot.writeFieldStop()
11065 
    oprot.writeStructEnd()
11066 
 
11067 
  def __repr__(self):
11068 
    L = ['%s=%r' % (key, value)
11069 
      for key, value in self.__dict__.iteritems()]
11070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11071 
 
11072 
  def __eq__(self, other):
11073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11074 
 
11075 
  def __ne__(self, other):
11076 
    return not (self == other)
11077 
 
11078 
class getMyResearch_result:
94 ashish 11079 
  """
11080 
  Attributes:
11081 
   - success
559 chandransh 11082 
   - scx
94 ashish 11083 
  """
11084 
 
11085 
  thrift_spec = (
559 chandransh 11086 
    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
11087 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
94 ashish 11088 
  )
11089 
 
559 chandransh 11090 
  def __init__(self, success=None, scx=None,):
94 ashish 11091 
    self.success = success
559 chandransh 11092 
    self.scx = scx
94 ashish 11093 
 
11094 
  def read(self, iprot):
11095 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11096 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11097 
      return
11098 
    iprot.readStructBegin()
11099 
    while True:
11100 
      (fname, ftype, fid) = iprot.readFieldBegin()
11101 
      if ftype == TType.STOP:
11102 
        break
11103 
      if fid == 0:
559 chandransh 11104 
        if ftype == TType.STRUCT:
11105 
          self.success = Widget()
11106 
          self.success.read(iprot)
94 ashish 11107 
        else:
11108 
          iprot.skip(ftype)
11109 
      elif fid == 1:
11110 
        if ftype == TType.STRUCT:
559 chandransh 11111 
          self.scx = WidgetException()
11112 
          self.scx.read(iprot)
94 ashish 11113 
        else:
11114 
          iprot.skip(ftype)
11115 
      else:
11116 
        iprot.skip(ftype)
11117 
      iprot.readFieldEnd()
11118 
    iprot.readStructEnd()
11119 
 
11120 
  def write(self, oprot):
11121 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11122 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11123 
      return
559 chandransh 11124 
    oprot.writeStructBegin('getMyResearch_result')
94 ashish 11125 
    if self.success != None:
559 chandransh 11126 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11127 
      self.success.write(oprot)
94 ashish 11128 
      oprot.writeFieldEnd()
559 chandransh 11129 
    if self.scx != None:
11130 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11131 
      self.scx.write(oprot)
94 ashish 11132 
      oprot.writeFieldEnd()
11133 
    oprot.writeFieldStop()
11134 
    oprot.writeStructEnd()
11135 
 
11136 
  def __repr__(self):
11137 
    L = ['%s=%r' % (key, value)
11138 
      for key, value in self.__dict__.iteritems()]
11139 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11140 
 
11141 
  def __eq__(self, other):
11142 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11143 
 
11144 
  def __ne__(self, other):
11145 
    return not (self == other)
11146 
 
559 chandransh 11147 
class updateMyResearch_args:
94 ashish 11148 
  """
11149 
  Attributes:
772 rajveer 11150 
   - userId
11151 
   - itemId
94 ashish 11152 
  """
11153 
 
11154 
  thrift_spec = (
11155 
    None, # 0
772 rajveer 11156 
    (1, TType.I64, 'userId', None, None, ), # 1
11157 
    (2, TType.I64, 'itemId', None, None, ), # 2
94 ashish 11158 
  )
11159 
 
772 rajveer 11160 
  def __init__(self, userId=None, itemId=None,):
11161 
    self.userId = userId
11162 
    self.itemId = itemId
94 ashish 11163 
 
11164 
  def read(self, iprot):
11165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11167 
      return
11168 
    iprot.readStructBegin()
11169 
    while True:
11170 
      (fname, ftype, fid) = iprot.readFieldBegin()
11171 
      if ftype == TType.STOP:
11172 
        break
11173 
      if fid == 1:
11174 
        if ftype == TType.I64:
772 rajveer 11175 
          self.userId = iprot.readI64();
94 ashish 11176 
        else:
11177 
          iprot.skip(ftype)
11178 
      elif fid == 2:
559 chandransh 11179 
        if ftype == TType.I64:
772 rajveer 11180 
          self.itemId = iprot.readI64();
94 ashish 11181 
        else:
11182 
          iprot.skip(ftype)
11183 
      else:
11184 
        iprot.skip(ftype)
11185 
      iprot.readFieldEnd()
11186 
    iprot.readStructEnd()
11187 
 
11188 
  def write(self, oprot):
11189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11191 
      return
559 chandransh 11192 
    oprot.writeStructBegin('updateMyResearch_args')
772 rajveer 11193 
    if self.userId != None:
11194 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11195 
      oprot.writeI64(self.userId)
94 ashish 11196 
      oprot.writeFieldEnd()
772 rajveer 11197 
    if self.itemId != None:
11198 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11199 
      oprot.writeI64(self.itemId)
94 ashish 11200 
      oprot.writeFieldEnd()
11201 
    oprot.writeFieldStop()
11202 
    oprot.writeStructEnd()
11203 
 
11204 
  def __repr__(self):
11205 
    L = ['%s=%r' % (key, value)
11206 
      for key, value in self.__dict__.iteritems()]
11207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11208 
 
11209 
  def __eq__(self, other):
11210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11211 
 
11212 
  def __ne__(self, other):
11213 
    return not (self == other)
11214 
 
559 chandransh 11215 
class updateMyResearch_result:
94 ashish 11216 
  """
11217 
  Attributes:
11218 
   - success
559 chandransh 11219 
   - scx
94 ashish 11220 
  """
11221 
 
11222 
  thrift_spec = (
11223 
    (0, TType.BOOL, 'success', None, None, ), # 0
559 chandransh 11224 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
94 ashish 11225 
  )
11226 
 
559 chandransh 11227 
  def __init__(self, success=None, scx=None,):
94 ashish 11228 
    self.success = success
559 chandransh 11229 
    self.scx = scx
94 ashish 11230 
 
11231 
  def read(self, iprot):
11232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11234 
      return
11235 
    iprot.readStructBegin()
11236 
    while True:
11237 
      (fname, ftype, fid) = iprot.readFieldBegin()
11238 
      if ftype == TType.STOP:
11239 
        break
11240 
      if fid == 0:
11241 
        if ftype == TType.BOOL:
11242 
          self.success = iprot.readBool();
11243 
        else:
11244 
          iprot.skip(ftype)
11245 
      elif fid == 1:
11246 
        if ftype == TType.STRUCT:
559 chandransh 11247 
          self.scx = WidgetException()
11248 
          self.scx.read(iprot)
94 ashish 11249 
        else:
11250 
          iprot.skip(ftype)
11251 
      else:
11252 
        iprot.skip(ftype)
11253 
      iprot.readFieldEnd()
11254 
    iprot.readStructEnd()
11255 
 
11256 
  def write(self, oprot):
11257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11259 
      return
559 chandransh 11260 
    oprot.writeStructBegin('updateMyResearch_result')
94 ashish 11261 
    if self.success != None:
11262 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11263 
      oprot.writeBool(self.success)
11264 
      oprot.writeFieldEnd()
559 chandransh 11265 
    if self.scx != None:
11266 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11267 
      self.scx.write(oprot)
94 ashish 11268 
      oprot.writeFieldEnd()
11269 
    oprot.writeFieldStop()
11270 
    oprot.writeStructEnd()
11271 
 
11272 
  def __repr__(self):
11273 
    L = ['%s=%r' % (key, value)
11274 
      for key, value in self.__dict__.iteritems()]
11275 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11276 
 
11277 
  def __eq__(self, other):
11278 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11279 
 
11280 
  def __ne__(self, other):
11281 
    return not (self == other)
11282 
 
559 chandransh 11283 
class deleteItemFromMyResearch_args:
130 ashish 11284 
  """
11285 
  Attributes:
772 rajveer 11286 
   - userId
11287 
   - itemId
130 ashish 11288 
  """
94 ashish 11289 
 
130 ashish 11290 
  thrift_spec = (
11291 
    None, # 0
772 rajveer 11292 
    (1, TType.I64, 'userId', None, None, ), # 1
11293 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 11294 
  )
11295 
 
772 rajveer 11296 
  def __init__(self, userId=None, itemId=None,):
11297 
    self.userId = userId
11298 
    self.itemId = itemId
130 ashish 11299 
 
11300 
  def read(self, iprot):
11301 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11302 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11303 
      return
11304 
    iprot.readStructBegin()
11305 
    while True:
11306 
      (fname, ftype, fid) = iprot.readFieldBegin()
11307 
      if ftype == TType.STOP:
11308 
        break
11309 
      if fid == 1:
11310 
        if ftype == TType.I64:
772 rajveer 11311 
          self.userId = iprot.readI64();
130 ashish 11312 
        else:
11313 
          iprot.skip(ftype)
559 chandransh 11314 
      elif fid == 2:
11315 
        if ftype == TType.I64:
772 rajveer 11316 
          self.itemId = iprot.readI64();
559 chandransh 11317 
        else:
11318 
          iprot.skip(ftype)
130 ashish 11319 
      else:
11320 
        iprot.skip(ftype)
11321 
      iprot.readFieldEnd()
11322 
    iprot.readStructEnd()
11323 
 
11324 
  def write(self, oprot):
11325 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11326 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11327 
      return
559 chandransh 11328 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
772 rajveer 11329 
    if self.userId != None:
11330 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11331 
      oprot.writeI64(self.userId)
130 ashish 11332 
      oprot.writeFieldEnd()
772 rajveer 11333 
    if self.itemId != None:
11334 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11335 
      oprot.writeI64(self.itemId)
559 chandransh 11336 
      oprot.writeFieldEnd()
130 ashish 11337 
    oprot.writeFieldStop()
11338 
    oprot.writeStructEnd()
11339 
 
11340 
  def __repr__(self):
11341 
    L = ['%s=%r' % (key, value)
11342 
      for key, value in self.__dict__.iteritems()]
11343 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11344 
 
11345 
  def __eq__(self, other):
11346 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11347 
 
11348 
  def __ne__(self, other):
11349 
    return not (self == other)
11350 
 
559 chandransh 11351 
class deleteItemFromMyResearch_result:
130 ashish 11352 
  """
11353 
  Attributes:
559 chandransh 11354 
   - scx
11355 
  """
11356 
 
11357 
  thrift_spec = (
11358 
    None, # 0
11359 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
11360 
  )
11361 
 
11362 
  def __init__(self, scx=None,):
11363 
    self.scx = scx
11364 
 
11365 
  def read(self, iprot):
11366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11368 
      return
11369 
    iprot.readStructBegin()
11370 
    while True:
11371 
      (fname, ftype, fid) = iprot.readFieldBegin()
11372 
      if ftype == TType.STOP:
11373 
        break
11374 
      if fid == 1:
11375 
        if ftype == TType.STRUCT:
11376 
          self.scx = WidgetException()
11377 
          self.scx.read(iprot)
11378 
        else:
11379 
          iprot.skip(ftype)
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
11389 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
11390 
    if self.scx != None:
11391 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11392 
      self.scx.write(oprot)
11393 
      oprot.writeFieldEnd()
11394 
    oprot.writeFieldStop()
11395 
    oprot.writeStructEnd()
11396 
 
11397 
  def __repr__(self):
11398 
    L = ['%s=%r' % (key, value)
11399 
      for key, value in self.__dict__.iteritems()]
11400 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11401 
 
11402 
  def __eq__(self, other):
11403 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11404 
 
11405 
  def __ne__(self, other):
11406 
    return not (self == other)
11407 
 
772 rajveer 11408 
class updateBrowseHistory_args:
559 chandransh 11409 
  """
11410 
  Attributes:
772 rajveer 11411 
   - userId
11412 
   - itemId
559 chandransh 11413 
  """
11414 
 
11415 
  thrift_spec = (
11416 
    None, # 0
772 rajveer 11417 
    (1, TType.I64, 'userId', None, None, ), # 1
11418 
    (2, TType.I64, 'itemId', None, None, ), # 2
559 chandransh 11419 
  )
11420 
 
772 rajveer 11421 
  def __init__(self, userId=None, itemId=None,):
11422 
    self.userId = userId
11423 
    self.itemId = itemId
559 chandransh 11424 
 
11425 
  def read(self, iprot):
11426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11428 
      return
11429 
    iprot.readStructBegin()
11430 
    while True:
11431 
      (fname, ftype, fid) = iprot.readFieldBegin()
11432 
      if ftype == TType.STOP:
11433 
        break
11434 
      if fid == 1:
11435 
        if ftype == TType.I64:
772 rajveer 11436 
          self.userId = iprot.readI64();
559 chandransh 11437 
        else:
11438 
          iprot.skip(ftype)
11439 
      elif fid == 2:
11440 
        if ftype == TType.I64:
772 rajveer 11441 
          self.itemId = iprot.readI64();
559 chandransh 11442 
        else:
11443 
          iprot.skip(ftype)
11444 
      else:
11445 
        iprot.skip(ftype)
11446 
      iprot.readFieldEnd()
11447 
    iprot.readStructEnd()
11448 
 
11449 
  def write(self, oprot):
11450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11452 
      return
772 rajveer 11453 
    oprot.writeStructBegin('updateBrowseHistory_args')
11454 
    if self.userId != None:
11455 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11456 
      oprot.writeI64(self.userId)
559 chandransh 11457 
      oprot.writeFieldEnd()
772 rajveer 11458 
    if self.itemId != None:
11459 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11460 
      oprot.writeI64(self.itemId)
559 chandransh 11461 
      oprot.writeFieldEnd()
11462 
    oprot.writeFieldStop()
11463 
    oprot.writeStructEnd()
11464 
 
11465 
  def __repr__(self):
11466 
    L = ['%s=%r' % (key, value)
11467 
      for key, value in self.__dict__.iteritems()]
11468 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11469 
 
11470 
  def __eq__(self, other):
11471 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11472 
 
11473 
  def __ne__(self, other):
11474 
    return not (self == other)
11475 
 
772 rajveer 11476 
class updateBrowseHistory_result:
559 chandransh 11477 
 
11478 
  thrift_spec = (
11479 
  )
11480 
 
11481 
  def read(self, iprot):
11482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11484 
      return
11485 
    iprot.readStructBegin()
11486 
    while True:
11487 
      (fname, ftype, fid) = iprot.readFieldBegin()
11488 
      if ftype == TType.STOP:
11489 
        break
11490 
      else:
11491 
        iprot.skip(ftype)
11492 
      iprot.readFieldEnd()
11493 
    iprot.readStructEnd()
11494 
 
11495 
  def write(self, oprot):
11496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11498 
      return
772 rajveer 11499 
    oprot.writeStructBegin('updateBrowseHistory_result')
559 chandransh 11500 
    oprot.writeFieldStop()
11501 
    oprot.writeStructEnd()
11502 
 
11503 
  def __repr__(self):
11504 
    L = ['%s=%r' % (key, value)
11505 
      for key, value in self.__dict__.iteritems()]
11506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11507 
 
11508 
  def __eq__(self, other):
11509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11510 
 
11511 
  def __ne__(self, other):
11512 
    return not (self == other)
11513 
 
772 rajveer 11514 
class getBrowseHistory_args:
559 chandransh 11515 
  """
11516 
  Attributes:
772 rajveer 11517 
   - userId
559 chandransh 11518 
  """
11519 
 
11520 
  thrift_spec = (
11521 
    None, # 0
772 rajveer 11522 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 11523 
  )
11524 
 
772 rajveer 11525 
  def __init__(self, userId=None,):
11526 
    self.userId = userId
559 chandransh 11527 
 
11528 
  def read(self, iprot):
11529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11531 
      return
11532 
    iprot.readStructBegin()
11533 
    while True:
11534 
      (fname, ftype, fid) = iprot.readFieldBegin()
11535 
      if ftype == TType.STOP:
11536 
        break
11537 
      if fid == 1:
11538 
        if ftype == TType.I64:
772 rajveer 11539 
          self.userId = iprot.readI64();
559 chandransh 11540 
        else:
11541 
          iprot.skip(ftype)
11542 
      else:
11543 
        iprot.skip(ftype)
11544 
      iprot.readFieldEnd()
11545 
    iprot.readStructEnd()
11546 
 
11547 
  def write(self, oprot):
11548 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11549 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11550 
      return
772 rajveer 11551 
    oprot.writeStructBegin('getBrowseHistory_args')
11552 
    if self.userId != None:
11553 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11554 
      oprot.writeI64(self.userId)
559 chandransh 11555 
      oprot.writeFieldEnd()
11556 
    oprot.writeFieldStop()
11557 
    oprot.writeStructEnd()
11558 
 
11559 
  def __repr__(self):
11560 
    L = ['%s=%r' % (key, value)
11561 
      for key, value in self.__dict__.iteritems()]
11562 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11563 
 
11564 
  def __eq__(self, other):
11565 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11566 
 
11567 
  def __ne__(self, other):
11568 
    return not (self == other)
11569 
 
772 rajveer 11570 
class getBrowseHistory_result:
559 chandransh 11571 
  """
11572 
  Attributes:
130 ashish 11573 
   - success
559 chandransh 11574 
   - scx
130 ashish 11575 
  """
11576 
 
11577 
  thrift_spec = (
772 rajveer 11578 
    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
559 chandransh 11579 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 11580 
  )
11581 
 
559 chandransh 11582 
  def __init__(self, success=None, scx=None,):
130 ashish 11583 
    self.success = success
559 chandransh 11584 
    self.scx = scx
130 ashish 11585 
 
11586 
  def read(self, iprot):
11587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11589 
      return
11590 
    iprot.readStructBegin()
11591 
    while True:
11592 
      (fname, ftype, fid) = iprot.readFieldBegin()
11593 
      if ftype == TType.STOP:
11594 
        break
11595 
      if fid == 0:
559 chandransh 11596 
        if ftype == TType.STRUCT:
772 rajveer 11597 
          self.success = Widget()
559 chandransh 11598 
          self.success.read(iprot)
130 ashish 11599 
        else:
11600 
          iprot.skip(ftype)
11601 
      elif fid == 1:
11602 
        if ftype == TType.STRUCT:
559 chandransh 11603 
          self.scx = WidgetException()
11604 
          self.scx.read(iprot)
130 ashish 11605 
        else:
11606 
          iprot.skip(ftype)
11607 
      else:
11608 
        iprot.skip(ftype)
11609 
      iprot.readFieldEnd()
11610 
    iprot.readStructEnd()
11611 
 
11612 
  def write(self, oprot):
11613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11615 
      return
772 rajveer 11616 
    oprot.writeStructBegin('getBrowseHistory_result')
130 ashish 11617 
    if self.success != None:
559 chandransh 11618 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11619 
      self.success.write(oprot)
130 ashish 11620 
      oprot.writeFieldEnd()
559 chandransh 11621 
    if self.scx != None:
11622 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11623 
      self.scx.write(oprot)
130 ashish 11624 
      oprot.writeFieldEnd()
11625 
    oprot.writeFieldStop()
11626 
    oprot.writeStructEnd()
11627 
 
11628 
  def __repr__(self):
11629 
    L = ['%s=%r' % (key, value)
11630 
      for key, value in self.__dict__.iteritems()]
11631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11632 
 
11633 
  def __eq__(self, other):
11634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11635 
 
11636 
  def __ne__(self, other):
11637 
    return not (self == other)
11638 
 
772 rajveer 11639 
class mergeBrowseHistory_args:
130 ashish 11640 
  """
11641 
  Attributes:
772 rajveer 11642 
   - fromUserId
11643 
   - toUserId
130 ashish 11644 
  """
11645 
 
11646 
  thrift_spec = (
11647 
    None, # 0
772 rajveer 11648 
    (1, TType.I64, 'fromUserId', None, None, ), # 1
11649 
    (2, TType.I64, 'toUserId', None, None, ), # 2
130 ashish 11650 
  )
11651 
 
772 rajveer 11652 
  def __init__(self, fromUserId=None, toUserId=None,):
11653 
    self.fromUserId = fromUserId
11654 
    self.toUserId = toUserId
130 ashish 11655 
 
11656 
  def read(self, iprot):
11657 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11658 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11659 
      return
11660 
    iprot.readStructBegin()
11661 
    while True:
11662 
      (fname, ftype, fid) = iprot.readFieldBegin()
11663 
      if ftype == TType.STOP:
11664 
        break
11665 
      if fid == 1:
559 chandransh 11666 
        if ftype == TType.I64:
772 rajveer 11667 
          self.fromUserId = iprot.readI64();
130 ashish 11668 
        else:
11669 
          iprot.skip(ftype)
11670 
      elif fid == 2:
559 chandransh 11671 
        if ftype == TType.I64:
772 rajveer 11672 
          self.toUserId = iprot.readI64();
559 chandransh 11673 
        else:
11674 
          iprot.skip(ftype)
130 ashish 11675 
      else:
11676 
        iprot.skip(ftype)
11677 
      iprot.readFieldEnd()
11678 
    iprot.readStructEnd()
11679 
 
11680 
  def write(self, oprot):
11681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11683 
      return
772 rajveer 11684 
    oprot.writeStructBegin('mergeBrowseHistory_args')
11685 
    if self.fromUserId != None:
11686 
      oprot.writeFieldBegin('fromUserId', TType.I64, 1)
11687 
      oprot.writeI64(self.fromUserId)
130 ashish 11688 
      oprot.writeFieldEnd()
772 rajveer 11689 
    if self.toUserId != None:
11690 
      oprot.writeFieldBegin('toUserId', TType.I64, 2)
11691 
      oprot.writeI64(self.toUserId)
130 ashish 11692 
      oprot.writeFieldEnd()
11693 
    oprot.writeFieldStop()
11694 
    oprot.writeStructEnd()
11695 
 
11696 
  def __repr__(self):
11697 
    L = ['%s=%r' % (key, value)
11698 
      for key, value in self.__dict__.iteritems()]
11699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11700 
 
11701 
  def __eq__(self, other):
11702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11703 
 
11704 
  def __ne__(self, other):
11705 
    return not (self == other)
11706 
 
772 rajveer 11707 
class mergeBrowseHistory_result:
559 chandransh 11708 
 
11709 
  thrift_spec = (
11710 
  )
11711 
 
11712 
  def read(self, iprot):
11713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11715 
      return
11716 
    iprot.readStructBegin()
11717 
    while True:
11718 
      (fname, ftype, fid) = iprot.readFieldBegin()
11719 
      if ftype == TType.STOP:
11720 
        break
11721 
      else:
11722 
        iprot.skip(ftype)
11723 
      iprot.readFieldEnd()
11724 
    iprot.readStructEnd()
11725 
 
11726 
  def write(self, oprot):
11727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11729 
      return
772 rajveer 11730 
    oprot.writeStructBegin('mergeBrowseHistory_result')
559 chandransh 11731 
    oprot.writeFieldStop()
11732 
    oprot.writeStructEnd()
11733 
 
11734 
  def __repr__(self):
11735 
    L = ['%s=%r' % (key, value)
11736 
      for key, value in self.__dict__.iteritems()]
11737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11738 
 
11739 
  def __eq__(self, other):
11740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11741 
 
11742 
  def __ne__(self, other):
11743 
    return not (self == other)
11744 
 
1596 ankur.sing 11745 
class getUserCount_args:
11746 
  """
11747 
  Attributes:
11748 
   - userType
11749 
  """
559 chandransh 11750 
 
1596 ankur.sing 11751 
  thrift_spec = (
11752 
    None, # 0
11753 
    (1, TType.I32, 'userType', None, None, ), # 1
11754 
  )
11755 
 
11756 
  def __init__(self, userType=None,):
11757 
    self.userType = userType
11758 
 
11759 
  def read(self, iprot):
11760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11762 
      return
11763 
    iprot.readStructBegin()
11764 
    while True:
11765 
      (fname, ftype, fid) = iprot.readFieldBegin()
11766 
      if ftype == TType.STOP:
11767 
        break
11768 
      if fid == 1:
11769 
        if ftype == TType.I32:
11770 
          self.userType = iprot.readI32();
11771 
        else:
11772 
          iprot.skip(ftype)
11773 
      else:
11774 
        iprot.skip(ftype)
11775 
      iprot.readFieldEnd()
11776 
    iprot.readStructEnd()
11777 
 
11778 
  def write(self, oprot):
11779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11781 
      return
11782 
    oprot.writeStructBegin('getUserCount_args')
11783 
    if self.userType != None:
11784 
      oprot.writeFieldBegin('userType', TType.I32, 1)
11785 
      oprot.writeI32(self.userType)
11786 
      oprot.writeFieldEnd()
11787 
    oprot.writeFieldStop()
11788 
    oprot.writeStructEnd()
11789 
 
11790 
  def __repr__(self):
11791 
    L = ['%s=%r' % (key, value)
11792 
      for key, value in self.__dict__.iteritems()]
11793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11794 
 
11795 
  def __eq__(self, other):
11796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11797 
 
11798 
  def __ne__(self, other):
11799 
    return not (self == other)
11800 
 
11801 
class getUserCount_result:
11802 
  """
11803 
  Attributes:
11804 
   - success
11805 
  """
11806 
 
11807 
  thrift_spec = (
11808 
    (0, TType.I64, 'success', None, None, ), # 0
11809 
  )
11810 
 
11811 
  def __init__(self, success=None,):
11812 
    self.success = success
11813 
 
11814 
  def read(self, iprot):
11815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11817 
      return
11818 
    iprot.readStructBegin()
11819 
    while True:
11820 
      (fname, ftype, fid) = iprot.readFieldBegin()
11821 
      if ftype == TType.STOP:
11822 
        break
11823 
      if fid == 0:
11824 
        if ftype == TType.I64:
11825 
          self.success = iprot.readI64();
11826 
        else:
11827 
          iprot.skip(ftype)
11828 
      else:
11829 
        iprot.skip(ftype)
11830 
      iprot.readFieldEnd()
11831 
    iprot.readStructEnd()
11832 
 
11833 
  def write(self, oprot):
11834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11836 
      return
11837 
    oprot.writeStructBegin('getUserCount_result')
11838 
    if self.success != None:
11839 
      oprot.writeFieldBegin('success', TType.I64, 0)
11840 
      oprot.writeI64(self.success)
11841 
      oprot.writeFieldEnd()
11842 
    oprot.writeFieldStop()
11843 
    oprot.writeStructEnd()
11844 
 
11845 
  def __repr__(self):
11846 
    L = ['%s=%r' % (key, value)
11847 
      for key, value in self.__dict__.iteritems()]
11848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11849 
 
11850 
  def __eq__(self, other):
11851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11852 
 
11853 
  def __ne__(self, other):
11854 
    return not (self == other)
11855 
 
1673 ankur.sing 11856 
class getAllUsers_args:
11857 
  """
11858 
  Attributes:
11859 
   - userType
11860 
  """
1596 ankur.sing 11861 
 
1673 ankur.sing 11862 
  thrift_spec = (
11863 
    None, # 0
11864 
    (1, TType.I32, 'userType', None, None, ), # 1
11865 
  )
11866 
 
11867 
  def __init__(self, userType=None,):
11868 
    self.userType = userType
11869 
 
11870 
  def read(self, iprot):
11871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11873 
      return
11874 
    iprot.readStructBegin()
11875 
    while True:
11876 
      (fname, ftype, fid) = iprot.readFieldBegin()
11877 
      if ftype == TType.STOP:
11878 
        break
11879 
      if fid == 1:
11880 
        if ftype == TType.I32:
11881 
          self.userType = iprot.readI32();
11882 
        else:
11883 
          iprot.skip(ftype)
11884 
      else:
11885 
        iprot.skip(ftype)
11886 
      iprot.readFieldEnd()
11887 
    iprot.readStructEnd()
11888 
 
11889 
  def write(self, oprot):
11890 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11891 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11892 
      return
11893 
    oprot.writeStructBegin('getAllUsers_args')
11894 
    if self.userType != None:
11895 
      oprot.writeFieldBegin('userType', TType.I32, 1)
11896 
      oprot.writeI32(self.userType)
11897 
      oprot.writeFieldEnd()
11898 
    oprot.writeFieldStop()
11899 
    oprot.writeStructEnd()
11900 
 
11901 
  def __repr__(self):
11902 
    L = ['%s=%r' % (key, value)
11903 
      for key, value in self.__dict__.iteritems()]
11904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11905 
 
11906 
  def __eq__(self, other):
11907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11908 
 
11909 
  def __ne__(self, other):
11910 
    return not (self == other)
11911 
 
11912 
class getAllUsers_result:
11913 
  """
11914 
  Attributes:
11915 
   - success
11916 
  """
11917 
 
11918 
  thrift_spec = (
11919 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
11920 
  )
11921 
 
11922 
  def __init__(self, success=None,):
11923 
    self.success = success
11924 
 
11925 
  def read(self, iprot):
11926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11928 
      return
11929 
    iprot.readStructBegin()
11930 
    while True:
11931 
      (fname, ftype, fid) = iprot.readFieldBegin()
11932 
      if ftype == TType.STOP:
11933 
        break
11934 
      if fid == 0:
11935 
        if ftype == TType.LIST:
11936 
          self.success = []
1845 vikas 11937 
          (_etype117, _size114) = iprot.readListBegin()
11938 
          for _i118 in xrange(_size114):
11939 
            _elem119 = User()
11940 
            _elem119.read(iprot)
11941 
            self.success.append(_elem119)
1673 ankur.sing 11942 
          iprot.readListEnd()
11943 
        else:
11944 
          iprot.skip(ftype)
11945 
      else:
11946 
        iprot.skip(ftype)
11947 
      iprot.readFieldEnd()
11948 
    iprot.readStructEnd()
11949 
 
11950 
  def write(self, oprot):
11951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11953 
      return
11954 
    oprot.writeStructBegin('getAllUsers_result')
11955 
    if self.success != None:
11956 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11957 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1845 vikas 11958 
      for iter120 in self.success:
11959 
        iter120.write(oprot)
1673 ankur.sing 11960 
      oprot.writeListEnd()
11961 
      oprot.writeFieldEnd()
11962 
    oprot.writeFieldStop()
11963 
    oprot.writeStructEnd()
11964 
 
11965 
  def __repr__(self):
11966 
    L = ['%s=%r' % (key, value)
11967 
      for key, value in self.__dict__.iteritems()]
11968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11969 
 
11970 
  def __eq__(self, other):
11971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11972 
 
11973 
  def __ne__(self, other):
11974 
    return not (self == other)
11975 
 
11976