Subversion Repositories SmartDukaan

Rev

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