Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
2 
# Autogenerated by Thrift
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
from ttypes import *
9 
from thrift.Thrift import TProcessor
10 
from thrift.transport import TTransport
11 
from thrift.protocol import TBinaryProtocol
12 
try:
13 
  from thrift.protocol import fastbinary
14 
except:
15 
  fastbinary = None
16 
 
17 
 
18 
class Iface:
19 
  """
20 
  service
21 
  """
765 rajveer 22 
  def closeSession(self, ):
23 
    """
24 
    For closing the open session in sqlalchemy
25 
    """
26 
    pass
27 
 
559 chandransh 28 
  def createAnonymousUser(self, jsessionId):
94 ashish 29 
    """
30 
    Parameters:
559 chandransh 31 
     - jsessionId
94 ashish 32 
    """
33 
    pass
34 
 
559 chandransh 35 
  def getUserById(self, userId):
94 ashish 36 
    """
37 
    Parameters:
38 
     - userId
39 
    """
40 
    pass
41 
 
1491 vikas 42 
  def getUserByEmail(self, email):
43 
    """
44 
    Parameters:
45 
     - email
46 
    """
47 
    pass
48 
 
559 chandransh 49 
  def createUser(self, user):
94 ashish 50 
    """
51 
    Parameters:
559 chandransh 52 
     - user
94 ashish 53 
    """
54 
    pass
55 
 
559 chandransh 56 
  def updateUser(self, user):
94 ashish 57 
    """
58 
    Parameters:
559 chandransh 59 
     - user
94 ashish 60 
    """
61 
    pass
62 
 
559 chandransh 63 
  def deleteUser(self, userId):
94 ashish 64 
    """
65 
    Parameters:
66 
     - userId
67 
    """
68 
    pass
69 
 
559 chandransh 70 
  def getUserState(self, userId):
94 ashish 71 
    """
72 
    Parameters:
73 
     - userId
74 
    """
75 
    pass
76 
 
559 chandransh 77 
  def authenticateUser(self, email, password):
94 ashish 78 
    """
79 
    Parameters:
80 
     - email
81 
     - password
82 
    """
83 
    pass
84 
 
85 
  def userExists(self, email):
86 
    """
87 
    Parameters:
88 
     - email
89 
    """
90 
    pass
91 
 
567 rajveer 92 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 93 
    """
94 
    Parameters:
95 
     - userId
96 
     - address
513 rajveer 97 
     - setDefault
94 ashish 98 
    """
99 
    pass
100 
 
101 
  def removeAddressForUser(self, userid, addressId):
102 
    """
103 
    Parameters:
104 
     - userid
105 
     - addressId
106 
    """
107 
    pass
108 
 
109 
  def setUserAsLoggedIn(self, userId, timestamp):
110 
    """
111 
    Parameters:
112 
     - userId
113 
     - timestamp
114 
    """
115 
    pass
116 
 
117 
  def setUserAsLoggedOut(self, userid, timestamp):
118 
    """
119 
    Parameters:
120 
     - userid
121 
     - timestamp
122 
    """
123 
    pass
124 
 
504 rajveer 125 
  def setDefaultAddress(self, userid, addressId):
126 
    """
127 
    Parameters:
128 
     - userid
129 
     - addressId
130 
    """
131 
    pass
132 
 
594 rajveer 133 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 134 
    """
135 
    Parameters:
136 
     - userid
594 rajveer 137 
     - oldPassword
138 
     - newPassword
94 ashish 139 
    """
140 
    pass
141 
 
884 rajveer 142 
  def forgotPassword(self, email, newPassword):
581 rajveer 143 
    """
144 
    Parameters:
145 
     - email
884 rajveer 146 
     - newPassword
581 rajveer 147 
    """
148 
    pass
149 
 
594 rajveer 150 
  def getAllAddressesForUser(self, userId):
151 
    """
152 
    Parameters:
153 
     - userId
154 
    """
155 
    pass
156 
 
1894 vikas 157 
  def getAddressById(self, addressId):
158 
    """
159 
    Parameters:
160 
     - addressId
161 
    """
162 
    pass
163 
 
594 rajveer 164 
  def getDefaultAddressId(self, userId):
165 
    """
166 
    Parameters:
167 
     - userId
168 
    """
169 
    pass
170 
 
785 rajveer 171 
  def getDefaultPincode(self, userId):
172 
    """
173 
    Parameters:
174 
     - userId
175 
    """
176 
    pass
177 
 
1274 varun.gupt 178 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
179 
    """
180 
    Parameters:
181 
     - userId
182 
     - replyTo
183 
     - communicationType
184 
     - orderId
185 
     - airwaybillNo
186 
     - productName
187 
     - subject
188 
     - message
189 
    """
190 
    pass
191 
 
1590 varun.gupt 192 
  def getUserCommunicationById(self, id):
193 
    """
194 
    Parameters:
195 
     - id
196 
    """
197 
    pass
198 
 
199 
  def getUserCommunicationByUser(self, userId):
200 
    """
201 
    Parameters:
202 
     - userId
203 
    """
204 
    pass
205 
 
206 
  def getAllUserCommunications(self, ):
207 
    pass
208 
 
1859 vikas 209 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 210 
    """
211 
    Parameters:
212 
     - name
1859 vikas 213 
     - addedOn
1845 vikas 214 
    """
215 
    pass
216 
 
1899 vikas 217 
  def getAllMasterAffiliates(self, ):
218 
    pass
219 
 
1845 vikas 220 
  def getMasterAffiliateById(self, id):
221 
    """
222 
    Parameters:
223 
     - id
224 
    """
225 
    pass
226 
 
227 
  def getMasterAffiliateByName(self, name):
228 
    """
229 
    Parameters:
230 
     - name
231 
    """
232 
    pass
233 
 
1859 vikas 234 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 235 
    """
236 
    Parameters:
237 
     - name
238 
     - url
239 
     - masterAffiliateId
1859 vikas 240 
     - addedOn
1845 vikas 241 
    """
242 
    pass
243 
 
244 
  def getAffiliateById(self, id):
245 
    """
246 
    Parameters:
247 
     - id
248 
    """
249 
    pass
250 
 
251 
  def getAffiliateByName(self, name):
252 
    """
253 
    Parameters:
254 
     - name
255 
    """
256 
    pass
257 
 
258 
  def getAffiliatesByMasterAffiliate(self, id):
259 
    """
260 
    Parameters:
261 
     - id
262 
    """
263 
    pass
264 
 
1859 vikas 265 
  def createTracker(self, affiliateId, addedOn):
1845 vikas 266 
    """
267 
    Parameters:
268 
     - affiliateId
1859 vikas 269 
     - addedOn
1845 vikas 270 
    """
271 
    pass
272 
 
273 
  def getTrackerById(self, trackerId):
274 
    """
275 
    Parameters:
276 
     - trackerId
277 
    """
278 
    pass
279 
 
280 
  def getTrackersByAffiliate(self, affiliateId):
281 
    """
282 
    Parameters:
283 
     - affiliateId
284 
    """
285 
    pass
286 
 
1859 vikas 287 
  def addTrackLog(self, trackerId, userId, event, url, data, addedOn):
1845 vikas 288 
    """
289 
    Parameters:
290 
     - trackerId
291 
     - userId
292 
     - event
293 
     - url
294 
     - data
1859 vikas 295 
     - addedOn
1845 vikas 296 
    """
297 
    pass
298 
 
299 
  def getTrackLogById(self, id):
300 
    """
301 
    Parameters:
302 
     - id
303 
    """
304 
    pass
305 
 
306 
  def getTrackLogsByTracker(self, trackerId):
307 
    """
308 
    Parameters:
309 
     - trackerId
310 
    """
311 
    pass
312 
 
313 
  def getTrackLogsByUser(self, userId):
314 
    """
315 
    Parameters:
316 
     - userId
317 
    """
318 
    pass
319 
 
320 
  def getTrackLogs(self, trackerId, userId, event, url):
321 
    """
322 
    Parameters:
323 
     - trackerId
324 
     - userId
325 
     - event
326 
     - url
327 
    """
328 
    pass
329 
 
559 chandransh 330 
  def createCart(self, userId):
94 ashish 331 
    """
332 
    Parameters:
559 chandransh 333 
     - userId
94 ashish 334 
    """
335 
    pass
336 
 
559 chandransh 337 
  def getCurrentCart(self, userId):
94 ashish 338 
    """
339 
    Parameters:
559 chandransh 340 
     - userId
94 ashish 341 
    """
342 
    pass
343 
 
559 chandransh 344 
  def getCart(self, cartId):
94 ashish 345 
    """
346 
    Parameters:
559 chandransh 347 
     - cartId
94 ashish 348 
    """
349 
    pass
350 
 
559 chandransh 351 
  def getCartsForUser(self, userId, status):
94 ashish 352 
    """
353 
    Parameters:
559 chandransh 354 
     - userId
355 
     - status
94 ashish 356 
    """
357 
    pass
358 
 
559 chandransh 359 
  def getCartsByStatus(self, status):
94 ashish 360 
    """
361 
    Parameters:
559 chandransh 362 
     - status
94 ashish 363 
    """
364 
    pass
365 
 
559 chandransh 366 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 367 
    """
368 
    Parameters:
559 chandransh 369 
     - from_time
370 
     - to_time
371 
     - status
94 ashish 372 
    """
373 
    pass
374 
 
559 chandransh 375 
  def changeCartStatus(self, cartId, status):
130 ashish 376 
    """
377 
    Parameters:
559 chandransh 378 
     - cartId
379 
     - status
130 ashish 380 
    """
381 
    pass
94 ashish 382 
 
559 chandransh 383 
  def addItemToCart(self, cartId, itemId, quantity):
130 ashish 384 
    """
385 
    Parameters:
559 chandransh 386 
     - cartId
387 
     - itemId
388 
     - quantity
130 ashish 389 
    """
390 
    pass
391 
 
559 chandransh 392 
  def deleteItemFromCart(self, cartId, itemId):
393 
    """
394 
    Parameters:
395 
     - cartId
396 
     - itemId
397 
    """
398 
    pass
130 ashish 399 
 
559 chandransh 400 
  def changeQuantity(self, cartId, itemId, quantity):
401 
    """
402 
    Parameters:
403 
     - cartId
404 
     - itemId
405 
     - quantity
406 
    """
407 
    pass
408 
 
409 
  def changeItemStatus(self, cartId, itemId, status):
410 
    """
411 
    Parameters:
412 
     - cartId
413 
     - itemId
414 
     - status
415 
    """
416 
    pass
417 
 
418 
  def addAddressToCart(self, cartId, addressId):
419 
    """
420 
    Parameters:
421 
     - cartId
422 
     - addressId
423 
    """
424 
    pass
425 
 
1976 varun.gupt 426 
  def applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
427 
    """
428 
    Parameters:
429 
     - cartId
430 
     - couponCode
431 
     - totalPrice
432 
     - discountedPrice
433 
    """
434 
    pass
435 
 
436 
  def removeCoupon(self, cartId):
437 
    """
438 
    Parameters:
439 
     - cartId
440 
    """
441 
    pass
442 
 
690 chandransh 443 
  def createOrders(self, cartId):
559 chandransh 444 
    """
690 chandransh 445 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
446 
 
559 chandransh 447 
    Parameters:
448 
     - cartId
449 
    """
450 
    pass
451 
 
452 
  def validateCart(self, cartId):
453 
    """
690 chandransh 454 
    Validates that:
455 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 456 
    2. All of the lines in the cart are active items.
690 chandransh 457 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 458 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 459 
 
559 chandransh 460 
    Parameters:
461 
     - cartId
462 
    """
463 
    pass
464 
 
690 chandransh 465 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 466 
    """
690 chandransh 467 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
468 
 
575 chandransh 469 
    Parameters:
690 chandransh 470 
     - fromCartId
471 
     - toCartId
472 
    """
473 
    pass
474 
 
475 
  def checkOut(self, cartId):
476 
    """
477 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
478 
 
479 
    Parameters:
575 chandransh 480 
     - cartId
481 
    """
482 
    pass
483 
 
690 chandransh 484 
  def resetCart(self, cartId, items):
559 chandransh 485 
    """
690 chandransh 486 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
487 
    This methods removes the specified quantiry of the specified item from the cart.
488 
 
559 chandransh 489 
    Parameters:
690 chandransh 490 
     - cartId
491 
     - items
559 chandransh 492 
    """
493 
    pass
494 
 
772 rajveer 495 
  def getMyResearch(self, userId):
559 chandransh 496 
    """
772 rajveer 497 
    Widgets
498 
 
559 chandransh 499 
    Parameters:
772 rajveer 500 
     - userId
559 chandransh 501 
    """
502 
    pass
503 
 
772 rajveer 504 
  def updateMyResearch(self, userId, itemId):
559 chandransh 505 
    """
506 
    Parameters:
772 rajveer 507 
     - userId
508 
     - itemId
559 chandransh 509 
    """
510 
    pass
511 
 
772 rajveer 512 
  def deleteItemFromMyResearch(self, userId, itemId):
559 chandransh 513 
    """
514 
    Parameters:
772 rajveer 515 
     - userId
516 
     - itemId
559 chandransh 517 
    """
518 
    pass
519 
 
772 rajveer 520 
  def updateBrowseHistory(self, userId, itemId):
559 chandransh 521 
    """
522 
    Parameters:
772 rajveer 523 
     - userId
524 
     - itemId
559 chandransh 525 
    """
526 
    pass
527 
 
772 rajveer 528 
  def getBrowseHistory(self, userId):
559 chandransh 529 
    """
530 
    Parameters:
531 
     - userId
532 
    """
533 
    pass
534 
 
772 rajveer 535 
  def mergeBrowseHistory(self, fromUserId, toUserId):
559 chandransh 536 
    """
537 
    Parameters:
772 rajveer 538 
     - fromUserId
539 
     - toUserId
559 chandransh 540 
    """
541 
    pass
542 
 
1596 ankur.sing 543 
  def getUserCount(self, userType):
544 
    """
545 
    Returns number of registered users.
546 
    If userType = null, then it returns count of all users, including anonymous
547 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
548 
    If userType = UserType.USER, then it returns count of non-anonymous users only
549 
 
550 
    Parameters:
551 
     - userType
552 
    """
553 
    pass
559 chandransh 554 
 
1891 ankur.sing 555 
  def getAllUsers(self, userType, startDate, endDate):
1673 ankur.sing 556 
    """
1891 ankur.sing 557 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
558 
    If any of startDate or endDate is -1, then that filter is ignored.
559 
    If userType is null, then returns all the users, irrespective of anonymous flag
1673 ankur.sing 560 
 
1891 ankur.sing 561 
 
1673 ankur.sing 562 
    Parameters:
563 
     - userType
1891 ankur.sing 564 
     - startDate
565 
     - endDate
1673 ankur.sing 566 
    """
567 
    pass
1596 ankur.sing 568 
 
1673 ankur.sing 569 
 
94 ashish 570 
class Client(Iface):
571 
  """
572 
  service
573 
  """
574 
  def __init__(self, iprot, oprot=None):
575 
    self._iprot = self._oprot = iprot
576 
    if oprot != None:
577 
      self._oprot = oprot
578 
    self._seqid = 0
579 
 
765 rajveer 580 
  def closeSession(self, ):
581 
    """
582 
    For closing the open session in sqlalchemy
583 
    """
584 
    self.send_closeSession()
585 
    self.recv_closeSession()
586 
 
587 
  def send_closeSession(self, ):
588 
    self._oprot.writeMessageBegin('closeSession', TMessageType.CALL, self._seqid)
589 
    args = closeSession_args()
590 
    args.write(self._oprot)
591 
    self._oprot.writeMessageEnd()
592 
    self._oprot.trans.flush()
593 
 
594 
  def recv_closeSession(self, ):
595 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
596 
    if mtype == TMessageType.EXCEPTION:
597 
      x = TApplicationException()
598 
      x.read(self._iprot)
599 
      self._iprot.readMessageEnd()
600 
      raise x
601 
    result = closeSession_result()
602 
    result.read(self._iprot)
603 
    self._iprot.readMessageEnd()
604 
    return
605 
 
559 chandransh 606 
  def createAnonymousUser(self, jsessionId):
94 ashish 607 
    """
608 
    Parameters:
559 chandransh 609 
     - jsessionId
94 ashish 610 
    """
559 chandransh 611 
    self.send_createAnonymousUser(jsessionId)
612 
    return self.recv_createAnonymousUser()
94 ashish 613 
 
559 chandransh 614 
  def send_createAnonymousUser(self, jsessionId):
615 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
616 
    args = createAnonymousUser_args()
617 
    args.jsessionId = jsessionId
94 ashish 618 
    args.write(self._oprot)
619 
    self._oprot.writeMessageEnd()
620 
    self._oprot.trans.flush()
621 
 
559 chandransh 622 
  def recv_createAnonymousUser(self, ):
94 ashish 623 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
624 
    if mtype == TMessageType.EXCEPTION:
625 
      x = TApplicationException()
626 
      x.read(self._iprot)
627 
      self._iprot.readMessageEnd()
628 
      raise x
559 chandransh 629 
    result = createAnonymousUser_result()
94 ashish 630 
    result.read(self._iprot)
631 
    self._iprot.readMessageEnd()
632 
    if result.success != None:
633 
      return result.success
559 chandransh 634 
    if result.ucex != None:
635 
      raise result.ucex
636 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 637 
 
559 chandransh 638 
  def getUserById(self, userId):
94 ashish 639 
    """
640 
    Parameters:
641 
     - userId
642 
    """
559 chandransh 643 
    self.send_getUserById(userId)
644 
    return self.recv_getUserById()
94 ashish 645 
 
559 chandransh 646 
  def send_getUserById(self, userId):
647 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
648 
    args = getUserById_args()
94 ashish 649 
    args.userId = userId
650 
    args.write(self._oprot)
651 
    self._oprot.writeMessageEnd()
652 
    self._oprot.trans.flush()
653 
 
559 chandransh 654 
  def recv_getUserById(self, ):
94 ashish 655 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
656 
    if mtype == TMessageType.EXCEPTION:
657 
      x = TApplicationException()
658 
      x.read(self._iprot)
659 
      self._iprot.readMessageEnd()
660 
      raise x
559 chandransh 661 
    result = getUserById_result()
94 ashish 662 
    result.read(self._iprot)
663 
    self._iprot.readMessageEnd()
664 
    if result.success != None:
665 
      return result.success
559 chandransh 666 
    if result.ucex != None:
667 
      raise result.ucex
668 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 669 
 
1491 vikas 670 
  def getUserByEmail(self, email):
671 
    """
672 
    Parameters:
673 
     - email
674 
    """
675 
    self.send_getUserByEmail(email)
676 
    return self.recv_getUserByEmail()
677 
 
678 
  def send_getUserByEmail(self, email):
679 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
680 
    args = getUserByEmail_args()
681 
    args.email = email
682 
    args.write(self._oprot)
683 
    self._oprot.writeMessageEnd()
684 
    self._oprot.trans.flush()
685 
 
686 
  def recv_getUserByEmail(self, ):
687 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
688 
    if mtype == TMessageType.EXCEPTION:
689 
      x = TApplicationException()
690 
      x.read(self._iprot)
691 
      self._iprot.readMessageEnd()
692 
      raise x
693 
    result = getUserByEmail_result()
694 
    result.read(self._iprot)
695 
    self._iprot.readMessageEnd()
696 
    if result.success != None:
697 
      return result.success
698 
    if result.ucex != None:
699 
      raise result.ucex
700 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
701 
 
559 chandransh 702 
  def createUser(self, user):
94 ashish 703 
    """
704 
    Parameters:
559 chandransh 705 
     - user
94 ashish 706 
    """
559 chandransh 707 
    self.send_createUser(user)
708 
    return self.recv_createUser()
94 ashish 709 
 
559 chandransh 710 
  def send_createUser(self, user):
711 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
712 
    args = createUser_args()
713 
    args.user = user
94 ashish 714 
    args.write(self._oprot)
715 
    self._oprot.writeMessageEnd()
716 
    self._oprot.trans.flush()
717 
 
559 chandransh 718 
  def recv_createUser(self, ):
94 ashish 719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
720 
    if mtype == TMessageType.EXCEPTION:
721 
      x = TApplicationException()
722 
      x.read(self._iprot)
723 
      self._iprot.readMessageEnd()
724 
      raise x
559 chandransh 725 
    result = createUser_result()
94 ashish 726 
    result.read(self._iprot)
727 
    self._iprot.readMessageEnd()
728 
    if result.success != None:
729 
      return result.success
559 chandransh 730 
    if result.ucex != None:
731 
      raise result.ucex
732 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 733 
 
559 chandransh 734 
  def updateUser(self, user):
94 ashish 735 
    """
736 
    Parameters:
559 chandransh 737 
     - user
94 ashish 738 
    """
559 chandransh 739 
    self.send_updateUser(user)
740 
    return self.recv_updateUser()
94 ashish 741 
 
559 chandransh 742 
  def send_updateUser(self, user):
743 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
744 
    args = updateUser_args()
745 
    args.user = user
94 ashish 746 
    args.write(self._oprot)
747 
    self._oprot.writeMessageEnd()
748 
    self._oprot.trans.flush()
749 
 
559 chandransh 750 
  def recv_updateUser(self, ):
94 ashish 751 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
752 
    if mtype == TMessageType.EXCEPTION:
753 
      x = TApplicationException()
754 
      x.read(self._iprot)
755 
      self._iprot.readMessageEnd()
756 
      raise x
559 chandransh 757 
    result = updateUser_result()
94 ashish 758 
    result.read(self._iprot)
759 
    self._iprot.readMessageEnd()
760 
    if result.success != None:
761 
      return result.success
559 chandransh 762 
    if result.ucex != None:
763 
      raise result.ucex
764 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 765 
 
559 chandransh 766 
  def deleteUser(self, userId):
94 ashish 767 
    """
768 
    Parameters:
769 
     - userId
770 
    """
559 chandransh 771 
    self.send_deleteUser(userId)
772 
    return self.recv_deleteUser()
94 ashish 773 
 
559 chandransh 774 
  def send_deleteUser(self, userId):
775 
    self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
776 
    args = deleteUser_args()
94 ashish 777 
    args.userId = userId
778 
    args.write(self._oprot)
779 
    self._oprot.writeMessageEnd()
780 
    self._oprot.trans.flush()
781 
 
559 chandransh 782 
  def recv_deleteUser(self, ):
94 ashish 783 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
784 
    if mtype == TMessageType.EXCEPTION:
785 
      x = TApplicationException()
786 
      x.read(self._iprot)
787 
      self._iprot.readMessageEnd()
788 
      raise x
559 chandransh 789 
    result = deleteUser_result()
94 ashish 790 
    result.read(self._iprot)
791 
    self._iprot.readMessageEnd()
792 
    if result.success != None:
793 
      return result.success
559 chandransh 794 
    if result.ucex != None:
795 
      raise result.ucex
796 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
94 ashish 797 
 
559 chandransh 798 
  def getUserState(self, userId):
94 ashish 799 
    """
800 
    Parameters:
801 
     - userId
802 
    """
559 chandransh 803 
    self.send_getUserState(userId)
804 
    return self.recv_getUserState()
94 ashish 805 
 
559 chandransh 806 
  def send_getUserState(self, userId):
807 
    self._oprot.writeMessageBegin('getUserState', TMessageType.CALL, self._seqid)
808 
    args = getUserState_args()
94 ashish 809 
    args.userId = userId
810 
    args.write(self._oprot)
811 
    self._oprot.writeMessageEnd()
812 
    self._oprot.trans.flush()
813 
 
559 chandransh 814 
  def recv_getUserState(self, ):
94 ashish 815 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
816 
    if mtype == TMessageType.EXCEPTION:
817 
      x = TApplicationException()
818 
      x.read(self._iprot)
819 
      self._iprot.readMessageEnd()
820 
      raise x
559 chandransh 821 
    result = getUserState_result()
94 ashish 822 
    result.read(self._iprot)
823 
    self._iprot.readMessageEnd()
824 
    if result.success != None:
825 
      return result.success
559 chandransh 826 
    if result.ucex != None:
827 
      raise result.ucex
828 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserState failed: unknown result");
94 ashish 829 
 
559 chandransh 830 
  def authenticateUser(self, email, password):
94 ashish 831 
    """
832 
    Parameters:
833 
     - email
834 
     - password
835 
    """
559 chandransh 836 
    self.send_authenticateUser(email, password)
122 ashish 837 
    return self.recv_authenticateUser()
838 
 
559 chandransh 839 
  def send_authenticateUser(self, email, password):
122 ashish 840 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
841 
    args = authenticateUser_args()
559 chandransh 842 
    args.email = email
122 ashish 843 
    args.password = password
844 
    args.write(self._oprot)
845 
    self._oprot.writeMessageEnd()
846 
    self._oprot.trans.flush()
847 
 
848 
  def recv_authenticateUser(self, ):
849 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
850 
    if mtype == TMessageType.EXCEPTION:
851 
      x = TApplicationException()
852 
      x.read(self._iprot)
853 
      self._iprot.readMessageEnd()
854 
      raise x
855 
    result = authenticateUser_result()
856 
    result.read(self._iprot)
857 
    self._iprot.readMessageEnd()
858 
    if result.success != None:
859 
      return result.success
559 chandransh 860 
    if result.auex != None:
861 
      raise result.auex
122 ashish 862 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
863 
 
94 ashish 864 
  def userExists(self, email):
865 
    """
866 
    Parameters:
867 
     - email
868 
    """
869 
    self.send_userExists(email)
870 
    return self.recv_userExists()
871 
 
872 
  def send_userExists(self, email):
873 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
874 
    args = userExists_args()
875 
    args.email = email
876 
    args.write(self._oprot)
877 
    self._oprot.writeMessageEnd()
878 
    self._oprot.trans.flush()
879 
 
880 
  def recv_userExists(self, ):
881 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
882 
    if mtype == TMessageType.EXCEPTION:
883 
      x = TApplicationException()
884 
      x.read(self._iprot)
885 
      self._iprot.readMessageEnd()
886 
      raise x
887 
    result = userExists_result()
888 
    result.read(self._iprot)
889 
    self._iprot.readMessageEnd()
890 
    if result.success != None:
891 
      return result.success
892 
    if result.ucx != None:
893 
      raise result.ucx
894 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
895 
 
567 rajveer 896 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 897 
    """
898 
    Parameters:
899 
     - userId
900 
     - address
513 rajveer 901 
     - setDefault
94 ashish 902 
    """
567 rajveer 903 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 904 
    return self.recv_addAddressForUser()
905 
 
567 rajveer 906 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 907 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
908 
    args = addAddressForUser_args()
559 chandransh 909 
    args.userId = userId
94 ashish 910 
    args.address = address
513 rajveer 911 
    args.setDefault = setDefault
94 ashish 912 
    args.write(self._oprot)
913 
    self._oprot.writeMessageEnd()
914 
    self._oprot.trans.flush()
915 
 
916 
  def recv_addAddressForUser(self, ):
917 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
918 
    if mtype == TMessageType.EXCEPTION:
919 
      x = TApplicationException()
920 
      x.read(self._iprot)
921 
      self._iprot.readMessageEnd()
922 
      raise x
923 
    result = addAddressForUser_result()
924 
    result.read(self._iprot)
925 
    self._iprot.readMessageEnd()
926 
    if result.success != None:
927 
      return result.success
928 
    if result.ucx != None:
929 
      raise result.ucx
930 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
931 
 
932 
  def removeAddressForUser(self, userid, addressId):
933 
    """
934 
    Parameters:
935 
     - userid
936 
     - addressId
937 
    """
938 
    self.send_removeAddressForUser(userid, addressId)
939 
    return self.recv_removeAddressForUser()
940 
 
941 
  def send_removeAddressForUser(self, userid, addressId):
942 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
943 
    args = removeAddressForUser_args()
944 
    args.userid = userid
945 
    args.addressId = addressId
946 
    args.write(self._oprot)
947 
    self._oprot.writeMessageEnd()
948 
    self._oprot.trans.flush()
949 
 
950 
  def recv_removeAddressForUser(self, ):
951 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
952 
    if mtype == TMessageType.EXCEPTION:
953 
      x = TApplicationException()
954 
      x.read(self._iprot)
955 
      self._iprot.readMessageEnd()
956 
      raise x
957 
    result = removeAddressForUser_result()
958 
    result.read(self._iprot)
959 
    self._iprot.readMessageEnd()
960 
    if result.success != None:
961 
      return result.success
962 
    if result.ucx != None:
963 
      raise result.ucx
964 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
965 
 
966 
  def setUserAsLoggedIn(self, userId, timestamp):
967 
    """
968 
    Parameters:
969 
     - userId
970 
     - timestamp
971 
    """
972 
    self.send_setUserAsLoggedIn(userId, timestamp)
973 
    return self.recv_setUserAsLoggedIn()
974 
 
975 
  def send_setUserAsLoggedIn(self, userId, timestamp):
976 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
977 
    args = setUserAsLoggedIn_args()
978 
    args.userId = userId
979 
    args.timestamp = timestamp
980 
    args.write(self._oprot)
981 
    self._oprot.writeMessageEnd()
982 
    self._oprot.trans.flush()
983 
 
984 
  def recv_setUserAsLoggedIn(self, ):
985 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
986 
    if mtype == TMessageType.EXCEPTION:
987 
      x = TApplicationException()
988 
      x.read(self._iprot)
989 
      self._iprot.readMessageEnd()
990 
      raise x
991 
    result = setUserAsLoggedIn_result()
992 
    result.read(self._iprot)
993 
    self._iprot.readMessageEnd()
994 
    if result.success != None:
995 
      return result.success
996 
    if result.ucx != None:
997 
      raise result.ucx
998 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
999 
 
1000 
  def setUserAsLoggedOut(self, userid, timestamp):
1001 
    """
1002 
    Parameters:
1003 
     - userid
1004 
     - timestamp
1005 
    """
1006 
    self.send_setUserAsLoggedOut(userid, timestamp)
1007 
    return self.recv_setUserAsLoggedOut()
1008 
 
1009 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1010 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1011 
    args = setUserAsLoggedOut_args()
1012 
    args.userid = userid
1013 
    args.timestamp = timestamp
1014 
    args.write(self._oprot)
1015 
    self._oprot.writeMessageEnd()
1016 
    self._oprot.trans.flush()
1017 
 
1018 
  def recv_setUserAsLoggedOut(self, ):
1019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1020 
    if mtype == TMessageType.EXCEPTION:
1021 
      x = TApplicationException()
1022 
      x.read(self._iprot)
1023 
      self._iprot.readMessageEnd()
1024 
      raise x
1025 
    result = setUserAsLoggedOut_result()
1026 
    result.read(self._iprot)
1027 
    self._iprot.readMessageEnd()
1028 
    if result.success != None:
1029 
      return result.success
1030 
    if result.ucx != None:
1031 
      raise result.ucx
1032 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1033 
 
504 rajveer 1034 
  def setDefaultAddress(self, userid, addressId):
1035 
    """
1036 
    Parameters:
1037 
     - userid
1038 
     - addressId
1039 
    """
1040 
    self.send_setDefaultAddress(userid, addressId)
1041 
    return self.recv_setDefaultAddress()
1042 
 
1043 
  def send_setDefaultAddress(self, userid, addressId):
1044 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1045 
    args = setDefaultAddress_args()
1046 
    args.userid = userid
1047 
    args.addressId = addressId
1048 
    args.write(self._oprot)
1049 
    self._oprot.writeMessageEnd()
1050 
    self._oprot.trans.flush()
1051 
 
1052 
  def recv_setDefaultAddress(self, ):
1053 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1054 
    if mtype == TMessageType.EXCEPTION:
1055 
      x = TApplicationException()
1056 
      x.read(self._iprot)
1057 
      self._iprot.readMessageEnd()
1058 
      raise x
1059 
    result = setDefaultAddress_result()
1060 
    result.read(self._iprot)
1061 
    self._iprot.readMessageEnd()
1062 
    if result.success != None:
1063 
      return result.success
1064 
    if result.ucx != None:
1065 
      raise result.ucx
1066 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1067 
 
594 rajveer 1068 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1069 
    """
1070 
    Parameters:
1071 
     - userid
594 rajveer 1072 
     - oldPassword
1073 
     - newPassword
94 ashish 1074 
    """
594 rajveer 1075 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1076 
    return self.recv_updatePassword()
1077 
 
594 rajveer 1078 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1079 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1080 
    args = updatePassword_args()
1081 
    args.userid = userid
594 rajveer 1082 
    args.oldPassword = oldPassword
1083 
    args.newPassword = newPassword
94 ashish 1084 
    args.write(self._oprot)
1085 
    self._oprot.writeMessageEnd()
1086 
    self._oprot.trans.flush()
1087 
 
1088 
  def recv_updatePassword(self, ):
1089 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1090 
    if mtype == TMessageType.EXCEPTION:
1091 
      x = TApplicationException()
1092 
      x.read(self._iprot)
1093 
      self._iprot.readMessageEnd()
1094 
      raise x
1095 
    result = updatePassword_result()
1096 
    result.read(self._iprot)
1097 
    self._iprot.readMessageEnd()
1098 
    if result.success != None:
1099 
      return result.success
1100 
    if result.ucx != None:
1101 
      raise result.ucx
1102 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1103 
 
884 rajveer 1104 
  def forgotPassword(self, email, newPassword):
581 rajveer 1105 
    """
1106 
    Parameters:
1107 
     - email
884 rajveer 1108 
     - newPassword
581 rajveer 1109 
    """
884 rajveer 1110 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1111 
    return self.recv_forgotPassword()
1112 
 
884 rajveer 1113 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1114 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1115 
    args = forgotPassword_args()
1116 
    args.email = email
884 rajveer 1117 
    args.newPassword = newPassword
581 rajveer 1118 
    args.write(self._oprot)
1119 
    self._oprot.writeMessageEnd()
1120 
    self._oprot.trans.flush()
1121 
 
1122 
  def recv_forgotPassword(self, ):
1123 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1124 
    if mtype == TMessageType.EXCEPTION:
1125 
      x = TApplicationException()
1126 
      x.read(self._iprot)
1127 
      self._iprot.readMessageEnd()
1128 
      raise x
1129 
    result = forgotPassword_result()
1130 
    result.read(self._iprot)
1131 
    self._iprot.readMessageEnd()
1132 
    if result.success != None:
1133 
      return result.success
1134 
    if result.ucx != None:
1135 
      raise result.ucx
1136 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1137 
 
594 rajveer 1138 
  def getAllAddressesForUser(self, userId):
1139 
    """
1140 
    Parameters:
1141 
     - userId
1142 
    """
1143 
    self.send_getAllAddressesForUser(userId)
1144 
    return self.recv_getAllAddressesForUser()
1145 
 
1146 
  def send_getAllAddressesForUser(self, userId):
1147 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1148 
    args = getAllAddressesForUser_args()
1149 
    args.userId = userId
1150 
    args.write(self._oprot)
1151 
    self._oprot.writeMessageEnd()
1152 
    self._oprot.trans.flush()
1153 
 
1154 
  def recv_getAllAddressesForUser(self, ):
1155 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1156 
    if mtype == TMessageType.EXCEPTION:
1157 
      x = TApplicationException()
1158 
      x.read(self._iprot)
1159 
      self._iprot.readMessageEnd()
1160 
      raise x
1161 
    result = getAllAddressesForUser_result()
1162 
    result.read(self._iprot)
1163 
    self._iprot.readMessageEnd()
1164 
    if result.success != None:
1165 
      return result.success
1166 
    if result.ucx != None:
1167 
      raise result.ucx
1168 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1169 
 
1894 vikas 1170 
  def getAddressById(self, addressId):
1171 
    """
1172 
    Parameters:
1173 
     - addressId
1174 
    """
1175 
    self.send_getAddressById(addressId)
1176 
    return self.recv_getAddressById()
1177 
 
1178 
  def send_getAddressById(self, addressId):
1179 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1180 
    args = getAddressById_args()
1181 
    args.addressId = addressId
1182 
    args.write(self._oprot)
1183 
    self._oprot.writeMessageEnd()
1184 
    self._oprot.trans.flush()
1185 
 
1186 
  def recv_getAddressById(self, ):
1187 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1188 
    if mtype == TMessageType.EXCEPTION:
1189 
      x = TApplicationException()
1190 
      x.read(self._iprot)
1191 
      self._iprot.readMessageEnd()
1192 
      raise x
1193 
    result = getAddressById_result()
1194 
    result.read(self._iprot)
1195 
    self._iprot.readMessageEnd()
1196 
    if result.success != None:
1197 
      return result.success
1198 
    if result.ucx != None:
1199 
      raise result.ucx
1200 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1201 
 
594 rajveer 1202 
  def getDefaultAddressId(self, userId):
1203 
    """
1204 
    Parameters:
1205 
     - userId
1206 
    """
1207 
    self.send_getDefaultAddressId(userId)
1208 
    return self.recv_getDefaultAddressId()
1209 
 
1210 
  def send_getDefaultAddressId(self, userId):
1211 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1212 
    args = getDefaultAddressId_args()
1213 
    args.userId = userId
1214 
    args.write(self._oprot)
1215 
    self._oprot.writeMessageEnd()
1216 
    self._oprot.trans.flush()
1217 
 
1218 
  def recv_getDefaultAddressId(self, ):
1219 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1220 
    if mtype == TMessageType.EXCEPTION:
1221 
      x = TApplicationException()
1222 
      x.read(self._iprot)
1223 
      self._iprot.readMessageEnd()
1224 
      raise x
1225 
    result = getDefaultAddressId_result()
1226 
    result.read(self._iprot)
1227 
    self._iprot.readMessageEnd()
1228 
    if result.success != None:
1229 
      return result.success
1230 
    if result.ucx != None:
1231 
      raise result.ucx
1232 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1233 
 
785 rajveer 1234 
  def getDefaultPincode(self, userId):
1235 
    """
1236 
    Parameters:
1237 
     - userId
1238 
    """
1239 
    self.send_getDefaultPincode(userId)
1240 
    return self.recv_getDefaultPincode()
1241 
 
1242 
  def send_getDefaultPincode(self, userId):
1243 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1244 
    args = getDefaultPincode_args()
1245 
    args.userId = userId
1246 
    args.write(self._oprot)
1247 
    self._oprot.writeMessageEnd()
1248 
    self._oprot.trans.flush()
1249 
 
1250 
  def recv_getDefaultPincode(self, ):
1251 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1252 
    if mtype == TMessageType.EXCEPTION:
1253 
      x = TApplicationException()
1254 
      x.read(self._iprot)
1255 
      self._iprot.readMessageEnd()
1256 
      raise x
1257 
    result = getDefaultPincode_result()
1258 
    result.read(self._iprot)
1259 
    self._iprot.readMessageEnd()
1260 
    if result.success != None:
1261 
      return result.success
1262 
    if result.ucx != None:
1263 
      raise result.ucx
1264 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1265 
 
1274 varun.gupt 1266 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1267 
    """
1268 
    Parameters:
1269 
     - userId
1270 
     - replyTo
1271 
     - communicationType
1272 
     - orderId
1273 
     - airwaybillNo
1274 
     - productName
1275 
     - subject
1276 
     - message
1277 
    """
1278 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1279 
    return self.recv_saveUserCommunication()
1280 
 
1281 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1282 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1283 
    args = saveUserCommunication_args()
1284 
    args.userId = userId
1285 
    args.replyTo = replyTo
1286 
    args.communicationType = communicationType
1287 
    args.orderId = orderId
1288 
    args.airwaybillNo = airwaybillNo
1289 
    args.productName = productName
1290 
    args.subject = subject
1291 
    args.message = message
1292 
    args.write(self._oprot)
1293 
    self._oprot.writeMessageEnd()
1294 
    self._oprot.trans.flush()
1295 
 
1296 
  def recv_saveUserCommunication(self, ):
1297 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1298 
    if mtype == TMessageType.EXCEPTION:
1299 
      x = TApplicationException()
1300 
      x.read(self._iprot)
1301 
      self._iprot.readMessageEnd()
1302 
      raise x
1303 
    result = saveUserCommunication_result()
1304 
    result.read(self._iprot)
1305 
    self._iprot.readMessageEnd()
1306 
    if result.success != None:
1307 
      return result.success
1308 
    if result.ucx != None:
1309 
      raise result.ucx
1310 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1311 
 
1590 varun.gupt 1312 
  def getUserCommunicationById(self, id):
1313 
    """
1314 
    Parameters:
1315 
     - id
1316 
    """
1317 
    self.send_getUserCommunicationById(id)
1318 
    return self.recv_getUserCommunicationById()
1319 
 
1320 
  def send_getUserCommunicationById(self, id):
1321 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1322 
    args = getUserCommunicationById_args()
1323 
    args.id = id
1324 
    args.write(self._oprot)
1325 
    self._oprot.writeMessageEnd()
1326 
    self._oprot.trans.flush()
1327 
 
1328 
  def recv_getUserCommunicationById(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 = getUserCommunicationById_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, "getUserCommunicationById failed: unknown result");
1343 
 
1344 
  def getUserCommunicationByUser(self, userId):
1345 
    """
1346 
    Parameters:
1347 
     - userId
1348 
    """
1349 
    self.send_getUserCommunicationByUser(userId)
1350 
    return self.recv_getUserCommunicationByUser()
1351 
 
1352 
  def send_getUserCommunicationByUser(self, userId):
1353 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1354 
    args = getUserCommunicationByUser_args()
1355 
    args.userId = userId
1356 
    args.write(self._oprot)
1357 
    self._oprot.writeMessageEnd()
1358 
    self._oprot.trans.flush()
1359 
 
1360 
  def recv_getUserCommunicationByUser(self, ):
1361 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1362 
    if mtype == TMessageType.EXCEPTION:
1363 
      x = TApplicationException()
1364 
      x.read(self._iprot)
1365 
      self._iprot.readMessageEnd()
1366 
      raise x
1367 
    result = getUserCommunicationByUser_result()
1368 
    result.read(self._iprot)
1369 
    self._iprot.readMessageEnd()
1370 
    if result.success != None:
1371 
      return result.success
1372 
    if result.ucx != None:
1373 
      raise result.ucx
1374 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1375 
 
1376 
  def getAllUserCommunications(self, ):
1377 
    self.send_getAllUserCommunications()
1378 
    return self.recv_getAllUserCommunications()
1379 
 
1380 
  def send_getAllUserCommunications(self, ):
1381 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1382 
    args = getAllUserCommunications_args()
1383 
    args.write(self._oprot)
1384 
    self._oprot.writeMessageEnd()
1385 
    self._oprot.trans.flush()
1386 
 
1387 
  def recv_getAllUserCommunications(self, ):
1388 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1389 
    if mtype == TMessageType.EXCEPTION:
1390 
      x = TApplicationException()
1391 
      x.read(self._iprot)
1392 
      self._iprot.readMessageEnd()
1393 
      raise x
1394 
    result = getAllUserCommunications_result()
1395 
    result.read(self._iprot)
1396 
    self._iprot.readMessageEnd()
1397 
    if result.success != None:
1398 
      return result.success
1399 
    if result.ucx != None:
1400 
      raise result.ucx
1401 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1402 
 
1859 vikas 1403 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1404 
    """
1405 
    Parameters:
1406 
     - name
1859 vikas 1407 
     - addedOn
1845 vikas 1408 
    """
1859 vikas 1409 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1410 
    return self.recv_createMasterAffiliate()
1411 
 
1859 vikas 1412 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1413 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1414 
    args = createMasterAffiliate_args()
1415 
    args.name = name
1859 vikas 1416 
    args.addedOn = addedOn
1845 vikas 1417 
    args.write(self._oprot)
1418 
    self._oprot.writeMessageEnd()
1419 
    self._oprot.trans.flush()
1420 
 
1421 
  def recv_createMasterAffiliate(self, ):
1422 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1423 
    if mtype == TMessageType.EXCEPTION:
1424 
      x = TApplicationException()
1425 
      x.read(self._iprot)
1426 
      self._iprot.readMessageEnd()
1427 
      raise x
1428 
    result = createMasterAffiliate_result()
1429 
    result.read(self._iprot)
1430 
    self._iprot.readMessageEnd()
1431 
    if result.success != None:
1432 
      return result.success
1433 
    if result.utx != None:
1434 
      raise result.utx
1435 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1436 
 
1899 vikas 1437 
  def getAllMasterAffiliates(self, ):
1438 
    self.send_getAllMasterAffiliates()
1439 
    return self.recv_getAllMasterAffiliates()
1440 
 
1441 
  def send_getAllMasterAffiliates(self, ):
1442 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1443 
    args = getAllMasterAffiliates_args()
1444 
    args.write(self._oprot)
1445 
    self._oprot.writeMessageEnd()
1446 
    self._oprot.trans.flush()
1447 
 
1448 
  def recv_getAllMasterAffiliates(self, ):
1449 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1450 
    if mtype == TMessageType.EXCEPTION:
1451 
      x = TApplicationException()
1452 
      x.read(self._iprot)
1453 
      self._iprot.readMessageEnd()
1454 
      raise x
1455 
    result = getAllMasterAffiliates_result()
1456 
    result.read(self._iprot)
1457 
    self._iprot.readMessageEnd()
1458 
    if result.success != None:
1459 
      return result.success
1460 
    if result.utx != None:
1461 
      raise result.utx
1462 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1463 
 
1845 vikas 1464 
  def getMasterAffiliateById(self, id):
1465 
    """
1466 
    Parameters:
1467 
     - id
1468 
    """
1469 
    self.send_getMasterAffiliateById(id)
1470 
    return self.recv_getMasterAffiliateById()
1471 
 
1472 
  def send_getMasterAffiliateById(self, id):
1473 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1474 
    args = getMasterAffiliateById_args()
1475 
    args.id = id
1476 
    args.write(self._oprot)
1477 
    self._oprot.writeMessageEnd()
1478 
    self._oprot.trans.flush()
1479 
 
1480 
  def recv_getMasterAffiliateById(self, ):
1481 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1482 
    if mtype == TMessageType.EXCEPTION:
1483 
      x = TApplicationException()
1484 
      x.read(self._iprot)
1485 
      self._iprot.readMessageEnd()
1486 
      raise x
1487 
    result = getMasterAffiliateById_result()
1488 
    result.read(self._iprot)
1489 
    self._iprot.readMessageEnd()
1490 
    if result.success != None:
1491 
      return result.success
1492 
    if result.utx != None:
1493 
      raise result.utx
1494 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1495 
 
1496 
  def getMasterAffiliateByName(self, name):
1497 
    """
1498 
    Parameters:
1499 
     - name
1500 
    """
1501 
    self.send_getMasterAffiliateByName(name)
1502 
    return self.recv_getMasterAffiliateByName()
1503 
 
1504 
  def send_getMasterAffiliateByName(self, name):
1505 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1506 
    args = getMasterAffiliateByName_args()
1507 
    args.name = name
1508 
    args.write(self._oprot)
1509 
    self._oprot.writeMessageEnd()
1510 
    self._oprot.trans.flush()
1511 
 
1512 
  def recv_getMasterAffiliateByName(self, ):
1513 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1514 
    if mtype == TMessageType.EXCEPTION:
1515 
      x = TApplicationException()
1516 
      x.read(self._iprot)
1517 
      self._iprot.readMessageEnd()
1518 
      raise x
1519 
    result = getMasterAffiliateByName_result()
1520 
    result.read(self._iprot)
1521 
    self._iprot.readMessageEnd()
1522 
    if result.success != None:
1523 
      return result.success
1524 
    if result.utx != None:
1525 
      raise result.utx
1526 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1527 
 
1859 vikas 1528 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1529 
    """
1530 
    Parameters:
1531 
     - name
1532 
     - url
1533 
     - masterAffiliateId
1859 vikas 1534 
     - addedOn
1845 vikas 1535 
    """
1859 vikas 1536 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1537 
    return self.recv_createAffiliate()
1538 
 
1859 vikas 1539 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1540 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1541 
    args = createAffiliate_args()
1542 
    args.name = name
1543 
    args.url = url
1544 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1545 
    args.addedOn = addedOn
1845 vikas 1546 
    args.write(self._oprot)
1547 
    self._oprot.writeMessageEnd()
1548 
    self._oprot.trans.flush()
1549 
 
1550 
  def recv_createAffiliate(self, ):
1551 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1552 
    if mtype == TMessageType.EXCEPTION:
1553 
      x = TApplicationException()
1554 
      x.read(self._iprot)
1555 
      self._iprot.readMessageEnd()
1556 
      raise x
1557 
    result = createAffiliate_result()
1558 
    result.read(self._iprot)
1559 
    self._iprot.readMessageEnd()
1560 
    if result.success != None:
1561 
      return result.success
1562 
    if result.utx != None:
1563 
      raise result.utx
1564 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1565 
 
1566 
  def getAffiliateById(self, id):
1567 
    """
1568 
    Parameters:
1569 
     - id
1570 
    """
1571 
    self.send_getAffiliateById(id)
1572 
    return self.recv_getAffiliateById()
1573 
 
1574 
  def send_getAffiliateById(self, id):
1575 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1576 
    args = getAffiliateById_args()
1577 
    args.id = id
1578 
    args.write(self._oprot)
1579 
    self._oprot.writeMessageEnd()
1580 
    self._oprot.trans.flush()
1581 
 
1582 
  def recv_getAffiliateById(self, ):
1583 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1584 
    if mtype == TMessageType.EXCEPTION:
1585 
      x = TApplicationException()
1586 
      x.read(self._iprot)
1587 
      self._iprot.readMessageEnd()
1588 
      raise x
1589 
    result = getAffiliateById_result()
1590 
    result.read(self._iprot)
1591 
    self._iprot.readMessageEnd()
1592 
    if result.success != None:
1593 
      return result.success
1594 
    if result.utx != None:
1595 
      raise result.utx
1596 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1597 
 
1598 
  def getAffiliateByName(self, name):
1599 
    """
1600 
    Parameters:
1601 
     - name
1602 
    """
1603 
    self.send_getAffiliateByName(name)
1604 
    return self.recv_getAffiliateByName()
1605 
 
1606 
  def send_getAffiliateByName(self, name):
1607 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1608 
    args = getAffiliateByName_args()
1609 
    args.name = name
1610 
    args.write(self._oprot)
1611 
    self._oprot.writeMessageEnd()
1612 
    self._oprot.trans.flush()
1613 
 
1614 
  def recv_getAffiliateByName(self, ):
1615 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1616 
    if mtype == TMessageType.EXCEPTION:
1617 
      x = TApplicationException()
1618 
      x.read(self._iprot)
1619 
      self._iprot.readMessageEnd()
1620 
      raise x
1621 
    result = getAffiliateByName_result()
1622 
    result.read(self._iprot)
1623 
    self._iprot.readMessageEnd()
1624 
    if result.success != None:
1625 
      return result.success
1626 
    if result.utx != None:
1627 
      raise result.utx
1628 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1629 
 
1630 
  def getAffiliatesByMasterAffiliate(self, id):
1631 
    """
1632 
    Parameters:
1633 
     - id
1634 
    """
1635 
    self.send_getAffiliatesByMasterAffiliate(id)
1636 
    return self.recv_getAffiliatesByMasterAffiliate()
1637 
 
1638 
  def send_getAffiliatesByMasterAffiliate(self, id):
1639 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1640 
    args = getAffiliatesByMasterAffiliate_args()
1641 
    args.id = id
1642 
    args.write(self._oprot)
1643 
    self._oprot.writeMessageEnd()
1644 
    self._oprot.trans.flush()
1645 
 
1646 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1647 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1648 
    if mtype == TMessageType.EXCEPTION:
1649 
      x = TApplicationException()
1650 
      x.read(self._iprot)
1651 
      self._iprot.readMessageEnd()
1652 
      raise x
1653 
    result = getAffiliatesByMasterAffiliate_result()
1654 
    result.read(self._iprot)
1655 
    self._iprot.readMessageEnd()
1656 
    if result.success != None:
1657 
      return result.success
1658 
    if result.utx != None:
1659 
      raise result.utx
1660 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1661 
 
1859 vikas 1662 
  def createTracker(self, affiliateId, addedOn):
1845 vikas 1663 
    """
1664 
    Parameters:
1665 
     - affiliateId
1859 vikas 1666 
     - addedOn
1845 vikas 1667 
    """
1859 vikas 1668 
    self.send_createTracker(affiliateId, addedOn)
1845 vikas 1669 
    return self.recv_createTracker()
1670 
 
1859 vikas 1671 
  def send_createTracker(self, affiliateId, addedOn):
1845 vikas 1672 
    self._oprot.writeMessageBegin('createTracker', TMessageType.CALL, self._seqid)
1673 
    args = createTracker_args()
1674 
    args.affiliateId = affiliateId
1859 vikas 1675 
    args.addedOn = addedOn
1845 vikas 1676 
    args.write(self._oprot)
1677 
    self._oprot.writeMessageEnd()
1678 
    self._oprot.trans.flush()
1679 
 
1680 
  def recv_createTracker(self, ):
1681 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1682 
    if mtype == TMessageType.EXCEPTION:
1683 
      x = TApplicationException()
1684 
      x.read(self._iprot)
1685 
      self._iprot.readMessageEnd()
1686 
      raise x
1687 
    result = createTracker_result()
1688 
    result.read(self._iprot)
1689 
    self._iprot.readMessageEnd()
1690 
    if result.success != None:
1691 
      return result.success
1692 
    if result.utx != None:
1693 
      raise result.utx
1694 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTracker failed: unknown result");
1695 
 
1696 
  def getTrackerById(self, trackerId):
1697 
    """
1698 
    Parameters:
1699 
     - trackerId
1700 
    """
1701 
    self.send_getTrackerById(trackerId)
1702 
    return self.recv_getTrackerById()
1703 
 
1704 
  def send_getTrackerById(self, trackerId):
1705 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1706 
    args = getTrackerById_args()
1707 
    args.trackerId = trackerId
1708 
    args.write(self._oprot)
1709 
    self._oprot.writeMessageEnd()
1710 
    self._oprot.trans.flush()
1711 
 
1712 
  def recv_getTrackerById(self, ):
1713 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1714 
    if mtype == TMessageType.EXCEPTION:
1715 
      x = TApplicationException()
1716 
      x.read(self._iprot)
1717 
      self._iprot.readMessageEnd()
1718 
      raise x
1719 
    result = getTrackerById_result()
1720 
    result.read(self._iprot)
1721 
    self._iprot.readMessageEnd()
1722 
    if result.success != None:
1723 
      return result.success
1724 
    if result.utx != None:
1725 
      raise result.utx
1726 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1727 
 
1728 
  def getTrackersByAffiliate(self, affiliateId):
1729 
    """
1730 
    Parameters:
1731 
     - affiliateId
1732 
    """
1733 
    self.send_getTrackersByAffiliate(affiliateId)
1734 
    return self.recv_getTrackersByAffiliate()
1735 
 
1736 
  def send_getTrackersByAffiliate(self, affiliateId):
1737 
    self._oprot.writeMessageBegin('getTrackersByAffiliate', TMessageType.CALL, self._seqid)
1738 
    args = getTrackersByAffiliate_args()
1739 
    args.affiliateId = affiliateId
1740 
    args.write(self._oprot)
1741 
    self._oprot.writeMessageEnd()
1742 
    self._oprot.trans.flush()
1743 
 
1744 
  def recv_getTrackersByAffiliate(self, ):
1745 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1746 
    if mtype == TMessageType.EXCEPTION:
1747 
      x = TApplicationException()
1748 
      x.read(self._iprot)
1749 
      self._iprot.readMessageEnd()
1750 
      raise x
1751 
    result = getTrackersByAffiliate_result()
1752 
    result.read(self._iprot)
1753 
    self._iprot.readMessageEnd()
1754 
    if result.success != None:
1755 
      return result.success
1756 
    if result.utx != None:
1757 
      raise result.utx
1758 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackersByAffiliate failed: unknown result");
1759 
 
1859 vikas 1760 
  def addTrackLog(self, trackerId, userId, event, url, data, addedOn):
1845 vikas 1761 
    """
1762 
    Parameters:
1763 
     - trackerId
1764 
     - userId
1765 
     - event
1766 
     - url
1767 
     - data
1859 vikas 1768 
     - addedOn
1845 vikas 1769 
    """
1859 vikas 1770 
    self.send_addTrackLog(trackerId, userId, event, url, data, addedOn)
1845 vikas 1771 
    return self.recv_addTrackLog()
1772 
 
1859 vikas 1773 
  def send_addTrackLog(self, trackerId, userId, event, url, data, addedOn):
1845 vikas 1774 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1775 
    args = addTrackLog_args()
1776 
    args.trackerId = trackerId
1777 
    args.userId = userId
1778 
    args.event = event
1779 
    args.url = url
1780 
    args.data = data
1859 vikas 1781 
    args.addedOn = addedOn
1845 vikas 1782 
    args.write(self._oprot)
1783 
    self._oprot.writeMessageEnd()
1784 
    self._oprot.trans.flush()
1785 
 
1786 
  def recv_addTrackLog(self, ):
1787 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1788 
    if mtype == TMessageType.EXCEPTION:
1789 
      x = TApplicationException()
1790 
      x.read(self._iprot)
1791 
      self._iprot.readMessageEnd()
1792 
      raise x
1793 
    result = addTrackLog_result()
1794 
    result.read(self._iprot)
1795 
    self._iprot.readMessageEnd()
1796 
    if result.success != None:
1797 
      return result.success
1798 
    if result.utx != None:
1799 
      raise result.utx
1800 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1801 
 
1802 
  def getTrackLogById(self, id):
1803 
    """
1804 
    Parameters:
1805 
     - id
1806 
    """
1807 
    self.send_getTrackLogById(id)
1808 
    return self.recv_getTrackLogById()
1809 
 
1810 
  def send_getTrackLogById(self, id):
1811 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1812 
    args = getTrackLogById_args()
1813 
    args.id = id
1814 
    args.write(self._oprot)
1815 
    self._oprot.writeMessageEnd()
1816 
    self._oprot.trans.flush()
1817 
 
1818 
  def recv_getTrackLogById(self, ):
1819 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1820 
    if mtype == TMessageType.EXCEPTION:
1821 
      x = TApplicationException()
1822 
      x.read(self._iprot)
1823 
      self._iprot.readMessageEnd()
1824 
      raise x
1825 
    result = getTrackLogById_result()
1826 
    result.read(self._iprot)
1827 
    self._iprot.readMessageEnd()
1828 
    if result.success != None:
1829 
      return result.success
1830 
    if result.utx != None:
1831 
      raise result.utx
1832 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1833 
 
1834 
  def getTrackLogsByTracker(self, trackerId):
1835 
    """
1836 
    Parameters:
1837 
     - trackerId
1838 
    """
1839 
    self.send_getTrackLogsByTracker(trackerId)
1840 
    return self.recv_getTrackLogsByTracker()
1841 
 
1842 
  def send_getTrackLogsByTracker(self, trackerId):
1843 
    self._oprot.writeMessageBegin('getTrackLogsByTracker', TMessageType.CALL, self._seqid)
1844 
    args = getTrackLogsByTracker_args()
1845 
    args.trackerId = trackerId
1846 
    args.write(self._oprot)
1847 
    self._oprot.writeMessageEnd()
1848 
    self._oprot.trans.flush()
1849 
 
1850 
  def recv_getTrackLogsByTracker(self, ):
1851 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1852 
    if mtype == TMessageType.EXCEPTION:
1853 
      x = TApplicationException()
1854 
      x.read(self._iprot)
1855 
      self._iprot.readMessageEnd()
1856 
      raise x
1857 
    result = getTrackLogsByTracker_result()
1858 
    result.read(self._iprot)
1859 
    self._iprot.readMessageEnd()
1860 
    if result.success != None:
1861 
      return result.success
1862 
    if result.utx != None:
1863 
      raise result.utx
1864 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByTracker failed: unknown result");
1865 
 
1866 
  def getTrackLogsByUser(self, userId):
1867 
    """
1868 
    Parameters:
1869 
     - userId
1870 
    """
1871 
    self.send_getTrackLogsByUser(userId)
1872 
    return self.recv_getTrackLogsByUser()
1873 
 
1874 
  def send_getTrackLogsByUser(self, userId):
1875 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
1876 
    args = getTrackLogsByUser_args()
1877 
    args.userId = userId
1878 
    args.write(self._oprot)
1879 
    self._oprot.writeMessageEnd()
1880 
    self._oprot.trans.flush()
1881 
 
1882 
  def recv_getTrackLogsByUser(self, ):
1883 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1884 
    if mtype == TMessageType.EXCEPTION:
1885 
      x = TApplicationException()
1886 
      x.read(self._iprot)
1887 
      self._iprot.readMessageEnd()
1888 
      raise x
1889 
    result = getTrackLogsByUser_result()
1890 
    result.read(self._iprot)
1891 
    self._iprot.readMessageEnd()
1892 
    if result.success != None:
1893 
      return result.success
1894 
    if result.utx != None:
1895 
      raise result.utx
1896 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
1897 
 
1898 
  def getTrackLogs(self, trackerId, userId, event, url):
1899 
    """
1900 
    Parameters:
1901 
     - trackerId
1902 
     - userId
1903 
     - event
1904 
     - url
1905 
    """
1906 
    self.send_getTrackLogs(trackerId, userId, event, url)
1907 
    return self.recv_getTrackLogs()
1908 
 
1909 
  def send_getTrackLogs(self, trackerId, userId, event, url):
1910 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
1911 
    args = getTrackLogs_args()
1912 
    args.trackerId = trackerId
1913 
    args.userId = userId
1914 
    args.event = event
1915 
    args.url = url
1916 
    args.write(self._oprot)
1917 
    self._oprot.writeMessageEnd()
1918 
    self._oprot.trans.flush()
1919 
 
1920 
  def recv_getTrackLogs(self, ):
1921 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1922 
    if mtype == TMessageType.EXCEPTION:
1923 
      x = TApplicationException()
1924 
      x.read(self._iprot)
1925 
      self._iprot.readMessageEnd()
1926 
      raise x
1927 
    result = getTrackLogs_result()
1928 
    result.read(self._iprot)
1929 
    self._iprot.readMessageEnd()
1930 
    if result.success != None:
1931 
      return result.success
1932 
    if result.utx != None:
1933 
      raise result.utx
1934 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
1935 
 
559 chandransh 1936 
  def createCart(self, userId):
94 ashish 1937 
    """
1938 
    Parameters:
559 chandransh 1939 
     - userId
94 ashish 1940 
    """
559 chandransh 1941 
    self.send_createCart(userId)
1942 
    return self.recv_createCart()
94 ashish 1943 
 
559 chandransh 1944 
  def send_createCart(self, userId):
1945 
    self._oprot.writeMessageBegin('createCart', TMessageType.CALL, self._seqid)
1946 
    args = createCart_args()
1947 
    args.userId = userId
94 ashish 1948 
    args.write(self._oprot)
1949 
    self._oprot.writeMessageEnd()
1950 
    self._oprot.trans.flush()
1951 
 
559 chandransh 1952 
  def recv_createCart(self, ):
94 ashish 1953 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1954 
    if mtype == TMessageType.EXCEPTION:
1955 
      x = TApplicationException()
1956 
      x.read(self._iprot)
1957 
      self._iprot.readMessageEnd()
1958 
      raise x
559 chandransh 1959 
    result = createCart_result()
94 ashish 1960 
    result.read(self._iprot)
1961 
    self._iprot.readMessageEnd()
1962 
    if result.success != None:
1963 
      return result.success
559 chandransh 1964 
    if result.scx != None:
1965 
      raise result.scx
1966 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createCart failed: unknown result");
94 ashish 1967 
 
559 chandransh 1968 
  def getCurrentCart(self, userId):
94 ashish 1969 
    """
1970 
    Parameters:
559 chandransh 1971 
     - userId
94 ashish 1972 
    """
559 chandransh 1973 
    self.send_getCurrentCart(userId)
1974 
    return self.recv_getCurrentCart()
94 ashish 1975 
 
559 chandransh 1976 
  def send_getCurrentCart(self, userId):
1977 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
1978 
    args = getCurrentCart_args()
1979 
    args.userId = userId
94 ashish 1980 
    args.write(self._oprot)
1981 
    self._oprot.writeMessageEnd()
1982 
    self._oprot.trans.flush()
1983 
 
559 chandransh 1984 
  def recv_getCurrentCart(self, ):
94 ashish 1985 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1986 
    if mtype == TMessageType.EXCEPTION:
1987 
      x = TApplicationException()
1988 
      x.read(self._iprot)
1989 
      self._iprot.readMessageEnd()
1990 
      raise x
559 chandransh 1991 
    result = getCurrentCart_result()
94 ashish 1992 
    result.read(self._iprot)
1993 
    self._iprot.readMessageEnd()
1994 
    if result.success != None:
1995 
      return result.success
559 chandransh 1996 
    if result.scx != None:
1997 
      raise result.scx
1998 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 1999 
 
559 chandransh 2000 
  def getCart(self, cartId):
94 ashish 2001 
    """
2002 
    Parameters:
559 chandransh 2003 
     - cartId
94 ashish 2004 
    """
559 chandransh 2005 
    self.send_getCart(cartId)
2006 
    return self.recv_getCart()
94 ashish 2007 
 
559 chandransh 2008 
  def send_getCart(self, cartId):
2009 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
2010 
    args = getCart_args()
2011 
    args.cartId = cartId
94 ashish 2012 
    args.write(self._oprot)
2013 
    self._oprot.writeMessageEnd()
2014 
    self._oprot.trans.flush()
2015 
 
559 chandransh 2016 
  def recv_getCart(self, ):
94 ashish 2017 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2018 
    if mtype == TMessageType.EXCEPTION:
2019 
      x = TApplicationException()
2020 
      x.read(self._iprot)
2021 
      self._iprot.readMessageEnd()
2022 
      raise x
559 chandransh 2023 
    result = getCart_result()
94 ashish 2024 
    result.read(self._iprot)
2025 
    self._iprot.readMessageEnd()
2026 
    if result.success != None:
2027 
      return result.success
559 chandransh 2028 
    if result.scx != None:
2029 
      raise result.scx
2030 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 2031 
 
559 chandransh 2032 
  def getCartsForUser(self, userId, status):
94 ashish 2033 
    """
2034 
    Parameters:
559 chandransh 2035 
     - userId
2036 
     - status
94 ashish 2037 
    """
559 chandransh 2038 
    self.send_getCartsForUser(userId, status)
2039 
    return self.recv_getCartsForUser()
94 ashish 2040 
 
559 chandransh 2041 
  def send_getCartsForUser(self, userId, status):
2042 
    self._oprot.writeMessageBegin('getCartsForUser', TMessageType.CALL, self._seqid)
2043 
    args = getCartsForUser_args()
2044 
    args.userId = userId
2045 
    args.status = status
94 ashish 2046 
    args.write(self._oprot)
2047 
    self._oprot.writeMessageEnd()
2048 
    self._oprot.trans.flush()
2049 
 
559 chandransh 2050 
  def recv_getCartsForUser(self, ):
94 ashish 2051 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2052 
    if mtype == TMessageType.EXCEPTION:
2053 
      x = TApplicationException()
2054 
      x.read(self._iprot)
2055 
      self._iprot.readMessageEnd()
2056 
      raise x
559 chandransh 2057 
    result = getCartsForUser_result()
94 ashish 2058 
    result.read(self._iprot)
2059 
    self._iprot.readMessageEnd()
2060 
    if result.success != None:
2061 
      return result.success
559 chandransh 2062 
    if result.scx != None:
2063 
      raise result.scx
2064 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsForUser failed: unknown result");
94 ashish 2065 
 
559 chandransh 2066 
  def getCartsByStatus(self, status):
94 ashish 2067 
    """
2068 
    Parameters:
559 chandransh 2069 
     - status
94 ashish 2070 
    """
559 chandransh 2071 
    self.send_getCartsByStatus(status)
2072 
    return self.recv_getCartsByStatus()
94 ashish 2073 
 
559 chandransh 2074 
  def send_getCartsByStatus(self, status):
2075 
    self._oprot.writeMessageBegin('getCartsByStatus', TMessageType.CALL, self._seqid)
2076 
    args = getCartsByStatus_args()
2077 
    args.status = status
94 ashish 2078 
    args.write(self._oprot)
2079 
    self._oprot.writeMessageEnd()
2080 
    self._oprot.trans.flush()
2081 
 
559 chandransh 2082 
  def recv_getCartsByStatus(self, ):
94 ashish 2083 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2084 
    if mtype == TMessageType.EXCEPTION:
2085 
      x = TApplicationException()
2086 
      x.read(self._iprot)
2087 
      self._iprot.readMessageEnd()
2088 
      raise x
559 chandransh 2089 
    result = getCartsByStatus_result()
94 ashish 2090 
    result.read(self._iprot)
2091 
    self._iprot.readMessageEnd()
2092 
    if result.success != None:
2093 
      return result.success
559 chandransh 2094 
    if result.scx != None:
2095 
      raise result.scx
2096 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByStatus failed: unknown result");
94 ashish 2097 
 
559 chandransh 2098 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2099 
    """
2100 
    Parameters:
559 chandransh 2101 
     - from_time
2102 
     - to_time
2103 
     - status
94 ashish 2104 
    """
559 chandransh 2105 
    self.send_getCartsByTime(from_time, to_time, status)
2106 
    return self.recv_getCartsByTime()
94 ashish 2107 
 
559 chandransh 2108 
  def send_getCartsByTime(self, from_time, to_time, status):
2109 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2110 
    args = getCartsByTime_args()
2111 
    args.from_time = from_time
2112 
    args.to_time = to_time
2113 
    args.status = status
94 ashish 2114 
    args.write(self._oprot)
2115 
    self._oprot.writeMessageEnd()
2116 
    self._oprot.trans.flush()
2117 
 
559 chandransh 2118 
  def recv_getCartsByTime(self, ):
94 ashish 2119 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2120 
    if mtype == TMessageType.EXCEPTION:
2121 
      x = TApplicationException()
2122 
      x.read(self._iprot)
2123 
      self._iprot.readMessageEnd()
2124 
      raise x
559 chandransh 2125 
    result = getCartsByTime_result()
94 ashish 2126 
    result.read(self._iprot)
2127 
    self._iprot.readMessageEnd()
2128 
    if result.success != None:
2129 
      return result.success
559 chandransh 2130 
    if result.scx != None:
2131 
      raise result.scx
2132 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2133 
 
559 chandransh 2134 
  def changeCartStatus(self, cartId, status):
130 ashish 2135 
    """
2136 
    Parameters:
559 chandransh 2137 
     - cartId
2138 
     - status
130 ashish 2139 
    """
559 chandransh 2140 
    self.send_changeCartStatus(cartId, status)
2141 
    self.recv_changeCartStatus()
94 ashish 2142 
 
559 chandransh 2143 
  def send_changeCartStatus(self, cartId, status):
2144 
    self._oprot.writeMessageBegin('changeCartStatus', TMessageType.CALL, self._seqid)
2145 
    args = changeCartStatus_args()
2146 
    args.cartId = cartId
2147 
    args.status = status
130 ashish 2148 
    args.write(self._oprot)
2149 
    self._oprot.writeMessageEnd()
2150 
    self._oprot.trans.flush()
2151 
 
559 chandransh 2152 
  def recv_changeCartStatus(self, ):
130 ashish 2153 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2154 
    if mtype == TMessageType.EXCEPTION:
2155 
      x = TApplicationException()
2156 
      x.read(self._iprot)
2157 
      self._iprot.readMessageEnd()
2158 
      raise x
559 chandransh 2159 
    result = changeCartStatus_result()
130 ashish 2160 
    result.read(self._iprot)
2161 
    self._iprot.readMessageEnd()
559 chandransh 2162 
    if result.scx != None:
2163 
      raise result.scx
2164 
    return
2165 
 
2166 
  def addItemToCart(self, cartId, itemId, quantity):
2167 
    """
2168 
    Parameters:
2169 
     - cartId
2170 
     - itemId
2171 
     - quantity
2172 
    """
2173 
    self.send_addItemToCart(cartId, itemId, quantity)
2174 
    self.recv_addItemToCart()
2175 
 
2176 
  def send_addItemToCart(self, cartId, itemId, quantity):
2177 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2178 
    args = addItemToCart_args()
2179 
    args.cartId = cartId
2180 
    args.itemId = itemId
2181 
    args.quantity = quantity
2182 
    args.write(self._oprot)
2183 
    self._oprot.writeMessageEnd()
2184 
    self._oprot.trans.flush()
2185 
 
2186 
  def recv_addItemToCart(self, ):
2187 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2188 
    if mtype == TMessageType.EXCEPTION:
2189 
      x = TApplicationException()
2190 
      x.read(self._iprot)
2191 
      self._iprot.readMessageEnd()
2192 
      raise x
2193 
    result = addItemToCart_result()
2194 
    result.read(self._iprot)
2195 
    self._iprot.readMessageEnd()
2196 
    if result.scx != None:
2197 
      raise result.scx
2198 
    return
2199 
 
2200 
  def deleteItemFromCart(self, cartId, itemId):
2201 
    """
2202 
    Parameters:
2203 
     - cartId
2204 
     - itemId
2205 
    """
2206 
    self.send_deleteItemFromCart(cartId, itemId)
2207 
    self.recv_deleteItemFromCart()
2208 
 
2209 
  def send_deleteItemFromCart(self, cartId, itemId):
2210 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2211 
    args = deleteItemFromCart_args()
2212 
    args.cartId = cartId
2213 
    args.itemId = itemId
2214 
    args.write(self._oprot)
2215 
    self._oprot.writeMessageEnd()
2216 
    self._oprot.trans.flush()
2217 
 
2218 
  def recv_deleteItemFromCart(self, ):
2219 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2220 
    if mtype == TMessageType.EXCEPTION:
2221 
      x = TApplicationException()
2222 
      x.read(self._iprot)
2223 
      self._iprot.readMessageEnd()
2224 
      raise x
2225 
    result = deleteItemFromCart_result()
2226 
    result.read(self._iprot)
2227 
    self._iprot.readMessageEnd()
2228 
    if result.scx != None:
2229 
      raise result.scx
2230 
    return
2231 
 
2232 
  def changeQuantity(self, cartId, itemId, quantity):
2233 
    """
2234 
    Parameters:
2235 
     - cartId
2236 
     - itemId
2237 
     - quantity
2238 
    """
2239 
    self.send_changeQuantity(cartId, itemId, quantity)
2240 
    self.recv_changeQuantity()
2241 
 
2242 
  def send_changeQuantity(self, cartId, itemId, quantity):
2243 
    self._oprot.writeMessageBegin('changeQuantity', TMessageType.CALL, self._seqid)
2244 
    args = changeQuantity_args()
2245 
    args.cartId = cartId
2246 
    args.itemId = itemId
2247 
    args.quantity = quantity
2248 
    args.write(self._oprot)
2249 
    self._oprot.writeMessageEnd()
2250 
    self._oprot.trans.flush()
2251 
 
2252 
  def recv_changeQuantity(self, ):
2253 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2254 
    if mtype == TMessageType.EXCEPTION:
2255 
      x = TApplicationException()
2256 
      x.read(self._iprot)
2257 
      self._iprot.readMessageEnd()
2258 
      raise x
2259 
    result = changeQuantity_result()
2260 
    result.read(self._iprot)
2261 
    self._iprot.readMessageEnd()
2262 
    if result.scx != None:
2263 
      raise result.scx
2264 
    return
2265 
 
2266 
  def changeItemStatus(self, cartId, itemId, status):
2267 
    """
2268 
    Parameters:
2269 
     - cartId
2270 
     - itemId
2271 
     - status
2272 
    """
2273 
    self.send_changeItemStatus(cartId, itemId, status)
2274 
    self.recv_changeItemStatus()
2275 
 
2276 
  def send_changeItemStatus(self, cartId, itemId, status):
2277 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
2278 
    args = changeItemStatus_args()
2279 
    args.cartId = cartId
2280 
    args.itemId = itemId
2281 
    args.status = status
2282 
    args.write(self._oprot)
2283 
    self._oprot.writeMessageEnd()
2284 
    self._oprot.trans.flush()
2285 
 
2286 
  def recv_changeItemStatus(self, ):
2287 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2288 
    if mtype == TMessageType.EXCEPTION:
2289 
      x = TApplicationException()
2290 
      x.read(self._iprot)
2291 
      self._iprot.readMessageEnd()
2292 
      raise x
2293 
    result = changeItemStatus_result()
2294 
    result.read(self._iprot)
2295 
    self._iprot.readMessageEnd()
2296 
    if result.scx != None:
2297 
      raise result.scx
2298 
    return
2299 
 
2300 
  def addAddressToCart(self, cartId, addressId):
2301 
    """
2302 
    Parameters:
2303 
     - cartId
2304 
     - addressId
2305 
    """
2306 
    self.send_addAddressToCart(cartId, addressId)
2307 
    self.recv_addAddressToCart()
2308 
 
2309 
  def send_addAddressToCart(self, cartId, addressId):
2310 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2311 
    args = addAddressToCart_args()
2312 
    args.cartId = cartId
2313 
    args.addressId = addressId
2314 
    args.write(self._oprot)
2315 
    self._oprot.writeMessageEnd()
2316 
    self._oprot.trans.flush()
2317 
 
2318 
  def recv_addAddressToCart(self, ):
2319 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2320 
    if mtype == TMessageType.EXCEPTION:
2321 
      x = TApplicationException()
2322 
      x.read(self._iprot)
2323 
      self._iprot.readMessageEnd()
2324 
      raise x
2325 
    result = addAddressToCart_result()
2326 
    result.read(self._iprot)
2327 
    self._iprot.readMessageEnd()
575 chandransh 2328 
    if result.scx != None:
2329 
      raise result.scx
559 chandransh 2330 
    return
2331 
 
1976 varun.gupt 2332 
  def applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
2333 
    """
2334 
    Parameters:
2335 
     - cartId
2336 
     - couponCode
2337 
     - totalPrice
2338 
     - discountedPrice
2339 
    """
2340 
    self.send_applyCouponToCart(cartId, couponCode, totalPrice, discountedPrice)
2341 
    self.recv_applyCouponToCart()
2342 
 
2343 
  def send_applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
2344 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2345 
    args = applyCouponToCart_args()
2346 
    args.cartId = cartId
2347 
    args.couponCode = couponCode
2348 
    args.totalPrice = totalPrice
2349 
    args.discountedPrice = discountedPrice
2350 
    args.write(self._oprot)
2351 
    self._oprot.writeMessageEnd()
2352 
    self._oprot.trans.flush()
2353 
 
2354 
  def recv_applyCouponToCart(self, ):
2355 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2356 
    if mtype == TMessageType.EXCEPTION:
2357 
      x = TApplicationException()
2358 
      x.read(self._iprot)
2359 
      self._iprot.readMessageEnd()
2360 
      raise x
2361 
    result = applyCouponToCart_result()
2362 
    result.read(self._iprot)
2363 
    self._iprot.readMessageEnd()
2364 
    if result.scx != None:
2365 
      raise result.scx
2366 
    return
2367 
 
2368 
  def removeCoupon(self, cartId):
2369 
    """
2370 
    Parameters:
2371 
     - cartId
2372 
    """
2373 
    self.send_removeCoupon(cartId)
2374 
    self.recv_removeCoupon()
2375 
 
2376 
  def send_removeCoupon(self, cartId):
2377 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2378 
    args = removeCoupon_args()
2379 
    args.cartId = cartId
2380 
    args.write(self._oprot)
2381 
    self._oprot.writeMessageEnd()
2382 
    self._oprot.trans.flush()
2383 
 
2384 
  def recv_removeCoupon(self, ):
2385 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2386 
    if mtype == TMessageType.EXCEPTION:
2387 
      x = TApplicationException()
2388 
      x.read(self._iprot)
2389 
      self._iprot.readMessageEnd()
2390 
      raise x
2391 
    result = removeCoupon_result()
2392 
    result.read(self._iprot)
2393 
    self._iprot.readMessageEnd()
2394 
    if result.scx != None:
2395 
      raise result.scx
2396 
    return
2397 
 
690 chandransh 2398 
  def createOrders(self, cartId):
559 chandransh 2399 
    """
690 chandransh 2400 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
2401 
 
559 chandransh 2402 
    Parameters:
2403 
     - cartId
2404 
    """
690 chandransh 2405 
    self.send_createOrders(cartId)
2406 
    return self.recv_createOrders()
559 chandransh 2407 
 
690 chandransh 2408 
  def send_createOrders(self, cartId):
2409 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2410 
    args = createOrders_args()
559 chandransh 2411 
    args.cartId = cartId
2412 
    args.write(self._oprot)
2413 
    self._oprot.writeMessageEnd()
2414 
    self._oprot.trans.flush()
2415 
 
690 chandransh 2416 
  def recv_createOrders(self, ):
559 chandransh 2417 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2418 
    if mtype == TMessageType.EXCEPTION:
2419 
      x = TApplicationException()
2420 
      x.read(self._iprot)
2421 
      self._iprot.readMessageEnd()
2422 
      raise x
690 chandransh 2423 
    result = createOrders_result()
559 chandransh 2424 
    result.read(self._iprot)
2425 
    self._iprot.readMessageEnd()
130 ashish 2426 
    if result.success != None:
2427 
      return result.success
559 chandransh 2428 
    if result.scx != None:
2429 
      raise result.scx
690 chandransh 2430 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2431 
 
559 chandransh 2432 
  def validateCart(self, cartId):
130 ashish 2433 
    """
690 chandransh 2434 
    Validates that:
2435 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2436 
    2. All of the lines in the cart are active items.
690 chandransh 2437 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2438 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 2439 
 
130 ashish 2440 
    Parameters:
559 chandransh 2441 
     - cartId
130 ashish 2442 
    """
559 chandransh 2443 
    self.send_validateCart(cartId)
2444 
    return self.recv_validateCart()
130 ashish 2445 
 
559 chandransh 2446 
  def send_validateCart(self, cartId):
2447 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2448 
    args = validateCart_args()
2449 
    args.cartId = cartId
130 ashish 2450 
    args.write(self._oprot)
2451 
    self._oprot.writeMessageEnd()
2452 
    self._oprot.trans.flush()
2453 
 
559 chandransh 2454 
  def recv_validateCart(self, ):
130 ashish 2455 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2456 
    if mtype == TMessageType.EXCEPTION:
2457 
      x = TApplicationException()
2458 
      x.read(self._iprot)
2459 
      self._iprot.readMessageEnd()
2460 
      raise x
559 chandransh 2461 
    result = validateCart_result()
130 ashish 2462 
    result.read(self._iprot)
2463 
    self._iprot.readMessageEnd()
2464 
    if result.success != None:
2465 
      return result.success
575 chandransh 2466 
    if result.scex != None:
2467 
      raise result.scex
559 chandransh 2468 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2469 
 
690 chandransh 2470 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2471 
    """
690 chandransh 2472 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
2473 
 
575 chandransh 2474 
    Parameters:
690 chandransh 2475 
     - fromCartId
2476 
     - toCartId
2477 
    """
2478 
    self.send_mergeCart(fromCartId, toCartId)
2479 
    self.recv_mergeCart()
2480 
 
2481 
  def send_mergeCart(self, fromCartId, toCartId):
2482 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2483 
    args = mergeCart_args()
2484 
    args.fromCartId = fromCartId
2485 
    args.toCartId = toCartId
2486 
    args.write(self._oprot)
2487 
    self._oprot.writeMessageEnd()
2488 
    self._oprot.trans.flush()
2489 
 
2490 
  def recv_mergeCart(self, ):
2491 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2492 
    if mtype == TMessageType.EXCEPTION:
2493 
      x = TApplicationException()
2494 
      x.read(self._iprot)
2495 
      self._iprot.readMessageEnd()
2496 
      raise x
2497 
    result = mergeCart_result()
2498 
    result.read(self._iprot)
2499 
    self._iprot.readMessageEnd()
2500 
    return
2501 
 
2502 
  def checkOut(self, cartId):
2503 
    """
2504 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
2505 
 
2506 
    Parameters:
575 chandransh 2507 
     - cartId
2508 
    """
690 chandransh 2509 
    self.send_checkOut(cartId)
2510 
    return self.recv_checkOut()
575 chandransh 2511 
 
690 chandransh 2512 
  def send_checkOut(self, cartId):
2513 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2514 
    args = checkOut_args()
575 chandransh 2515 
    args.cartId = cartId
2516 
    args.write(self._oprot)
2517 
    self._oprot.writeMessageEnd()
2518 
    self._oprot.trans.flush()
2519 
 
690 chandransh 2520 
  def recv_checkOut(self, ):
575 chandransh 2521 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2522 
    if mtype == TMessageType.EXCEPTION:
2523 
      x = TApplicationException()
2524 
      x.read(self._iprot)
2525 
      self._iprot.readMessageEnd()
2526 
      raise x
690 chandransh 2527 
    result = checkOut_result()
575 chandransh 2528 
    result.read(self._iprot)
2529 
    self._iprot.readMessageEnd()
2530 
    if result.success != None:
2531 
      return result.success
2532 
    if result.scex != None:
2533 
      raise result.scex
690 chandransh 2534 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2535 
 
690 chandransh 2536 
  def resetCart(self, cartId, items):
559 chandransh 2537 
    """
690 chandransh 2538 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2539 
    This methods removes the specified quantiry of the specified item from the cart.
2540 
 
559 chandransh 2541 
    Parameters:
690 chandransh 2542 
     - cartId
2543 
     - items
559 chandransh 2544 
    """
690 chandransh 2545 
    self.send_resetCart(cartId, items)
2546 
    return self.recv_resetCart()
130 ashish 2547 
 
690 chandransh 2548 
  def send_resetCart(self, cartId, items):
2549 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2550 
    args = resetCart_args()
2551 
    args.cartId = cartId
2552 
    args.items = items
559 chandransh 2553 
    args.write(self._oprot)
2554 
    self._oprot.writeMessageEnd()
2555 
    self._oprot.trans.flush()
2556 
 
690 chandransh 2557 
  def recv_resetCart(self, ):
559 chandransh 2558 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2559 
    if mtype == TMessageType.EXCEPTION:
2560 
      x = TApplicationException()
2561 
      x.read(self._iprot)
2562 
      self._iprot.readMessageEnd()
2563 
      raise x
690 chandransh 2564 
    result = resetCart_result()
559 chandransh 2565 
    result.read(self._iprot)
2566 
    self._iprot.readMessageEnd()
690 chandransh 2567 
    if result.success != None:
2568 
      return result.success
2569 
    if result.scex != None:
2570 
      raise result.scex
2571 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2572 
 
772 rajveer 2573 
  def getMyResearch(self, userId):
559 chandransh 2574 
    """
772 rajveer 2575 
    Widgets
2576 
 
559 chandransh 2577 
    Parameters:
2578 
     - userId
2579 
    """
772 rajveer 2580 
    self.send_getMyResearch(userId)
559 chandransh 2581 
    return self.recv_getMyResearch()
2582 
 
772 rajveer 2583 
  def send_getMyResearch(self, userId):
559 chandransh 2584 
    self._oprot.writeMessageBegin('getMyResearch', TMessageType.CALL, self._seqid)
2585 
    args = getMyResearch_args()
772 rajveer 2586 
    args.userId = userId
559 chandransh 2587 
    args.write(self._oprot)
2588 
    self._oprot.writeMessageEnd()
2589 
    self._oprot.trans.flush()
2590 
 
2591 
  def recv_getMyResearch(self, ):
2592 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2593 
    if mtype == TMessageType.EXCEPTION:
2594 
      x = TApplicationException()
2595 
      x.read(self._iprot)
2596 
      self._iprot.readMessageEnd()
2597 
      raise x
2598 
    result = getMyResearch_result()
2599 
    result.read(self._iprot)
2600 
    self._iprot.readMessageEnd()
2601 
    if result.success != None:
2602 
      return result.success
2603 
    if result.scx != None:
2604 
      raise result.scx
2605 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearch failed: unknown result");
2606 
 
772 rajveer 2607 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2608 
    """
2609 
    Parameters:
772 rajveer 2610 
     - userId
2611 
     - itemId
559 chandransh 2612 
    """
772 rajveer 2613 
    self.send_updateMyResearch(userId, itemId)
559 chandransh 2614 
    return self.recv_updateMyResearch()
2615 
 
772 rajveer 2616 
  def send_updateMyResearch(self, userId, itemId):
559 chandransh 2617 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2618 
    args = updateMyResearch_args()
772 rajveer 2619 
    args.userId = userId
2620 
    args.itemId = itemId
559 chandransh 2621 
    args.write(self._oprot)
2622 
    self._oprot.writeMessageEnd()
2623 
    self._oprot.trans.flush()
2624 
 
2625 
  def recv_updateMyResearch(self, ):
2626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2627 
    if mtype == TMessageType.EXCEPTION:
2628 
      x = TApplicationException()
2629 
      x.read(self._iprot)
2630 
      self._iprot.readMessageEnd()
2631 
      raise x
2632 
    result = updateMyResearch_result()
2633 
    result.read(self._iprot)
2634 
    self._iprot.readMessageEnd()
2635 
    if result.success != None:
2636 
      return result.success
2637 
    if result.scx != None:
2638 
      raise result.scx
2639 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
2640 
 
772 rajveer 2641 
  def deleteItemFromMyResearch(self, userId, itemId):
559 chandransh 2642 
    """
2643 
    Parameters:
772 rajveer 2644 
     - userId
2645 
     - itemId
559 chandransh 2646 
    """
772 rajveer 2647 
    self.send_deleteItemFromMyResearch(userId, itemId)
559 chandransh 2648 
    self.recv_deleteItemFromMyResearch()
2649 
 
772 rajveer 2650 
  def send_deleteItemFromMyResearch(self, userId, itemId):
559 chandransh 2651 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2652 
    args = deleteItemFromMyResearch_args()
772 rajveer 2653 
    args.userId = userId
2654 
    args.itemId = itemId
559 chandransh 2655 
    args.write(self._oprot)
2656 
    self._oprot.writeMessageEnd()
2657 
    self._oprot.trans.flush()
2658 
 
2659 
  def recv_deleteItemFromMyResearch(self, ):
2660 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2661 
    if mtype == TMessageType.EXCEPTION:
2662 
      x = TApplicationException()
2663 
      x.read(self._iprot)
2664 
      self._iprot.readMessageEnd()
2665 
      raise x
2666 
    result = deleteItemFromMyResearch_result()
2667 
    result.read(self._iprot)
2668 
    self._iprot.readMessageEnd()
2669 
    if result.scx != None:
2670 
      raise result.scx
2671 
    return
2672 
 
772 rajveer 2673 
  def updateBrowseHistory(self, userId, itemId):
559 chandransh 2674 
    """
2675 
    Parameters:
772 rajveer 2676 
     - userId
2677 
     - itemId
559 chandransh 2678 
    """
772 rajveer 2679 
    self.send_updateBrowseHistory(userId, itemId)
2680 
    self.recv_updateBrowseHistory()
559 chandransh 2681 
 
772 rajveer 2682 
  def send_updateBrowseHistory(self, userId, itemId):
2683 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2684 
    args = updateBrowseHistory_args()
2685 
    args.userId = userId
2686 
    args.itemId = itemId
559 chandransh 2687 
    args.write(self._oprot)
2688 
    self._oprot.writeMessageEnd()
2689 
    self._oprot.trans.flush()
2690 
 
772 rajveer 2691 
  def recv_updateBrowseHistory(self, ):
559 chandransh 2692 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2693 
    if mtype == TMessageType.EXCEPTION:
2694 
      x = TApplicationException()
2695 
      x.read(self._iprot)
2696 
      self._iprot.readMessageEnd()
2697 
      raise x
772 rajveer 2698 
    result = updateBrowseHistory_result()
559 chandransh 2699 
    result.read(self._iprot)
2700 
    self._iprot.readMessageEnd()
2701 
    return
2702 
 
772 rajveer 2703 
  def getBrowseHistory(self, userId):
559 chandransh 2704 
    """
2705 
    Parameters:
772 rajveer 2706 
     - userId
559 chandransh 2707 
    """
772 rajveer 2708 
    self.send_getBrowseHistory(userId)
2709 
    return self.recv_getBrowseHistory()
559 chandransh 2710 
 
772 rajveer 2711 
  def send_getBrowseHistory(self, userId):
2712 
    self._oprot.writeMessageBegin('getBrowseHistory', TMessageType.CALL, self._seqid)
2713 
    args = getBrowseHistory_args()
2714 
    args.userId = userId
559 chandransh 2715 
    args.write(self._oprot)
2716 
    self._oprot.writeMessageEnd()
2717 
    self._oprot.trans.flush()
2718 
 
772 rajveer 2719 
  def recv_getBrowseHistory(self, ):
559 chandransh 2720 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2721 
    if mtype == TMessageType.EXCEPTION:
2722 
      x = TApplicationException()
2723 
      x.read(self._iprot)
2724 
      self._iprot.readMessageEnd()
2725 
      raise x
772 rajveer 2726 
    result = getBrowseHistory_result()
559 chandransh 2727 
    result.read(self._iprot)
2728 
    self._iprot.readMessageEnd()
2729 
    if result.success != None:
2730 
      return result.success
2731 
    if result.scx != None:
2732 
      raise result.scx
772 rajveer 2733 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistory failed: unknown result");
559 chandransh 2734 
 
772 rajveer 2735 
  def mergeBrowseHistory(self, fromUserId, toUserId):
559 chandransh 2736 
    """
2737 
    Parameters:
772 rajveer 2738 
     - fromUserId
2739 
     - toUserId
559 chandransh 2740 
    """
772 rajveer 2741 
    self.send_mergeBrowseHistory(fromUserId, toUserId)
2742 
    self.recv_mergeBrowseHistory()
559 chandransh 2743 
 
772 rajveer 2744 
  def send_mergeBrowseHistory(self, fromUserId, toUserId):
2745 
    self._oprot.writeMessageBegin('mergeBrowseHistory', TMessageType.CALL, self._seqid)
2746 
    args = mergeBrowseHistory_args()
2747 
    args.fromUserId = fromUserId
2748 
    args.toUserId = toUserId
559 chandransh 2749 
    args.write(self._oprot)
2750 
    self._oprot.writeMessageEnd()
2751 
    self._oprot.trans.flush()
2752 
 
772 rajveer 2753 
  def recv_mergeBrowseHistory(self, ):
559 chandransh 2754 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2755 
    if mtype == TMessageType.EXCEPTION:
2756 
      x = TApplicationException()
2757 
      x.read(self._iprot)
2758 
      self._iprot.readMessageEnd()
2759 
      raise x
772 rajveer 2760 
    result = mergeBrowseHistory_result()
559 chandransh 2761 
    result.read(self._iprot)
2762 
    self._iprot.readMessageEnd()
2763 
    return
2764 
 
1596 ankur.sing 2765 
  def getUserCount(self, userType):
2766 
    """
2767 
    Returns number of registered users.
2768 
    If userType = null, then it returns count of all users, including anonymous
2769 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2770 
    If userType = UserType.USER, then it returns count of non-anonymous users only
2771 
 
2772 
    Parameters:
2773 
     - userType
2774 
    """
2775 
    self.send_getUserCount(userType)
2776 
    return self.recv_getUserCount()
559 chandransh 2777 
 
1596 ankur.sing 2778 
  def send_getUserCount(self, userType):
2779 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2780 
    args = getUserCount_args()
2781 
    args.userType = userType
2782 
    args.write(self._oprot)
2783 
    self._oprot.writeMessageEnd()
2784 
    self._oprot.trans.flush()
2785 
 
2786 
  def recv_getUserCount(self, ):
2787 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2788 
    if mtype == TMessageType.EXCEPTION:
2789 
      x = TApplicationException()
2790 
      x.read(self._iprot)
2791 
      self._iprot.readMessageEnd()
2792 
      raise x
2793 
    result = getUserCount_result()
2794 
    result.read(self._iprot)
2795 
    self._iprot.readMessageEnd()
2796 
    if result.success != None:
2797 
      return result.success
2798 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
2799 
 
1891 ankur.sing 2800 
  def getAllUsers(self, userType, startDate, endDate):
1673 ankur.sing 2801 
    """
1891 ankur.sing 2802 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2803 
    If any of startDate or endDate is -1, then that filter is ignored.
2804 
    If userType is null, then returns all the users, irrespective of anonymous flag
1673 ankur.sing 2805 
 
1891 ankur.sing 2806 
 
1673 ankur.sing 2807 
    Parameters:
2808 
     - userType
1891 ankur.sing 2809 
     - startDate
2810 
     - endDate
1673 ankur.sing 2811 
    """
1891 ankur.sing 2812 
    self.send_getAllUsers(userType, startDate, endDate)
1673 ankur.sing 2813 
    return self.recv_getAllUsers()
1596 ankur.sing 2814 
 
1891 ankur.sing 2815 
  def send_getAllUsers(self, userType, startDate, endDate):
1673 ankur.sing 2816 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2817 
    args = getAllUsers_args()
2818 
    args.userType = userType
1891 ankur.sing 2819 
    args.startDate = startDate
2820 
    args.endDate = endDate
1673 ankur.sing 2821 
    args.write(self._oprot)
2822 
    self._oprot.writeMessageEnd()
2823 
    self._oprot.trans.flush()
2824 
 
2825 
  def recv_getAllUsers(self, ):
2826 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2827 
    if mtype == TMessageType.EXCEPTION:
2828 
      x = TApplicationException()
2829 
      x.read(self._iprot)
2830 
      self._iprot.readMessageEnd()
2831 
      raise x
2832 
    result = getAllUsers_result()
2833 
    result.read(self._iprot)
2834 
    self._iprot.readMessageEnd()
2835 
    if result.success != None:
2836 
      return result.success
2837 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
2838 
 
2839 
 
94 ashish 2840 
class Processor(Iface, TProcessor):
2841 
  def __init__(self, handler):
2842 
    self._handler = handler
2843 
    self._processMap = {}
765 rajveer 2844 
    self._processMap["closeSession"] = Processor.process_closeSession
559 chandransh 2845 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
2846 
    self._processMap["getUserById"] = Processor.process_getUserById
1491 vikas 2847 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
559 chandransh 2848 
    self._processMap["createUser"] = Processor.process_createUser
2849 
    self._processMap["updateUser"] = Processor.process_updateUser
2850 
    self._processMap["deleteUser"] = Processor.process_deleteUser
2851 
    self._processMap["getUserState"] = Processor.process_getUserState
122 ashish 2852 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 2853 
    self._processMap["userExists"] = Processor.process_userExists
2854 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
2855 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
2856 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
2857 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 2858 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 2859 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 2860 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 2861 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 2862 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 2863 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 2864 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 2865 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 2866 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
2867 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
2868 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
1845 vikas 2869 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 2870 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 2871 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
2872 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
2873 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
2874 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
2875 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
2876 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
2877 
    self._processMap["createTracker"] = Processor.process_createTracker
2878 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
2879 
    self._processMap["getTrackersByAffiliate"] = Processor.process_getTrackersByAffiliate
2880 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
2881 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
2882 
    self._processMap["getTrackLogsByTracker"] = Processor.process_getTrackLogsByTracker
2883 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
2884 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 2885 
    self._processMap["createCart"] = Processor.process_createCart
2886 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
2887 
    self._processMap["getCart"] = Processor.process_getCart
2888 
    self._processMap["getCartsForUser"] = Processor.process_getCartsForUser
2889 
    self._processMap["getCartsByStatus"] = Processor.process_getCartsByStatus
2890 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
2891 
    self._processMap["changeCartStatus"] = Processor.process_changeCartStatus
2892 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
2893 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
2894 
    self._processMap["changeQuantity"] = Processor.process_changeQuantity
2895 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
2896 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
1976 varun.gupt 2897 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
2898 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
690 chandransh 2899 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 2900 
    self._processMap["validateCart"] = Processor.process_validateCart
2901 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 2902 
    self._processMap["checkOut"] = Processor.process_checkOut
2903 
    self._processMap["resetCart"] = Processor.process_resetCart
559 chandransh 2904 
    self._processMap["getMyResearch"] = Processor.process_getMyResearch
2905 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
2906 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
2907 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
2908 
    self._processMap["getBrowseHistory"] = Processor.process_getBrowseHistory
772 rajveer 2909 
    self._processMap["mergeBrowseHistory"] = Processor.process_mergeBrowseHistory
1596 ankur.sing 2910 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 2911 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
94 ashish 2912 
 
2913 
  def process(self, iprot, oprot):
2914 
    (name, type, seqid) = iprot.readMessageBegin()
2915 
    if name not in self._processMap:
2916 
      iprot.skip(TType.STRUCT)
2917 
      iprot.readMessageEnd()
2918 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
2919 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
2920 
      x.write(oprot)
2921 
      oprot.writeMessageEnd()
2922 
      oprot.trans.flush()
2923 
      return
2924 
    else:
2925 
      self._processMap[name](self, seqid, iprot, oprot)
2926 
    return True
2927 
 
765 rajveer 2928 
  def process_closeSession(self, seqid, iprot, oprot):
2929 
    args = closeSession_args()
2930 
    args.read(iprot)
2931 
    iprot.readMessageEnd()
2932 
    result = closeSession_result()
2933 
    self._handler.closeSession()
2934 
    oprot.writeMessageBegin("closeSession", TMessageType.REPLY, seqid)
2935 
    result.write(oprot)
2936 
    oprot.writeMessageEnd()
2937 
    oprot.trans.flush()
2938 
 
559 chandransh 2939 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
2940 
    args = createAnonymousUser_args()
94 ashish 2941 
    args.read(iprot)
2942 
    iprot.readMessageEnd()
559 chandransh 2943 
    result = createAnonymousUser_result()
94 ashish 2944 
    try:
559 chandransh 2945 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
2946 
    except UserContextException, ucex:
2947 
      result.ucex = ucex
2948 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 2949 
    result.write(oprot)
2950 
    oprot.writeMessageEnd()
2951 
    oprot.trans.flush()
2952 
 
559 chandransh 2953 
  def process_getUserById(self, seqid, iprot, oprot):
2954 
    args = getUserById_args()
94 ashish 2955 
    args.read(iprot)
2956 
    iprot.readMessageEnd()
559 chandransh 2957 
    result = getUserById_result()
94 ashish 2958 
    try:
559 chandransh 2959 
      result.success = self._handler.getUserById(args.userId)
2960 
    except UserContextException, ucex:
2961 
      result.ucex = ucex
2962 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 2963 
    result.write(oprot)
2964 
    oprot.writeMessageEnd()
2965 
    oprot.trans.flush()
2966 
 
1491 vikas 2967 
  def process_getUserByEmail(self, seqid, iprot, oprot):
2968 
    args = getUserByEmail_args()
2969 
    args.read(iprot)
2970 
    iprot.readMessageEnd()
2971 
    result = getUserByEmail_result()
2972 
    try:
2973 
      result.success = self._handler.getUserByEmail(args.email)
2974 
    except UserContextException, ucex:
2975 
      result.ucex = ucex
2976 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
2977 
    result.write(oprot)
2978 
    oprot.writeMessageEnd()
2979 
    oprot.trans.flush()
2980 
 
559 chandransh 2981 
  def process_createUser(self, seqid, iprot, oprot):
2982 
    args = createUser_args()
94 ashish 2983 
    args.read(iprot)
2984 
    iprot.readMessageEnd()
559 chandransh 2985 
    result = createUser_result()
94 ashish 2986 
    try:
559 chandransh 2987 
      result.success = self._handler.createUser(args.user)
2988 
    except UserContextException, ucex:
2989 
      result.ucex = ucex
2990 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 2991 
    result.write(oprot)
2992 
    oprot.writeMessageEnd()
2993 
    oprot.trans.flush()
2994 
 
559 chandransh 2995 
  def process_updateUser(self, seqid, iprot, oprot):
2996 
    args = updateUser_args()
94 ashish 2997 
    args.read(iprot)
2998 
    iprot.readMessageEnd()
559 chandransh 2999 
    result = updateUser_result()
94 ashish 3000 
    try:
559 chandransh 3001 
      result.success = self._handler.updateUser(args.user)
3002 
    except UserContextException, ucex:
3003 
      result.ucex = ucex
3004 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 3005 
    result.write(oprot)
3006 
    oprot.writeMessageEnd()
3007 
    oprot.trans.flush()
3008 
 
559 chandransh 3009 
  def process_deleteUser(self, seqid, iprot, oprot):
3010 
    args = deleteUser_args()
94 ashish 3011 
    args.read(iprot)
3012 
    iprot.readMessageEnd()
559 chandransh 3013 
    result = deleteUser_result()
94 ashish 3014 
    try:
559 chandransh 3015 
      result.success = self._handler.deleteUser(args.userId)
3016 
    except UserContextException, ucex:
3017 
      result.ucex = ucex
3018 
    oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
94 ashish 3019 
    result.write(oprot)
3020 
    oprot.writeMessageEnd()
3021 
    oprot.trans.flush()
3022 
 
559 chandransh 3023 
  def process_getUserState(self, seqid, iprot, oprot):
3024 
    args = getUserState_args()
94 ashish 3025 
    args.read(iprot)
3026 
    iprot.readMessageEnd()
559 chandransh 3027 
    result = getUserState_result()
94 ashish 3028 
    try:
559 chandransh 3029 
      result.success = self._handler.getUserState(args.userId)
3030 
    except UserContextException, ucex:
3031 
      result.ucex = ucex
3032 
    oprot.writeMessageBegin("getUserState", TMessageType.REPLY, seqid)
94 ashish 3033 
    result.write(oprot)
3034 
    oprot.writeMessageEnd()
3035 
    oprot.trans.flush()
3036 
 
122 ashish 3037 
  def process_authenticateUser(self, seqid, iprot, oprot):
3038 
    args = authenticateUser_args()
3039 
    args.read(iprot)
3040 
    iprot.readMessageEnd()
3041 
    result = authenticateUser_result()
3042 
    try:
559 chandransh 3043 
      result.success = self._handler.authenticateUser(args.email, args.password)
3044 
    except AuthenticationException, auex:
3045 
      result.auex = auex
122 ashish 3046 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
3047 
    result.write(oprot)
3048 
    oprot.writeMessageEnd()
3049 
    oprot.trans.flush()
3050 
 
94 ashish 3051 
  def process_userExists(self, seqid, iprot, oprot):
3052 
    args = userExists_args()
3053 
    args.read(iprot)
3054 
    iprot.readMessageEnd()
3055 
    result = userExists_result()
3056 
    try:
3057 
      result.success = self._handler.userExists(args.email)
3058 
    except UserContextException, ucx:
3059 
      result.ucx = ucx
3060 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
3061 
    result.write(oprot)
3062 
    oprot.writeMessageEnd()
3063 
    oprot.trans.flush()
3064 
 
3065 
  def process_addAddressForUser(self, seqid, iprot, oprot):
3066 
    args = addAddressForUser_args()
3067 
    args.read(iprot)
3068 
    iprot.readMessageEnd()
3069 
    result = addAddressForUser_result()
3070 
    try:
567 rajveer 3071 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 3072 
    except UserContextException, ucx:
3073 
      result.ucx = ucx
3074 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
3075 
    result.write(oprot)
3076 
    oprot.writeMessageEnd()
3077 
    oprot.trans.flush()
3078 
 
3079 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
3080 
    args = removeAddressForUser_args()
3081 
    args.read(iprot)
3082 
    iprot.readMessageEnd()
3083 
    result = removeAddressForUser_result()
3084 
    try:
3085 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
3086 
    except UserContextException, ucx:
3087 
      result.ucx = ucx
3088 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
3089 
    result.write(oprot)
3090 
    oprot.writeMessageEnd()
3091 
    oprot.trans.flush()
3092 
 
3093 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
3094 
    args = setUserAsLoggedIn_args()
3095 
    args.read(iprot)
3096 
    iprot.readMessageEnd()
3097 
    result = setUserAsLoggedIn_result()
3098 
    try:
3099 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
3100 
    except UserContextException, ucx:
3101 
      result.ucx = ucx
3102 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
3103 
    result.write(oprot)
3104 
    oprot.writeMessageEnd()
3105 
    oprot.trans.flush()
3106 
 
3107 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
3108 
    args = setUserAsLoggedOut_args()
3109 
    args.read(iprot)
3110 
    iprot.readMessageEnd()
3111 
    result = setUserAsLoggedOut_result()
3112 
    try:
3113 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
3114 
    except UserContextException, ucx:
3115 
      result.ucx = ucx
3116 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
3117 
    result.write(oprot)
3118 
    oprot.writeMessageEnd()
3119 
    oprot.trans.flush()
3120 
 
504 rajveer 3121 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
3122 
    args = setDefaultAddress_args()
3123 
    args.read(iprot)
3124 
    iprot.readMessageEnd()
3125 
    result = setDefaultAddress_result()
3126 
    try:
3127 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
3128 
    except UserContextException, ucx:
3129 
      result.ucx = ucx
3130 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
3131 
    result.write(oprot)
3132 
    oprot.writeMessageEnd()
3133 
    oprot.trans.flush()
3134 
 
94 ashish 3135 
  def process_updatePassword(self, seqid, iprot, oprot):
3136 
    args = updatePassword_args()
3137 
    args.read(iprot)
3138 
    iprot.readMessageEnd()
3139 
    result = updatePassword_result()
3140 
    try:
594 rajveer 3141 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 3142 
    except UserContextException, ucx:
3143 
      result.ucx = ucx
3144 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
3145 
    result.write(oprot)
3146 
    oprot.writeMessageEnd()
3147 
    oprot.trans.flush()
3148 
 
581 rajveer 3149 
  def process_forgotPassword(self, seqid, iprot, oprot):
3150 
    args = forgotPassword_args()
3151 
    args.read(iprot)
3152 
    iprot.readMessageEnd()
3153 
    result = forgotPassword_result()
3154 
    try:
884 rajveer 3155 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 3156 
    except UserContextException, ucx:
3157 
      result.ucx = ucx
3158 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
3159 
    result.write(oprot)
3160 
    oprot.writeMessageEnd()
3161 
    oprot.trans.flush()
3162 
 
594 rajveer 3163 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
3164 
    args = getAllAddressesForUser_args()
3165 
    args.read(iprot)
3166 
    iprot.readMessageEnd()
3167 
    result = getAllAddressesForUser_result()
3168 
    try:
3169 
      result.success = self._handler.getAllAddressesForUser(args.userId)
3170 
    except UserContextException, ucx:
3171 
      result.ucx = ucx
3172 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
3173 
    result.write(oprot)
3174 
    oprot.writeMessageEnd()
3175 
    oprot.trans.flush()
3176 
 
1894 vikas 3177 
  def process_getAddressById(self, seqid, iprot, oprot):
3178 
    args = getAddressById_args()
3179 
    args.read(iprot)
3180 
    iprot.readMessageEnd()
3181 
    result = getAddressById_result()
3182 
    try:
3183 
      result.success = self._handler.getAddressById(args.addressId)
3184 
    except UserContextException, ucx:
3185 
      result.ucx = ucx
3186 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
3187 
    result.write(oprot)
3188 
    oprot.writeMessageEnd()
3189 
    oprot.trans.flush()
3190 
 
594 rajveer 3191 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
3192 
    args = getDefaultAddressId_args()
3193 
    args.read(iprot)
3194 
    iprot.readMessageEnd()
3195 
    result = getDefaultAddressId_result()
3196 
    try:
3197 
      result.success = self._handler.getDefaultAddressId(args.userId)
3198 
    except UserContextException, ucx:
3199 
      result.ucx = ucx
3200 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
3201 
    result.write(oprot)
3202 
    oprot.writeMessageEnd()
3203 
    oprot.trans.flush()
3204 
 
785 rajveer 3205 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
3206 
    args = getDefaultPincode_args()
3207 
    args.read(iprot)
3208 
    iprot.readMessageEnd()
3209 
    result = getDefaultPincode_result()
3210 
    try:
3211 
      result.success = self._handler.getDefaultPincode(args.userId)
3212 
    except UserContextException, ucx:
3213 
      result.ucx = ucx
3214 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
3215 
    result.write(oprot)
3216 
    oprot.writeMessageEnd()
3217 
    oprot.trans.flush()
3218 
 
1274 varun.gupt 3219 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
3220 
    args = saveUserCommunication_args()
3221 
    args.read(iprot)
3222 
    iprot.readMessageEnd()
3223 
    result = saveUserCommunication_result()
3224 
    try:
3225 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
3226 
    except UserCommunicationException, ucx:
3227 
      result.ucx = ucx
3228 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
3229 
    result.write(oprot)
3230 
    oprot.writeMessageEnd()
3231 
    oprot.trans.flush()
3232 
 
1590 varun.gupt 3233 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
3234 
    args = getUserCommunicationById_args()
3235 
    args.read(iprot)
3236 
    iprot.readMessageEnd()
3237 
    result = getUserCommunicationById_result()
3238 
    try:
3239 
      result.success = self._handler.getUserCommunicationById(args.id)
3240 
    except UserCommunicationException, ucx:
3241 
      result.ucx = ucx
3242 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
3243 
    result.write(oprot)
3244 
    oprot.writeMessageEnd()
3245 
    oprot.trans.flush()
3246 
 
3247 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
3248 
    args = getUserCommunicationByUser_args()
3249 
    args.read(iprot)
3250 
    iprot.readMessageEnd()
3251 
    result = getUserCommunicationByUser_result()
3252 
    try:
3253 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
3254 
    except UserCommunicationException, ucx:
3255 
      result.ucx = ucx
3256 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
3257 
    result.write(oprot)
3258 
    oprot.writeMessageEnd()
3259 
    oprot.trans.flush()
3260 
 
3261 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
3262 
    args = getAllUserCommunications_args()
3263 
    args.read(iprot)
3264 
    iprot.readMessageEnd()
3265 
    result = getAllUserCommunications_result()
3266 
    try:
3267 
      result.success = self._handler.getAllUserCommunications()
3268 
    except UserCommunicationException, ucx:
3269 
      result.ucx = ucx
3270 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
3271 
    result.write(oprot)
3272 
    oprot.writeMessageEnd()
3273 
    oprot.trans.flush()
3274 
 
1845 vikas 3275 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
3276 
    args = createMasterAffiliate_args()
3277 
    args.read(iprot)
3278 
    iprot.readMessageEnd()
3279 
    result = createMasterAffiliate_result()
3280 
    try:
1859 vikas 3281 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1845 vikas 3282 
    except UserTrackerException, utx:
3283 
      result.utx = utx
3284 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
3285 
    result.write(oprot)
3286 
    oprot.writeMessageEnd()
3287 
    oprot.trans.flush()
3288 
 
1899 vikas 3289 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
3290 
    args = getAllMasterAffiliates_args()
3291 
    args.read(iprot)
3292 
    iprot.readMessageEnd()
3293 
    result = getAllMasterAffiliates_result()
3294 
    try:
3295 
      result.success = self._handler.getAllMasterAffiliates()
3296 
    except UserTrackerException, utx:
3297 
      result.utx = utx
3298 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
3299 
    result.write(oprot)
3300 
    oprot.writeMessageEnd()
3301 
    oprot.trans.flush()
3302 
 
1845 vikas 3303 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
3304 
    args = getMasterAffiliateById_args()
3305 
    args.read(iprot)
3306 
    iprot.readMessageEnd()
3307 
    result = getMasterAffiliateById_result()
3308 
    try:
3309 
      result.success = self._handler.getMasterAffiliateById(args.id)
3310 
    except UserTrackerException, utx:
3311 
      result.utx = utx
3312 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
3313 
    result.write(oprot)
3314 
    oprot.writeMessageEnd()
3315 
    oprot.trans.flush()
3316 
 
3317 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
3318 
    args = getMasterAffiliateByName_args()
3319 
    args.read(iprot)
3320 
    iprot.readMessageEnd()
3321 
    result = getMasterAffiliateByName_result()
3322 
    try:
3323 
      result.success = self._handler.getMasterAffiliateByName(args.name)
3324 
    except UserTrackerException, utx:
3325 
      result.utx = utx
3326 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
3327 
    result.write(oprot)
3328 
    oprot.writeMessageEnd()
3329 
    oprot.trans.flush()
3330 
 
3331 
  def process_createAffiliate(self, seqid, iprot, oprot):
3332 
    args = createAffiliate_args()
3333 
    args.read(iprot)
3334 
    iprot.readMessageEnd()
3335 
    result = createAffiliate_result()
3336 
    try:
1859 vikas 3337 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1845 vikas 3338 
    except UserTrackerException, utx:
3339 
      result.utx = utx
3340 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
3341 
    result.write(oprot)
3342 
    oprot.writeMessageEnd()
3343 
    oprot.trans.flush()
3344 
 
3345 
  def process_getAffiliateById(self, seqid, iprot, oprot):
3346 
    args = getAffiliateById_args()
3347 
    args.read(iprot)
3348 
    iprot.readMessageEnd()
3349 
    result = getAffiliateById_result()
3350 
    try:
3351 
      result.success = self._handler.getAffiliateById(args.id)
3352 
    except UserTrackerException, utx:
3353 
      result.utx = utx
3354 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
3355 
    result.write(oprot)
3356 
    oprot.writeMessageEnd()
3357 
    oprot.trans.flush()
3358 
 
3359 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
3360 
    args = getAffiliateByName_args()
3361 
    args.read(iprot)
3362 
    iprot.readMessageEnd()
3363 
    result = getAffiliateByName_result()
3364 
    try:
3365 
      result.success = self._handler.getAffiliateByName(args.name)
3366 
    except UserTrackerException, utx:
3367 
      result.utx = utx
3368 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
3369 
    result.write(oprot)
3370 
    oprot.writeMessageEnd()
3371 
    oprot.trans.flush()
3372 
 
3373 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
3374 
    args = getAffiliatesByMasterAffiliate_args()
3375 
    args.read(iprot)
3376 
    iprot.readMessageEnd()
3377 
    result = getAffiliatesByMasterAffiliate_result()
3378 
    try:
3379 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
3380 
    except UserTrackerException, utx:
3381 
      result.utx = utx
3382 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
3383 
    result.write(oprot)
3384 
    oprot.writeMessageEnd()
3385 
    oprot.trans.flush()
3386 
 
3387 
  def process_createTracker(self, seqid, iprot, oprot):
3388 
    args = createTracker_args()
3389 
    args.read(iprot)
3390 
    iprot.readMessageEnd()
3391 
    result = createTracker_result()
3392 
    try:
1859 vikas 3393 
      result.success = self._handler.createTracker(args.affiliateId, args.addedOn)
1845 vikas 3394 
    except UserTrackerException, utx:
3395 
      result.utx = utx
3396 
    oprot.writeMessageBegin("createTracker", TMessageType.REPLY, seqid)
3397 
    result.write(oprot)
3398 
    oprot.writeMessageEnd()
3399 
    oprot.trans.flush()
3400 
 
3401 
  def process_getTrackerById(self, seqid, iprot, oprot):
3402 
    args = getTrackerById_args()
3403 
    args.read(iprot)
3404 
    iprot.readMessageEnd()
3405 
    result = getTrackerById_result()
3406 
    try:
3407 
      result.success = self._handler.getTrackerById(args.trackerId)
3408 
    except UserTrackerException, utx:
3409 
      result.utx = utx
3410 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
3411 
    result.write(oprot)
3412 
    oprot.writeMessageEnd()
3413 
    oprot.trans.flush()
3414 
 
3415 
  def process_getTrackersByAffiliate(self, seqid, iprot, oprot):
3416 
    args = getTrackersByAffiliate_args()
3417 
    args.read(iprot)
3418 
    iprot.readMessageEnd()
3419 
    result = getTrackersByAffiliate_result()
3420 
    try:
3421 
      result.success = self._handler.getTrackersByAffiliate(args.affiliateId)
3422 
    except UserTrackerException, utx:
3423 
      result.utx = utx
3424 
    oprot.writeMessageBegin("getTrackersByAffiliate", TMessageType.REPLY, seqid)
3425 
    result.write(oprot)
3426 
    oprot.writeMessageEnd()
3427 
    oprot.trans.flush()
3428 
 
3429 
  def process_addTrackLog(self, seqid, iprot, oprot):
3430 
    args = addTrackLog_args()
3431 
    args.read(iprot)
3432 
    iprot.readMessageEnd()
3433 
    result = addTrackLog_result()
3434 
    try:
1859 vikas 3435 
      result.success = self._handler.addTrackLog(args.trackerId, args.userId, args.event, args.url, args.data, args.addedOn)
1845 vikas 3436 
    except UserTrackerException, utx:
3437 
      result.utx = utx
3438 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
3439 
    result.write(oprot)
3440 
    oprot.writeMessageEnd()
3441 
    oprot.trans.flush()
3442 
 
3443 
  def process_getTrackLogById(self, seqid, iprot, oprot):
3444 
    args = getTrackLogById_args()
3445 
    args.read(iprot)
3446 
    iprot.readMessageEnd()
3447 
    result = getTrackLogById_result()
3448 
    try:
3449 
      result.success = self._handler.getTrackLogById(args.id)
3450 
    except UserTrackerException, utx:
3451 
      result.utx = utx
3452 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
3453 
    result.write(oprot)
3454 
    oprot.writeMessageEnd()
3455 
    oprot.trans.flush()
3456 
 
3457 
  def process_getTrackLogsByTracker(self, seqid, iprot, oprot):
3458 
    args = getTrackLogsByTracker_args()
3459 
    args.read(iprot)
3460 
    iprot.readMessageEnd()
3461 
    result = getTrackLogsByTracker_result()
3462 
    try:
3463 
      result.success = self._handler.getTrackLogsByTracker(args.trackerId)
3464 
    except UserTrackerException, utx:
3465 
      result.utx = utx
3466 
    oprot.writeMessageBegin("getTrackLogsByTracker", TMessageType.REPLY, seqid)
3467 
    result.write(oprot)
3468 
    oprot.writeMessageEnd()
3469 
    oprot.trans.flush()
3470 
 
3471 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
3472 
    args = getTrackLogsByUser_args()
3473 
    args.read(iprot)
3474 
    iprot.readMessageEnd()
3475 
    result = getTrackLogsByUser_result()
3476 
    try:
3477 
      result.success = self._handler.getTrackLogsByUser(args.userId)
3478 
    except UserTrackerException, utx:
3479 
      result.utx = utx
3480 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
3481 
    result.write(oprot)
3482 
    oprot.writeMessageEnd()
3483 
    oprot.trans.flush()
3484 
 
3485 
  def process_getTrackLogs(self, seqid, iprot, oprot):
3486 
    args = getTrackLogs_args()
3487 
    args.read(iprot)
3488 
    iprot.readMessageEnd()
3489 
    result = getTrackLogs_result()
3490 
    try:
3491 
      result.success = self._handler.getTrackLogs(args.trackerId, args.userId, args.event, args.url)
3492 
    except UserTrackerException, utx:
3493 
      result.utx = utx
3494 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
3495 
    result.write(oprot)
3496 
    oprot.writeMessageEnd()
3497 
    oprot.trans.flush()
3498 
 
559 chandransh 3499 
  def process_createCart(self, seqid, iprot, oprot):
3500 
    args = createCart_args()
94 ashish 3501 
    args.read(iprot)
3502 
    iprot.readMessageEnd()
559 chandransh 3503 
    result = createCart_result()
94 ashish 3504 
    try:
559 chandransh 3505 
      result.success = self._handler.createCart(args.userId)
3506 
    except ShoppingCartException, scx:
3507 
      result.scx = scx
3508 
    oprot.writeMessageBegin("createCart", TMessageType.REPLY, seqid)
94 ashish 3509 
    result.write(oprot)
3510 
    oprot.writeMessageEnd()
3511 
    oprot.trans.flush()
3512 
 
559 chandransh 3513 
  def process_getCurrentCart(self, seqid, iprot, oprot):
3514 
    args = getCurrentCart_args()
94 ashish 3515 
    args.read(iprot)
3516 
    iprot.readMessageEnd()
559 chandransh 3517 
    result = getCurrentCart_result()
94 ashish 3518 
    try:
559 chandransh 3519 
      result.success = self._handler.getCurrentCart(args.userId)
3520 
    except ShoppingCartException, scx:
3521 
      result.scx = scx
3522 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 3523 
    result.write(oprot)
3524 
    oprot.writeMessageEnd()
3525 
    oprot.trans.flush()
3526 
 
559 chandransh 3527 
  def process_getCart(self, seqid, iprot, oprot):
3528 
    args = getCart_args()
94 ashish 3529 
    args.read(iprot)
3530 
    iprot.readMessageEnd()
559 chandransh 3531 
    result = getCart_result()
94 ashish 3532 
    try:
559 chandransh 3533 
      result.success = self._handler.getCart(args.cartId)
3534 
    except ShoppingCartException, scx:
3535 
      result.scx = scx
3536 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 3537 
    result.write(oprot)
3538 
    oprot.writeMessageEnd()
3539 
    oprot.trans.flush()
3540 
 
559 chandransh 3541 
  def process_getCartsForUser(self, seqid, iprot, oprot):
3542 
    args = getCartsForUser_args()
94 ashish 3543 
    args.read(iprot)
3544 
    iprot.readMessageEnd()
559 chandransh 3545 
    result = getCartsForUser_result()
94 ashish 3546 
    try:
559 chandransh 3547 
      result.success = self._handler.getCartsForUser(args.userId, args.status)
3548 
    except ShoppingCartException, scx:
3549 
      result.scx = scx
3550 
    oprot.writeMessageBegin("getCartsForUser", TMessageType.REPLY, seqid)
94 ashish 3551 
    result.write(oprot)
3552 
    oprot.writeMessageEnd()
3553 
    oprot.trans.flush()
3554 
 
559 chandransh 3555 
  def process_getCartsByStatus(self, seqid, iprot, oprot):
3556 
    args = getCartsByStatus_args()
94 ashish 3557 
    args.read(iprot)
3558 
    iprot.readMessageEnd()
559 chandransh 3559 
    result = getCartsByStatus_result()
94 ashish 3560 
    try:
559 chandransh 3561 
      result.success = self._handler.getCartsByStatus(args.status)
3562 
    except ShoppingCartException, scx:
3563 
      result.scx = scx
3564 
    oprot.writeMessageBegin("getCartsByStatus", TMessageType.REPLY, seqid)
94 ashish 3565 
    result.write(oprot)
3566 
    oprot.writeMessageEnd()
3567 
    oprot.trans.flush()
3568 
 
559 chandransh 3569 
  def process_getCartsByTime(self, seqid, iprot, oprot):
3570 
    args = getCartsByTime_args()
94 ashish 3571 
    args.read(iprot)
3572 
    iprot.readMessageEnd()
559 chandransh 3573 
    result = getCartsByTime_result()
94 ashish 3574 
    try:
559 chandransh 3575 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
3576 
    except ShoppingCartException, scx:
3577 
      result.scx = scx
3578 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 3579 
    result.write(oprot)
3580 
    oprot.writeMessageEnd()
3581 
    oprot.trans.flush()
3582 
 
559 chandransh 3583 
  def process_changeCartStatus(self, seqid, iprot, oprot):
3584 
    args = changeCartStatus_args()
130 ashish 3585 
    args.read(iprot)
3586 
    iprot.readMessageEnd()
559 chandransh 3587 
    result = changeCartStatus_result()
130 ashish 3588 
    try:
559 chandransh 3589 
      self._handler.changeCartStatus(args.cartId, args.status)
3590 
    except ShoppingCartException, scx:
3591 
      result.scx = scx
3592 
    oprot.writeMessageBegin("changeCartStatus", TMessageType.REPLY, seqid)
130 ashish 3593 
    result.write(oprot)
3594 
    oprot.writeMessageEnd()
3595 
    oprot.trans.flush()
94 ashish 3596 
 
559 chandransh 3597 
  def process_addItemToCart(self, seqid, iprot, oprot):
3598 
    args = addItemToCart_args()
130 ashish 3599 
    args.read(iprot)
3600 
    iprot.readMessageEnd()
559 chandransh 3601 
    result = addItemToCart_result()
130 ashish 3602 
    try:
559 chandransh 3603 
      self._handler.addItemToCart(args.cartId, args.itemId, args.quantity)
3604 
    except ShoppingCartException, scx:
3605 
      result.scx = scx
3606 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 3607 
    result.write(oprot)
3608 
    oprot.writeMessageEnd()
3609 
    oprot.trans.flush()
3610 
 
559 chandransh 3611 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
3612 
    args = deleteItemFromCart_args()
3613 
    args.read(iprot)
3614 
    iprot.readMessageEnd()
3615 
    result = deleteItemFromCart_result()
3616 
    try:
3617 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
3618 
    except ShoppingCartException, scx:
3619 
      result.scx = scx
3620 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
3621 
    result.write(oprot)
3622 
    oprot.writeMessageEnd()
3623 
    oprot.trans.flush()
130 ashish 3624 
 
559 chandransh 3625 
  def process_changeQuantity(self, seqid, iprot, oprot):
3626 
    args = changeQuantity_args()
3627 
    args.read(iprot)
3628 
    iprot.readMessageEnd()
3629 
    result = changeQuantity_result()
3630 
    try:
3631 
      self._handler.changeQuantity(args.cartId, args.itemId, args.quantity)
3632 
    except ShoppingCartException, scx:
3633 
      result.scx = scx
3634 
    oprot.writeMessageBegin("changeQuantity", TMessageType.REPLY, seqid)
3635 
    result.write(oprot)
3636 
    oprot.writeMessageEnd()
3637 
    oprot.trans.flush()
3638 
 
3639 
  def process_changeItemStatus(self, seqid, iprot, oprot):
3640 
    args = changeItemStatus_args()
3641 
    args.read(iprot)
3642 
    iprot.readMessageEnd()
3643 
    result = changeItemStatus_result()
3644 
    try:
3645 
      self._handler.changeItemStatus(args.cartId, args.itemId, args.status)
3646 
    except ShoppingCartException, scx:
3647 
      result.scx = scx
3648 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
3649 
    result.write(oprot)
3650 
    oprot.writeMessageEnd()
3651 
    oprot.trans.flush()
3652 
 
3653 
  def process_addAddressToCart(self, seqid, iprot, oprot):
3654 
    args = addAddressToCart_args()
3655 
    args.read(iprot)
3656 
    iprot.readMessageEnd()
3657 
    result = addAddressToCart_result()
575 chandransh 3658 
    try:
3659 
      self._handler.addAddressToCart(args.cartId, args.addressId)
3660 
    except ShoppingCartException, scx:
3661 
      result.scx = scx
559 chandransh 3662 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
3663 
    result.write(oprot)
3664 
    oprot.writeMessageEnd()
3665 
    oprot.trans.flush()
3666 
 
1976 varun.gupt 3667 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
3668 
    args = applyCouponToCart_args()
3669 
    args.read(iprot)
3670 
    iprot.readMessageEnd()
3671 
    result = applyCouponToCart_result()
3672 
    try:
3673 
      self._handler.applyCouponToCart(args.cartId, args.couponCode, args.totalPrice, args.discountedPrice)
3674 
    except ShoppingCartException, scx:
3675 
      result.scx = scx
3676 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
3677 
    result.write(oprot)
3678 
    oprot.writeMessageEnd()
3679 
    oprot.trans.flush()
3680 
 
3681 
  def process_removeCoupon(self, seqid, iprot, oprot):
3682 
    args = removeCoupon_args()
3683 
    args.read(iprot)
3684 
    iprot.readMessageEnd()
3685 
    result = removeCoupon_result()
3686 
    try:
3687 
      self._handler.removeCoupon(args.cartId)
3688 
    except ShoppingCartException, scx:
3689 
      result.scx = scx
3690 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
3691 
    result.write(oprot)
3692 
    oprot.writeMessageEnd()
3693 
    oprot.trans.flush()
3694 
 
690 chandransh 3695 
  def process_createOrders(self, seqid, iprot, oprot):
3696 
    args = createOrders_args()
559 chandransh 3697 
    args.read(iprot)
3698 
    iprot.readMessageEnd()
690 chandransh 3699 
    result = createOrders_result()
559 chandransh 3700 
    try:
690 chandransh 3701 
      result.success = self._handler.createOrders(args.cartId)
559 chandransh 3702 
    except ShoppingCartException, scx:
3703 
      result.scx = scx
690 chandransh 3704 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 3705 
    result.write(oprot)
3706 
    oprot.writeMessageEnd()
3707 
    oprot.trans.flush()
3708 
 
3709 
  def process_validateCart(self, seqid, iprot, oprot):
3710 
    args = validateCart_args()
3711 
    args.read(iprot)
3712 
    iprot.readMessageEnd()
3713 
    result = validateCart_result()
575 chandransh 3714 
    try:
3715 
      result.success = self._handler.validateCart(args.cartId)
3716 
    except ShoppingCartException, scex:
3717 
      result.scex = scex
559 chandransh 3718 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
3719 
    result.write(oprot)
3720 
    oprot.writeMessageEnd()
3721 
    oprot.trans.flush()
3722 
 
690 chandransh 3723 
  def process_mergeCart(self, seqid, iprot, oprot):
3724 
    args = mergeCart_args()
575 chandransh 3725 
    args.read(iprot)
3726 
    iprot.readMessageEnd()
690 chandransh 3727 
    result = mergeCart_result()
3728 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
3729 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
3730 
    result.write(oprot)
3731 
    oprot.writeMessageEnd()
3732 
    oprot.trans.flush()
3733 
 
3734 
  def process_checkOut(self, seqid, iprot, oprot):
3735 
    args = checkOut_args()
3736 
    args.read(iprot)
3737 
    iprot.readMessageEnd()
3738 
    result = checkOut_result()
575 chandransh 3739 
    try:
690 chandransh 3740 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 3741 
    except ShoppingCartException, scex:
3742 
      result.scex = scex
690 chandransh 3743 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 3744 
    result.write(oprot)
3745 
    oprot.writeMessageEnd()
3746 
    oprot.trans.flush()
3747 
 
690 chandransh 3748 
  def process_resetCart(self, seqid, iprot, oprot):
3749 
    args = resetCart_args()
559 chandransh 3750 
    args.read(iprot)
3751 
    iprot.readMessageEnd()
690 chandransh 3752 
    result = resetCart_result()
3753 
    try:
3754 
      result.success = self._handler.resetCart(args.cartId, args.items)
3755 
    except ShoppingCartException, scex:
3756 
      result.scex = scex
3757 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 3758 
    result.write(oprot)
3759 
    oprot.writeMessageEnd()
3760 
    oprot.trans.flush()
3761 
 
3762 
  def process_getMyResearch(self, seqid, iprot, oprot):
3763 
    args = getMyResearch_args()
3764 
    args.read(iprot)
3765 
    iprot.readMessageEnd()
3766 
    result = getMyResearch_result()
3767 
    try:
772 rajveer 3768 
      result.success = self._handler.getMyResearch(args.userId)
559 chandransh 3769 
    except WidgetException, scx:
3770 
      result.scx = scx
3771 
    oprot.writeMessageBegin("getMyResearch", TMessageType.REPLY, seqid)
3772 
    result.write(oprot)
3773 
    oprot.writeMessageEnd()
3774 
    oprot.trans.flush()
3775 
 
3776 
  def process_updateMyResearch(self, seqid, iprot, oprot):
3777 
    args = updateMyResearch_args()
3778 
    args.read(iprot)
3779 
    iprot.readMessageEnd()
3780 
    result = updateMyResearch_result()
3781 
    try:
772 rajveer 3782 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
559 chandransh 3783 
    except WidgetException, scx:
3784 
      result.scx = scx
3785 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
3786 
    result.write(oprot)
3787 
    oprot.writeMessageEnd()
3788 
    oprot.trans.flush()
3789 
 
3790 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
3791 
    args = deleteItemFromMyResearch_args()
3792 
    args.read(iprot)
3793 
    iprot.readMessageEnd()
3794 
    result = deleteItemFromMyResearch_result()
3795 
    try:
772 rajveer 3796 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
559 chandransh 3797 
    except WidgetException, scx:
3798 
      result.scx = scx
3799 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
3800 
    result.write(oprot)
3801 
    oprot.writeMessageEnd()
3802 
    oprot.trans.flush()
3803 
 
3804 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
3805 
    args = updateBrowseHistory_args()
3806 
    args.read(iprot)
3807 
    iprot.readMessageEnd()
3808 
    result = updateBrowseHistory_result()
772 rajveer 3809 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
559 chandransh 3810 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
3811 
    result.write(oprot)
3812 
    oprot.writeMessageEnd()
3813 
    oprot.trans.flush()
3814 
 
3815 
  def process_getBrowseHistory(self, seqid, iprot, oprot):
3816 
    args = getBrowseHistory_args()
3817 
    args.read(iprot)
3818 
    iprot.readMessageEnd()
3819 
    result = getBrowseHistory_result()
3820 
    try:
772 rajveer 3821 
      result.success = self._handler.getBrowseHistory(args.userId)
559 chandransh 3822 
    except WidgetException, scx:
3823 
      result.scx = scx
3824 
    oprot.writeMessageBegin("getBrowseHistory", TMessageType.REPLY, seqid)
3825 
    result.write(oprot)
3826 
    oprot.writeMessageEnd()
3827 
    oprot.trans.flush()
3828 
 
772 rajveer 3829 
  def process_mergeBrowseHistory(self, seqid, iprot, oprot):
3830 
    args = mergeBrowseHistory_args()
3831 
    args.read(iprot)
3832 
    iprot.readMessageEnd()
3833 
    result = mergeBrowseHistory_result()
3834 
    self._handler.mergeBrowseHistory(args.fromUserId, args.toUserId)
3835 
    oprot.writeMessageBegin("mergeBrowseHistory", TMessageType.REPLY, seqid)
3836 
    result.write(oprot)
3837 
    oprot.writeMessageEnd()
3838 
    oprot.trans.flush()
559 chandransh 3839 
 
1596 ankur.sing 3840 
  def process_getUserCount(self, seqid, iprot, oprot):
3841 
    args = getUserCount_args()
3842 
    args.read(iprot)
3843 
    iprot.readMessageEnd()
3844 
    result = getUserCount_result()
3845 
    result.success = self._handler.getUserCount(args.userType)
3846 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
3847 
    result.write(oprot)
3848 
    oprot.writeMessageEnd()
3849 
    oprot.trans.flush()
772 rajveer 3850 
 
1673 ankur.sing 3851 
  def process_getAllUsers(self, seqid, iprot, oprot):
3852 
    args = getAllUsers_args()
3853 
    args.read(iprot)
3854 
    iprot.readMessageEnd()
3855 
    result = getAllUsers_result()
1891 ankur.sing 3856 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
1673 ankur.sing 3857 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
3858 
    result.write(oprot)
3859 
    oprot.writeMessageEnd()
3860 
    oprot.trans.flush()
1596 ankur.sing 3861 
 
1673 ankur.sing 3862 
 
94 ashish 3863 
# HELPER FUNCTIONS AND STRUCTURES
3864 
 
765 rajveer 3865 
class closeSession_args:
3866 
 
3867 
  thrift_spec = (
3868 
  )
3869 
 
3870 
  def read(self, iprot):
3871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3873 
      return
3874 
    iprot.readStructBegin()
3875 
    while True:
3876 
      (fname, ftype, fid) = iprot.readFieldBegin()
3877 
      if ftype == TType.STOP:
3878 
        break
3879 
      else:
3880 
        iprot.skip(ftype)
3881 
      iprot.readFieldEnd()
3882 
    iprot.readStructEnd()
3883 
 
3884 
  def write(self, oprot):
3885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3887 
      return
3888 
    oprot.writeStructBegin('closeSession_args')
3889 
    oprot.writeFieldStop()
3890 
    oprot.writeStructEnd()
3891 
 
3892 
  def __repr__(self):
3893 
    L = ['%s=%r' % (key, value)
3894 
      for key, value in self.__dict__.iteritems()]
3895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3896 
 
3897 
  def __eq__(self, other):
3898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3899 
 
3900 
  def __ne__(self, other):
3901 
    return not (self == other)
3902 
 
3903 
class closeSession_result:
3904 
 
3905 
  thrift_spec = (
3906 
  )
3907 
 
3908 
  def read(self, iprot):
3909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3911 
      return
3912 
    iprot.readStructBegin()
3913 
    while True:
3914 
      (fname, ftype, fid) = iprot.readFieldBegin()
3915 
      if ftype == TType.STOP:
3916 
        break
3917 
      else:
3918 
        iprot.skip(ftype)
3919 
      iprot.readFieldEnd()
3920 
    iprot.readStructEnd()
3921 
 
3922 
  def write(self, oprot):
3923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3925 
      return
3926 
    oprot.writeStructBegin('closeSession_result')
3927 
    oprot.writeFieldStop()
3928 
    oprot.writeStructEnd()
3929 
 
3930 
  def __repr__(self):
3931 
    L = ['%s=%r' % (key, value)
3932 
      for key, value in self.__dict__.iteritems()]
3933 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3934 
 
3935 
  def __eq__(self, other):
3936 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3937 
 
3938 
  def __ne__(self, other):
3939 
    return not (self == other)
3940 
 
559 chandransh 3941 
class createAnonymousUser_args:
94 ashish 3942 
  """
3943 
  Attributes:
559 chandransh 3944 
   - jsessionId
94 ashish 3945 
  """
3946 
 
3947 
  thrift_spec = (
3948 
    None, # 0
559 chandransh 3949 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 3950 
  )
3951 
 
559 chandransh 3952 
  def __init__(self, jsessionId=None,):
3953 
    self.jsessionId = jsessionId
94 ashish 3954 
 
3955 
  def read(self, iprot):
3956 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3957 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3958 
      return
3959 
    iprot.readStructBegin()
3960 
    while True:
3961 
      (fname, ftype, fid) = iprot.readFieldBegin()
3962 
      if ftype == TType.STOP:
3963 
        break
3964 
      if fid == 1:
559 chandransh 3965 
        if ftype == TType.STRING:
3966 
          self.jsessionId = iprot.readString();
94 ashish 3967 
        else:
3968 
          iprot.skip(ftype)
3969 
      else:
3970 
        iprot.skip(ftype)
3971 
      iprot.readFieldEnd()
3972 
    iprot.readStructEnd()
3973 
 
3974 
  def write(self, oprot):
3975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3977 
      return
559 chandransh 3978 
    oprot.writeStructBegin('createAnonymousUser_args')
3979 
    if self.jsessionId != None:
3980 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
3981 
      oprot.writeString(self.jsessionId)
94 ashish 3982 
      oprot.writeFieldEnd()
3983 
    oprot.writeFieldStop()
3984 
    oprot.writeStructEnd()
3985 
 
3986 
  def __repr__(self):
3987 
    L = ['%s=%r' % (key, value)
3988 
      for key, value in self.__dict__.iteritems()]
3989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3990 
 
3991 
  def __eq__(self, other):
3992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3993 
 
3994 
  def __ne__(self, other):
3995 
    return not (self == other)
3996 
 
559 chandransh 3997 
class createAnonymousUser_result:
94 ashish 3998 
  """
3999 
  Attributes:
4000 
   - success
559 chandransh 4001 
   - ucex
94 ashish 4002 
  """
4003 
 
4004 
  thrift_spec = (
559 chandransh 4005 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4006 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4007 
  )
4008 
 
559 chandransh 4009 
  def __init__(self, success=None, ucex=None,):
94 ashish 4010 
    self.success = success
559 chandransh 4011 
    self.ucex = ucex
94 ashish 4012 
 
4013 
  def read(self, iprot):
4014 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4015 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4016 
      return
4017 
    iprot.readStructBegin()
4018 
    while True:
4019 
      (fname, ftype, fid) = iprot.readFieldBegin()
4020 
      if ftype == TType.STOP:
4021 
        break
4022 
      if fid == 0:
4023 
        if ftype == TType.STRUCT:
559 chandransh 4024 
          self.success = User()
94 ashish 4025 
          self.success.read(iprot)
4026 
        else:
4027 
          iprot.skip(ftype)
4028 
      elif fid == 1:
4029 
        if ftype == TType.STRUCT:
559 chandransh 4030 
          self.ucex = UserContextException()
4031 
          self.ucex.read(iprot)
94 ashish 4032 
        else:
4033 
          iprot.skip(ftype)
4034 
      else:
4035 
        iprot.skip(ftype)
4036 
      iprot.readFieldEnd()
4037 
    iprot.readStructEnd()
4038 
 
4039 
  def write(self, oprot):
4040 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4041 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4042 
      return
559 chandransh 4043 
    oprot.writeStructBegin('createAnonymousUser_result')
94 ashish 4044 
    if self.success != None:
4045 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4046 
      self.success.write(oprot)
4047 
      oprot.writeFieldEnd()
559 chandransh 4048 
    if self.ucex != None:
4049 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4050 
      self.ucex.write(oprot)
94 ashish 4051 
      oprot.writeFieldEnd()
4052 
    oprot.writeFieldStop()
4053 
    oprot.writeStructEnd()
4054 
 
4055 
  def __repr__(self):
4056 
    L = ['%s=%r' % (key, value)
4057 
      for key, value in self.__dict__.iteritems()]
4058 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4059 
 
4060 
  def __eq__(self, other):
4061 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4062 
 
4063 
  def __ne__(self, other):
4064 
    return not (self == other)
4065 
 
559 chandransh 4066 
class getUserById_args:
94 ashish 4067 
  """
4068 
  Attributes:
4069 
   - userId
4070 
  """
4071 
 
4072 
  thrift_spec = (
4073 
    None, # 0
4074 
    (1, TType.I64, 'userId', None, None, ), # 1
4075 
  )
4076 
 
559 chandransh 4077 
  def __init__(self, userId=None,):
94 ashish 4078 
    self.userId = userId
4079 
 
4080 
  def read(self, iprot):
4081 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4082 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4083 
      return
4084 
    iprot.readStructBegin()
4085 
    while True:
4086 
      (fname, ftype, fid) = iprot.readFieldBegin()
4087 
      if ftype == TType.STOP:
4088 
        break
4089 
      if fid == 1:
4090 
        if ftype == TType.I64:
4091 
          self.userId = iprot.readI64();
4092 
        else:
4093 
          iprot.skip(ftype)
4094 
      else:
4095 
        iprot.skip(ftype)
4096 
      iprot.readFieldEnd()
4097 
    iprot.readStructEnd()
4098 
 
4099 
  def write(self, oprot):
4100 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4101 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4102 
      return
559 chandransh 4103 
    oprot.writeStructBegin('getUserById_args')
94 ashish 4104 
    if self.userId != None:
4105 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4106 
      oprot.writeI64(self.userId)
4107 
      oprot.writeFieldEnd()
4108 
    oprot.writeFieldStop()
4109 
    oprot.writeStructEnd()
4110 
 
4111 
  def __repr__(self):
4112 
    L = ['%s=%r' % (key, value)
4113 
      for key, value in self.__dict__.iteritems()]
4114 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4115 
 
4116 
  def __eq__(self, other):
4117 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4118 
 
4119 
  def __ne__(self, other):
4120 
    return not (self == other)
4121 
 
559 chandransh 4122 
class getUserById_result:
94 ashish 4123 
  """
4124 
  Attributes:
4125 
   - success
559 chandransh 4126 
   - ucex
94 ashish 4127 
  """
4128 
 
4129 
  thrift_spec = (
559 chandransh 4130 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4131 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4132 
  )
4133 
 
559 chandransh 4134 
  def __init__(self, success=None, ucex=None,):
94 ashish 4135 
    self.success = success
559 chandransh 4136 
    self.ucex = ucex
94 ashish 4137 
 
4138 
  def read(self, iprot):
4139 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4140 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4141 
      return
4142 
    iprot.readStructBegin()
4143 
    while True:
4144 
      (fname, ftype, fid) = iprot.readFieldBegin()
4145 
      if ftype == TType.STOP:
4146 
        break
4147 
      if fid == 0:
4148 
        if ftype == TType.STRUCT:
559 chandransh 4149 
          self.success = User()
94 ashish 4150 
          self.success.read(iprot)
4151 
        else:
4152 
          iprot.skip(ftype)
4153 
      elif fid == 1:
4154 
        if ftype == TType.STRUCT:
559 chandransh 4155 
          self.ucex = UserContextException()
4156 
          self.ucex.read(iprot)
94 ashish 4157 
        else:
4158 
          iprot.skip(ftype)
4159 
      else:
4160 
        iprot.skip(ftype)
4161 
      iprot.readFieldEnd()
4162 
    iprot.readStructEnd()
4163 
 
4164 
  def write(self, oprot):
4165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4167 
      return
559 chandransh 4168 
    oprot.writeStructBegin('getUserById_result')
94 ashish 4169 
    if self.success != None:
4170 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4171 
      self.success.write(oprot)
4172 
      oprot.writeFieldEnd()
559 chandransh 4173 
    if self.ucex != None:
4174 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4175 
      self.ucex.write(oprot)
94 ashish 4176 
      oprot.writeFieldEnd()
4177 
    oprot.writeFieldStop()
4178 
    oprot.writeStructEnd()
4179 
 
4180 
  def __repr__(self):
4181 
    L = ['%s=%r' % (key, value)
4182 
      for key, value in self.__dict__.iteritems()]
4183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4184 
 
4185 
  def __eq__(self, other):
4186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4187 
 
4188 
  def __ne__(self, other):
4189 
    return not (self == other)
4190 
 
1491 vikas 4191 
class getUserByEmail_args:
4192 
  """
4193 
  Attributes:
4194 
   - email
4195 
  """
4196 
 
4197 
  thrift_spec = (
4198 
    None, # 0
4199 
    (1, TType.STRING, 'email', None, None, ), # 1
4200 
  )
4201 
 
4202 
  def __init__(self, email=None,):
4203 
    self.email = email
4204 
 
4205 
  def read(self, iprot):
4206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4208 
      return
4209 
    iprot.readStructBegin()
4210 
    while True:
4211 
      (fname, ftype, fid) = iprot.readFieldBegin()
4212 
      if ftype == TType.STOP:
4213 
        break
4214 
      if fid == 1:
4215 
        if ftype == TType.STRING:
4216 
          self.email = iprot.readString();
4217 
        else:
4218 
          iprot.skip(ftype)
4219 
      else:
4220 
        iprot.skip(ftype)
4221 
      iprot.readFieldEnd()
4222 
    iprot.readStructEnd()
4223 
 
4224 
  def write(self, oprot):
4225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4227 
      return
4228 
    oprot.writeStructBegin('getUserByEmail_args')
4229 
    if self.email != None:
4230 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4231 
      oprot.writeString(self.email)
4232 
      oprot.writeFieldEnd()
4233 
    oprot.writeFieldStop()
4234 
    oprot.writeStructEnd()
4235 
 
4236 
  def __repr__(self):
4237 
    L = ['%s=%r' % (key, value)
4238 
      for key, value in self.__dict__.iteritems()]
4239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4240 
 
4241 
  def __eq__(self, other):
4242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4243 
 
4244 
  def __ne__(self, other):
4245 
    return not (self == other)
4246 
 
4247 
class getUserByEmail_result:
4248 
  """
4249 
  Attributes:
4250 
   - success
4251 
   - ucex
4252 
  """
4253 
 
4254 
  thrift_spec = (
4255 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4256 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4257 
  )
4258 
 
4259 
  def __init__(self, success=None, ucex=None,):
4260 
    self.success = success
4261 
    self.ucex = ucex
4262 
 
4263 
  def read(self, iprot):
4264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4266 
      return
4267 
    iprot.readStructBegin()
4268 
    while True:
4269 
      (fname, ftype, fid) = iprot.readFieldBegin()
4270 
      if ftype == TType.STOP:
4271 
        break
4272 
      if fid == 0:
4273 
        if ftype == TType.STRUCT:
4274 
          self.success = User()
4275 
          self.success.read(iprot)
4276 
        else:
4277 
          iprot.skip(ftype)
4278 
      elif fid == 1:
4279 
        if ftype == TType.STRUCT:
4280 
          self.ucex = UserContextException()
4281 
          self.ucex.read(iprot)
4282 
        else:
4283 
          iprot.skip(ftype)
4284 
      else:
4285 
        iprot.skip(ftype)
4286 
      iprot.readFieldEnd()
4287 
    iprot.readStructEnd()
4288 
 
4289 
  def write(self, oprot):
4290 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4291 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4292 
      return
4293 
    oprot.writeStructBegin('getUserByEmail_result')
4294 
    if self.success != None:
4295 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4296 
      self.success.write(oprot)
4297 
      oprot.writeFieldEnd()
4298 
    if self.ucex != None:
4299 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4300 
      self.ucex.write(oprot)
4301 
      oprot.writeFieldEnd()
4302 
    oprot.writeFieldStop()
4303 
    oprot.writeStructEnd()
4304 
 
4305 
  def __repr__(self):
4306 
    L = ['%s=%r' % (key, value)
4307 
      for key, value in self.__dict__.iteritems()]
4308 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4309 
 
4310 
  def __eq__(self, other):
4311 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4312 
 
4313 
  def __ne__(self, other):
4314 
    return not (self == other)
4315 
 
559 chandransh 4316 
class createUser_args:
94 ashish 4317 
  """
4318 
  Attributes:
559 chandransh 4319 
   - user
94 ashish 4320 
  """
4321 
 
4322 
  thrift_spec = (
4323 
    None, # 0
559 chandransh 4324 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4325 
  )
4326 
 
559 chandransh 4327 
  def __init__(self, user=None,):
4328 
    self.user = user
94 ashish 4329 
 
4330 
  def read(self, iprot):
4331 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4332 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4333 
      return
4334 
    iprot.readStructBegin()
4335 
    while True:
4336 
      (fname, ftype, fid) = iprot.readFieldBegin()
4337 
      if ftype == TType.STOP:
4338 
        break
4339 
      if fid == 1:
559 chandransh 4340 
        if ftype == TType.STRUCT:
4341 
          self.user = User()
4342 
          self.user.read(iprot)
94 ashish 4343 
        else:
4344 
          iprot.skip(ftype)
4345 
      else:
4346 
        iprot.skip(ftype)
4347 
      iprot.readFieldEnd()
4348 
    iprot.readStructEnd()
4349 
 
4350 
  def write(self, oprot):
4351 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4352 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4353 
      return
559 chandransh 4354 
    oprot.writeStructBegin('createUser_args')
4355 
    if self.user != None:
4356 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4357 
      self.user.write(oprot)
94 ashish 4358 
      oprot.writeFieldEnd()
4359 
    oprot.writeFieldStop()
4360 
    oprot.writeStructEnd()
4361 
 
4362 
  def __repr__(self):
4363 
    L = ['%s=%r' % (key, value)
4364 
      for key, value in self.__dict__.iteritems()]
4365 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4366 
 
4367 
  def __eq__(self, other):
4368 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4369 
 
4370 
  def __ne__(self, other):
4371 
    return not (self == other)
4372 
 
559 chandransh 4373 
class createUser_result:
94 ashish 4374 
  """
4375 
  Attributes:
4376 
   - success
559 chandransh 4377 
   - ucex
94 ashish 4378 
  """
4379 
 
4380 
  thrift_spec = (
559 chandransh 4381 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4382 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4383 
  )
4384 
 
559 chandransh 4385 
  def __init__(self, success=None, ucex=None,):
94 ashish 4386 
    self.success = success
559 chandransh 4387 
    self.ucex = ucex
94 ashish 4388 
 
4389 
  def read(self, iprot):
4390 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4391 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4392 
      return
4393 
    iprot.readStructBegin()
4394 
    while True:
4395 
      (fname, ftype, fid) = iprot.readFieldBegin()
4396 
      if ftype == TType.STOP:
4397 
        break
4398 
      if fid == 0:
4399 
        if ftype == TType.STRUCT:
559 chandransh 4400 
          self.success = User()
94 ashish 4401 
          self.success.read(iprot)
4402 
        else:
4403 
          iprot.skip(ftype)
4404 
      elif fid == 1:
4405 
        if ftype == TType.STRUCT:
559 chandransh 4406 
          self.ucex = UserContextException()
4407 
          self.ucex.read(iprot)
94 ashish 4408 
        else:
4409 
          iprot.skip(ftype)
4410 
      else:
4411 
        iprot.skip(ftype)
4412 
      iprot.readFieldEnd()
4413 
    iprot.readStructEnd()
4414 
 
4415 
  def write(self, oprot):
4416 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4417 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4418 
      return
559 chandransh 4419 
    oprot.writeStructBegin('createUser_result')
94 ashish 4420 
    if self.success != None:
4421 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4422 
      self.success.write(oprot)
4423 
      oprot.writeFieldEnd()
559 chandransh 4424 
    if self.ucex != None:
4425 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4426 
      self.ucex.write(oprot)
94 ashish 4427 
      oprot.writeFieldEnd()
4428 
    oprot.writeFieldStop()
4429 
    oprot.writeStructEnd()
4430 
 
4431 
  def __repr__(self):
4432 
    L = ['%s=%r' % (key, value)
4433 
      for key, value in self.__dict__.iteritems()]
4434 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4435 
 
4436 
  def __eq__(self, other):
4437 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4438 
 
4439 
  def __ne__(self, other):
4440 
    return not (self == other)
4441 
 
559 chandransh 4442 
class updateUser_args:
94 ashish 4443 
  """
4444 
  Attributes:
559 chandransh 4445 
   - user
94 ashish 4446 
  """
4447 
 
4448 
  thrift_spec = (
4449 
    None, # 0
559 chandransh 4450 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4451 
  )
4452 
 
559 chandransh 4453 
  def __init__(self, user=None,):
4454 
    self.user = user
94 ashish 4455 
 
4456 
  def read(self, iprot):
4457 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4458 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4459 
      return
4460 
    iprot.readStructBegin()
4461 
    while True:
4462 
      (fname, ftype, fid) = iprot.readFieldBegin()
4463 
      if ftype == TType.STOP:
4464 
        break
4465 
      if fid == 1:
559 chandransh 4466 
        if ftype == TType.STRUCT:
4467 
          self.user = User()
4468 
          self.user.read(iprot)
94 ashish 4469 
        else:
4470 
          iprot.skip(ftype)
4471 
      else:
4472 
        iprot.skip(ftype)
4473 
      iprot.readFieldEnd()
4474 
    iprot.readStructEnd()
4475 
 
4476 
  def write(self, oprot):
4477 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4478 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4479 
      return
559 chandransh 4480 
    oprot.writeStructBegin('updateUser_args')
4481 
    if self.user != None:
4482 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4483 
      self.user.write(oprot)
94 ashish 4484 
      oprot.writeFieldEnd()
4485 
    oprot.writeFieldStop()
4486 
    oprot.writeStructEnd()
4487 
 
4488 
  def __repr__(self):
4489 
    L = ['%s=%r' % (key, value)
4490 
      for key, value in self.__dict__.iteritems()]
4491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4492 
 
4493 
  def __eq__(self, other):
4494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4495 
 
4496 
  def __ne__(self, other):
4497 
    return not (self == other)
4498 
 
559 chandransh 4499 
class updateUser_result:
94 ashish 4500 
  """
4501 
  Attributes:
4502 
   - success
559 chandransh 4503 
   - ucex
94 ashish 4504 
  """
4505 
 
4506 
  thrift_spec = (
559 chandransh 4507 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4508 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4509 
  )
4510 
 
559 chandransh 4511 
  def __init__(self, success=None, ucex=None,):
94 ashish 4512 
    self.success = success
559 chandransh 4513 
    self.ucex = ucex
94 ashish 4514 
 
4515 
  def read(self, iprot):
4516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4518 
      return
4519 
    iprot.readStructBegin()
4520 
    while True:
4521 
      (fname, ftype, fid) = iprot.readFieldBegin()
4522 
      if ftype == TType.STOP:
4523 
        break
4524 
      if fid == 0:
4525 
        if ftype == TType.STRUCT:
559 chandransh 4526 
          self.success = User()
94 ashish 4527 
          self.success.read(iprot)
4528 
        else:
4529 
          iprot.skip(ftype)
4530 
      elif fid == 1:
4531 
        if ftype == TType.STRUCT:
559 chandransh 4532 
          self.ucex = UserContextException()
4533 
          self.ucex.read(iprot)
94 ashish 4534 
        else:
4535 
          iprot.skip(ftype)
4536 
      else:
4537 
        iprot.skip(ftype)
4538 
      iprot.readFieldEnd()
4539 
    iprot.readStructEnd()
4540 
 
4541 
  def write(self, oprot):
4542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4544 
      return
559 chandransh 4545 
    oprot.writeStructBegin('updateUser_result')
94 ashish 4546 
    if self.success != None:
4547 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4548 
      self.success.write(oprot)
4549 
      oprot.writeFieldEnd()
559 chandransh 4550 
    if self.ucex != None:
4551 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4552 
      self.ucex.write(oprot)
94 ashish 4553 
      oprot.writeFieldEnd()
4554 
    oprot.writeFieldStop()
4555 
    oprot.writeStructEnd()
4556 
 
4557 
  def __repr__(self):
4558 
    L = ['%s=%r' % (key, value)
4559 
      for key, value in self.__dict__.iteritems()]
4560 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4561 
 
4562 
  def __eq__(self, other):
4563 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4564 
 
4565 
  def __ne__(self, other):
4566 
    return not (self == other)
4567 
 
559 chandransh 4568 
class deleteUser_args:
94 ashish 4569 
  """
4570 
  Attributes:
4571 
   - userId
4572 
  """
4573 
 
4574 
  thrift_spec = (
4575 
    None, # 0
4576 
    (1, TType.I64, 'userId', None, None, ), # 1
4577 
  )
4578 
 
559 chandransh 4579 
  def __init__(self, userId=None,):
94 ashish 4580 
    self.userId = userId
4581 
 
4582 
  def read(self, iprot):
4583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4585 
      return
4586 
    iprot.readStructBegin()
4587 
    while True:
4588 
      (fname, ftype, fid) = iprot.readFieldBegin()
4589 
      if ftype == TType.STOP:
4590 
        break
4591 
      if fid == 1:
4592 
        if ftype == TType.I64:
4593 
          self.userId = iprot.readI64();
4594 
        else:
4595 
          iprot.skip(ftype)
4596 
      else:
4597 
        iprot.skip(ftype)
4598 
      iprot.readFieldEnd()
4599 
    iprot.readStructEnd()
4600 
 
4601 
  def write(self, oprot):
4602 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4603 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4604 
      return
559 chandransh 4605 
    oprot.writeStructBegin('deleteUser_args')
94 ashish 4606 
    if self.userId != None:
4607 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4608 
      oprot.writeI64(self.userId)
4609 
      oprot.writeFieldEnd()
4610 
    oprot.writeFieldStop()
4611 
    oprot.writeStructEnd()
4612 
 
4613 
  def __repr__(self):
4614 
    L = ['%s=%r' % (key, value)
4615 
      for key, value in self.__dict__.iteritems()]
4616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4617 
 
4618 
  def __eq__(self, other):
4619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4620 
 
4621 
  def __ne__(self, other):
4622 
    return not (self == other)
4623 
 
559 chandransh 4624 
class deleteUser_result:
94 ashish 4625 
  """
4626 
  Attributes:
4627 
   - success
559 chandransh 4628 
   - ucex
94 ashish 4629 
  """
4630 
 
4631 
  thrift_spec = (
559 chandransh 4632 
    (0, TType.BOOL, 'success', None, None, ), # 0
4633 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4634 
  )
4635 
 
559 chandransh 4636 
  def __init__(self, success=None, ucex=None,):
94 ashish 4637 
    self.success = success
559 chandransh 4638 
    self.ucex = ucex
94 ashish 4639 
 
4640 
  def read(self, iprot):
4641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4643 
      return
4644 
    iprot.readStructBegin()
4645 
    while True:
4646 
      (fname, ftype, fid) = iprot.readFieldBegin()
4647 
      if ftype == TType.STOP:
4648 
        break
4649 
      if fid == 0:
559 chandransh 4650 
        if ftype == TType.BOOL:
4651 
          self.success = iprot.readBool();
94 ashish 4652 
        else:
4653 
          iprot.skip(ftype)
4654 
      elif fid == 1:
4655 
        if ftype == TType.STRUCT:
559 chandransh 4656 
          self.ucex = UserContextException()
4657 
          self.ucex.read(iprot)
94 ashish 4658 
        else:
4659 
          iprot.skip(ftype)
4660 
      else:
4661 
        iprot.skip(ftype)
4662 
      iprot.readFieldEnd()
4663 
    iprot.readStructEnd()
4664 
 
4665 
  def write(self, oprot):
4666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4668 
      return
559 chandransh 4669 
    oprot.writeStructBegin('deleteUser_result')
94 ashish 4670 
    if self.success != None:
559 chandransh 4671 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4672 
      oprot.writeBool(self.success)
94 ashish 4673 
      oprot.writeFieldEnd()
559 chandransh 4674 
    if self.ucex != None:
4675 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4676 
      self.ucex.write(oprot)
94 ashish 4677 
      oprot.writeFieldEnd()
4678 
    oprot.writeFieldStop()
4679 
    oprot.writeStructEnd()
4680 
 
4681 
  def __repr__(self):
4682 
    L = ['%s=%r' % (key, value)
4683 
      for key, value in self.__dict__.iteritems()]
4684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4685 
 
4686 
  def __eq__(self, other):
4687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4688 
 
4689 
  def __ne__(self, other):
4690 
    return not (self == other)
4691 
 
559 chandransh 4692 
class getUserState_args:
94 ashish 4693 
  """
4694 
  Attributes:
4695 
   - userId
4696 
  """
4697 
 
4698 
  thrift_spec = (
4699 
    None, # 0
4700 
    (1, TType.I64, 'userId', None, None, ), # 1
4701 
  )
4702 
 
559 chandransh 4703 
  def __init__(self, userId=None,):
94 ashish 4704 
    self.userId = userId
4705 
 
4706 
  def read(self, iprot):
4707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4709 
      return
4710 
    iprot.readStructBegin()
4711 
    while True:
4712 
      (fname, ftype, fid) = iprot.readFieldBegin()
4713 
      if ftype == TType.STOP:
4714 
        break
4715 
      if fid == 1:
4716 
        if ftype == TType.I64:
4717 
          self.userId = iprot.readI64();
4718 
        else:
4719 
          iprot.skip(ftype)
4720 
      else:
4721 
        iprot.skip(ftype)
4722 
      iprot.readFieldEnd()
4723 
    iprot.readStructEnd()
4724 
 
4725 
  def write(self, oprot):
4726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4728 
      return
559 chandransh 4729 
    oprot.writeStructBegin('getUserState_args')
94 ashish 4730 
    if self.userId != None:
4731 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4732 
      oprot.writeI64(self.userId)
4733 
      oprot.writeFieldEnd()
4734 
    oprot.writeFieldStop()
4735 
    oprot.writeStructEnd()
4736 
 
4737 
  def __repr__(self):
4738 
    L = ['%s=%r' % (key, value)
4739 
      for key, value in self.__dict__.iteritems()]
4740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4741 
 
4742 
  def __eq__(self, other):
4743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4744 
 
4745 
  def __ne__(self, other):
4746 
    return not (self == other)
4747 
 
559 chandransh 4748 
class getUserState_result:
94 ashish 4749 
  """
4750 
  Attributes:
4751 
   - success
559 chandransh 4752 
   - ucex
94 ashish 4753 
  """
4754 
 
4755 
  thrift_spec = (
559 chandransh 4756 
    (0, TType.STRUCT, 'success', (UserState, UserState.thrift_spec), None, ), # 0
4757 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4758 
  )
4759 
 
559 chandransh 4760 
  def __init__(self, success=None, ucex=None,):
94 ashish 4761 
    self.success = success
559 chandransh 4762 
    self.ucex = ucex
94 ashish 4763 
 
4764 
  def read(self, iprot):
4765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4767 
      return
4768 
    iprot.readStructBegin()
4769 
    while True:
4770 
      (fname, ftype, fid) = iprot.readFieldBegin()
4771 
      if ftype == TType.STOP:
4772 
        break
4773 
      if fid == 0:
4774 
        if ftype == TType.STRUCT:
559 chandransh 4775 
          self.success = UserState()
94 ashish 4776 
          self.success.read(iprot)
4777 
        else:
4778 
          iprot.skip(ftype)
4779 
      elif fid == 1:
4780 
        if ftype == TType.STRUCT:
559 chandransh 4781 
          self.ucex = UserContextException()
4782 
          self.ucex.read(iprot)
94 ashish 4783 
        else:
4784 
          iprot.skip(ftype)
4785 
      else:
4786 
        iprot.skip(ftype)
4787 
      iprot.readFieldEnd()
4788 
    iprot.readStructEnd()
4789 
 
4790 
  def write(self, oprot):
4791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4793 
      return
559 chandransh 4794 
    oprot.writeStructBegin('getUserState_result')
94 ashish 4795 
    if self.success != None:
4796 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4797 
      self.success.write(oprot)
4798 
      oprot.writeFieldEnd()
559 chandransh 4799 
    if self.ucex != None:
4800 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4801 
      self.ucex.write(oprot)
94 ashish 4802 
      oprot.writeFieldEnd()
4803 
    oprot.writeFieldStop()
4804 
    oprot.writeStructEnd()
4805 
 
4806 
  def __repr__(self):
4807 
    L = ['%s=%r' % (key, value)
4808 
      for key, value in self.__dict__.iteritems()]
4809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4810 
 
4811 
  def __eq__(self, other):
4812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4813 
 
4814 
  def __ne__(self, other):
4815 
    return not (self == other)
4816 
 
559 chandransh 4817 
class authenticateUser_args:
94 ashish 4818 
  """
4819 
  Attributes:
4820 
   - email
4821 
   - password
4822 
  """
4823 
 
4824 
  thrift_spec = (
4825 
    None, # 0
4826 
    (1, TType.STRING, 'email', None, None, ), # 1
4827 
    (2, TType.STRING, 'password', None, None, ), # 2
4828 
  )
4829 
 
4830 
  def __init__(self, email=None, password=None,):
4831 
    self.email = email
4832 
    self.password = password
4833 
 
4834 
  def read(self, iprot):
4835 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4836 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4837 
      return
4838 
    iprot.readStructBegin()
4839 
    while True:
4840 
      (fname, ftype, fid) = iprot.readFieldBegin()
4841 
      if ftype == TType.STOP:
4842 
        break
4843 
      if fid == 1:
4844 
        if ftype == TType.STRING:
4845 
          self.email = iprot.readString();
4846 
        else:
4847 
          iprot.skip(ftype)
4848 
      elif fid == 2:
4849 
        if ftype == TType.STRING:
4850 
          self.password = iprot.readString();
4851 
        else:
4852 
          iprot.skip(ftype)
4853 
      else:
4854 
        iprot.skip(ftype)
4855 
      iprot.readFieldEnd()
4856 
    iprot.readStructEnd()
4857 
 
4858 
  def write(self, oprot):
4859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4861 
      return
559 chandransh 4862 
    oprot.writeStructBegin('authenticateUser_args')
94 ashish 4863 
    if self.email != None:
4864 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4865 
      oprot.writeString(self.email)
4866 
      oprot.writeFieldEnd()
4867 
    if self.password != None:
4868 
      oprot.writeFieldBegin('password', TType.STRING, 2)
4869 
      oprot.writeString(self.password)
4870 
      oprot.writeFieldEnd()
4871 
    oprot.writeFieldStop()
4872 
    oprot.writeStructEnd()
4873 
 
4874 
  def __repr__(self):
4875 
    L = ['%s=%r' % (key, value)
4876 
      for key, value in self.__dict__.iteritems()]
4877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4878 
 
4879 
  def __eq__(self, other):
4880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4881 
 
4882 
  def __ne__(self, other):
4883 
    return not (self == other)
4884 
 
559 chandransh 4885 
class authenticateUser_result:
94 ashish 4886 
  """
4887 
  Attributes:
4888 
   - success
559 chandransh 4889 
   - auex
94 ashish 4890 
  """
4891 
 
4892 
  thrift_spec = (
559 chandransh 4893 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4894 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 4895 
  )
4896 
 
559 chandransh 4897 
  def __init__(self, success=None, auex=None,):
94 ashish 4898 
    self.success = success
559 chandransh 4899 
    self.auex = auex
94 ashish 4900 
 
4901 
  def read(self, iprot):
4902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4904 
      return
4905 
    iprot.readStructBegin()
4906 
    while True:
4907 
      (fname, ftype, fid) = iprot.readFieldBegin()
4908 
      if ftype == TType.STOP:
4909 
        break
4910 
      if fid == 0:
4911 
        if ftype == TType.STRUCT:
559 chandransh 4912 
          self.success = User()
94 ashish 4913 
          self.success.read(iprot)
4914 
        else:
4915 
          iprot.skip(ftype)
4916 
      elif fid == 1:
4917 
        if ftype == TType.STRUCT:
559 chandransh 4918 
          self.auex = AuthenticationException()
4919 
          self.auex.read(iprot)
94 ashish 4920 
        else:
4921 
          iprot.skip(ftype)
4922 
      else:
4923 
        iprot.skip(ftype)
4924 
      iprot.readFieldEnd()
4925 
    iprot.readStructEnd()
4926 
 
4927 
  def write(self, oprot):
4928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4930 
      return
559 chandransh 4931 
    oprot.writeStructBegin('authenticateUser_result')
94 ashish 4932 
    if self.success != None:
4933 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4934 
      self.success.write(oprot)
4935 
      oprot.writeFieldEnd()
559 chandransh 4936 
    if self.auex != None:
4937 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
4938 
      self.auex.write(oprot)
94 ashish 4939 
      oprot.writeFieldEnd()
4940 
    oprot.writeFieldStop()
4941 
    oprot.writeStructEnd()
4942 
 
4943 
  def __repr__(self):
4944 
    L = ['%s=%r' % (key, value)
4945 
      for key, value in self.__dict__.iteritems()]
4946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4947 
 
4948 
  def __eq__(self, other):
4949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4950 
 
4951 
  def __ne__(self, other):
4952 
    return not (self == other)
4953 
 
559 chandransh 4954 
class userExists_args:
122 ashish 4955 
  """
4956 
  Attributes:
559 chandransh 4957 
   - email
122 ashish 4958 
  """
4959 
 
4960 
  thrift_spec = (
4961 
    None, # 0
559 chandransh 4962 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 4963 
  )
4964 
 
559 chandransh 4965 
  def __init__(self, email=None,):
4966 
    self.email = email
122 ashish 4967 
 
4968 
  def read(self, iprot):
4969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4971 
      return
4972 
    iprot.readStructBegin()
4973 
    while True:
4974 
      (fname, ftype, fid) = iprot.readFieldBegin()
4975 
      if ftype == TType.STOP:
4976 
        break
4977 
      if fid == 1:
4978 
        if ftype == TType.STRING:
559 chandransh 4979 
          self.email = iprot.readString();
122 ashish 4980 
        else:
4981 
          iprot.skip(ftype)
559 chandransh 4982 
      else:
4983 
        iprot.skip(ftype)
4984 
      iprot.readFieldEnd()
4985 
    iprot.readStructEnd()
4986 
 
4987 
  def write(self, oprot):
4988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4990 
      return
4991 
    oprot.writeStructBegin('userExists_args')
4992 
    if self.email != None:
4993 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4994 
      oprot.writeString(self.email)
4995 
      oprot.writeFieldEnd()
4996 
    oprot.writeFieldStop()
4997 
    oprot.writeStructEnd()
4998 
 
4999 
  def __repr__(self):
5000 
    L = ['%s=%r' % (key, value)
5001 
      for key, value in self.__dict__.iteritems()]
5002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5003 
 
5004 
  def __eq__(self, other):
5005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5006 
 
5007 
  def __ne__(self, other):
5008 
    return not (self == other)
5009 
 
5010 
class userExists_result:
5011 
  """
5012 
  Attributes:
5013 
   - success
5014 
   - ucx
5015 
  """
5016 
 
5017 
  thrift_spec = (
5018 
    (0, TType.BOOL, 'success', None, None, ), # 0
5019 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5020 
  )
5021 
 
5022 
  def __init__(self, success=None, ucx=None,):
5023 
    self.success = success
5024 
    self.ucx = ucx
5025 
 
5026 
  def read(self, iprot):
5027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5029 
      return
5030 
    iprot.readStructBegin()
5031 
    while True:
5032 
      (fname, ftype, fid) = iprot.readFieldBegin()
5033 
      if ftype == TType.STOP:
5034 
        break
5035 
      if fid == 0:
5036 
        if ftype == TType.BOOL:
5037 
          self.success = iprot.readBool();
5038 
        else:
5039 
          iprot.skip(ftype)
5040 
      elif fid == 1:
5041 
        if ftype == TType.STRUCT:
5042 
          self.ucx = UserContextException()
5043 
          self.ucx.read(iprot)
5044 
        else:
5045 
          iprot.skip(ftype)
5046 
      else:
5047 
        iprot.skip(ftype)
5048 
      iprot.readFieldEnd()
5049 
    iprot.readStructEnd()
5050 
 
5051 
  def write(self, oprot):
5052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5054 
      return
5055 
    oprot.writeStructBegin('userExists_result')
5056 
    if self.success != None:
5057 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5058 
      oprot.writeBool(self.success)
5059 
      oprot.writeFieldEnd()
5060 
    if self.ucx != None:
5061 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5062 
      self.ucx.write(oprot)
5063 
      oprot.writeFieldEnd()
5064 
    oprot.writeFieldStop()
5065 
    oprot.writeStructEnd()
5066 
 
5067 
  def __repr__(self):
5068 
    L = ['%s=%r' % (key, value)
5069 
      for key, value in self.__dict__.iteritems()]
5070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5071 
 
5072 
  def __eq__(self, other):
5073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5074 
 
5075 
  def __ne__(self, other):
5076 
    return not (self == other)
5077 
 
5078 
class addAddressForUser_args:
5079 
  """
5080 
  Attributes:
5081 
   - userId
5082 
   - address
5083 
   - setDefault
5084 
  """
5085 
 
5086 
  thrift_spec = (
5087 
    None, # 0
5088 
    (1, TType.I64, 'userId', None, None, ), # 1
5089 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 5090 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 5091 
  )
5092 
 
567 rajveer 5093 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 5094 
    self.userId = userId
5095 
    self.address = address
5096 
    self.setDefault = setDefault
5097 
 
5098 
  def read(self, iprot):
5099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5101 
      return
5102 
    iprot.readStructBegin()
5103 
    while True:
5104 
      (fname, ftype, fid) = iprot.readFieldBegin()
5105 
      if ftype == TType.STOP:
5106 
        break
5107 
      if fid == 1:
5108 
        if ftype == TType.I64:
5109 
          self.userId = iprot.readI64();
5110 
        else:
5111 
          iprot.skip(ftype)
122 ashish 5112 
      elif fid == 2:
559 chandransh 5113 
        if ftype == TType.STRUCT:
5114 
          self.address = Address()
5115 
          self.address.read(iprot)
122 ashish 5116 
        else:
5117 
          iprot.skip(ftype)
5118 
      elif fid == 3:
5119 
        if ftype == TType.BOOL:
559 chandransh 5120 
          self.setDefault = iprot.readBool();
122 ashish 5121 
        else:
5122 
          iprot.skip(ftype)
5123 
      else:
5124 
        iprot.skip(ftype)
5125 
      iprot.readFieldEnd()
5126 
    iprot.readStructEnd()
5127 
 
5128 
  def write(self, oprot):
5129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5131 
      return
559 chandransh 5132 
    oprot.writeStructBegin('addAddressForUser_args')
5133 
    if self.userId != None:
5134 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5135 
      oprot.writeI64(self.userId)
122 ashish 5136 
      oprot.writeFieldEnd()
559 chandransh 5137 
    if self.address != None:
5138 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
5139 
      self.address.write(oprot)
122 ashish 5140 
      oprot.writeFieldEnd()
559 chandransh 5141 
    if self.setDefault != None:
567 rajveer 5142 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 5143 
      oprot.writeBool(self.setDefault)
5144 
      oprot.writeFieldEnd()
122 ashish 5145 
    oprot.writeFieldStop()
5146 
    oprot.writeStructEnd()
5147 
 
5148 
  def __repr__(self):
5149 
    L = ['%s=%r' % (key, value)
5150 
      for key, value in self.__dict__.iteritems()]
5151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5152 
 
5153 
  def __eq__(self, other):
5154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5155 
 
5156 
  def __ne__(self, other):
5157 
    return not (self == other)
5158 
 
559 chandransh 5159 
class addAddressForUser_result:
122 ashish 5160 
  """
5161 
  Attributes:
5162 
   - success
559 chandransh 5163 
   - ucx
122 ashish 5164 
  """
5165 
 
5166 
  thrift_spec = (
567 rajveer 5167 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 5168 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 5169 
  )
5170 
 
559 chandransh 5171 
  def __init__(self, success=None, ucx=None,):
122 ashish 5172 
    self.success = success
559 chandransh 5173 
    self.ucx = ucx
122 ashish 5174 
 
5175 
  def read(self, iprot):
5176 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5177 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5178 
      return
5179 
    iprot.readStructBegin()
5180 
    while True:
5181 
      (fname, ftype, fid) = iprot.readFieldBegin()
5182 
      if ftype == TType.STOP:
5183 
        break
5184 
      if fid == 0:
567 rajveer 5185 
        if ftype == TType.I64:
5186 
          self.success = iprot.readI64();
122 ashish 5187 
        else:
5188 
          iprot.skip(ftype)
5189 
      elif fid == 1:
5190 
        if ftype == TType.STRUCT:
559 chandransh 5191 
          self.ucx = UserContextException()
5192 
          self.ucx.read(iprot)
122 ashish 5193 
        else:
5194 
          iprot.skip(ftype)
5195 
      else:
5196 
        iprot.skip(ftype)
5197 
      iprot.readFieldEnd()
5198 
    iprot.readStructEnd()
5199 
 
5200 
  def write(self, oprot):
5201 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5202 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5203 
      return
559 chandransh 5204 
    oprot.writeStructBegin('addAddressForUser_result')
122 ashish 5205 
    if self.success != None:
567 rajveer 5206 
      oprot.writeFieldBegin('success', TType.I64, 0)
5207 
      oprot.writeI64(self.success)
122 ashish 5208 
      oprot.writeFieldEnd()
559 chandransh 5209 
    if self.ucx != None:
5210 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5211 
      self.ucx.write(oprot)
122 ashish 5212 
      oprot.writeFieldEnd()
5213 
    oprot.writeFieldStop()
5214 
    oprot.writeStructEnd()
5215 
 
5216 
  def __repr__(self):
5217 
    L = ['%s=%r' % (key, value)
5218 
      for key, value in self.__dict__.iteritems()]
5219 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5220 
 
5221 
  def __eq__(self, other):
5222 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5223 
 
5224 
  def __ne__(self, other):
5225 
    return not (self == other)
5226 
 
559 chandransh 5227 
class removeAddressForUser_args:
94 ashish 5228 
  """
5229 
  Attributes:
559 chandransh 5230 
   - userid
5231 
   - addressId
94 ashish 5232 
  """
5233 
 
5234 
  thrift_spec = (
5235 
    None, # 0
559 chandransh 5236 
    (1, TType.I64, 'userid', None, None, ), # 1
5237 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 5238 
  )
5239 
 
559 chandransh 5240 
  def __init__(self, userid=None, addressId=None,):
5241 
    self.userid = userid
5242 
    self.addressId = addressId
94 ashish 5243 
 
5244 
  def read(self, iprot):
5245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5247 
      return
5248 
    iprot.readStructBegin()
5249 
    while True:
5250 
      (fname, ftype, fid) = iprot.readFieldBegin()
5251 
      if ftype == TType.STOP:
5252 
        break
5253 
      if fid == 1:
559 chandransh 5254 
        if ftype == TType.I64:
5255 
          self.userid = iprot.readI64();
94 ashish 5256 
        else:
5257 
          iprot.skip(ftype)
559 chandransh 5258 
      elif fid == 2:
5259 
        if ftype == TType.I64:
5260 
          self.addressId = iprot.readI64();
5261 
        else:
5262 
          iprot.skip(ftype)
94 ashish 5263 
      else:
5264 
        iprot.skip(ftype)
5265 
      iprot.readFieldEnd()
5266 
    iprot.readStructEnd()
5267 
 
5268 
  def write(self, oprot):
5269 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5270 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5271 
      return
559 chandransh 5272 
    oprot.writeStructBegin('removeAddressForUser_args')
5273 
    if self.userid != None:
5274 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5275 
      oprot.writeI64(self.userid)
94 ashish 5276 
      oprot.writeFieldEnd()
559 chandransh 5277 
    if self.addressId != None:
5278 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5279 
      oprot.writeI64(self.addressId)
5280 
      oprot.writeFieldEnd()
94 ashish 5281 
    oprot.writeFieldStop()
5282 
    oprot.writeStructEnd()
5283 
 
5284 
  def __repr__(self):
5285 
    L = ['%s=%r' % (key, value)
5286 
      for key, value in self.__dict__.iteritems()]
5287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5288 
 
5289 
  def __eq__(self, other):
5290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5291 
 
5292 
  def __ne__(self, other):
5293 
    return not (self == other)
5294 
 
559 chandransh 5295 
class removeAddressForUser_result:
94 ashish 5296 
  """
5297 
  Attributes:
5298 
   - success
5299 
   - ucx
5300 
  """
5301 
 
5302 
  thrift_spec = (
5303 
    (0, TType.BOOL, 'success', None, None, ), # 0
5304 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5305 
  )
5306 
 
5307 
  def __init__(self, success=None, ucx=None,):
5308 
    self.success = success
5309 
    self.ucx = ucx
5310 
 
5311 
  def read(self, iprot):
5312 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5313 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5314 
      return
5315 
    iprot.readStructBegin()
5316 
    while True:
5317 
      (fname, ftype, fid) = iprot.readFieldBegin()
5318 
      if ftype == TType.STOP:
5319 
        break
5320 
      if fid == 0:
5321 
        if ftype == TType.BOOL:
5322 
          self.success = iprot.readBool();
5323 
        else:
5324 
          iprot.skip(ftype)
5325 
      elif fid == 1:
5326 
        if ftype == TType.STRUCT:
5327 
          self.ucx = UserContextException()
5328 
          self.ucx.read(iprot)
5329 
        else:
5330 
          iprot.skip(ftype)
5331 
      else:
5332 
        iprot.skip(ftype)
5333 
      iprot.readFieldEnd()
5334 
    iprot.readStructEnd()
5335 
 
5336 
  def write(self, oprot):
5337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5339 
      return
559 chandransh 5340 
    oprot.writeStructBegin('removeAddressForUser_result')
94 ashish 5341 
    if self.success != None:
5342 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5343 
      oprot.writeBool(self.success)
5344 
      oprot.writeFieldEnd()
5345 
    if self.ucx != None:
5346 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5347 
      self.ucx.write(oprot)
5348 
      oprot.writeFieldEnd()
5349 
    oprot.writeFieldStop()
5350 
    oprot.writeStructEnd()
5351 
 
5352 
  def __repr__(self):
5353 
    L = ['%s=%r' % (key, value)
5354 
      for key, value in self.__dict__.iteritems()]
5355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5356 
 
5357 
  def __eq__(self, other):
5358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5359 
 
5360 
  def __ne__(self, other):
5361 
    return not (self == other)
5362 
 
559 chandransh 5363 
class setUserAsLoggedIn_args:
94 ashish 5364 
  """
5365 
  Attributes:
559 chandransh 5366 
   - userId
94 ashish 5367 
   - timestamp
5368 
  """
5369 
 
5370 
  thrift_spec = (
5371 
    None, # 0
559 chandransh 5372 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 5373 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5374 
  )
5375 
 
559 chandransh 5376 
  def __init__(self, userId=None, timestamp=None,):
5377 
    self.userId = userId
94 ashish 5378 
    self.timestamp = timestamp
5379 
 
5380 
  def read(self, iprot):
5381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5383 
      return
5384 
    iprot.readStructBegin()
5385 
    while True:
5386 
      (fname, ftype, fid) = iprot.readFieldBegin()
5387 
      if ftype == TType.STOP:
5388 
        break
5389 
      if fid == 1:
559 chandransh 5390 
        if ftype == TType.I64:
5391 
          self.userId = iprot.readI64();
94 ashish 5392 
        else:
5393 
          iprot.skip(ftype)
5394 
      elif fid == 2:
5395 
        if ftype == TType.I64:
5396 
          self.timestamp = iprot.readI64();
5397 
        else:
5398 
          iprot.skip(ftype)
5399 
      else:
5400 
        iprot.skip(ftype)
5401 
      iprot.readFieldEnd()
5402 
    iprot.readStructEnd()
5403 
 
5404 
  def write(self, oprot):
5405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5407 
      return
559 chandransh 5408 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
5409 
    if self.userId != None:
5410 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5411 
      oprot.writeI64(self.userId)
94 ashish 5412 
      oprot.writeFieldEnd()
5413 
    if self.timestamp != None:
5414 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5415 
      oprot.writeI64(self.timestamp)
5416 
      oprot.writeFieldEnd()
5417 
    oprot.writeFieldStop()
5418 
    oprot.writeStructEnd()
5419 
 
5420 
  def __repr__(self):
5421 
    L = ['%s=%r' % (key, value)
5422 
      for key, value in self.__dict__.iteritems()]
5423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5424 
 
5425 
  def __eq__(self, other):
5426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5427 
 
5428 
  def __ne__(self, other):
5429 
    return not (self == other)
5430 
 
559 chandransh 5431 
class setUserAsLoggedIn_result:
94 ashish 5432 
  """
5433 
  Attributes:
5434 
   - success
5435 
   - ucx
5436 
  """
5437 
 
5438 
  thrift_spec = (
5439 
    (0, TType.BOOL, 'success', None, None, ), # 0
5440 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5441 
  )
5442 
 
5443 
  def __init__(self, success=None, ucx=None,):
5444 
    self.success = success
5445 
    self.ucx = ucx
5446 
 
5447 
  def read(self, iprot):
5448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5450 
      return
5451 
    iprot.readStructBegin()
5452 
    while True:
5453 
      (fname, ftype, fid) = iprot.readFieldBegin()
5454 
      if ftype == TType.STOP:
5455 
        break
5456 
      if fid == 0:
5457 
        if ftype == TType.BOOL:
5458 
          self.success = iprot.readBool();
5459 
        else:
5460 
          iprot.skip(ftype)
5461 
      elif fid == 1:
5462 
        if ftype == TType.STRUCT:
5463 
          self.ucx = UserContextException()
5464 
          self.ucx.read(iprot)
5465 
        else:
5466 
          iprot.skip(ftype)
5467 
      else:
5468 
        iprot.skip(ftype)
5469 
      iprot.readFieldEnd()
5470 
    iprot.readStructEnd()
5471 
 
5472 
  def write(self, oprot):
5473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5475 
      return
559 chandransh 5476 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
94 ashish 5477 
    if self.success != None:
5478 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5479 
      oprot.writeBool(self.success)
5480 
      oprot.writeFieldEnd()
5481 
    if self.ucx != None:
5482 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5483 
      self.ucx.write(oprot)
5484 
      oprot.writeFieldEnd()
5485 
    oprot.writeFieldStop()
5486 
    oprot.writeStructEnd()
5487 
 
5488 
  def __repr__(self):
5489 
    L = ['%s=%r' % (key, value)
5490 
      for key, value in self.__dict__.iteritems()]
5491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5492 
 
5493 
  def __eq__(self, other):
5494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5495 
 
5496 
  def __ne__(self, other):
5497 
    return not (self == other)
5498 
 
559 chandransh 5499 
class setUserAsLoggedOut_args:
94 ashish 5500 
  """
5501 
  Attributes:
5502 
   - userid
5503 
   - timestamp
5504 
  """
5505 
 
5506 
  thrift_spec = (
5507 
    None, # 0
559 chandransh 5508 
    (1, TType.I64, 'userid', None, None, ), # 1
5509 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 5510 
  )
5511 
 
559 chandransh 5512 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 5513 
    self.userid = userid
5514 
    self.timestamp = timestamp
5515 
 
5516 
  def read(self, iprot):
5517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5519 
      return
5520 
    iprot.readStructBegin()
5521 
    while True:
5522 
      (fname, ftype, fid) = iprot.readFieldBegin()
5523 
      if ftype == TType.STOP:
5524 
        break
5525 
      if fid == 1:
5526 
        if ftype == TType.I64:
5527 
          self.userid = iprot.readI64();
5528 
        else:
5529 
          iprot.skip(ftype)
559 chandransh 5530 
      elif fid == 2:
94 ashish 5531 
        if ftype == TType.I64:
5532 
          self.timestamp = iprot.readI64();
5533 
        else:
5534 
          iprot.skip(ftype)
5535 
      else:
5536 
        iprot.skip(ftype)
5537 
      iprot.readFieldEnd()
5538 
    iprot.readStructEnd()
5539 
 
5540 
  def write(self, oprot):
5541 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5542 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5543 
      return
559 chandransh 5544 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
94 ashish 5545 
    if self.userid != None:
559 chandransh 5546 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 5547 
      oprot.writeI64(self.userid)
5548 
      oprot.writeFieldEnd()
5549 
    if self.timestamp != None:
559 chandransh 5550 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 5551 
      oprot.writeI64(self.timestamp)
5552 
      oprot.writeFieldEnd()
5553 
    oprot.writeFieldStop()
5554 
    oprot.writeStructEnd()
5555 
 
5556 
  def __repr__(self):
5557 
    L = ['%s=%r' % (key, value)
5558 
      for key, value in self.__dict__.iteritems()]
5559 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5560 
 
5561 
  def __eq__(self, other):
5562 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5563 
 
5564 
  def __ne__(self, other):
5565 
    return not (self == other)
5566 
 
559 chandransh 5567 
class setUserAsLoggedOut_result:
94 ashish 5568 
  """
5569 
  Attributes:
5570 
   - success
5571 
   - ucx
5572 
  """
5573 
 
5574 
  thrift_spec = (
5575 
    (0, TType.BOOL, 'success', None, None, ), # 0
5576 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5577 
  )
5578 
 
5579 
  def __init__(self, success=None, ucx=None,):
5580 
    self.success = success
5581 
    self.ucx = ucx
5582 
 
5583 
  def read(self, iprot):
5584 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5585 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5586 
      return
5587 
    iprot.readStructBegin()
5588 
    while True:
5589 
      (fname, ftype, fid) = iprot.readFieldBegin()
5590 
      if ftype == TType.STOP:
5591 
        break
5592 
      if fid == 0:
5593 
        if ftype == TType.BOOL:
5594 
          self.success = iprot.readBool();
5595 
        else:
5596 
          iprot.skip(ftype)
5597 
      elif fid == 1:
5598 
        if ftype == TType.STRUCT:
5599 
          self.ucx = UserContextException()
5600 
          self.ucx.read(iprot)
5601 
        else:
5602 
          iprot.skip(ftype)
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('setUserAsLoggedOut_result')
94 ashish 5613 
    if self.success != None:
5614 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5615 
      oprot.writeBool(self.success)
5616 
      oprot.writeFieldEnd()
5617 
    if self.ucx != None:
5618 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5619 
      self.ucx.write(oprot)
5620 
      oprot.writeFieldEnd()
5621 
    oprot.writeFieldStop()
5622 
    oprot.writeStructEnd()
5623 
 
5624 
  def __repr__(self):
5625 
    L = ['%s=%r' % (key, value)
5626 
      for key, value in self.__dict__.iteritems()]
5627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5628 
 
5629 
  def __eq__(self, other):
5630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5631 
 
5632 
  def __ne__(self, other):
5633 
    return not (self == other)
5634 
 
559 chandransh 5635 
class setDefaultAddress_args:
94 ashish 5636 
  """
5637 
  Attributes:
5638 
   - userid
5639 
   - addressId
5640 
  """
5641 
 
5642 
  thrift_spec = (
5643 
    None, # 0
5644 
    (1, TType.I64, 'userid', None, None, ), # 1
5645 
    (2, TType.I64, 'addressId', None, None, ), # 2
5646 
  )
5647 
 
5648 
  def __init__(self, userid=None, addressId=None,):
5649 
    self.userid = userid
5650 
    self.addressId = addressId
5651 
 
5652 
  def read(self, iprot):
5653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5655 
      return
5656 
    iprot.readStructBegin()
5657 
    while True:
5658 
      (fname, ftype, fid) = iprot.readFieldBegin()
5659 
      if ftype == TType.STOP:
5660 
        break
5661 
      if fid == 1:
5662 
        if ftype == TType.I64:
5663 
          self.userid = iprot.readI64();
5664 
        else:
5665 
          iprot.skip(ftype)
5666 
      elif fid == 2:
5667 
        if ftype == TType.I64:
5668 
          self.addressId = iprot.readI64();
5669 
        else:
5670 
          iprot.skip(ftype)
5671 
      else:
5672 
        iprot.skip(ftype)
5673 
      iprot.readFieldEnd()
5674 
    iprot.readStructEnd()
5675 
 
5676 
  def write(self, oprot):
5677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5679 
      return
559 chandransh 5680 
    oprot.writeStructBegin('setDefaultAddress_args')
94 ashish 5681 
    if self.userid != None:
5682 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5683 
      oprot.writeI64(self.userid)
5684 
      oprot.writeFieldEnd()
5685 
    if self.addressId != None:
5686 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5687 
      oprot.writeI64(self.addressId)
5688 
      oprot.writeFieldEnd()
5689 
    oprot.writeFieldStop()
5690 
    oprot.writeStructEnd()
5691 
 
5692 
  def __repr__(self):
5693 
    L = ['%s=%r' % (key, value)
5694 
      for key, value in self.__dict__.iteritems()]
5695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5696 
 
5697 
  def __eq__(self, other):
5698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5699 
 
5700 
  def __ne__(self, other):
5701 
    return not (self == other)
5702 
 
559 chandransh 5703 
class setDefaultAddress_result:
94 ashish 5704 
  """
5705 
  Attributes:
5706 
   - success
5707 
   - ucx
5708 
  """
5709 
 
5710 
  thrift_spec = (
5711 
    (0, TType.BOOL, 'success', None, None, ), # 0
5712 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5713 
  )
5714 
 
5715 
  def __init__(self, success=None, ucx=None,):
5716 
    self.success = success
5717 
    self.ucx = ucx
5718 
 
5719 
  def read(self, iprot):
5720 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5721 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5722 
      return
5723 
    iprot.readStructBegin()
5724 
    while True:
5725 
      (fname, ftype, fid) = iprot.readFieldBegin()
5726 
      if ftype == TType.STOP:
5727 
        break
5728 
      if fid == 0:
5729 
        if ftype == TType.BOOL:
5730 
          self.success = iprot.readBool();
5731 
        else:
5732 
          iprot.skip(ftype)
5733 
      elif fid == 1:
5734 
        if ftype == TType.STRUCT:
5735 
          self.ucx = UserContextException()
5736 
          self.ucx.read(iprot)
5737 
        else:
5738 
          iprot.skip(ftype)
5739 
      else:
5740 
        iprot.skip(ftype)
5741 
      iprot.readFieldEnd()
5742 
    iprot.readStructEnd()
5743 
 
5744 
  def write(self, oprot):
5745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5747 
      return
559 chandransh 5748 
    oprot.writeStructBegin('setDefaultAddress_result')
94 ashish 5749 
    if self.success != None:
5750 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5751 
      oprot.writeBool(self.success)
5752 
      oprot.writeFieldEnd()
5753 
    if self.ucx != None:
5754 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5755 
      self.ucx.write(oprot)
5756 
      oprot.writeFieldEnd()
5757 
    oprot.writeFieldStop()
5758 
    oprot.writeStructEnd()
5759 
 
5760 
  def __repr__(self):
5761 
    L = ['%s=%r' % (key, value)
5762 
      for key, value in self.__dict__.iteritems()]
5763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5764 
 
5765 
  def __eq__(self, other):
5766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5767 
 
5768 
  def __ne__(self, other):
5769 
    return not (self == other)
5770 
 
559 chandransh 5771 
class updatePassword_args:
94 ashish 5772 
  """
5773 
  Attributes:
559 chandransh 5774 
   - userid
594 rajveer 5775 
   - oldPassword
5776 
   - newPassword
94 ashish 5777 
  """
5778 
 
5779 
  thrift_spec = (
5780 
    None, # 0
559 chandransh 5781 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 5782 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
5783 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 5784 
  )
5785 
 
594 rajveer 5786 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 5787 
    self.userid = userid
594 rajveer 5788 
    self.oldPassword = oldPassword
5789 
    self.newPassword = newPassword
94 ashish 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 == 1:
5801 
        if ftype == TType.I64:
559 chandransh 5802 
          self.userid = iprot.readI64();
94 ashish 5803 
        else:
5804 
          iprot.skip(ftype)
5805 
      elif fid == 2:
559 chandransh 5806 
        if ftype == TType.STRING:
594 rajveer 5807 
          self.oldPassword = iprot.readString();
94 ashish 5808 
        else:
5809 
          iprot.skip(ftype)
594 rajveer 5810 
      elif fid == 3:
5811 
        if ftype == TType.STRING:
5812 
          self.newPassword = iprot.readString();
5813 
        else:
5814 
          iprot.skip(ftype)
94 ashish 5815 
      else:
5816 
        iprot.skip(ftype)
5817 
      iprot.readFieldEnd()
5818 
    iprot.readStructEnd()
5819 
 
5820 
  def write(self, oprot):
5821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5823 
      return
559 chandransh 5824 
    oprot.writeStructBegin('updatePassword_args')
5825 
    if self.userid != None:
5826 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5827 
      oprot.writeI64(self.userid)
94 ashish 5828 
      oprot.writeFieldEnd()
594 rajveer 5829 
    if self.oldPassword != None:
5830 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
5831 
      oprot.writeString(self.oldPassword)
94 ashish 5832 
      oprot.writeFieldEnd()
594 rajveer 5833 
    if self.newPassword != None:
5834 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
5835 
      oprot.writeString(self.newPassword)
5836 
      oprot.writeFieldEnd()
94 ashish 5837 
    oprot.writeFieldStop()
5838 
    oprot.writeStructEnd()
5839 
 
5840 
  def __repr__(self):
5841 
    L = ['%s=%r' % (key, value)
5842 
      for key, value in self.__dict__.iteritems()]
5843 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5844 
 
5845 
  def __eq__(self, other):
5846 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5847 
 
5848 
  def __ne__(self, other):
5849 
    return not (self == other)
5850 
 
559 chandransh 5851 
class updatePassword_result:
94 ashish 5852 
  """
5853 
  Attributes:
5854 
   - success
5855 
   - ucx
5856 
  """
5857 
 
5858 
  thrift_spec = (
5859 
    (0, TType.BOOL, 'success', None, None, ), # 0
5860 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5861 
  )
5862 
 
5863 
  def __init__(self, success=None, ucx=None,):
5864 
    self.success = success
5865 
    self.ucx = ucx
5866 
 
5867 
  def read(self, iprot):
5868 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5869 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5870 
      return
5871 
    iprot.readStructBegin()
5872 
    while True:
5873 
      (fname, ftype, fid) = iprot.readFieldBegin()
5874 
      if ftype == TType.STOP:
5875 
        break
5876 
      if fid == 0:
5877 
        if ftype == TType.BOOL:
5878 
          self.success = iprot.readBool();
5879 
        else:
5880 
          iprot.skip(ftype)
5881 
      elif fid == 1:
5882 
        if ftype == TType.STRUCT:
5883 
          self.ucx = UserContextException()
5884 
          self.ucx.read(iprot)
5885 
        else:
5886 
          iprot.skip(ftype)
5887 
      else:
5888 
        iprot.skip(ftype)
5889 
      iprot.readFieldEnd()
5890 
    iprot.readStructEnd()
5891 
 
5892 
  def write(self, oprot):
5893 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5894 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5895 
      return
559 chandransh 5896 
    oprot.writeStructBegin('updatePassword_result')
94 ashish 5897 
    if self.success != None:
5898 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5899 
      oprot.writeBool(self.success)
5900 
      oprot.writeFieldEnd()
5901 
    if self.ucx != None:
5902 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5903 
      self.ucx.write(oprot)
5904 
      oprot.writeFieldEnd()
5905 
    oprot.writeFieldStop()
5906 
    oprot.writeStructEnd()
5907 
 
5908 
  def __repr__(self):
5909 
    L = ['%s=%r' % (key, value)
5910 
      for key, value in self.__dict__.iteritems()]
5911 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5912 
 
5913 
  def __eq__(self, other):
5914 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5915 
 
5916 
  def __ne__(self, other):
5917 
    return not (self == other)
5918 
 
581 rajveer 5919 
class forgotPassword_args:
5920 
  """
5921 
  Attributes:
5922 
   - email
884 rajveer 5923 
   - newPassword
581 rajveer 5924 
  """
5925 
 
5926 
  thrift_spec = (
5927 
    None, # 0
5928 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 5929 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 5930 
  )
5931 
 
884 rajveer 5932 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 5933 
    self.email = email
884 rajveer 5934 
    self.newPassword = newPassword
581 rajveer 5935 
 
5936 
  def read(self, iprot):
5937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5939 
      return
5940 
    iprot.readStructBegin()
5941 
    while True:
5942 
      (fname, ftype, fid) = iprot.readFieldBegin()
5943 
      if ftype == TType.STOP:
5944 
        break
5945 
      if fid == 1:
5946 
        if ftype == TType.STRING:
5947 
          self.email = iprot.readString();
5948 
        else:
5949 
          iprot.skip(ftype)
884 rajveer 5950 
      elif fid == 2:
5951 
        if ftype == TType.STRING:
5952 
          self.newPassword = iprot.readString();
5953 
        else:
5954 
          iprot.skip(ftype)
581 rajveer 5955 
      else:
5956 
        iprot.skip(ftype)
5957 
      iprot.readFieldEnd()
5958 
    iprot.readStructEnd()
5959 
 
5960 
  def write(self, oprot):
5961 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5962 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5963 
      return
5964 
    oprot.writeStructBegin('forgotPassword_args')
5965 
    if self.email != None:
5966 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5967 
      oprot.writeString(self.email)
5968 
      oprot.writeFieldEnd()
884 rajveer 5969 
    if self.newPassword != None:
5970 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
5971 
      oprot.writeString(self.newPassword)
5972 
      oprot.writeFieldEnd()
581 rajveer 5973 
    oprot.writeFieldStop()
5974 
    oprot.writeStructEnd()
5975 
 
5976 
  def __repr__(self):
5977 
    L = ['%s=%r' % (key, value)
5978 
      for key, value in self.__dict__.iteritems()]
5979 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5980 
 
5981 
  def __eq__(self, other):
5982 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5983 
 
5984 
  def __ne__(self, other):
5985 
    return not (self == other)
5986 
 
5987 
class forgotPassword_result:
5988 
  """
5989 
  Attributes:
5990 
   - success
5991 
   - ucx
5992 
  """
5993 
 
5994 
  thrift_spec = (
5995 
    (0, TType.BOOL, 'success', None, None, ), # 0
5996 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5997 
  )
5998 
 
5999 
  def __init__(self, success=None, ucx=None,):
6000 
    self.success = success
6001 
    self.ucx = ucx
6002 
 
6003 
  def read(self, iprot):
6004 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6005 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6006 
      return
6007 
    iprot.readStructBegin()
6008 
    while True:
6009 
      (fname, ftype, fid) = iprot.readFieldBegin()
6010 
      if ftype == TType.STOP:
6011 
        break
6012 
      if fid == 0:
6013 
        if ftype == TType.BOOL:
6014 
          self.success = iprot.readBool();
6015 
        else:
6016 
          iprot.skip(ftype)
6017 
      elif fid == 1:
6018 
        if ftype == TType.STRUCT:
6019 
          self.ucx = UserContextException()
6020 
          self.ucx.read(iprot)
6021 
        else:
6022 
          iprot.skip(ftype)
6023 
      else:
6024 
        iprot.skip(ftype)
6025 
      iprot.readFieldEnd()
6026 
    iprot.readStructEnd()
6027 
 
6028 
  def write(self, oprot):
6029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6031 
      return
6032 
    oprot.writeStructBegin('forgotPassword_result')
6033 
    if self.success != None:
6034 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6035 
      oprot.writeBool(self.success)
6036 
      oprot.writeFieldEnd()
6037 
    if self.ucx != None:
6038 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6039 
      self.ucx.write(oprot)
6040 
      oprot.writeFieldEnd()
6041 
    oprot.writeFieldStop()
6042 
    oprot.writeStructEnd()
6043 
 
6044 
  def __repr__(self):
6045 
    L = ['%s=%r' % (key, value)
6046 
      for key, value in self.__dict__.iteritems()]
6047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6048 
 
6049 
  def __eq__(self, other):
6050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6051 
 
6052 
  def __ne__(self, other):
6053 
    return not (self == other)
6054 
 
594 rajveer 6055 
class getAllAddressesForUser_args:
6056 
  """
6057 
  Attributes:
6058 
   - userId
6059 
  """
6060 
 
6061 
  thrift_spec = (
6062 
    None, # 0
6063 
    (1, TType.I64, 'userId', None, None, ), # 1
6064 
  )
6065 
 
6066 
  def __init__(self, userId=None,):
6067 
    self.userId = userId
6068 
 
6069 
  def read(self, iprot):
6070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6072 
      return
6073 
    iprot.readStructBegin()
6074 
    while True:
6075 
      (fname, ftype, fid) = iprot.readFieldBegin()
6076 
      if ftype == TType.STOP:
6077 
        break
6078 
      if fid == 1:
6079 
        if ftype == TType.I64:
6080 
          self.userId = iprot.readI64();
6081 
        else:
6082 
          iprot.skip(ftype)
6083 
      else:
6084 
        iprot.skip(ftype)
6085 
      iprot.readFieldEnd()
6086 
    iprot.readStructEnd()
6087 
 
6088 
  def write(self, oprot):
6089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6091 
      return
6092 
    oprot.writeStructBegin('getAllAddressesForUser_args')
6093 
    if self.userId != None:
6094 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6095 
      oprot.writeI64(self.userId)
6096 
      oprot.writeFieldEnd()
6097 
    oprot.writeFieldStop()
6098 
    oprot.writeStructEnd()
6099 
 
6100 
  def __repr__(self):
6101 
    L = ['%s=%r' % (key, value)
6102 
      for key, value in self.__dict__.iteritems()]
6103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6104 
 
6105 
  def __eq__(self, other):
6106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6107 
 
6108 
  def __ne__(self, other):
6109 
    return not (self == other)
6110 
 
6111 
class getAllAddressesForUser_result:
6112 
  """
6113 
  Attributes:
6114 
   - success
6115 
   - ucx
6116 
  """
6117 
 
6118 
  thrift_spec = (
6119 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
6120 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6121 
  )
6122 
 
6123 
  def __init__(self, success=None, ucx=None,):
6124 
    self.success = success
6125 
    self.ucx = ucx
6126 
 
6127 
  def read(self, iprot):
6128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6130 
      return
6131 
    iprot.readStructBegin()
6132 
    while True:
6133 
      (fname, ftype, fid) = iprot.readFieldBegin()
6134 
      if ftype == TType.STOP:
6135 
        break
6136 
      if fid == 0:
6137 
        if ftype == TType.LIST:
6138 
          self.success = []
1976 varun.gupt 6139 
          (_etype38, _size35) = iprot.readListBegin()
6140 
          for _i39 in xrange(_size35):
6141 
            _elem40 = Address()
6142 
            _elem40.read(iprot)
6143 
            self.success.append(_elem40)
594 rajveer 6144 
          iprot.readListEnd()
6145 
        else:
6146 
          iprot.skip(ftype)
6147 
      elif fid == 1:
6148 
        if ftype == TType.STRUCT:
6149 
          self.ucx = UserContextException()
6150 
          self.ucx.read(iprot)
6151 
        else:
6152 
          iprot.skip(ftype)
6153 
      else:
6154 
        iprot.skip(ftype)
6155 
      iprot.readFieldEnd()
6156 
    iprot.readStructEnd()
6157 
 
6158 
  def write(self, oprot):
6159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6161 
      return
6162 
    oprot.writeStructBegin('getAllAddressesForUser_result')
6163 
    if self.success != None:
6164 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6165 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 6166 
      for iter41 in self.success:
6167 
        iter41.write(oprot)
594 rajveer 6168 
      oprot.writeListEnd()
6169 
      oprot.writeFieldEnd()
6170 
    if self.ucx != None:
6171 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6172 
      self.ucx.write(oprot)
6173 
      oprot.writeFieldEnd()
6174 
    oprot.writeFieldStop()
6175 
    oprot.writeStructEnd()
6176 
 
6177 
  def __repr__(self):
6178 
    L = ['%s=%r' % (key, value)
6179 
      for key, value in self.__dict__.iteritems()]
6180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6181 
 
6182 
  def __eq__(self, other):
6183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6184 
 
6185 
  def __ne__(self, other):
6186 
    return not (self == other)
6187 
 
1894 vikas 6188 
class getAddressById_args:
6189 
  """
6190 
  Attributes:
6191 
   - addressId
6192 
  """
6193 
 
6194 
  thrift_spec = (
6195 
    None, # 0
6196 
    (1, TType.I64, 'addressId', None, None, ), # 1
6197 
  )
6198 
 
6199 
  def __init__(self, addressId=None,):
6200 
    self.addressId = addressId
6201 
 
6202 
  def read(self, iprot):
6203 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6204 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6205 
      return
6206 
    iprot.readStructBegin()
6207 
    while True:
6208 
      (fname, ftype, fid) = iprot.readFieldBegin()
6209 
      if ftype == TType.STOP:
6210 
        break
6211 
      if fid == 1:
6212 
        if ftype == TType.I64:
6213 
          self.addressId = iprot.readI64();
6214 
        else:
6215 
          iprot.skip(ftype)
6216 
      else:
6217 
        iprot.skip(ftype)
6218 
      iprot.readFieldEnd()
6219 
    iprot.readStructEnd()
6220 
 
6221 
  def write(self, oprot):
6222 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6223 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6224 
      return
6225 
    oprot.writeStructBegin('getAddressById_args')
6226 
    if self.addressId != None:
6227 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
6228 
      oprot.writeI64(self.addressId)
6229 
      oprot.writeFieldEnd()
6230 
    oprot.writeFieldStop()
6231 
    oprot.writeStructEnd()
6232 
 
6233 
  def __repr__(self):
6234 
    L = ['%s=%r' % (key, value)
6235 
      for key, value in self.__dict__.iteritems()]
6236 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6237 
 
6238 
  def __eq__(self, other):
6239 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6240 
 
6241 
  def __ne__(self, other):
6242 
    return not (self == other)
6243 
 
6244 
class getAddressById_result:
6245 
  """
6246 
  Attributes:
6247 
   - success
6248 
   - ucx
6249 
  """
6250 
 
6251 
  thrift_spec = (
6252 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
6253 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6254 
  )
6255 
 
6256 
  def __init__(self, success=None, ucx=None,):
6257 
    self.success = success
6258 
    self.ucx = ucx
6259 
 
6260 
  def read(self, iprot):
6261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6263 
      return
6264 
    iprot.readStructBegin()
6265 
    while True:
6266 
      (fname, ftype, fid) = iprot.readFieldBegin()
6267 
      if ftype == TType.STOP:
6268 
        break
6269 
      if fid == 0:
6270 
        if ftype == TType.STRUCT:
6271 
          self.success = Address()
6272 
          self.success.read(iprot)
6273 
        else:
6274 
          iprot.skip(ftype)
6275 
      elif fid == 1:
6276 
        if ftype == TType.STRUCT:
6277 
          self.ucx = UserContextException()
6278 
          self.ucx.read(iprot)
6279 
        else:
6280 
          iprot.skip(ftype)
6281 
      else:
6282 
        iprot.skip(ftype)
6283 
      iprot.readFieldEnd()
6284 
    iprot.readStructEnd()
6285 
 
6286 
  def write(self, oprot):
6287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6289 
      return
6290 
    oprot.writeStructBegin('getAddressById_result')
6291 
    if self.success != None:
6292 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6293 
      self.success.write(oprot)
6294 
      oprot.writeFieldEnd()
6295 
    if self.ucx != None:
6296 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6297 
      self.ucx.write(oprot)
6298 
      oprot.writeFieldEnd()
6299 
    oprot.writeFieldStop()
6300 
    oprot.writeStructEnd()
6301 
 
6302 
  def __repr__(self):
6303 
    L = ['%s=%r' % (key, value)
6304 
      for key, value in self.__dict__.iteritems()]
6305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6306 
 
6307 
  def __eq__(self, other):
6308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6309 
 
6310 
  def __ne__(self, other):
6311 
    return not (self == other)
6312 
 
594 rajveer 6313 
class getDefaultAddressId_args:
6314 
  """
6315 
  Attributes:
6316 
   - userId
6317 
  """
6318 
 
6319 
  thrift_spec = (
6320 
    None, # 0
6321 
    (1, TType.I64, 'userId', None, None, ), # 1
6322 
  )
6323 
 
6324 
  def __init__(self, userId=None,):
6325 
    self.userId = userId
6326 
 
6327 
  def read(self, iprot):
6328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6330 
      return
6331 
    iprot.readStructBegin()
6332 
    while True:
6333 
      (fname, ftype, fid) = iprot.readFieldBegin()
6334 
      if ftype == TType.STOP:
6335 
        break
6336 
      if fid == 1:
6337 
        if ftype == TType.I64:
6338 
          self.userId = iprot.readI64();
6339 
        else:
6340 
          iprot.skip(ftype)
6341 
      else:
6342 
        iprot.skip(ftype)
6343 
      iprot.readFieldEnd()
6344 
    iprot.readStructEnd()
6345 
 
6346 
  def write(self, oprot):
6347 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6348 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6349 
      return
6350 
    oprot.writeStructBegin('getDefaultAddressId_args')
6351 
    if self.userId != None:
6352 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6353 
      oprot.writeI64(self.userId)
6354 
      oprot.writeFieldEnd()
6355 
    oprot.writeFieldStop()
6356 
    oprot.writeStructEnd()
6357 
 
6358 
  def __repr__(self):
6359 
    L = ['%s=%r' % (key, value)
6360 
      for key, value in self.__dict__.iteritems()]
6361 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6362 
 
6363 
  def __eq__(self, other):
6364 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6365 
 
6366 
  def __ne__(self, other):
6367 
    return not (self == other)
6368 
 
6369 
class getDefaultAddressId_result:
6370 
  """
6371 
  Attributes:
6372 
   - success
6373 
   - ucx
6374 
  """
6375 
 
6376 
  thrift_spec = (
6377 
    (0, TType.I64, 'success', None, None, ), # 0
6378 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6379 
  )
6380 
 
6381 
  def __init__(self, success=None, ucx=None,):
6382 
    self.success = success
6383 
    self.ucx = ucx
6384 
 
6385 
  def read(self, iprot):
6386 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6387 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6388 
      return
6389 
    iprot.readStructBegin()
6390 
    while True:
6391 
      (fname, ftype, fid) = iprot.readFieldBegin()
6392 
      if ftype == TType.STOP:
6393 
        break
6394 
      if fid == 0:
6395 
        if ftype == TType.I64:
6396 
          self.success = iprot.readI64();
6397 
        else:
6398 
          iprot.skip(ftype)
6399 
      elif fid == 1:
6400 
        if ftype == TType.STRUCT:
6401 
          self.ucx = UserContextException()
6402 
          self.ucx.read(iprot)
6403 
        else:
6404 
          iprot.skip(ftype)
6405 
      else:
6406 
        iprot.skip(ftype)
6407 
      iprot.readFieldEnd()
6408 
    iprot.readStructEnd()
6409 
 
6410 
  def write(self, oprot):
6411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6413 
      return
6414 
    oprot.writeStructBegin('getDefaultAddressId_result')
6415 
    if self.success != None:
6416 
      oprot.writeFieldBegin('success', TType.I64, 0)
6417 
      oprot.writeI64(self.success)
6418 
      oprot.writeFieldEnd()
6419 
    if self.ucx != None:
6420 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6421 
      self.ucx.write(oprot)
6422 
      oprot.writeFieldEnd()
6423 
    oprot.writeFieldStop()
6424 
    oprot.writeStructEnd()
6425 
 
6426 
  def __repr__(self):
6427 
    L = ['%s=%r' % (key, value)
6428 
      for key, value in self.__dict__.iteritems()]
6429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6430 
 
6431 
  def __eq__(self, other):
6432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6433 
 
6434 
  def __ne__(self, other):
6435 
    return not (self == other)
6436 
 
785 rajveer 6437 
class getDefaultPincode_args:
6438 
  """
6439 
  Attributes:
6440 
   - userId
6441 
  """
6442 
 
6443 
  thrift_spec = (
6444 
    None, # 0
6445 
    (1, TType.I64, 'userId', None, None, ), # 1
6446 
  )
6447 
 
6448 
  def __init__(self, userId=None,):
6449 
    self.userId = userId
6450 
 
6451 
  def read(self, iprot):
6452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6454 
      return
6455 
    iprot.readStructBegin()
6456 
    while True:
6457 
      (fname, ftype, fid) = iprot.readFieldBegin()
6458 
      if ftype == TType.STOP:
6459 
        break
6460 
      if fid == 1:
6461 
        if ftype == TType.I64:
6462 
          self.userId = iprot.readI64();
6463 
        else:
6464 
          iprot.skip(ftype)
6465 
      else:
6466 
        iprot.skip(ftype)
6467 
      iprot.readFieldEnd()
6468 
    iprot.readStructEnd()
6469 
 
6470 
  def write(self, oprot):
6471 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6472 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6473 
      return
6474 
    oprot.writeStructBegin('getDefaultPincode_args')
6475 
    if self.userId != None:
6476 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6477 
      oprot.writeI64(self.userId)
6478 
      oprot.writeFieldEnd()
6479 
    oprot.writeFieldStop()
6480 
    oprot.writeStructEnd()
6481 
 
6482 
  def __repr__(self):
6483 
    L = ['%s=%r' % (key, value)
6484 
      for key, value in self.__dict__.iteritems()]
6485 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6486 
 
6487 
  def __eq__(self, other):
6488 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6489 
 
6490 
  def __ne__(self, other):
6491 
    return not (self == other)
6492 
 
6493 
class getDefaultPincode_result:
6494 
  """
6495 
  Attributes:
6496 
   - success
6497 
   - ucx
6498 
  """
6499 
 
6500 
  thrift_spec = (
6501 
    (0, TType.STRING, 'success', None, None, ), # 0
6502 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6503 
  )
6504 
 
6505 
  def __init__(self, success=None, ucx=None,):
6506 
    self.success = success
6507 
    self.ucx = ucx
6508 
 
6509 
  def read(self, iprot):
6510 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6511 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6512 
      return
6513 
    iprot.readStructBegin()
6514 
    while True:
6515 
      (fname, ftype, fid) = iprot.readFieldBegin()
6516 
      if ftype == TType.STOP:
6517 
        break
6518 
      if fid == 0:
6519 
        if ftype == TType.STRING:
6520 
          self.success = iprot.readString();
6521 
        else:
6522 
          iprot.skip(ftype)
6523 
      elif fid == 1:
6524 
        if ftype == TType.STRUCT:
6525 
          self.ucx = UserContextException()
6526 
          self.ucx.read(iprot)
6527 
        else:
6528 
          iprot.skip(ftype)
6529 
      else:
6530 
        iprot.skip(ftype)
6531 
      iprot.readFieldEnd()
6532 
    iprot.readStructEnd()
6533 
 
6534 
  def write(self, oprot):
6535 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6536 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6537 
      return
6538 
    oprot.writeStructBegin('getDefaultPincode_result')
6539 
    if self.success != None:
6540 
      oprot.writeFieldBegin('success', TType.STRING, 0)
6541 
      oprot.writeString(self.success)
6542 
      oprot.writeFieldEnd()
6543 
    if self.ucx != None:
6544 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6545 
      self.ucx.write(oprot)
6546 
      oprot.writeFieldEnd()
6547 
    oprot.writeFieldStop()
6548 
    oprot.writeStructEnd()
6549 
 
6550 
  def __repr__(self):
6551 
    L = ['%s=%r' % (key, value)
6552 
      for key, value in self.__dict__.iteritems()]
6553 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6554 
 
6555 
  def __eq__(self, other):
6556 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6557 
 
6558 
  def __ne__(self, other):
6559 
    return not (self == other)
6560 
 
1274 varun.gupt 6561 
class saveUserCommunication_args:
6562 
  """
6563 
  Attributes:
6564 
   - userId
6565 
   - replyTo
6566 
   - communicationType
6567 
   - orderId
6568 
   - airwaybillNo
6569 
   - productName
6570 
   - subject
6571 
   - message
6572 
  """
6573 
 
6574 
  thrift_spec = (
6575 
    None, # 0
6576 
    (1, TType.I64, 'userId', None, None, ), # 1
6577 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
6578 
    (3, TType.I64, 'communicationType', None, None, ), # 3
6579 
    (4, TType.I64, 'orderId', None, None, ), # 4
6580 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
6581 
    (6, TType.STRING, 'productName', None, None, ), # 6
6582 
    (7, TType.STRING, 'subject', None, None, ), # 7
6583 
    (8, TType.STRING, 'message', None, None, ), # 8
6584 
  )
6585 
 
6586 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
6587 
    self.userId = userId
6588 
    self.replyTo = replyTo
6589 
    self.communicationType = communicationType
6590 
    self.orderId = orderId
6591 
    self.airwaybillNo = airwaybillNo
6592 
    self.productName = productName
6593 
    self.subject = subject
6594 
    self.message = message
6595 
 
6596 
  def read(self, iprot):
6597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6599 
      return
6600 
    iprot.readStructBegin()
6601 
    while True:
6602 
      (fname, ftype, fid) = iprot.readFieldBegin()
6603 
      if ftype == TType.STOP:
6604 
        break
6605 
      if fid == 1:
6606 
        if ftype == TType.I64:
6607 
          self.userId = iprot.readI64();
6608 
        else:
6609 
          iprot.skip(ftype)
6610 
      elif fid == 2:
6611 
        if ftype == TType.STRING:
6612 
          self.replyTo = iprot.readString();
6613 
        else:
6614 
          iprot.skip(ftype)
6615 
      elif fid == 3:
6616 
        if ftype == TType.I64:
6617 
          self.communicationType = iprot.readI64();
6618 
        else:
6619 
          iprot.skip(ftype)
6620 
      elif fid == 4:
6621 
        if ftype == TType.I64:
6622 
          self.orderId = iprot.readI64();
6623 
        else:
6624 
          iprot.skip(ftype)
6625 
      elif fid == 5:
6626 
        if ftype == TType.STRING:
6627 
          self.airwaybillNo = iprot.readString();
6628 
        else:
6629 
          iprot.skip(ftype)
6630 
      elif fid == 6:
6631 
        if ftype == TType.STRING:
6632 
          self.productName = iprot.readString();
6633 
        else:
6634 
          iprot.skip(ftype)
6635 
      elif fid == 7:
6636 
        if ftype == TType.STRING:
6637 
          self.subject = iprot.readString();
6638 
        else:
6639 
          iprot.skip(ftype)
6640 
      elif fid == 8:
6641 
        if ftype == TType.STRING:
6642 
          self.message = iprot.readString();
6643 
        else:
6644 
          iprot.skip(ftype)
6645 
      else:
6646 
        iprot.skip(ftype)
6647 
      iprot.readFieldEnd()
6648 
    iprot.readStructEnd()
6649 
 
6650 
  def write(self, oprot):
6651 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6652 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6653 
      return
6654 
    oprot.writeStructBegin('saveUserCommunication_args')
6655 
    if self.userId != None:
6656 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6657 
      oprot.writeI64(self.userId)
6658 
      oprot.writeFieldEnd()
6659 
    if self.replyTo != None:
6660 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
6661 
      oprot.writeString(self.replyTo)
6662 
      oprot.writeFieldEnd()
6663 
    if self.communicationType != None:
6664 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
6665 
      oprot.writeI64(self.communicationType)
6666 
      oprot.writeFieldEnd()
6667 
    if self.orderId != None:
6668 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
6669 
      oprot.writeI64(self.orderId)
6670 
      oprot.writeFieldEnd()
6671 
    if self.airwaybillNo != None:
6672 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
6673 
      oprot.writeString(self.airwaybillNo)
6674 
      oprot.writeFieldEnd()
6675 
    if self.productName != None:
6676 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
6677 
      oprot.writeString(self.productName)
6678 
      oprot.writeFieldEnd()
6679 
    if self.subject != None:
6680 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
6681 
      oprot.writeString(self.subject)
6682 
      oprot.writeFieldEnd()
6683 
    if self.message != None:
6684 
      oprot.writeFieldBegin('message', TType.STRING, 8)
6685 
      oprot.writeString(self.message)
6686 
      oprot.writeFieldEnd()
6687 
    oprot.writeFieldStop()
6688 
    oprot.writeStructEnd()
6689 
 
6690 
  def __repr__(self):
6691 
    L = ['%s=%r' % (key, value)
6692 
      for key, value in self.__dict__.iteritems()]
6693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6694 
 
6695 
  def __eq__(self, other):
6696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6697 
 
6698 
  def __ne__(self, other):
6699 
    return not (self == other)
6700 
 
6701 
class saveUserCommunication_result:
6702 
  """
6703 
  Attributes:
6704 
   - success
6705 
   - ucx
6706 
  """
6707 
 
6708 
  thrift_spec = (
6709 
    (0, TType.BOOL, 'success', None, None, ), # 0
6710 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6711 
  )
6712 
 
6713 
  def __init__(self, success=None, ucx=None,):
6714 
    self.success = success
6715 
    self.ucx = ucx
6716 
 
6717 
  def read(self, iprot):
6718 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6719 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6720 
      return
6721 
    iprot.readStructBegin()
6722 
    while True:
6723 
      (fname, ftype, fid) = iprot.readFieldBegin()
6724 
      if ftype == TType.STOP:
6725 
        break
6726 
      if fid == 0:
6727 
        if ftype == TType.BOOL:
6728 
          self.success = iprot.readBool();
6729 
        else:
6730 
          iprot.skip(ftype)
6731 
      elif fid == 1:
6732 
        if ftype == TType.STRUCT:
6733 
          self.ucx = UserCommunicationException()
6734 
          self.ucx.read(iprot)
6735 
        else:
6736 
          iprot.skip(ftype)
6737 
      else:
6738 
        iprot.skip(ftype)
6739 
      iprot.readFieldEnd()
6740 
    iprot.readStructEnd()
6741 
 
6742 
  def write(self, oprot):
6743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6745 
      return
6746 
    oprot.writeStructBegin('saveUserCommunication_result')
6747 
    if self.success != None:
6748 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6749 
      oprot.writeBool(self.success)
6750 
      oprot.writeFieldEnd()
6751 
    if self.ucx != None:
6752 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6753 
      self.ucx.write(oprot)
6754 
      oprot.writeFieldEnd()
6755 
    oprot.writeFieldStop()
6756 
    oprot.writeStructEnd()
6757 
 
6758 
  def __repr__(self):
6759 
    L = ['%s=%r' % (key, value)
6760 
      for key, value in self.__dict__.iteritems()]
6761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6762 
 
6763 
  def __eq__(self, other):
6764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6765 
 
6766 
  def __ne__(self, other):
6767 
    return not (self == other)
6768 
 
1590 varun.gupt 6769 
class getUserCommunicationById_args:
6770 
  """
6771 
  Attributes:
6772 
   - id
6773 
  """
6774 
 
6775 
  thrift_spec = (
6776 
    None, # 0
6777 
    (1, TType.I64, 'id', None, None, ), # 1
6778 
  )
6779 
 
6780 
  def __init__(self, id=None,):
6781 
    self.id = id
6782 
 
6783 
  def read(self, iprot):
6784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6786 
      return
6787 
    iprot.readStructBegin()
6788 
    while True:
6789 
      (fname, ftype, fid) = iprot.readFieldBegin()
6790 
      if ftype == TType.STOP:
6791 
        break
6792 
      if fid == 1:
6793 
        if ftype == TType.I64:
6794 
          self.id = iprot.readI64();
6795 
        else:
6796 
          iprot.skip(ftype)
6797 
      else:
6798 
        iprot.skip(ftype)
6799 
      iprot.readFieldEnd()
6800 
    iprot.readStructEnd()
6801 
 
6802 
  def write(self, oprot):
6803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6805 
      return
6806 
    oprot.writeStructBegin('getUserCommunicationById_args')
6807 
    if self.id != None:
6808 
      oprot.writeFieldBegin('id', TType.I64, 1)
6809 
      oprot.writeI64(self.id)
6810 
      oprot.writeFieldEnd()
6811 
    oprot.writeFieldStop()
6812 
    oprot.writeStructEnd()
6813 
 
6814 
  def __repr__(self):
6815 
    L = ['%s=%r' % (key, value)
6816 
      for key, value in self.__dict__.iteritems()]
6817 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6818 
 
6819 
  def __eq__(self, other):
6820 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6821 
 
6822 
  def __ne__(self, other):
6823 
    return not (self == other)
6824 
 
6825 
class getUserCommunicationById_result:
6826 
  """
6827 
  Attributes:
6828 
   - success
6829 
   - ucx
6830 
  """
6831 
 
6832 
  thrift_spec = (
6833 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
6834 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6835 
  )
6836 
 
6837 
  def __init__(self, success=None, ucx=None,):
6838 
    self.success = success
6839 
    self.ucx = ucx
6840 
 
6841 
  def read(self, iprot):
6842 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6843 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6844 
      return
6845 
    iprot.readStructBegin()
6846 
    while True:
6847 
      (fname, ftype, fid) = iprot.readFieldBegin()
6848 
      if ftype == TType.STOP:
6849 
        break
6850 
      if fid == 0:
6851 
        if ftype == TType.STRUCT:
6852 
          self.success = UserCommunication()
6853 
          self.success.read(iprot)
6854 
        else:
6855 
          iprot.skip(ftype)
6856 
      elif fid == 1:
6857 
        if ftype == TType.STRUCT:
6858 
          self.ucx = UserCommunicationException()
6859 
          self.ucx.read(iprot)
6860 
        else:
6861 
          iprot.skip(ftype)
6862 
      else:
6863 
        iprot.skip(ftype)
6864 
      iprot.readFieldEnd()
6865 
    iprot.readStructEnd()
6866 
 
6867 
  def write(self, oprot):
6868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6870 
      return
6871 
    oprot.writeStructBegin('getUserCommunicationById_result')
6872 
    if self.success != None:
6873 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6874 
      self.success.write(oprot)
6875 
      oprot.writeFieldEnd()
6876 
    if self.ucx != None:
6877 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6878 
      self.ucx.write(oprot)
6879 
      oprot.writeFieldEnd()
6880 
    oprot.writeFieldStop()
6881 
    oprot.writeStructEnd()
6882 
 
6883 
  def __repr__(self):
6884 
    L = ['%s=%r' % (key, value)
6885 
      for key, value in self.__dict__.iteritems()]
6886 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6887 
 
6888 
  def __eq__(self, other):
6889 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6890 
 
6891 
  def __ne__(self, other):
6892 
    return not (self == other)
6893 
 
6894 
class getUserCommunicationByUser_args:
6895 
  """
6896 
  Attributes:
6897 
   - userId
6898 
  """
6899 
 
6900 
  thrift_spec = (
6901 
    None, # 0
6902 
    (1, TType.I64, 'userId', None, None, ), # 1
6903 
  )
6904 
 
6905 
  def __init__(self, userId=None,):
6906 
    self.userId = userId
6907 
 
6908 
  def read(self, iprot):
6909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6911 
      return
6912 
    iprot.readStructBegin()
6913 
    while True:
6914 
      (fname, ftype, fid) = iprot.readFieldBegin()
6915 
      if ftype == TType.STOP:
6916 
        break
6917 
      if fid == 1:
6918 
        if ftype == TType.I64:
6919 
          self.userId = iprot.readI64();
6920 
        else:
6921 
          iprot.skip(ftype)
6922 
      else:
6923 
        iprot.skip(ftype)
6924 
      iprot.readFieldEnd()
6925 
    iprot.readStructEnd()
6926 
 
6927 
  def write(self, oprot):
6928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6930 
      return
6931 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
6932 
    if self.userId != None:
6933 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6934 
      oprot.writeI64(self.userId)
6935 
      oprot.writeFieldEnd()
6936 
    oprot.writeFieldStop()
6937 
    oprot.writeStructEnd()
6938 
 
6939 
  def __repr__(self):
6940 
    L = ['%s=%r' % (key, value)
6941 
      for key, value in self.__dict__.iteritems()]
6942 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6943 
 
6944 
  def __eq__(self, other):
6945 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6946 
 
6947 
  def __ne__(self, other):
6948 
    return not (self == other)
6949 
 
6950 
class getUserCommunicationByUser_result:
6951 
  """
6952 
  Attributes:
6953 
   - success
6954 
   - ucx
6955 
  """
6956 
 
6957 
  thrift_spec = (
6958 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
6959 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6960 
  )
6961 
 
6962 
  def __init__(self, success=None, ucx=None,):
6963 
    self.success = success
6964 
    self.ucx = ucx
6965 
 
6966 
  def read(self, iprot):
6967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6969 
      return
6970 
    iprot.readStructBegin()
6971 
    while True:
6972 
      (fname, ftype, fid) = iprot.readFieldBegin()
6973 
      if ftype == TType.STOP:
6974 
        break
6975 
      if fid == 0:
6976 
        if ftype == TType.LIST:
6977 
          self.success = []
1976 varun.gupt 6978 
          (_etype45, _size42) = iprot.readListBegin()
6979 
          for _i46 in xrange(_size42):
6980 
            _elem47 = UserCommunication()
6981 
            _elem47.read(iprot)
6982 
            self.success.append(_elem47)
1590 varun.gupt 6983 
          iprot.readListEnd()
6984 
        else:
6985 
          iprot.skip(ftype)
6986 
      elif fid == 1:
6987 
        if ftype == TType.STRUCT:
6988 
          self.ucx = UserCommunicationException()
6989 
          self.ucx.read(iprot)
6990 
        else:
6991 
          iprot.skip(ftype)
6992 
      else:
6993 
        iprot.skip(ftype)
6994 
      iprot.readFieldEnd()
6995 
    iprot.readStructEnd()
6996 
 
6997 
  def write(self, oprot):
6998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7000 
      return
7001 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
7002 
    if self.success != None:
7003 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7004 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 7005 
      for iter48 in self.success:
7006 
        iter48.write(oprot)
1590 varun.gupt 7007 
      oprot.writeListEnd()
7008 
      oprot.writeFieldEnd()
7009 
    if self.ucx != None:
7010 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7011 
      self.ucx.write(oprot)
7012 
      oprot.writeFieldEnd()
7013 
    oprot.writeFieldStop()
7014 
    oprot.writeStructEnd()
7015 
 
7016 
  def __repr__(self):
7017 
    L = ['%s=%r' % (key, value)
7018 
      for key, value in self.__dict__.iteritems()]
7019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7020 
 
7021 
  def __eq__(self, other):
7022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7023 
 
7024 
  def __ne__(self, other):
7025 
    return not (self == other)
7026 
 
7027 
class getAllUserCommunications_args:
7028 
 
7029 
  thrift_spec = (
7030 
  )
7031 
 
7032 
  def read(self, iprot):
7033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7035 
      return
7036 
    iprot.readStructBegin()
7037 
    while True:
7038 
      (fname, ftype, fid) = iprot.readFieldBegin()
7039 
      if ftype == TType.STOP:
7040 
        break
7041 
      else:
7042 
        iprot.skip(ftype)
7043 
      iprot.readFieldEnd()
7044 
    iprot.readStructEnd()
7045 
 
7046 
  def write(self, oprot):
7047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7049 
      return
7050 
    oprot.writeStructBegin('getAllUserCommunications_args')
7051 
    oprot.writeFieldStop()
7052 
    oprot.writeStructEnd()
7053 
 
7054 
  def __repr__(self):
7055 
    L = ['%s=%r' % (key, value)
7056 
      for key, value in self.__dict__.iteritems()]
7057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7058 
 
7059 
  def __eq__(self, other):
7060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7061 
 
7062 
  def __ne__(self, other):
7063 
    return not (self == other)
7064 
 
7065 
class getAllUserCommunications_result:
7066 
  """
7067 
  Attributes:
7068 
   - success
7069 
   - ucx
7070 
  """
7071 
 
7072 
  thrift_spec = (
7073 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
7074 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7075 
  )
7076 
 
7077 
  def __init__(self, success=None, ucx=None,):
7078 
    self.success = success
7079 
    self.ucx = ucx
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 == 0:
7091 
        if ftype == TType.LIST:
7092 
          self.success = []
1976 varun.gupt 7093 
          (_etype52, _size49) = iprot.readListBegin()
7094 
          for _i53 in xrange(_size49):
7095 
            _elem54 = UserCommunication()
7096 
            _elem54.read(iprot)
7097 
            self.success.append(_elem54)
1590 varun.gupt 7098 
          iprot.readListEnd()
7099 
        else:
7100 
          iprot.skip(ftype)
7101 
      elif fid == 1:
7102 
        if ftype == TType.STRUCT:
7103 
          self.ucx = UserCommunicationException()
7104 
          self.ucx.read(iprot)
7105 
        else:
7106 
          iprot.skip(ftype)
7107 
      else:
7108 
        iprot.skip(ftype)
7109 
      iprot.readFieldEnd()
7110 
    iprot.readStructEnd()
7111 
 
7112 
  def write(self, oprot):
7113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7115 
      return
7116 
    oprot.writeStructBegin('getAllUserCommunications_result')
7117 
    if self.success != None:
7118 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7119 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 7120 
      for iter55 in self.success:
7121 
        iter55.write(oprot)
1590 varun.gupt 7122 
      oprot.writeListEnd()
7123 
      oprot.writeFieldEnd()
7124 
    if self.ucx != None:
7125 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7126 
      self.ucx.write(oprot)
7127 
      oprot.writeFieldEnd()
7128 
    oprot.writeFieldStop()
7129 
    oprot.writeStructEnd()
7130 
 
7131 
  def __repr__(self):
7132 
    L = ['%s=%r' % (key, value)
7133 
      for key, value in self.__dict__.iteritems()]
7134 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7135 
 
7136 
  def __eq__(self, other):
7137 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7138 
 
7139 
  def __ne__(self, other):
7140 
    return not (self == other)
7141 
 
1845 vikas 7142 
class createMasterAffiliate_args:
7143 
  """
7144 
  Attributes:
7145 
   - name
1859 vikas 7146 
   - addedOn
1845 vikas 7147 
  """
7148 
 
7149 
  thrift_spec = (
7150 
    None, # 0
7151 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 7152 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 7153 
  )
7154 
 
1859 vikas 7155 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 7156 
    self.name = name
1859 vikas 7157 
    self.addedOn = addedOn
1845 vikas 7158 
 
7159 
  def read(self, iprot):
7160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7162 
      return
7163 
    iprot.readStructBegin()
7164 
    while True:
7165 
      (fname, ftype, fid) = iprot.readFieldBegin()
7166 
      if ftype == TType.STOP:
7167 
        break
7168 
      if fid == 1:
7169 
        if ftype == TType.STRING:
7170 
          self.name = iprot.readString();
7171 
        else:
7172 
          iprot.skip(ftype)
1859 vikas 7173 
      elif fid == 2:
7174 
        if ftype == TType.I64:
7175 
          self.addedOn = iprot.readI64();
7176 
        else:
7177 
          iprot.skip(ftype)
1845 vikas 7178 
      else:
7179 
        iprot.skip(ftype)
7180 
      iprot.readFieldEnd()
7181 
    iprot.readStructEnd()
7182 
 
7183 
  def write(self, oprot):
7184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7186 
      return
7187 
    oprot.writeStructBegin('createMasterAffiliate_args')
7188 
    if self.name != None:
7189 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7190 
      oprot.writeString(self.name)
7191 
      oprot.writeFieldEnd()
1859 vikas 7192 
    if self.addedOn != None:
7193 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
7194 
      oprot.writeI64(self.addedOn)
7195 
      oprot.writeFieldEnd()
1845 vikas 7196 
    oprot.writeFieldStop()
7197 
    oprot.writeStructEnd()
7198 
 
7199 
  def __repr__(self):
7200 
    L = ['%s=%r' % (key, value)
7201 
      for key, value in self.__dict__.iteritems()]
7202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7203 
 
7204 
  def __eq__(self, other):
7205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7206 
 
7207 
  def __ne__(self, other):
7208 
    return not (self == other)
7209 
 
7210 
class createMasterAffiliate_result:
7211 
  """
7212 
  Attributes:
7213 
   - success
7214 
   - utx
7215 
  """
7216 
 
7217 
  thrift_spec = (
7218 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
7219 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7220 
  )
7221 
 
7222 
  def __init__(self, success=None, utx=None,):
7223 
    self.success = success
7224 
    self.utx = utx
7225 
 
7226 
  def read(self, iprot):
7227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7229 
      return
7230 
    iprot.readStructBegin()
7231 
    while True:
7232 
      (fname, ftype, fid) = iprot.readFieldBegin()
7233 
      if ftype == TType.STOP:
7234 
        break
7235 
      if fid == 0:
7236 
        if ftype == TType.STRUCT:
7237 
          self.success = MasterAffiliate()
7238 
          self.success.read(iprot)
7239 
        else:
7240 
          iprot.skip(ftype)
7241 
      elif fid == 1:
7242 
        if ftype == TType.STRUCT:
7243 
          self.utx = UserTrackerException()
7244 
          self.utx.read(iprot)
7245 
        else:
7246 
          iprot.skip(ftype)
7247 
      else:
7248 
        iprot.skip(ftype)
7249 
      iprot.readFieldEnd()
7250 
    iprot.readStructEnd()
7251 
 
7252 
  def write(self, oprot):
7253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7255 
      return
7256 
    oprot.writeStructBegin('createMasterAffiliate_result')
7257 
    if self.success != None:
7258 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7259 
      self.success.write(oprot)
7260 
      oprot.writeFieldEnd()
7261 
    if self.utx != None:
7262 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7263 
      self.utx.write(oprot)
7264 
      oprot.writeFieldEnd()
7265 
    oprot.writeFieldStop()
7266 
    oprot.writeStructEnd()
7267 
 
7268 
  def __repr__(self):
7269 
    L = ['%s=%r' % (key, value)
7270 
      for key, value in self.__dict__.iteritems()]
7271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7272 
 
7273 
  def __eq__(self, other):
7274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7275 
 
7276 
  def __ne__(self, other):
7277 
    return not (self == other)
7278 
 
1899 vikas 7279 
class getAllMasterAffiliates_args:
7280 
 
7281 
  thrift_spec = (
7282 
  )
7283 
 
7284 
  def read(self, iprot):
7285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7287 
      return
7288 
    iprot.readStructBegin()
7289 
    while True:
7290 
      (fname, ftype, fid) = iprot.readFieldBegin()
7291 
      if ftype == TType.STOP:
7292 
        break
7293 
      else:
7294 
        iprot.skip(ftype)
7295 
      iprot.readFieldEnd()
7296 
    iprot.readStructEnd()
7297 
 
7298 
  def write(self, oprot):
7299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7301 
      return
7302 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
7303 
    oprot.writeFieldStop()
7304 
    oprot.writeStructEnd()
7305 
 
7306 
  def __repr__(self):
7307 
    L = ['%s=%r' % (key, value)
7308 
      for key, value in self.__dict__.iteritems()]
7309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7310 
 
7311 
  def __eq__(self, other):
7312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7313 
 
7314 
  def __ne__(self, other):
7315 
    return not (self == other)
7316 
 
7317 
class getAllMasterAffiliates_result:
7318 
  """
7319 
  Attributes:
7320 
   - success
7321 
   - utx
7322 
  """
7323 
 
7324 
  thrift_spec = (
7325 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
7326 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7327 
  )
7328 
 
7329 
  def __init__(self, success=None, utx=None,):
7330 
    self.success = success
7331 
    self.utx = utx
7332 
 
7333 
  def read(self, iprot):
7334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7336 
      return
7337 
    iprot.readStructBegin()
7338 
    while True:
7339 
      (fname, ftype, fid) = iprot.readFieldBegin()
7340 
      if ftype == TType.STOP:
7341 
        break
7342 
      if fid == 0:
7343 
        if ftype == TType.LIST:
7344 
          self.success = []
1976 varun.gupt 7345 
          (_etype59, _size56) = iprot.readListBegin()
7346 
          for _i60 in xrange(_size56):
7347 
            _elem61 = MasterAffiliate()
7348 
            _elem61.read(iprot)
7349 
            self.success.append(_elem61)
1899 vikas 7350 
          iprot.readListEnd()
7351 
        else:
7352 
          iprot.skip(ftype)
7353 
      elif fid == 1:
7354 
        if ftype == TType.STRUCT:
7355 
          self.utx = UserTrackerException()
7356 
          self.utx.read(iprot)
7357 
        else:
7358 
          iprot.skip(ftype)
7359 
      else:
7360 
        iprot.skip(ftype)
7361 
      iprot.readFieldEnd()
7362 
    iprot.readStructEnd()
7363 
 
7364 
  def write(self, oprot):
7365 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7366 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7367 
      return
7368 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
7369 
    if self.success != None:
7370 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7371 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 7372 
      for iter62 in self.success:
7373 
        iter62.write(oprot)
1899 vikas 7374 
      oprot.writeListEnd()
7375 
      oprot.writeFieldEnd()
7376 
    if self.utx != None:
7377 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7378 
      self.utx.write(oprot)
7379 
      oprot.writeFieldEnd()
7380 
    oprot.writeFieldStop()
7381 
    oprot.writeStructEnd()
7382 
 
7383 
  def __repr__(self):
7384 
    L = ['%s=%r' % (key, value)
7385 
      for key, value in self.__dict__.iteritems()]
7386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7387 
 
7388 
  def __eq__(self, other):
7389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7390 
 
7391 
  def __ne__(self, other):
7392 
    return not (self == other)
7393 
 
1845 vikas 7394 
class getMasterAffiliateById_args:
7395 
  """
7396 
  Attributes:
7397 
   - id
7398 
  """
7399 
 
7400 
  thrift_spec = (
7401 
    None, # 0
7402 
    (1, TType.I64, 'id', None, None, ), # 1
7403 
  )
7404 
 
7405 
  def __init__(self, id=None,):
7406 
    self.id = id
7407 
 
7408 
  def read(self, iprot):
7409 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7410 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7411 
      return
7412 
    iprot.readStructBegin()
7413 
    while True:
7414 
      (fname, ftype, fid) = iprot.readFieldBegin()
7415 
      if ftype == TType.STOP:
7416 
        break
7417 
      if fid == 1:
7418 
        if ftype == TType.I64:
7419 
          self.id = iprot.readI64();
7420 
        else:
7421 
          iprot.skip(ftype)
7422 
      else:
7423 
        iprot.skip(ftype)
7424 
      iprot.readFieldEnd()
7425 
    iprot.readStructEnd()
7426 
 
7427 
  def write(self, oprot):
7428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7430 
      return
7431 
    oprot.writeStructBegin('getMasterAffiliateById_args')
7432 
    if self.id != None:
7433 
      oprot.writeFieldBegin('id', TType.I64, 1)
7434 
      oprot.writeI64(self.id)
7435 
      oprot.writeFieldEnd()
7436 
    oprot.writeFieldStop()
7437 
    oprot.writeStructEnd()
7438 
 
7439 
  def __repr__(self):
7440 
    L = ['%s=%r' % (key, value)
7441 
      for key, value in self.__dict__.iteritems()]
7442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7443 
 
7444 
  def __eq__(self, other):
7445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7446 
 
7447 
  def __ne__(self, other):
7448 
    return not (self == other)
7449 
 
7450 
class getMasterAffiliateById_result:
7451 
  """
7452 
  Attributes:
7453 
   - success
7454 
   - utx
7455 
  """
7456 
 
7457 
  thrift_spec = (
7458 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
7459 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7460 
  )
7461 
 
7462 
  def __init__(self, success=None, utx=None,):
7463 
    self.success = success
7464 
    self.utx = utx
7465 
 
7466 
  def read(self, iprot):
7467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7469 
      return
7470 
    iprot.readStructBegin()
7471 
    while True:
7472 
      (fname, ftype, fid) = iprot.readFieldBegin()
7473 
      if ftype == TType.STOP:
7474 
        break
7475 
      if fid == 0:
7476 
        if ftype == TType.STRUCT:
7477 
          self.success = MasterAffiliate()
7478 
          self.success.read(iprot)
7479 
        else:
7480 
          iprot.skip(ftype)
7481 
      elif fid == 1:
7482 
        if ftype == TType.STRUCT:
7483 
          self.utx = UserTrackerException()
7484 
          self.utx.read(iprot)
7485 
        else:
7486 
          iprot.skip(ftype)
7487 
      else:
7488 
        iprot.skip(ftype)
7489 
      iprot.readFieldEnd()
7490 
    iprot.readStructEnd()
7491 
 
7492 
  def write(self, oprot):
7493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7495 
      return
7496 
    oprot.writeStructBegin('getMasterAffiliateById_result')
7497 
    if self.success != None:
7498 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7499 
      self.success.write(oprot)
7500 
      oprot.writeFieldEnd()
7501 
    if self.utx != None:
7502 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7503 
      self.utx.write(oprot)
7504 
      oprot.writeFieldEnd()
7505 
    oprot.writeFieldStop()
7506 
    oprot.writeStructEnd()
7507 
 
7508 
  def __repr__(self):
7509 
    L = ['%s=%r' % (key, value)
7510 
      for key, value in self.__dict__.iteritems()]
7511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7512 
 
7513 
  def __eq__(self, other):
7514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7515 
 
7516 
  def __ne__(self, other):
7517 
    return not (self == other)
7518 
 
7519 
class getMasterAffiliateByName_args:
7520 
  """
7521 
  Attributes:
7522 
   - name
7523 
  """
7524 
 
7525 
  thrift_spec = (
7526 
    None, # 0
7527 
    (1, TType.STRING, 'name', None, None, ), # 1
7528 
  )
7529 
 
7530 
  def __init__(self, name=None,):
7531 
    self.name = name
7532 
 
7533 
  def read(self, iprot):
7534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7536 
      return
7537 
    iprot.readStructBegin()
7538 
    while True:
7539 
      (fname, ftype, fid) = iprot.readFieldBegin()
7540 
      if ftype == TType.STOP:
7541 
        break
7542 
      if fid == 1:
7543 
        if ftype == TType.STRING:
7544 
          self.name = iprot.readString();
7545 
        else:
7546 
          iprot.skip(ftype)
7547 
      else:
7548 
        iprot.skip(ftype)
7549 
      iprot.readFieldEnd()
7550 
    iprot.readStructEnd()
7551 
 
7552 
  def write(self, oprot):
7553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7555 
      return
7556 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
7557 
    if self.name != None:
7558 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7559 
      oprot.writeString(self.name)
7560 
      oprot.writeFieldEnd()
7561 
    oprot.writeFieldStop()
7562 
    oprot.writeStructEnd()
7563 
 
7564 
  def __repr__(self):
7565 
    L = ['%s=%r' % (key, value)
7566 
      for key, value in self.__dict__.iteritems()]
7567 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7568 
 
7569 
  def __eq__(self, other):
7570 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7571 
 
7572 
  def __ne__(self, other):
7573 
    return not (self == other)
7574 
 
7575 
class getMasterAffiliateByName_result:
7576 
  """
7577 
  Attributes:
7578 
   - success
7579 
   - utx
7580 
  """
7581 
 
7582 
  thrift_spec = (
7583 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
7584 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7585 
  )
7586 
 
7587 
  def __init__(self, success=None, utx=None,):
7588 
    self.success = success
7589 
    self.utx = utx
7590 
 
7591 
  def read(self, iprot):
7592 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7593 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7594 
      return
7595 
    iprot.readStructBegin()
7596 
    while True:
7597 
      (fname, ftype, fid) = iprot.readFieldBegin()
7598 
      if ftype == TType.STOP:
7599 
        break
7600 
      if fid == 0:
7601 
        if ftype == TType.STRUCT:
7602 
          self.success = MasterAffiliate()
7603 
          self.success.read(iprot)
7604 
        else:
7605 
          iprot.skip(ftype)
7606 
      elif fid == 1:
7607 
        if ftype == TType.STRUCT:
7608 
          self.utx = UserTrackerException()
7609 
          self.utx.read(iprot)
7610 
        else:
7611 
          iprot.skip(ftype)
7612 
      else:
7613 
        iprot.skip(ftype)
7614 
      iprot.readFieldEnd()
7615 
    iprot.readStructEnd()
7616 
 
7617 
  def write(self, oprot):
7618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7620 
      return
7621 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
7622 
    if self.success != None:
7623 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7624 
      self.success.write(oprot)
7625 
      oprot.writeFieldEnd()
7626 
    if self.utx != None:
7627 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7628 
      self.utx.write(oprot)
7629 
      oprot.writeFieldEnd()
7630 
    oprot.writeFieldStop()
7631 
    oprot.writeStructEnd()
7632 
 
7633 
  def __repr__(self):
7634 
    L = ['%s=%r' % (key, value)
7635 
      for key, value in self.__dict__.iteritems()]
7636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7637 
 
7638 
  def __eq__(self, other):
7639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7640 
 
7641 
  def __ne__(self, other):
7642 
    return not (self == other)
7643 
 
7644 
class createAffiliate_args:
7645 
  """
7646 
  Attributes:
7647 
   - name
7648 
   - url
7649 
   - masterAffiliateId
1859 vikas 7650 
   - addedOn
1845 vikas 7651 
  """
7652 
 
7653 
  thrift_spec = (
7654 
    None, # 0
7655 
    (1, TType.STRING, 'name', None, None, ), # 1
7656 
    (2, TType.STRING, 'url', None, None, ), # 2
7657 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 7658 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 7659 
  )
7660 
 
1859 vikas 7661 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 7662 
    self.name = name
7663 
    self.url = url
7664 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 7665 
    self.addedOn = addedOn
1845 vikas 7666 
 
7667 
  def read(self, iprot):
7668 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7669 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7670 
      return
7671 
    iprot.readStructBegin()
7672 
    while True:
7673 
      (fname, ftype, fid) = iprot.readFieldBegin()
7674 
      if ftype == TType.STOP:
7675 
        break
7676 
      if fid == 1:
7677 
        if ftype == TType.STRING:
7678 
          self.name = iprot.readString();
7679 
        else:
7680 
          iprot.skip(ftype)
7681 
      elif fid == 2:
7682 
        if ftype == TType.STRING:
7683 
          self.url = iprot.readString();
7684 
        else:
7685 
          iprot.skip(ftype)
7686 
      elif fid == 3:
7687 
        if ftype == TType.I64:
7688 
          self.masterAffiliateId = iprot.readI64();
7689 
        else:
7690 
          iprot.skip(ftype)
1859 vikas 7691 
      elif fid == 4:
7692 
        if ftype == TType.I64:
7693 
          self.addedOn = iprot.readI64();
7694 
        else:
7695 
          iprot.skip(ftype)
1845 vikas 7696 
      else:
7697 
        iprot.skip(ftype)
7698 
      iprot.readFieldEnd()
7699 
    iprot.readStructEnd()
7700 
 
7701 
  def write(self, oprot):
7702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7704 
      return
7705 
    oprot.writeStructBegin('createAffiliate_args')
7706 
    if self.name != None:
7707 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7708 
      oprot.writeString(self.name)
7709 
      oprot.writeFieldEnd()
7710 
    if self.url != None:
7711 
      oprot.writeFieldBegin('url', TType.STRING, 2)
7712 
      oprot.writeString(self.url)
7713 
      oprot.writeFieldEnd()
7714 
    if self.masterAffiliateId != None:
7715 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
7716 
      oprot.writeI64(self.masterAffiliateId)
7717 
      oprot.writeFieldEnd()
1859 vikas 7718 
    if self.addedOn != None:
7719 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
7720 
      oprot.writeI64(self.addedOn)
7721 
      oprot.writeFieldEnd()
1845 vikas 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 createAffiliate_result:
7737 
  """
7738 
  Attributes:
7739 
   - success
7740 
   - utx
7741 
  """
7742 
 
7743 
  thrift_spec = (
7744 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
7745 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7746 
  )
7747 
 
7748 
  def __init__(self, success=None, utx=None,):
7749 
    self.success = success
7750 
    self.utx = utx
7751 
 
7752 
  def read(self, iprot):
7753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7755 
      return
7756 
    iprot.readStructBegin()
7757 
    while True:
7758 
      (fname, ftype, fid) = iprot.readFieldBegin()
7759 
      if ftype == TType.STOP:
7760 
        break
7761 
      if fid == 0:
7762 
        if ftype == TType.STRUCT:
7763 
          self.success = Affiliate()
7764 
          self.success.read(iprot)
7765 
        else:
7766 
          iprot.skip(ftype)
7767 
      elif fid == 1:
7768 
        if ftype == TType.STRUCT:
7769 
          self.utx = UserTrackerException()
7770 
          self.utx.read(iprot)
7771 
        else:
7772 
          iprot.skip(ftype)
7773 
      else:
7774 
        iprot.skip(ftype)
7775 
      iprot.readFieldEnd()
7776 
    iprot.readStructEnd()
7777 
 
7778 
  def write(self, oprot):
7779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7781 
      return
7782 
    oprot.writeStructBegin('createAffiliate_result')
7783 
    if self.success != None:
7784 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7785 
      self.success.write(oprot)
7786 
      oprot.writeFieldEnd()
7787 
    if self.utx != None:
7788 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7789 
      self.utx.write(oprot)
7790 
      oprot.writeFieldEnd()
7791 
    oprot.writeFieldStop()
7792 
    oprot.writeStructEnd()
7793 
 
7794 
  def __repr__(self):
7795 
    L = ['%s=%r' % (key, value)
7796 
      for key, value in self.__dict__.iteritems()]
7797 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7798 
 
7799 
  def __eq__(self, other):
7800 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7801 
 
7802 
  def __ne__(self, other):
7803 
    return not (self == other)
7804 
 
7805 
class getAffiliateById_args:
7806 
  """
7807 
  Attributes:
7808 
   - id
7809 
  """
7810 
 
7811 
  thrift_spec = (
7812 
    None, # 0
7813 
    (1, TType.I64, 'id', None, None, ), # 1
7814 
  )
7815 
 
7816 
  def __init__(self, id=None,):
7817 
    self.id = id
7818 
 
7819 
  def read(self, iprot):
7820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7822 
      return
7823 
    iprot.readStructBegin()
7824 
    while True:
7825 
      (fname, ftype, fid) = iprot.readFieldBegin()
7826 
      if ftype == TType.STOP:
7827 
        break
7828 
      if fid == 1:
7829 
        if ftype == TType.I64:
7830 
          self.id = iprot.readI64();
7831 
        else:
7832 
          iprot.skip(ftype)
7833 
      else:
7834 
        iprot.skip(ftype)
7835 
      iprot.readFieldEnd()
7836 
    iprot.readStructEnd()
7837 
 
7838 
  def write(self, oprot):
7839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7841 
      return
7842 
    oprot.writeStructBegin('getAffiliateById_args')
7843 
    if self.id != None:
7844 
      oprot.writeFieldBegin('id', TType.I64, 1)
7845 
      oprot.writeI64(self.id)
7846 
      oprot.writeFieldEnd()
7847 
    oprot.writeFieldStop()
7848 
    oprot.writeStructEnd()
7849 
 
7850 
  def __repr__(self):
7851 
    L = ['%s=%r' % (key, value)
7852 
      for key, value in self.__dict__.iteritems()]
7853 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7854 
 
7855 
  def __eq__(self, other):
7856 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7857 
 
7858 
  def __ne__(self, other):
7859 
    return not (self == other)
7860 
 
7861 
class getAffiliateById_result:
7862 
  """
7863 
  Attributes:
7864 
   - success
7865 
   - utx
7866 
  """
7867 
 
7868 
  thrift_spec = (
7869 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
7870 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7871 
  )
7872 
 
7873 
  def __init__(self, success=None, utx=None,):
7874 
    self.success = success
7875 
    self.utx = utx
7876 
 
7877 
  def read(self, iprot):
7878 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7879 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7880 
      return
7881 
    iprot.readStructBegin()
7882 
    while True:
7883 
      (fname, ftype, fid) = iprot.readFieldBegin()
7884 
      if ftype == TType.STOP:
7885 
        break
7886 
      if fid == 0:
7887 
        if ftype == TType.STRUCT:
7888 
          self.success = Affiliate()
7889 
          self.success.read(iprot)
7890 
        else:
7891 
          iprot.skip(ftype)
7892 
      elif fid == 1:
7893 
        if ftype == TType.STRUCT:
7894 
          self.utx = UserTrackerException()
7895 
          self.utx.read(iprot)
7896 
        else:
7897 
          iprot.skip(ftype)
7898 
      else:
7899 
        iprot.skip(ftype)
7900 
      iprot.readFieldEnd()
7901 
    iprot.readStructEnd()
7902 
 
7903 
  def write(self, oprot):
7904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7906 
      return
7907 
    oprot.writeStructBegin('getAffiliateById_result')
7908 
    if self.success != None:
7909 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7910 
      self.success.write(oprot)
7911 
      oprot.writeFieldEnd()
7912 
    if self.utx != None:
7913 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7914 
      self.utx.write(oprot)
7915 
      oprot.writeFieldEnd()
7916 
    oprot.writeFieldStop()
7917 
    oprot.writeStructEnd()
7918 
 
7919 
  def __repr__(self):
7920 
    L = ['%s=%r' % (key, value)
7921 
      for key, value in self.__dict__.iteritems()]
7922 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7923 
 
7924 
  def __eq__(self, other):
7925 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7926 
 
7927 
  def __ne__(self, other):
7928 
    return not (self == other)
7929 
 
7930 
class getAffiliateByName_args:
7931 
  """
7932 
  Attributes:
7933 
   - name
7934 
  """
7935 
 
7936 
  thrift_spec = (
7937 
    None, # 0
7938 
    (1, TType.STRING, 'name', None, None, ), # 1
7939 
  )
7940 
 
7941 
  def __init__(self, name=None,):
7942 
    self.name = name
7943 
 
7944 
  def read(self, iprot):
7945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7947 
      return
7948 
    iprot.readStructBegin()
7949 
    while True:
7950 
      (fname, ftype, fid) = iprot.readFieldBegin()
7951 
      if ftype == TType.STOP:
7952 
        break
7953 
      if fid == 1:
7954 
        if ftype == TType.STRING:
7955 
          self.name = iprot.readString();
7956 
        else:
7957 
          iprot.skip(ftype)
7958 
      else:
7959 
        iprot.skip(ftype)
7960 
      iprot.readFieldEnd()
7961 
    iprot.readStructEnd()
7962 
 
7963 
  def write(self, oprot):
7964 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7965 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7966 
      return
7967 
    oprot.writeStructBegin('getAffiliateByName_args')
7968 
    if self.name != None:
7969 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7970 
      oprot.writeString(self.name)
7971 
      oprot.writeFieldEnd()
7972 
    oprot.writeFieldStop()
7973 
    oprot.writeStructEnd()
7974 
 
7975 
  def __repr__(self):
7976 
    L = ['%s=%r' % (key, value)
7977 
      for key, value in self.__dict__.iteritems()]
7978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7979 
 
7980 
  def __eq__(self, other):
7981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7982 
 
7983 
  def __ne__(self, other):
7984 
    return not (self == other)
7985 
 
7986 
class getAffiliateByName_result:
7987 
  """
7988 
  Attributes:
7989 
   - success
7990 
   - utx
7991 
  """
7992 
 
7993 
  thrift_spec = (
7994 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
7995 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7996 
  )
7997 
 
7998 
  def __init__(self, success=None, utx=None,):
7999 
    self.success = success
8000 
    self.utx = utx
8001 
 
8002 
  def read(self, iprot):
8003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8005 
      return
8006 
    iprot.readStructBegin()
8007 
    while True:
8008 
      (fname, ftype, fid) = iprot.readFieldBegin()
8009 
      if ftype == TType.STOP:
8010 
        break
8011 
      if fid == 0:
8012 
        if ftype == TType.STRUCT:
8013 
          self.success = Affiliate()
8014 
          self.success.read(iprot)
8015 
        else:
8016 
          iprot.skip(ftype)
8017 
      elif fid == 1:
8018 
        if ftype == TType.STRUCT:
8019 
          self.utx = UserTrackerException()
8020 
          self.utx.read(iprot)
8021 
        else:
8022 
          iprot.skip(ftype)
8023 
      else:
8024 
        iprot.skip(ftype)
8025 
      iprot.readFieldEnd()
8026 
    iprot.readStructEnd()
8027 
 
8028 
  def write(self, oprot):
8029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8031 
      return
8032 
    oprot.writeStructBegin('getAffiliateByName_result')
8033 
    if self.success != None:
8034 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8035 
      self.success.write(oprot)
8036 
      oprot.writeFieldEnd()
8037 
    if self.utx != None:
8038 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8039 
      self.utx.write(oprot)
8040 
      oprot.writeFieldEnd()
8041 
    oprot.writeFieldStop()
8042 
    oprot.writeStructEnd()
8043 
 
8044 
  def __repr__(self):
8045 
    L = ['%s=%r' % (key, value)
8046 
      for key, value in self.__dict__.iteritems()]
8047 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8048 
 
8049 
  def __eq__(self, other):
8050 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8051 
 
8052 
  def __ne__(self, other):
8053 
    return not (self == other)
8054 
 
8055 
class getAffiliatesByMasterAffiliate_args:
8056 
  """
8057 
  Attributes:
8058 
   - id
8059 
  """
8060 
 
8061 
  thrift_spec = (
8062 
    None, # 0
8063 
    (1, TType.I64, 'id', None, None, ), # 1
8064 
  )
8065 
 
8066 
  def __init__(self, id=None,):
8067 
    self.id = id
8068 
 
8069 
  def read(self, iprot):
8070 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8071 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8072 
      return
8073 
    iprot.readStructBegin()
8074 
    while True:
8075 
      (fname, ftype, fid) = iprot.readFieldBegin()
8076 
      if ftype == TType.STOP:
8077 
        break
8078 
      if fid == 1:
8079 
        if ftype == TType.I64:
8080 
          self.id = iprot.readI64();
8081 
        else:
8082 
          iprot.skip(ftype)
8083 
      else:
8084 
        iprot.skip(ftype)
8085 
      iprot.readFieldEnd()
8086 
    iprot.readStructEnd()
8087 
 
8088 
  def write(self, oprot):
8089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8091 
      return
8092 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
8093 
    if self.id != None:
8094 
      oprot.writeFieldBegin('id', TType.I64, 1)
8095 
      oprot.writeI64(self.id)
8096 
      oprot.writeFieldEnd()
8097 
    oprot.writeFieldStop()
8098 
    oprot.writeStructEnd()
8099 
 
8100 
  def __repr__(self):
8101 
    L = ['%s=%r' % (key, value)
8102 
      for key, value in self.__dict__.iteritems()]
8103 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8104 
 
8105 
  def __eq__(self, other):
8106 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8107 
 
8108 
  def __ne__(self, other):
8109 
    return not (self == other)
8110 
 
8111 
class getAffiliatesByMasterAffiliate_result:
8112 
  """
8113 
  Attributes:
8114 
   - success
8115 
   - utx
8116 
  """
8117 
 
8118 
  thrift_spec = (
8119 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
8120 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8121 
  )
8122 
 
8123 
  def __init__(self, success=None, utx=None,):
8124 
    self.success = success
8125 
    self.utx = utx
8126 
 
8127 
  def read(self, iprot):
8128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8130 
      return
8131 
    iprot.readStructBegin()
8132 
    while True:
8133 
      (fname, ftype, fid) = iprot.readFieldBegin()
8134 
      if ftype == TType.STOP:
8135 
        break
8136 
      if fid == 0:
8137 
        if ftype == TType.LIST:
8138 
          self.success = []
1976 varun.gupt 8139 
          (_etype66, _size63) = iprot.readListBegin()
8140 
          for _i67 in xrange(_size63):
8141 
            _elem68 = Affiliate()
8142 
            _elem68.read(iprot)
8143 
            self.success.append(_elem68)
1845 vikas 8144 
          iprot.readListEnd()
8145 
        else:
8146 
          iprot.skip(ftype)
8147 
      elif fid == 1:
8148 
        if ftype == TType.STRUCT:
8149 
          self.utx = UserTrackerException()
8150 
          self.utx.read(iprot)
8151 
        else:
8152 
          iprot.skip(ftype)
8153 
      else:
8154 
        iprot.skip(ftype)
8155 
      iprot.readFieldEnd()
8156 
    iprot.readStructEnd()
8157 
 
8158 
  def write(self, oprot):
8159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8161 
      return
8162 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
8163 
    if self.success != None:
8164 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8165 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 8166 
      for iter69 in self.success:
8167 
        iter69.write(oprot)
1845 vikas 8168 
      oprot.writeListEnd()
8169 
      oprot.writeFieldEnd()
8170 
    if self.utx != None:
8171 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8172 
      self.utx.write(oprot)
8173 
      oprot.writeFieldEnd()
8174 
    oprot.writeFieldStop()
8175 
    oprot.writeStructEnd()
8176 
 
8177 
  def __repr__(self):
8178 
    L = ['%s=%r' % (key, value)
8179 
      for key, value in self.__dict__.iteritems()]
8180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8181 
 
8182 
  def __eq__(self, other):
8183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8184 
 
8185 
  def __ne__(self, other):
8186 
    return not (self == other)
8187 
 
8188 
class createTracker_args:
8189 
  """
8190 
  Attributes:
8191 
   - affiliateId
1859 vikas 8192 
   - addedOn
1845 vikas 8193 
  """
8194 
 
8195 
  thrift_spec = (
8196 
    None, # 0
8197 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1859 vikas 8198 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 8199 
  )
8200 
 
1859 vikas 8201 
  def __init__(self, affiliateId=None, addedOn=None,):
1845 vikas 8202 
    self.affiliateId = affiliateId
1859 vikas 8203 
    self.addedOn = addedOn
1845 vikas 8204 
 
8205 
  def read(self, iprot):
8206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8208 
      return
8209 
    iprot.readStructBegin()
8210 
    while True:
8211 
      (fname, ftype, fid) = iprot.readFieldBegin()
8212 
      if ftype == TType.STOP:
8213 
        break
8214 
      if fid == 1:
8215 
        if ftype == TType.I64:
8216 
          self.affiliateId = iprot.readI64();
8217 
        else:
8218 
          iprot.skip(ftype)
1859 vikas 8219 
      elif fid == 2:
8220 
        if ftype == TType.I64:
8221 
          self.addedOn = iprot.readI64();
8222 
        else:
8223 
          iprot.skip(ftype)
1845 vikas 8224 
      else:
8225 
        iprot.skip(ftype)
8226 
      iprot.readFieldEnd()
8227 
    iprot.readStructEnd()
8228 
 
8229 
  def write(self, oprot):
8230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8232 
      return
8233 
    oprot.writeStructBegin('createTracker_args')
8234 
    if self.affiliateId != None:
8235 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
8236 
      oprot.writeI64(self.affiliateId)
8237 
      oprot.writeFieldEnd()
1859 vikas 8238 
    if self.addedOn != None:
8239 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
8240 
      oprot.writeI64(self.addedOn)
8241 
      oprot.writeFieldEnd()
1845 vikas 8242 
    oprot.writeFieldStop()
8243 
    oprot.writeStructEnd()
8244 
 
8245 
  def __repr__(self):
8246 
    L = ['%s=%r' % (key, value)
8247 
      for key, value in self.__dict__.iteritems()]
8248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8249 
 
8250 
  def __eq__(self, other):
8251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8252 
 
8253 
  def __ne__(self, other):
8254 
    return not (self == other)
8255 
 
8256 
class createTracker_result:
8257 
  """
8258 
  Attributes:
8259 
   - success
8260 
   - utx
8261 
  """
8262 
 
8263 
  thrift_spec = (
8264 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
8265 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8266 
  )
8267 
 
8268 
  def __init__(self, success=None, utx=None,):
8269 
    self.success = success
8270 
    self.utx = utx
8271 
 
8272 
  def read(self, iprot):
8273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8275 
      return
8276 
    iprot.readStructBegin()
8277 
    while True:
8278 
      (fname, ftype, fid) = iprot.readFieldBegin()
8279 
      if ftype == TType.STOP:
8280 
        break
8281 
      if fid == 0:
8282 
        if ftype == TType.STRUCT:
8283 
          self.success = Tracker()
8284 
          self.success.read(iprot)
8285 
        else:
8286 
          iprot.skip(ftype)
8287 
      elif fid == 1:
8288 
        if ftype == TType.STRUCT:
8289 
          self.utx = UserTrackerException()
8290 
          self.utx.read(iprot)
8291 
        else:
8292 
          iprot.skip(ftype)
8293 
      else:
8294 
        iprot.skip(ftype)
8295 
      iprot.readFieldEnd()
8296 
    iprot.readStructEnd()
8297 
 
8298 
  def write(self, oprot):
8299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8301 
      return
8302 
    oprot.writeStructBegin('createTracker_result')
8303 
    if self.success != None:
8304 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8305 
      self.success.write(oprot)
8306 
      oprot.writeFieldEnd()
8307 
    if self.utx != None:
8308 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8309 
      self.utx.write(oprot)
8310 
      oprot.writeFieldEnd()
8311 
    oprot.writeFieldStop()
8312 
    oprot.writeStructEnd()
8313 
 
8314 
  def __repr__(self):
8315 
    L = ['%s=%r' % (key, value)
8316 
      for key, value in self.__dict__.iteritems()]
8317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8318 
 
8319 
  def __eq__(self, other):
8320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8321 
 
8322 
  def __ne__(self, other):
8323 
    return not (self == other)
8324 
 
8325 
class getTrackerById_args:
8326 
  """
8327 
  Attributes:
8328 
   - trackerId
8329 
  """
8330 
 
8331 
  thrift_spec = (
8332 
    None, # 0
8333 
    (1, TType.I64, 'trackerId', None, None, ), # 1
8334 
  )
8335 
 
8336 
  def __init__(self, trackerId=None,):
8337 
    self.trackerId = trackerId
8338 
 
8339 
  def read(self, iprot):
8340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8342 
      return
8343 
    iprot.readStructBegin()
8344 
    while True:
8345 
      (fname, ftype, fid) = iprot.readFieldBegin()
8346 
      if ftype == TType.STOP:
8347 
        break
8348 
      if fid == 1:
8349 
        if ftype == TType.I64:
8350 
          self.trackerId = iprot.readI64();
8351 
        else:
8352 
          iprot.skip(ftype)
8353 
      else:
8354 
        iprot.skip(ftype)
8355 
      iprot.readFieldEnd()
8356 
    iprot.readStructEnd()
8357 
 
8358 
  def write(self, oprot):
8359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8361 
      return
8362 
    oprot.writeStructBegin('getTrackerById_args')
8363 
    if self.trackerId != None:
8364 
      oprot.writeFieldBegin('trackerId', TType.I64, 1)
8365 
      oprot.writeI64(self.trackerId)
8366 
      oprot.writeFieldEnd()
8367 
    oprot.writeFieldStop()
8368 
    oprot.writeStructEnd()
8369 
 
8370 
  def __repr__(self):
8371 
    L = ['%s=%r' % (key, value)
8372 
      for key, value in self.__dict__.iteritems()]
8373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8374 
 
8375 
  def __eq__(self, other):
8376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8377 
 
8378 
  def __ne__(self, other):
8379 
    return not (self == other)
8380 
 
8381 
class getTrackerById_result:
8382 
  """
8383 
  Attributes:
8384 
   - success
8385 
   - utx
8386 
  """
8387 
 
8388 
  thrift_spec = (
8389 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
8390 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8391 
  )
8392 
 
8393 
  def __init__(self, success=None, utx=None,):
8394 
    self.success = success
8395 
    self.utx = utx
8396 
 
8397 
  def read(self, iprot):
8398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8400 
      return
8401 
    iprot.readStructBegin()
8402 
    while True:
8403 
      (fname, ftype, fid) = iprot.readFieldBegin()
8404 
      if ftype == TType.STOP:
8405 
        break
8406 
      if fid == 0:
8407 
        if ftype == TType.STRUCT:
8408 
          self.success = Tracker()
8409 
          self.success.read(iprot)
8410 
        else:
8411 
          iprot.skip(ftype)
8412 
      elif fid == 1:
8413 
        if ftype == TType.STRUCT:
8414 
          self.utx = UserTrackerException()
8415 
          self.utx.read(iprot)
8416 
        else:
8417 
          iprot.skip(ftype)
8418 
      else:
8419 
        iprot.skip(ftype)
8420 
      iprot.readFieldEnd()
8421 
    iprot.readStructEnd()
8422 
 
8423 
  def write(self, oprot):
8424 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8425 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8426 
      return
8427 
    oprot.writeStructBegin('getTrackerById_result')
8428 
    if self.success != None:
8429 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8430 
      self.success.write(oprot)
8431 
      oprot.writeFieldEnd()
8432 
    if self.utx != None:
8433 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8434 
      self.utx.write(oprot)
8435 
      oprot.writeFieldEnd()
8436 
    oprot.writeFieldStop()
8437 
    oprot.writeStructEnd()
8438 
 
8439 
  def __repr__(self):
8440 
    L = ['%s=%r' % (key, value)
8441 
      for key, value in self.__dict__.iteritems()]
8442 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8443 
 
8444 
  def __eq__(self, other):
8445 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8446 
 
8447 
  def __ne__(self, other):
8448 
    return not (self == other)
8449 
 
8450 
class getTrackersByAffiliate_args:
8451 
  """
8452 
  Attributes:
8453 
   - affiliateId
8454 
  """
8455 
 
8456 
  thrift_spec = (
8457 
    None, # 0
8458 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
8459 
  )
8460 
 
8461 
  def __init__(self, affiliateId=None,):
8462 
    self.affiliateId = affiliateId
8463 
 
8464 
  def read(self, iprot):
8465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8467 
      return
8468 
    iprot.readStructBegin()
8469 
    while True:
8470 
      (fname, ftype, fid) = iprot.readFieldBegin()
8471 
      if ftype == TType.STOP:
8472 
        break
8473 
      if fid == 1:
8474 
        if ftype == TType.I64:
8475 
          self.affiliateId = iprot.readI64();
8476 
        else:
8477 
          iprot.skip(ftype)
8478 
      else:
8479 
        iprot.skip(ftype)
8480 
      iprot.readFieldEnd()
8481 
    iprot.readStructEnd()
8482 
 
8483 
  def write(self, oprot):
8484 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8485 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8486 
      return
8487 
    oprot.writeStructBegin('getTrackersByAffiliate_args')
8488 
    if self.affiliateId != None:
8489 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
8490 
      oprot.writeI64(self.affiliateId)
8491 
      oprot.writeFieldEnd()
8492 
    oprot.writeFieldStop()
8493 
    oprot.writeStructEnd()
8494 
 
8495 
  def __repr__(self):
8496 
    L = ['%s=%r' % (key, value)
8497 
      for key, value in self.__dict__.iteritems()]
8498 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8499 
 
8500 
  def __eq__(self, other):
8501 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8502 
 
8503 
  def __ne__(self, other):
8504 
    return not (self == other)
8505 
 
8506 
class getTrackersByAffiliate_result:
8507 
  """
8508 
  Attributes:
8509 
   - success
8510 
   - utx
8511 
  """
8512 
 
8513 
  thrift_spec = (
8514 
    (0, TType.LIST, 'success', (TType.STRUCT,(Tracker, Tracker.thrift_spec)), None, ), # 0
8515 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8516 
  )
8517 
 
8518 
  def __init__(self, success=None, utx=None,):
8519 
    self.success = success
8520 
    self.utx = utx
8521 
 
8522 
  def read(self, iprot):
8523 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8524 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8525 
      return
8526 
    iprot.readStructBegin()
8527 
    while True:
8528 
      (fname, ftype, fid) = iprot.readFieldBegin()
8529 
      if ftype == TType.STOP:
8530 
        break
8531 
      if fid == 0:
8532 
        if ftype == TType.LIST:
8533 
          self.success = []
1976 varun.gupt 8534 
          (_etype73, _size70) = iprot.readListBegin()
8535 
          for _i74 in xrange(_size70):
8536 
            _elem75 = Tracker()
8537 
            _elem75.read(iprot)
8538 
            self.success.append(_elem75)
1845 vikas 8539 
          iprot.readListEnd()
8540 
        else:
8541 
          iprot.skip(ftype)
8542 
      elif fid == 1:
8543 
        if ftype == TType.STRUCT:
8544 
          self.utx = UserTrackerException()
8545 
          self.utx.read(iprot)
8546 
        else:
8547 
          iprot.skip(ftype)
8548 
      else:
8549 
        iprot.skip(ftype)
8550 
      iprot.readFieldEnd()
8551 
    iprot.readStructEnd()
8552 
 
8553 
  def write(self, oprot):
8554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8556 
      return
8557 
    oprot.writeStructBegin('getTrackersByAffiliate_result')
8558 
    if self.success != None:
8559 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8560 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 8561 
      for iter76 in self.success:
8562 
        iter76.write(oprot)
1845 vikas 8563 
      oprot.writeListEnd()
8564 
      oprot.writeFieldEnd()
8565 
    if self.utx != None:
8566 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8567 
      self.utx.write(oprot)
8568 
      oprot.writeFieldEnd()
8569 
    oprot.writeFieldStop()
8570 
    oprot.writeStructEnd()
8571 
 
8572 
  def __repr__(self):
8573 
    L = ['%s=%r' % (key, value)
8574 
      for key, value in self.__dict__.iteritems()]
8575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8576 
 
8577 
  def __eq__(self, other):
8578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8579 
 
8580 
  def __ne__(self, other):
8581 
    return not (self == other)
8582 
 
8583 
class addTrackLog_args:
8584 
  """
8585 
  Attributes:
8586 
   - trackerId
8587 
   - userId
8588 
   - event
8589 
   - url
8590 
   - data
1859 vikas 8591 
   - addedOn
1845 vikas 8592 
  """
8593 
 
8594 
  thrift_spec = (
8595 
    None, # 0
8596 
    (1, TType.I64, 'trackerId', None, None, ), # 1
8597 
    (2, TType.I64, 'userId', None, None, ), # 2
8598 
    (3, TType.STRING, 'event', None, None, ), # 3
8599 
    (4, TType.STRING, 'url', None, None, ), # 4
8600 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 8601 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 8602 
  )
8603 
 
1859 vikas 8604 
  def __init__(self, trackerId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
1845 vikas 8605 
    self.trackerId = trackerId
8606 
    self.userId = userId
8607 
    self.event = event
8608 
    self.url = url
8609 
    self.data = data
1859 vikas 8610 
    self.addedOn = addedOn
1845 vikas 8611 
 
8612 
  def read(self, iprot):
8613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8615 
      return
8616 
    iprot.readStructBegin()
8617 
    while True:
8618 
      (fname, ftype, fid) = iprot.readFieldBegin()
8619 
      if ftype == TType.STOP:
8620 
        break
8621 
      if fid == 1:
8622 
        if ftype == TType.I64:
8623 
          self.trackerId = iprot.readI64();
8624 
        else:
8625 
          iprot.skip(ftype)
8626 
      elif fid == 2:
8627 
        if ftype == TType.I64:
8628 
          self.userId = iprot.readI64();
8629 
        else:
8630 
          iprot.skip(ftype)
8631 
      elif fid == 3:
8632 
        if ftype == TType.STRING:
8633 
          self.event = iprot.readString();
8634 
        else:
8635 
          iprot.skip(ftype)
8636 
      elif fid == 4:
8637 
        if ftype == TType.STRING:
8638 
          self.url = iprot.readString();
8639 
        else:
8640 
          iprot.skip(ftype)
8641 
      elif fid == 5:
8642 
        if ftype == TType.STRING:
8643 
          self.data = iprot.readString();
8644 
        else:
8645 
          iprot.skip(ftype)
1859 vikas 8646 
      elif fid == 6:
8647 
        if ftype == TType.I64:
8648 
          self.addedOn = iprot.readI64();
8649 
        else:
8650 
          iprot.skip(ftype)
1845 vikas 8651 
      else:
8652 
        iprot.skip(ftype)
8653 
      iprot.readFieldEnd()
8654 
    iprot.readStructEnd()
8655 
 
8656 
  def write(self, oprot):
8657 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8658 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8659 
      return
8660 
    oprot.writeStructBegin('addTrackLog_args')
8661 
    if self.trackerId != None:
8662 
      oprot.writeFieldBegin('trackerId', TType.I64, 1)
8663 
      oprot.writeI64(self.trackerId)
8664 
      oprot.writeFieldEnd()
8665 
    if self.userId != None:
8666 
      oprot.writeFieldBegin('userId', TType.I64, 2)
8667 
      oprot.writeI64(self.userId)
8668 
      oprot.writeFieldEnd()
8669 
    if self.event != None:
8670 
      oprot.writeFieldBegin('event', TType.STRING, 3)
8671 
      oprot.writeString(self.event)
8672 
      oprot.writeFieldEnd()
8673 
    if self.url != None:
8674 
      oprot.writeFieldBegin('url', TType.STRING, 4)
8675 
      oprot.writeString(self.url)
8676 
      oprot.writeFieldEnd()
8677 
    if self.data != None:
8678 
      oprot.writeFieldBegin('data', TType.STRING, 5)
8679 
      oprot.writeString(self.data)
8680 
      oprot.writeFieldEnd()
1859 vikas 8681 
    if self.addedOn != None:
8682 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
8683 
      oprot.writeI64(self.addedOn)
8684 
      oprot.writeFieldEnd()
1845 vikas 8685 
    oprot.writeFieldStop()
8686 
    oprot.writeStructEnd()
8687 
 
8688 
  def __repr__(self):
8689 
    L = ['%s=%r' % (key, value)
8690 
      for key, value in self.__dict__.iteritems()]
8691 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8692 
 
8693 
  def __eq__(self, other):
8694 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8695 
 
8696 
  def __ne__(self, other):
8697 
    return not (self == other)
8698 
 
8699 
class addTrackLog_result:
8700 
  """
8701 
  Attributes:
8702 
   - success
8703 
   - utx
8704 
  """
8705 
 
8706 
  thrift_spec = (
8707 
    (0, TType.I64, 'success', None, None, ), # 0
8708 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8709 
  )
8710 
 
8711 
  def __init__(self, success=None, utx=None,):
8712 
    self.success = success
8713 
    self.utx = utx
8714 
 
8715 
  def read(self, iprot):
8716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8718 
      return
8719 
    iprot.readStructBegin()
8720 
    while True:
8721 
      (fname, ftype, fid) = iprot.readFieldBegin()
8722 
      if ftype == TType.STOP:
8723 
        break
8724 
      if fid == 0:
8725 
        if ftype == TType.I64:
8726 
          self.success = iprot.readI64();
8727 
        else:
8728 
          iprot.skip(ftype)
8729 
      elif fid == 1:
8730 
        if ftype == TType.STRUCT:
8731 
          self.utx = UserTrackerException()
8732 
          self.utx.read(iprot)
8733 
        else:
8734 
          iprot.skip(ftype)
8735 
      else:
8736 
        iprot.skip(ftype)
8737 
      iprot.readFieldEnd()
8738 
    iprot.readStructEnd()
8739 
 
8740 
  def write(self, oprot):
8741 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8742 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8743 
      return
8744 
    oprot.writeStructBegin('addTrackLog_result')
8745 
    if self.success != None:
8746 
      oprot.writeFieldBegin('success', TType.I64, 0)
8747 
      oprot.writeI64(self.success)
8748 
      oprot.writeFieldEnd()
8749 
    if self.utx != None:
8750 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8751 
      self.utx.write(oprot)
8752 
      oprot.writeFieldEnd()
8753 
    oprot.writeFieldStop()
8754 
    oprot.writeStructEnd()
8755 
 
8756 
  def __repr__(self):
8757 
    L = ['%s=%r' % (key, value)
8758 
      for key, value in self.__dict__.iteritems()]
8759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8760 
 
8761 
  def __eq__(self, other):
8762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8763 
 
8764 
  def __ne__(self, other):
8765 
    return not (self == other)
8766 
 
8767 
class getTrackLogById_args:
8768 
  """
8769 
  Attributes:
8770 
   - id
8771 
  """
8772 
 
8773 
  thrift_spec = (
8774 
    None, # 0
8775 
    (1, TType.I64, 'id', None, None, ), # 1
8776 
  )
8777 
 
8778 
  def __init__(self, id=None,):
8779 
    self.id = id
8780 
 
8781 
  def read(self, iprot):
8782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8784 
      return
8785 
    iprot.readStructBegin()
8786 
    while True:
8787 
      (fname, ftype, fid) = iprot.readFieldBegin()
8788 
      if ftype == TType.STOP:
8789 
        break
8790 
      if fid == 1:
8791 
        if ftype == TType.I64:
8792 
          self.id = iprot.readI64();
8793 
        else:
8794 
          iprot.skip(ftype)
8795 
      else:
8796 
        iprot.skip(ftype)
8797 
      iprot.readFieldEnd()
8798 
    iprot.readStructEnd()
8799 
 
8800 
  def write(self, oprot):
8801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8803 
      return
8804 
    oprot.writeStructBegin('getTrackLogById_args')
8805 
    if self.id != None:
8806 
      oprot.writeFieldBegin('id', TType.I64, 1)
8807 
      oprot.writeI64(self.id)
8808 
      oprot.writeFieldEnd()
8809 
    oprot.writeFieldStop()
8810 
    oprot.writeStructEnd()
8811 
 
8812 
  def __repr__(self):
8813 
    L = ['%s=%r' % (key, value)
8814 
      for key, value in self.__dict__.iteritems()]
8815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8816 
 
8817 
  def __eq__(self, other):
8818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8819 
 
8820 
  def __ne__(self, other):
8821 
    return not (self == other)
8822 
 
8823 
class getTrackLogById_result:
8824 
  """
8825 
  Attributes:
8826 
   - success
8827 
   - utx
8828 
  """
8829 
 
8830 
  thrift_spec = (
8831 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
8832 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8833 
  )
8834 
 
8835 
  def __init__(self, success=None, utx=None,):
8836 
    self.success = success
8837 
    self.utx = utx
8838 
 
8839 
  def read(self, iprot):
8840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8842 
      return
8843 
    iprot.readStructBegin()
8844 
    while True:
8845 
      (fname, ftype, fid) = iprot.readFieldBegin()
8846 
      if ftype == TType.STOP:
8847 
        break
8848 
      if fid == 0:
8849 
        if ftype == TType.STRUCT:
8850 
          self.success = TrackLog()
8851 
          self.success.read(iprot)
8852 
        else:
8853 
          iprot.skip(ftype)
8854 
      elif fid == 1:
8855 
        if ftype == TType.STRUCT:
8856 
          self.utx = UserTrackerException()
8857 
          self.utx.read(iprot)
8858 
        else:
8859 
          iprot.skip(ftype)
8860 
      else:
8861 
        iprot.skip(ftype)
8862 
      iprot.readFieldEnd()
8863 
    iprot.readStructEnd()
8864 
 
8865 
  def write(self, oprot):
8866 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8867 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8868 
      return
8869 
    oprot.writeStructBegin('getTrackLogById_result')
8870 
    if self.success != None:
8871 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8872 
      self.success.write(oprot)
8873 
      oprot.writeFieldEnd()
8874 
    if self.utx != None:
8875 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8876 
      self.utx.write(oprot)
8877 
      oprot.writeFieldEnd()
8878 
    oprot.writeFieldStop()
8879 
    oprot.writeStructEnd()
8880 
 
8881 
  def __repr__(self):
8882 
    L = ['%s=%r' % (key, value)
8883 
      for key, value in self.__dict__.iteritems()]
8884 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8885 
 
8886 
  def __eq__(self, other):
8887 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8888 
 
8889 
  def __ne__(self, other):
8890 
    return not (self == other)
8891 
 
8892 
class getTrackLogsByTracker_args:
8893 
  """
8894 
  Attributes:
8895 
   - trackerId
8896 
  """
8897 
 
8898 
  thrift_spec = (
8899 
    None, # 0
8900 
    (1, TType.I64, 'trackerId', None, None, ), # 1
8901 
  )
8902 
 
8903 
  def __init__(self, trackerId=None,):
8904 
    self.trackerId = trackerId
8905 
 
8906 
  def read(self, iprot):
8907 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8908 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8909 
      return
8910 
    iprot.readStructBegin()
8911 
    while True:
8912 
      (fname, ftype, fid) = iprot.readFieldBegin()
8913 
      if ftype == TType.STOP:
8914 
        break
8915 
      if fid == 1:
8916 
        if ftype == TType.I64:
8917 
          self.trackerId = iprot.readI64();
8918 
        else:
8919 
          iprot.skip(ftype)
8920 
      else:
8921 
        iprot.skip(ftype)
8922 
      iprot.readFieldEnd()
8923 
    iprot.readStructEnd()
8924 
 
8925 
  def write(self, oprot):
8926 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8927 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8928 
      return
8929 
    oprot.writeStructBegin('getTrackLogsByTracker_args')
8930 
    if self.trackerId != None:
8931 
      oprot.writeFieldBegin('trackerId', TType.I64, 1)
8932 
      oprot.writeI64(self.trackerId)
8933 
      oprot.writeFieldEnd()
8934 
    oprot.writeFieldStop()
8935 
    oprot.writeStructEnd()
8936 
 
8937 
  def __repr__(self):
8938 
    L = ['%s=%r' % (key, value)
8939 
      for key, value in self.__dict__.iteritems()]
8940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8941 
 
8942 
  def __eq__(self, other):
8943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8944 
 
8945 
  def __ne__(self, other):
8946 
    return not (self == other)
8947 
 
8948 
class getTrackLogsByTracker_result:
8949 
  """
8950 
  Attributes:
8951 
   - success
8952 
   - utx
8953 
  """
8954 
 
8955 
  thrift_spec = (
8956 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
8957 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8958 
  )
8959 
 
8960 
  def __init__(self, success=None, utx=None,):
8961 
    self.success = success
8962 
    self.utx = utx
8963 
 
8964 
  def read(self, iprot):
8965 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8966 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8967 
      return
8968 
    iprot.readStructBegin()
8969 
    while True:
8970 
      (fname, ftype, fid) = iprot.readFieldBegin()
8971 
      if ftype == TType.STOP:
8972 
        break
8973 
      if fid == 0:
8974 
        if ftype == TType.LIST:
8975 
          self.success = []
1976 varun.gupt 8976 
          (_etype80, _size77) = iprot.readListBegin()
8977 
          for _i81 in xrange(_size77):
8978 
            _elem82 = TrackLog()
8979 
            _elem82.read(iprot)
8980 
            self.success.append(_elem82)
1845 vikas 8981 
          iprot.readListEnd()
8982 
        else:
8983 
          iprot.skip(ftype)
8984 
      elif fid == 1:
8985 
        if ftype == TType.STRUCT:
8986 
          self.utx = UserTrackerException()
8987 
          self.utx.read(iprot)
8988 
        else:
8989 
          iprot.skip(ftype)
8990 
      else:
8991 
        iprot.skip(ftype)
8992 
      iprot.readFieldEnd()
8993 
    iprot.readStructEnd()
8994 
 
8995 
  def write(self, oprot):
8996 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8997 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8998 
      return
8999 
    oprot.writeStructBegin('getTrackLogsByTracker_result')
9000 
    if self.success != None:
9001 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9002 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 9003 
      for iter83 in self.success:
9004 
        iter83.write(oprot)
1845 vikas 9005 
      oprot.writeListEnd()
9006 
      oprot.writeFieldEnd()
9007 
    if self.utx != None:
9008 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9009 
      self.utx.write(oprot)
9010 
      oprot.writeFieldEnd()
9011 
    oprot.writeFieldStop()
9012 
    oprot.writeStructEnd()
9013 
 
9014 
  def __repr__(self):
9015 
    L = ['%s=%r' % (key, value)
9016 
      for key, value in self.__dict__.iteritems()]
9017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9018 
 
9019 
  def __eq__(self, other):
9020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9021 
 
9022 
  def __ne__(self, other):
9023 
    return not (self == other)
9024 
 
9025 
class getTrackLogsByUser_args:
9026 
  """
9027 
  Attributes:
9028 
   - userId
9029 
  """
9030 
 
9031 
  thrift_spec = (
9032 
    None, # 0
9033 
    (1, TType.I64, 'userId', None, None, ), # 1
9034 
  )
9035 
 
9036 
  def __init__(self, userId=None,):
9037 
    self.userId = userId
9038 
 
9039 
  def read(self, iprot):
9040 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9041 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9042 
      return
9043 
    iprot.readStructBegin()
9044 
    while True:
9045 
      (fname, ftype, fid) = iprot.readFieldBegin()
9046 
      if ftype == TType.STOP:
9047 
        break
9048 
      if fid == 1:
9049 
        if ftype == TType.I64:
9050 
          self.userId = iprot.readI64();
9051 
        else:
9052 
          iprot.skip(ftype)
9053 
      else:
9054 
        iprot.skip(ftype)
9055 
      iprot.readFieldEnd()
9056 
    iprot.readStructEnd()
9057 
 
9058 
  def write(self, oprot):
9059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9061 
      return
9062 
    oprot.writeStructBegin('getTrackLogsByUser_args')
9063 
    if self.userId != None:
9064 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9065 
      oprot.writeI64(self.userId)
9066 
      oprot.writeFieldEnd()
9067 
    oprot.writeFieldStop()
9068 
    oprot.writeStructEnd()
9069 
 
9070 
  def __repr__(self):
9071 
    L = ['%s=%r' % (key, value)
9072 
      for key, value in self.__dict__.iteritems()]
9073 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9074 
 
9075 
  def __eq__(self, other):
9076 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9077 
 
9078 
  def __ne__(self, other):
9079 
    return not (self == other)
9080 
 
9081 
class getTrackLogsByUser_result:
9082 
  """
9083 
  Attributes:
9084 
   - success
9085 
   - utx
9086 
  """
9087 
 
9088 
  thrift_spec = (
9089 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
9090 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
9091 
  )
9092 
 
9093 
  def __init__(self, success=None, utx=None,):
9094 
    self.success = success
9095 
    self.utx = utx
9096 
 
9097 
  def read(self, iprot):
9098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9100 
      return
9101 
    iprot.readStructBegin()
9102 
    while True:
9103 
      (fname, ftype, fid) = iprot.readFieldBegin()
9104 
      if ftype == TType.STOP:
9105 
        break
9106 
      if fid == 0:
9107 
        if ftype == TType.LIST:
9108 
          self.success = []
1976 varun.gupt 9109 
          (_etype87, _size84) = iprot.readListBegin()
9110 
          for _i88 in xrange(_size84):
9111 
            _elem89 = TrackLog()
9112 
            _elem89.read(iprot)
9113 
            self.success.append(_elem89)
1845 vikas 9114 
          iprot.readListEnd()
9115 
        else:
9116 
          iprot.skip(ftype)
9117 
      elif fid == 1:
9118 
        if ftype == TType.STRUCT:
9119 
          self.utx = UserTrackerException()
9120 
          self.utx.read(iprot)
9121 
        else:
9122 
          iprot.skip(ftype)
9123 
      else:
9124 
        iprot.skip(ftype)
9125 
      iprot.readFieldEnd()
9126 
    iprot.readStructEnd()
9127 
 
9128 
  def write(self, oprot):
9129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9131 
      return
9132 
    oprot.writeStructBegin('getTrackLogsByUser_result')
9133 
    if self.success != None:
9134 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9135 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 9136 
      for iter90 in self.success:
9137 
        iter90.write(oprot)
1845 vikas 9138 
      oprot.writeListEnd()
9139 
      oprot.writeFieldEnd()
9140 
    if self.utx != None:
9141 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9142 
      self.utx.write(oprot)
9143 
      oprot.writeFieldEnd()
9144 
    oprot.writeFieldStop()
9145 
    oprot.writeStructEnd()
9146 
 
9147 
  def __repr__(self):
9148 
    L = ['%s=%r' % (key, value)
9149 
      for key, value in self.__dict__.iteritems()]
9150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9151 
 
9152 
  def __eq__(self, other):
9153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9154 
 
9155 
  def __ne__(self, other):
9156 
    return not (self == other)
9157 
 
9158 
class getTrackLogs_args:
9159 
  """
9160 
  Attributes:
9161 
   - trackerId
9162 
   - userId
9163 
   - event
9164 
   - url
9165 
  """
9166 
 
9167 
  thrift_spec = (
9168 
    None, # 0
9169 
    (1, TType.I64, 'trackerId', None, None, ), # 1
9170 
    (2, TType.I64, 'userId', None, None, ), # 2
9171 
    (3, TType.STRING, 'event', None, None, ), # 3
9172 
    (4, TType.STRING, 'url', None, None, ), # 4
9173 
  )
9174 
 
9175 
  def __init__(self, trackerId=None, userId=None, event=None, url=None,):
9176 
    self.trackerId = trackerId
9177 
    self.userId = userId
9178 
    self.event = event
9179 
    self.url = url
9180 
 
9181 
  def read(self, iprot):
9182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9184 
      return
9185 
    iprot.readStructBegin()
9186 
    while True:
9187 
      (fname, ftype, fid) = iprot.readFieldBegin()
9188 
      if ftype == TType.STOP:
9189 
        break
9190 
      if fid == 1:
9191 
        if ftype == TType.I64:
9192 
          self.trackerId = iprot.readI64();
9193 
        else:
9194 
          iprot.skip(ftype)
9195 
      elif fid == 2:
9196 
        if ftype == TType.I64:
9197 
          self.userId = iprot.readI64();
9198 
        else:
9199 
          iprot.skip(ftype)
9200 
      elif fid == 3:
9201 
        if ftype == TType.STRING:
9202 
          self.event = iprot.readString();
9203 
        else:
9204 
          iprot.skip(ftype)
9205 
      elif fid == 4:
9206 
        if ftype == TType.STRING:
9207 
          self.url = iprot.readString();
9208 
        else:
9209 
          iprot.skip(ftype)
9210 
      else:
9211 
        iprot.skip(ftype)
9212 
      iprot.readFieldEnd()
9213 
    iprot.readStructEnd()
9214 
 
9215 
  def write(self, oprot):
9216 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9217 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9218 
      return
9219 
    oprot.writeStructBegin('getTrackLogs_args')
9220 
    if self.trackerId != None:
9221 
      oprot.writeFieldBegin('trackerId', TType.I64, 1)
9222 
      oprot.writeI64(self.trackerId)
9223 
      oprot.writeFieldEnd()
9224 
    if self.userId != None:
9225 
      oprot.writeFieldBegin('userId', TType.I64, 2)
9226 
      oprot.writeI64(self.userId)
9227 
      oprot.writeFieldEnd()
9228 
    if self.event != None:
9229 
      oprot.writeFieldBegin('event', TType.STRING, 3)
9230 
      oprot.writeString(self.event)
9231 
      oprot.writeFieldEnd()
9232 
    if self.url != None:
9233 
      oprot.writeFieldBegin('url', TType.STRING, 4)
9234 
      oprot.writeString(self.url)
9235 
      oprot.writeFieldEnd()
9236 
    oprot.writeFieldStop()
9237 
    oprot.writeStructEnd()
9238 
 
9239 
  def __repr__(self):
9240 
    L = ['%s=%r' % (key, value)
9241 
      for key, value in self.__dict__.iteritems()]
9242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9243 
 
9244 
  def __eq__(self, other):
9245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9246 
 
9247 
  def __ne__(self, other):
9248 
    return not (self == other)
9249 
 
9250 
class getTrackLogs_result:
9251 
  """
9252 
  Attributes:
9253 
   - success
9254 
   - utx
9255 
  """
9256 
 
9257 
  thrift_spec = (
9258 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
9259 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
9260 
  )
9261 
 
9262 
  def __init__(self, success=None, utx=None,):
9263 
    self.success = success
9264 
    self.utx = utx
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 == 0:
9276 
        if ftype == TType.LIST:
9277 
          self.success = []
1976 varun.gupt 9278 
          (_etype94, _size91) = iprot.readListBegin()
9279 
          for _i95 in xrange(_size91):
9280 
            _elem96 = TrackLog()
9281 
            _elem96.read(iprot)
9282 
            self.success.append(_elem96)
1845 vikas 9283 
          iprot.readListEnd()
9284 
        else:
9285 
          iprot.skip(ftype)
9286 
      elif fid == 1:
9287 
        if ftype == TType.STRUCT:
9288 
          self.utx = UserTrackerException()
9289 
          self.utx.read(iprot)
9290 
        else:
9291 
          iprot.skip(ftype)
9292 
      else:
9293 
        iprot.skip(ftype)
9294 
      iprot.readFieldEnd()
9295 
    iprot.readStructEnd()
9296 
 
9297 
  def write(self, oprot):
9298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9300 
      return
9301 
    oprot.writeStructBegin('getTrackLogs_result')
9302 
    if self.success != None:
9303 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9304 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 9305 
      for iter97 in self.success:
9306 
        iter97.write(oprot)
1845 vikas 9307 
      oprot.writeListEnd()
9308 
      oprot.writeFieldEnd()
9309 
    if self.utx != None:
9310 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9311 
      self.utx.write(oprot)
9312 
      oprot.writeFieldEnd()
9313 
    oprot.writeFieldStop()
9314 
    oprot.writeStructEnd()
9315 
 
9316 
  def __repr__(self):
9317 
    L = ['%s=%r' % (key, value)
9318 
      for key, value in self.__dict__.iteritems()]
9319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9320 
 
9321 
  def __eq__(self, other):
9322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9323 
 
9324 
  def __ne__(self, other):
9325 
    return not (self == other)
9326 
 
559 chandransh 9327 
class createCart_args:
94 ashish 9328 
  """
9329 
  Attributes:
559 chandransh 9330 
   - userId
94 ashish 9331 
  """
9332 
 
9333 
  thrift_spec = (
9334 
    None, # 0
559 chandransh 9335 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 9336 
  )
9337 
 
559 chandransh 9338 
  def __init__(self, userId=None,):
9339 
    self.userId = userId
94 ashish 9340 
 
9341 
  def read(self, iprot):
9342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9344 
      return
9345 
    iprot.readStructBegin()
9346 
    while True:
9347 
      (fname, ftype, fid) = iprot.readFieldBegin()
9348 
      if ftype == TType.STOP:
9349 
        break
9350 
      if fid == 1:
9351 
        if ftype == TType.I64:
559 chandransh 9352 
          self.userId = iprot.readI64();
94 ashish 9353 
        else:
9354 
          iprot.skip(ftype)
559 chandransh 9355 
      else:
9356 
        iprot.skip(ftype)
9357 
      iprot.readFieldEnd()
9358 
    iprot.readStructEnd()
9359 
 
9360 
  def write(self, oprot):
9361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9363 
      return
9364 
    oprot.writeStructBegin('createCart_args')
9365 
    if self.userId != None:
9366 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9367 
      oprot.writeI64(self.userId)
9368 
      oprot.writeFieldEnd()
9369 
    oprot.writeFieldStop()
9370 
    oprot.writeStructEnd()
9371 
 
9372 
  def __repr__(self):
9373 
    L = ['%s=%r' % (key, value)
9374 
      for key, value in self.__dict__.iteritems()]
9375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9376 
 
9377 
  def __eq__(self, other):
9378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9379 
 
9380 
  def __ne__(self, other):
9381 
    return not (self == other)
9382 
 
9383 
class createCart_result:
9384 
  """
9385 
  Attributes:
9386 
   - success
9387 
   - scx
9388 
  """
9389 
 
9390 
  thrift_spec = (
9391 
    (0, TType.I64, 'success', None, None, ), # 0
9392 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9393 
  )
9394 
 
9395 
  def __init__(self, success=None, scx=None,):
9396 
    self.success = success
9397 
    self.scx = scx
9398 
 
9399 
  def read(self, iprot):
9400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9402 
      return
9403 
    iprot.readStructBegin()
9404 
    while True:
9405 
      (fname, ftype, fid) = iprot.readFieldBegin()
9406 
      if ftype == TType.STOP:
9407 
        break
9408 
      if fid == 0:
94 ashish 9409 
        if ftype == TType.I64:
559 chandransh 9410 
          self.success = iprot.readI64();
94 ashish 9411 
        else:
9412 
          iprot.skip(ftype)
559 chandransh 9413 
      elif fid == 1:
9414 
        if ftype == TType.STRUCT:
9415 
          self.scx = ShoppingCartException()
9416 
          self.scx.read(iprot)
9417 
        else:
9418 
          iprot.skip(ftype)
94 ashish 9419 
      else:
9420 
        iprot.skip(ftype)
9421 
      iprot.readFieldEnd()
9422 
    iprot.readStructEnd()
9423 
 
9424 
  def write(self, oprot):
9425 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9426 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9427 
      return
559 chandransh 9428 
    oprot.writeStructBegin('createCart_result')
9429 
    if self.success != None:
9430 
      oprot.writeFieldBegin('success', TType.I64, 0)
9431 
      oprot.writeI64(self.success)
94 ashish 9432 
      oprot.writeFieldEnd()
559 chandransh 9433 
    if self.scx != None:
9434 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9435 
      self.scx.write(oprot)
94 ashish 9436 
      oprot.writeFieldEnd()
9437 
    oprot.writeFieldStop()
9438 
    oprot.writeStructEnd()
9439 
 
9440 
  def __repr__(self):
9441 
    L = ['%s=%r' % (key, value)
9442 
      for key, value in self.__dict__.iteritems()]
9443 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9444 
 
9445 
  def __eq__(self, other):
9446 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9447 
 
9448 
  def __ne__(self, other):
9449 
    return not (self == other)
9450 
 
559 chandransh 9451 
class getCurrentCart_args:
94 ashish 9452 
  """
9453 
  Attributes:
559 chandransh 9454 
   - userId
9455 
  """
9456 
 
9457 
  thrift_spec = (
9458 
    None, # 0
9459 
    (1, TType.I64, 'userId', None, None, ), # 1
9460 
  )
9461 
 
9462 
  def __init__(self, userId=None,):
9463 
    self.userId = userId
9464 
 
9465 
  def read(self, iprot):
9466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9468 
      return
9469 
    iprot.readStructBegin()
9470 
    while True:
9471 
      (fname, ftype, fid) = iprot.readFieldBegin()
9472 
      if ftype == TType.STOP:
9473 
        break
9474 
      if fid == 1:
9475 
        if ftype == TType.I64:
9476 
          self.userId = iprot.readI64();
9477 
        else:
9478 
          iprot.skip(ftype)
9479 
      else:
9480 
        iprot.skip(ftype)
9481 
      iprot.readFieldEnd()
9482 
    iprot.readStructEnd()
9483 
 
9484 
  def write(self, oprot):
9485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9487 
      return
9488 
    oprot.writeStructBegin('getCurrentCart_args')
9489 
    if self.userId != None:
9490 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9491 
      oprot.writeI64(self.userId)
9492 
      oprot.writeFieldEnd()
9493 
    oprot.writeFieldStop()
9494 
    oprot.writeStructEnd()
9495 
 
9496 
  def __repr__(self):
9497 
    L = ['%s=%r' % (key, value)
9498 
      for key, value in self.__dict__.iteritems()]
9499 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9500 
 
9501 
  def __eq__(self, other):
9502 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9503 
 
9504 
  def __ne__(self, other):
9505 
    return not (self == other)
9506 
 
9507 
class getCurrentCart_result:
9508 
  """
9509 
  Attributes:
94 ashish 9510 
   - success
559 chandransh 9511 
   - scx
94 ashish 9512 
  """
9513 
 
9514 
  thrift_spec = (
559 chandransh 9515 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9516 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9517 
  )
9518 
 
559 chandransh 9519 
  def __init__(self, success=None, scx=None,):
94 ashish 9520 
    self.success = success
559 chandransh 9521 
    self.scx = scx
94 ashish 9522 
 
9523 
  def read(self, iprot):
9524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9526 
      return
9527 
    iprot.readStructBegin()
9528 
    while True:
9529 
      (fname, ftype, fid) = iprot.readFieldBegin()
9530 
      if ftype == TType.STOP:
9531 
        break
9532 
      if fid == 0:
559 chandransh 9533 
        if ftype == TType.STRUCT:
9534 
          self.success = Cart()
9535 
          self.success.read(iprot)
94 ashish 9536 
        else:
9537 
          iprot.skip(ftype)
9538 
      elif fid == 1:
9539 
        if ftype == TType.STRUCT:
559 chandransh 9540 
          self.scx = ShoppingCartException()
9541 
          self.scx.read(iprot)
94 ashish 9542 
        else:
9543 
          iprot.skip(ftype)
9544 
      else:
9545 
        iprot.skip(ftype)
9546 
      iprot.readFieldEnd()
9547 
    iprot.readStructEnd()
9548 
 
9549 
  def write(self, oprot):
9550 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9551 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9552 
      return
559 chandransh 9553 
    oprot.writeStructBegin('getCurrentCart_result')
94 ashish 9554 
    if self.success != None:
559 chandransh 9555 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9556 
      self.success.write(oprot)
94 ashish 9557 
      oprot.writeFieldEnd()
559 chandransh 9558 
    if self.scx != None:
9559 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9560 
      self.scx.write(oprot)
94 ashish 9561 
      oprot.writeFieldEnd()
9562 
    oprot.writeFieldStop()
9563 
    oprot.writeStructEnd()
9564 
 
9565 
  def __repr__(self):
9566 
    L = ['%s=%r' % (key, value)
9567 
      for key, value in self.__dict__.iteritems()]
9568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9569 
 
9570 
  def __eq__(self, other):
9571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9572 
 
9573 
  def __ne__(self, other):
9574 
    return not (self == other)
9575 
 
559 chandransh 9576 
class getCart_args:
504 rajveer 9577 
  """
9578 
  Attributes:
559 chandransh 9579 
   - cartId
504 rajveer 9580 
  """
9581 
 
9582 
  thrift_spec = (
9583 
    None, # 0
559 chandransh 9584 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 9585 
  )
9586 
 
559 chandransh 9587 
  def __init__(self, cartId=None,):
9588 
    self.cartId = cartId
504 rajveer 9589 
 
9590 
  def read(self, iprot):
9591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9593 
      return
9594 
    iprot.readStructBegin()
9595 
    while True:
9596 
      (fname, ftype, fid) = iprot.readFieldBegin()
9597 
      if ftype == TType.STOP:
9598 
        break
9599 
      if fid == 1:
9600 
        if ftype == TType.I64:
559 chandransh 9601 
          self.cartId = iprot.readI64();
504 rajveer 9602 
        else:
9603 
          iprot.skip(ftype)
9604 
      else:
9605 
        iprot.skip(ftype)
9606 
      iprot.readFieldEnd()
9607 
    iprot.readStructEnd()
9608 
 
9609 
  def write(self, oprot):
9610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9612 
      return
559 chandransh 9613 
    oprot.writeStructBegin('getCart_args')
9614 
    if self.cartId != None:
9615 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9616 
      oprot.writeI64(self.cartId)
504 rajveer 9617 
      oprot.writeFieldEnd()
9618 
    oprot.writeFieldStop()
9619 
    oprot.writeStructEnd()
9620 
 
9621 
  def __repr__(self):
9622 
    L = ['%s=%r' % (key, value)
9623 
      for key, value in self.__dict__.iteritems()]
9624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9625 
 
9626 
  def __eq__(self, other):
9627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9628 
 
9629 
  def __ne__(self, other):
9630 
    return not (self == other)
9631 
 
559 chandransh 9632 
class getCart_result:
504 rajveer 9633 
  """
9634 
  Attributes:
9635 
   - success
559 chandransh 9636 
   - scx
504 rajveer 9637 
  """
9638 
 
9639 
  thrift_spec = (
559 chandransh 9640 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9641 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 9642 
  )
9643 
 
559 chandransh 9644 
  def __init__(self, success=None, scx=None,):
504 rajveer 9645 
    self.success = success
559 chandransh 9646 
    self.scx = scx
504 rajveer 9647 
 
9648 
  def read(self, iprot):
9649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9651 
      return
9652 
    iprot.readStructBegin()
9653 
    while True:
9654 
      (fname, ftype, fid) = iprot.readFieldBegin()
9655 
      if ftype == TType.STOP:
9656 
        break
9657 
      if fid == 0:
559 chandransh 9658 
        if ftype == TType.STRUCT:
9659 
          self.success = Cart()
9660 
          self.success.read(iprot)
504 rajveer 9661 
        else:
9662 
          iprot.skip(ftype)
9663 
      elif fid == 1:
9664 
        if ftype == TType.STRUCT:
559 chandransh 9665 
          self.scx = ShoppingCartException()
9666 
          self.scx.read(iprot)
504 rajveer 9667 
        else:
9668 
          iprot.skip(ftype)
9669 
      else:
9670 
        iprot.skip(ftype)
9671 
      iprot.readFieldEnd()
9672 
    iprot.readStructEnd()
9673 
 
9674 
  def write(self, oprot):
9675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9677 
      return
559 chandransh 9678 
    oprot.writeStructBegin('getCart_result')
504 rajveer 9679 
    if self.success != None:
559 chandransh 9680 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9681 
      self.success.write(oprot)
504 rajveer 9682 
      oprot.writeFieldEnd()
559 chandransh 9683 
    if self.scx != None:
9684 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9685 
      self.scx.write(oprot)
504 rajveer 9686 
      oprot.writeFieldEnd()
9687 
    oprot.writeFieldStop()
9688 
    oprot.writeStructEnd()
9689 
 
9690 
  def __repr__(self):
9691 
    L = ['%s=%r' % (key, value)
9692 
      for key, value in self.__dict__.iteritems()]
9693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9694 
 
9695 
  def __eq__(self, other):
9696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9697 
 
9698 
  def __ne__(self, other):
9699 
    return not (self == other)
9700 
 
559 chandransh 9701 
class getCartsForUser_args:
94 ashish 9702 
  """
9703 
  Attributes:
559 chandransh 9704 
   - userId
9705 
   - status
94 ashish 9706 
  """
9707 
 
9708 
  thrift_spec = (
9709 
    None, # 0
559 chandransh 9710 
    (1, TType.I64, 'userId', None, None, ), # 1
9711 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 9712 
  )
9713 
 
559 chandransh 9714 
  def __init__(self, userId=None, status=None,):
9715 
    self.userId = userId
9716 
    self.status = status
94 ashish 9717 
 
9718 
  def read(self, iprot):
9719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9721 
      return
9722 
    iprot.readStructBegin()
9723 
    while True:
9724 
      (fname, ftype, fid) = iprot.readFieldBegin()
9725 
      if ftype == TType.STOP:
9726 
        break
9727 
      if fid == 1:
9728 
        if ftype == TType.I64:
559 chandransh 9729 
          self.userId = iprot.readI64();
94 ashish 9730 
        else:
9731 
          iprot.skip(ftype)
9732 
      elif fid == 2:
559 chandransh 9733 
        if ftype == TType.I32:
9734 
          self.status = iprot.readI32();
94 ashish 9735 
        else:
9736 
          iprot.skip(ftype)
9737 
      else:
9738 
        iprot.skip(ftype)
9739 
      iprot.readFieldEnd()
9740 
    iprot.readStructEnd()
9741 
 
9742 
  def write(self, oprot):
9743 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9744 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9745 
      return
559 chandransh 9746 
    oprot.writeStructBegin('getCartsForUser_args')
9747 
    if self.userId != None:
9748 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9749 
      oprot.writeI64(self.userId)
94 ashish 9750 
      oprot.writeFieldEnd()
559 chandransh 9751 
    if self.status != None:
9752 
      oprot.writeFieldBegin('status', TType.I32, 2)
9753 
      oprot.writeI32(self.status)
94 ashish 9754 
      oprot.writeFieldEnd()
9755 
    oprot.writeFieldStop()
9756 
    oprot.writeStructEnd()
9757 
 
9758 
  def __repr__(self):
9759 
    L = ['%s=%r' % (key, value)
9760 
      for key, value in self.__dict__.iteritems()]
9761 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9762 
 
9763 
  def __eq__(self, other):
9764 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9765 
 
9766 
  def __ne__(self, other):
9767 
    return not (self == other)
9768 
 
559 chandransh 9769 
class getCartsForUser_result:
94 ashish 9770 
  """
9771 
  Attributes:
9772 
   - success
559 chandransh 9773 
   - scx
94 ashish 9774 
  """
9775 
 
9776 
  thrift_spec = (
559 chandransh 9777 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9778 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9779 
  )
9780 
 
559 chandransh 9781 
  def __init__(self, success=None, scx=None,):
94 ashish 9782 
    self.success = success
559 chandransh 9783 
    self.scx = scx
94 ashish 9784 
 
9785 
  def read(self, iprot):
9786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9788 
      return
9789 
    iprot.readStructBegin()
9790 
    while True:
9791 
      (fname, ftype, fid) = iprot.readFieldBegin()
9792 
      if ftype == TType.STOP:
9793 
        break
9794 
      if fid == 0:
559 chandransh 9795 
        if ftype == TType.LIST:
9796 
          self.success = []
1976 varun.gupt 9797 
          (_etype101, _size98) = iprot.readListBegin()
9798 
          for _i102 in xrange(_size98):
9799 
            _elem103 = Cart()
9800 
            _elem103.read(iprot)
9801 
            self.success.append(_elem103)
559 chandransh 9802 
          iprot.readListEnd()
94 ashish 9803 
        else:
9804 
          iprot.skip(ftype)
9805 
      elif fid == 1:
9806 
        if ftype == TType.STRUCT:
559 chandransh 9807 
          self.scx = ShoppingCartException()
9808 
          self.scx.read(iprot)
94 ashish 9809 
        else:
9810 
          iprot.skip(ftype)
9811 
      else:
9812 
        iprot.skip(ftype)
9813 
      iprot.readFieldEnd()
9814 
    iprot.readStructEnd()
9815 
 
9816 
  def write(self, oprot):
9817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9819 
      return
559 chandransh 9820 
    oprot.writeStructBegin('getCartsForUser_result')
94 ashish 9821 
    if self.success != None:
559 chandransh 9822 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9823 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 9824 
      for iter104 in self.success:
9825 
        iter104.write(oprot)
559 chandransh 9826 
      oprot.writeListEnd()
94 ashish 9827 
      oprot.writeFieldEnd()
559 chandransh 9828 
    if self.scx != None:
9829 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9830 
      self.scx.write(oprot)
94 ashish 9831 
      oprot.writeFieldEnd()
9832 
    oprot.writeFieldStop()
9833 
    oprot.writeStructEnd()
9834 
 
9835 
  def __repr__(self):
9836 
    L = ['%s=%r' % (key, value)
9837 
      for key, value in self.__dict__.iteritems()]
9838 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9839 
 
9840 
  def __eq__(self, other):
9841 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9842 
 
9843 
  def __ne__(self, other):
9844 
    return not (self == other)
9845 
 
559 chandransh 9846 
class getCartsByStatus_args:
94 ashish 9847 
  """
9848 
  Attributes:
559 chandransh 9849 
   - status
94 ashish 9850 
  """
9851 
 
9852 
  thrift_spec = (
9853 
    None, # 0
559 chandransh 9854 
    (1, TType.I32, 'status', None, None, ), # 1
94 ashish 9855 
  )
9856 
 
559 chandransh 9857 
  def __init__(self, status=None,):
9858 
    self.status = status
94 ashish 9859 
 
9860 
  def read(self, iprot):
9861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9863 
      return
9864 
    iprot.readStructBegin()
9865 
    while True:
9866 
      (fname, ftype, fid) = iprot.readFieldBegin()
9867 
      if ftype == TType.STOP:
9868 
        break
9869 
      if fid == 1:
559 chandransh 9870 
        if ftype == TType.I32:
9871 
          self.status = iprot.readI32();
9872 
        else:
9873 
          iprot.skip(ftype)
9874 
      else:
9875 
        iprot.skip(ftype)
9876 
      iprot.readFieldEnd()
9877 
    iprot.readStructEnd()
9878 
 
9879 
  def write(self, oprot):
9880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9882 
      return
9883 
    oprot.writeStructBegin('getCartsByStatus_args')
9884 
    if self.status != None:
9885 
      oprot.writeFieldBegin('status', TType.I32, 1)
9886 
      oprot.writeI32(self.status)
9887 
      oprot.writeFieldEnd()
9888 
    oprot.writeFieldStop()
9889 
    oprot.writeStructEnd()
9890 
 
9891 
  def __repr__(self):
9892 
    L = ['%s=%r' % (key, value)
9893 
      for key, value in self.__dict__.iteritems()]
9894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9895 
 
9896 
  def __eq__(self, other):
9897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9898 
 
9899 
  def __ne__(self, other):
9900 
    return not (self == other)
9901 
 
9902 
class getCartsByStatus_result:
9903 
  """
9904 
  Attributes:
9905 
   - success
9906 
   - scx
9907 
  """
9908 
 
9909 
  thrift_spec = (
9910 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9911 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9912 
  )
9913 
 
9914 
  def __init__(self, success=None, scx=None,):
9915 
    self.success = success
9916 
    self.scx = scx
9917 
 
9918 
  def read(self, iprot):
9919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9921 
      return
9922 
    iprot.readStructBegin()
9923 
    while True:
9924 
      (fname, ftype, fid) = iprot.readFieldBegin()
9925 
      if ftype == TType.STOP:
9926 
        break
9927 
      if fid == 0:
9928 
        if ftype == TType.LIST:
9929 
          self.success = []
1976 varun.gupt 9930 
          (_etype108, _size105) = iprot.readListBegin()
9931 
          for _i109 in xrange(_size105):
9932 
            _elem110 = Cart()
9933 
            _elem110.read(iprot)
9934 
            self.success.append(_elem110)
559 chandransh 9935 
          iprot.readListEnd()
9936 
        else:
9937 
          iprot.skip(ftype)
9938 
      elif fid == 1:
9939 
        if ftype == TType.STRUCT:
9940 
          self.scx = ShoppingCartException()
9941 
          self.scx.read(iprot)
9942 
        else:
9943 
          iprot.skip(ftype)
9944 
      else:
9945 
        iprot.skip(ftype)
9946 
      iprot.readFieldEnd()
9947 
    iprot.readStructEnd()
9948 
 
9949 
  def write(self, oprot):
9950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9952 
      return
9953 
    oprot.writeStructBegin('getCartsByStatus_result')
9954 
    if self.success != None:
9955 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9956 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 9957 
      for iter111 in self.success:
9958 
        iter111.write(oprot)
559 chandransh 9959 
      oprot.writeListEnd()
9960 
      oprot.writeFieldEnd()
9961 
    if self.scx != None:
9962 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9963 
      self.scx.write(oprot)
9964 
      oprot.writeFieldEnd()
9965 
    oprot.writeFieldStop()
9966 
    oprot.writeStructEnd()
9967 
 
9968 
  def __repr__(self):
9969 
    L = ['%s=%r' % (key, value)
9970 
      for key, value in self.__dict__.iteritems()]
9971 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9972 
 
9973 
  def __eq__(self, other):
9974 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9975 
 
9976 
  def __ne__(self, other):
9977 
    return not (self == other)
9978 
 
9979 
class getCartsByTime_args:
9980 
  """
9981 
  Attributes:
9982 
   - from_time
9983 
   - to_time
9984 
   - status
9985 
  """
9986 
 
9987 
  thrift_spec = (
9988 
    None, # 0
9989 
    (1, TType.I64, 'from_time', None, None, ), # 1
9990 
    (2, TType.I64, 'to_time', None, None, ), # 2
9991 
    (3, TType.I32, 'status', None, None, ), # 3
9992 
  )
9993 
 
9994 
  def __init__(self, from_time=None, to_time=None, status=None,):
9995 
    self.from_time = from_time
9996 
    self.to_time = to_time
9997 
    self.status = status
9998 
 
9999 
  def read(self, iprot):
10000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10002 
      return
10003 
    iprot.readStructBegin()
10004 
    while True:
10005 
      (fname, ftype, fid) = iprot.readFieldBegin()
10006 
      if ftype == TType.STOP:
10007 
        break
10008 
      if fid == 1:
94 ashish 10009 
        if ftype == TType.I64:
559 chandransh 10010 
          self.from_time = iprot.readI64();
94 ashish 10011 
        else:
10012 
          iprot.skip(ftype)
122 ashish 10013 
      elif fid == 2:
559 chandransh 10014 
        if ftype == TType.I64:
10015 
          self.to_time = iprot.readI64();
122 ashish 10016 
        else:
10017 
          iprot.skip(ftype)
559 chandransh 10018 
      elif fid == 3:
10019 
        if ftype == TType.I32:
10020 
          self.status = iprot.readI32();
10021 
        else:
10022 
          iprot.skip(ftype)
94 ashish 10023 
      else:
10024 
        iprot.skip(ftype)
10025 
      iprot.readFieldEnd()
10026 
    iprot.readStructEnd()
10027 
 
10028 
  def write(self, oprot):
10029 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10030 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10031 
      return
559 chandransh 10032 
    oprot.writeStructBegin('getCartsByTime_args')
10033 
    if self.from_time != None:
10034 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
10035 
      oprot.writeI64(self.from_time)
94 ashish 10036 
      oprot.writeFieldEnd()
559 chandransh 10037 
    if self.to_time != None:
10038 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
10039 
      oprot.writeI64(self.to_time)
122 ashish 10040 
      oprot.writeFieldEnd()
559 chandransh 10041 
    if self.status != None:
10042 
      oprot.writeFieldBegin('status', TType.I32, 3)
10043 
      oprot.writeI32(self.status)
10044 
      oprot.writeFieldEnd()
94 ashish 10045 
    oprot.writeFieldStop()
10046 
    oprot.writeStructEnd()
10047 
 
10048 
  def __repr__(self):
10049 
    L = ['%s=%r' % (key, value)
10050 
      for key, value in self.__dict__.iteritems()]
10051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10052 
 
10053 
  def __eq__(self, other):
10054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10055 
 
10056 
  def __ne__(self, other):
10057 
    return not (self == other)
10058 
 
559 chandransh 10059 
class getCartsByTime_result:
94 ashish 10060 
  """
10061 
  Attributes:
10062 
   - success
559 chandransh 10063 
   - scx
94 ashish 10064 
  """
10065 
 
10066 
  thrift_spec = (
559 chandransh 10067 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
10068 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10069 
  )
10070 
 
559 chandransh 10071 
  def __init__(self, success=None, scx=None,):
94 ashish 10072 
    self.success = success
559 chandransh 10073 
    self.scx = scx
94 ashish 10074 
 
10075 
  def read(self, iprot):
10076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10078 
      return
10079 
    iprot.readStructBegin()
10080 
    while True:
10081 
      (fname, ftype, fid) = iprot.readFieldBegin()
10082 
      if ftype == TType.STOP:
10083 
        break
10084 
      if fid == 0:
559 chandransh 10085 
        if ftype == TType.LIST:
10086 
          self.success = []
1976 varun.gupt 10087 
          (_etype115, _size112) = iprot.readListBegin()
10088 
          for _i116 in xrange(_size112):
10089 
            _elem117 = Cart()
10090 
            _elem117.read(iprot)
10091 
            self.success.append(_elem117)
559 chandransh 10092 
          iprot.readListEnd()
94 ashish 10093 
        else:
10094 
          iprot.skip(ftype)
10095 
      elif fid == 1:
10096 
        if ftype == TType.STRUCT:
559 chandransh 10097 
          self.scx = ShoppingCartException()
10098 
          self.scx.read(iprot)
94 ashish 10099 
        else:
10100 
          iprot.skip(ftype)
10101 
      else:
10102 
        iprot.skip(ftype)
10103 
      iprot.readFieldEnd()
10104 
    iprot.readStructEnd()
10105 
 
10106 
  def write(self, oprot):
10107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10109 
      return
559 chandransh 10110 
    oprot.writeStructBegin('getCartsByTime_result')
94 ashish 10111 
    if self.success != None:
559 chandransh 10112 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10113 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 10114 
      for iter118 in self.success:
10115 
        iter118.write(oprot)
559 chandransh 10116 
      oprot.writeListEnd()
94 ashish 10117 
      oprot.writeFieldEnd()
559 chandransh 10118 
    if self.scx != None:
10119 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10120 
      self.scx.write(oprot)
94 ashish 10121 
      oprot.writeFieldEnd()
10122 
    oprot.writeFieldStop()
10123 
    oprot.writeStructEnd()
10124 
 
10125 
  def __repr__(self):
10126 
    L = ['%s=%r' % (key, value)
10127 
      for key, value in self.__dict__.iteritems()]
10128 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10129 
 
10130 
  def __eq__(self, other):
10131 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10132 
 
10133 
  def __ne__(self, other):
10134 
    return not (self == other)
10135 
 
559 chandransh 10136 
class changeCartStatus_args:
94 ashish 10137 
  """
10138 
  Attributes:
559 chandransh 10139 
   - cartId
10140 
   - status
94 ashish 10141 
  """
10142 
 
10143 
  thrift_spec = (
10144 
    None, # 0
559 chandransh 10145 
    (1, TType.I64, 'cartId', None, None, ), # 1
10146 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 10147 
  )
10148 
 
559 chandransh 10149 
  def __init__(self, cartId=None, status=None,):
10150 
    self.cartId = cartId
10151 
    self.status = status
94 ashish 10152 
 
10153 
  def read(self, iprot):
10154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10156 
      return
10157 
    iprot.readStructBegin()
10158 
    while True:
10159 
      (fname, ftype, fid) = iprot.readFieldBegin()
10160 
      if ftype == TType.STOP:
10161 
        break
10162 
      if fid == 1:
10163 
        if ftype == TType.I64:
559 chandransh 10164 
          self.cartId = iprot.readI64();
94 ashish 10165 
        else:
10166 
          iprot.skip(ftype)
559 chandransh 10167 
      elif fid == 2:
10168 
        if ftype == TType.I32:
10169 
          self.status = iprot.readI32();
10170 
        else:
10171 
          iprot.skip(ftype)
94 ashish 10172 
      else:
10173 
        iprot.skip(ftype)
10174 
      iprot.readFieldEnd()
10175 
    iprot.readStructEnd()
10176 
 
10177 
  def write(self, oprot):
10178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10180 
      return
559 chandransh 10181 
    oprot.writeStructBegin('changeCartStatus_args')
10182 
    if self.cartId != None:
10183 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10184 
      oprot.writeI64(self.cartId)
94 ashish 10185 
      oprot.writeFieldEnd()
559 chandransh 10186 
    if self.status != None:
10187 
      oprot.writeFieldBegin('status', TType.I32, 2)
10188 
      oprot.writeI32(self.status)
10189 
      oprot.writeFieldEnd()
94 ashish 10190 
    oprot.writeFieldStop()
10191 
    oprot.writeStructEnd()
10192 
 
10193 
  def __repr__(self):
10194 
    L = ['%s=%r' % (key, value)
10195 
      for key, value in self.__dict__.iteritems()]
10196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10197 
 
10198 
  def __eq__(self, other):
10199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10200 
 
10201 
  def __ne__(self, other):
10202 
    return not (self == other)
10203 
 
559 chandransh 10204 
class changeCartStatus_result:
94 ashish 10205 
  """
10206 
  Attributes:
559 chandransh 10207 
   - scx
10208 
  """
10209 
 
10210 
  thrift_spec = (
10211 
    None, # 0
10212 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10213 
  )
10214 
 
10215 
  def __init__(self, scx=None,):
10216 
    self.scx = scx
10217 
 
10218 
  def read(self, iprot):
10219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10221 
      return
10222 
    iprot.readStructBegin()
10223 
    while True:
10224 
      (fname, ftype, fid) = iprot.readFieldBegin()
10225 
      if ftype == TType.STOP:
10226 
        break
10227 
      if fid == 1:
10228 
        if ftype == TType.STRUCT:
10229 
          self.scx = ShoppingCartException()
10230 
          self.scx.read(iprot)
10231 
        else:
10232 
          iprot.skip(ftype)
10233 
      else:
10234 
        iprot.skip(ftype)
10235 
      iprot.readFieldEnd()
10236 
    iprot.readStructEnd()
10237 
 
10238 
  def write(self, oprot):
10239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10241 
      return
10242 
    oprot.writeStructBegin('changeCartStatus_result')
10243 
    if self.scx != None:
10244 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10245 
      self.scx.write(oprot)
10246 
      oprot.writeFieldEnd()
10247 
    oprot.writeFieldStop()
10248 
    oprot.writeStructEnd()
10249 
 
10250 
  def __repr__(self):
10251 
    L = ['%s=%r' % (key, value)
10252 
      for key, value in self.__dict__.iteritems()]
10253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10254 
 
10255 
  def __eq__(self, other):
10256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10257 
 
10258 
  def __ne__(self, other):
10259 
    return not (self == other)
10260 
 
10261 
class addItemToCart_args:
10262 
  """
10263 
  Attributes:
10264 
   - cartId
10265 
   - itemId
10266 
   - quantity
10267 
  """
10268 
 
10269 
  thrift_spec = (
10270 
    None, # 0
10271 
    (1, TType.I64, 'cartId', None, None, ), # 1
10272 
    (2, TType.I64, 'itemId', None, None, ), # 2
10273 
    (3, TType.I64, 'quantity', None, None, ), # 3
10274 
  )
10275 
 
10276 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
10277 
    self.cartId = cartId
10278 
    self.itemId = itemId
10279 
    self.quantity = quantity
10280 
 
10281 
  def read(self, iprot):
10282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10284 
      return
10285 
    iprot.readStructBegin()
10286 
    while True:
10287 
      (fname, ftype, fid) = iprot.readFieldBegin()
10288 
      if ftype == TType.STOP:
10289 
        break
10290 
      if fid == 1:
10291 
        if ftype == TType.I64:
10292 
          self.cartId = iprot.readI64();
10293 
        else:
10294 
          iprot.skip(ftype)
10295 
      elif fid == 2:
10296 
        if ftype == TType.I64:
10297 
          self.itemId = iprot.readI64();
10298 
        else:
10299 
          iprot.skip(ftype)
10300 
      elif fid == 3:
10301 
        if ftype == TType.I64:
10302 
          self.quantity = iprot.readI64();
10303 
        else:
10304 
          iprot.skip(ftype)
10305 
      else:
10306 
        iprot.skip(ftype)
10307 
      iprot.readFieldEnd()
10308 
    iprot.readStructEnd()
10309 
 
10310 
  def write(self, oprot):
10311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10313 
      return
10314 
    oprot.writeStructBegin('addItemToCart_args')
10315 
    if self.cartId != None:
10316 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10317 
      oprot.writeI64(self.cartId)
10318 
      oprot.writeFieldEnd()
10319 
    if self.itemId != None:
10320 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10321 
      oprot.writeI64(self.itemId)
10322 
      oprot.writeFieldEnd()
10323 
    if self.quantity != None:
10324 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10325 
      oprot.writeI64(self.quantity)
10326 
      oprot.writeFieldEnd()
10327 
    oprot.writeFieldStop()
10328 
    oprot.writeStructEnd()
10329 
 
10330 
  def __repr__(self):
10331 
    L = ['%s=%r' % (key, value)
10332 
      for key, value in self.__dict__.iteritems()]
10333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10334 
 
10335 
  def __eq__(self, other):
10336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10337 
 
10338 
  def __ne__(self, other):
10339 
    return not (self == other)
10340 
 
10341 
class addItemToCart_result:
10342 
  """
10343 
  Attributes:
10344 
   - scx
10345 
  """
10346 
 
10347 
  thrift_spec = (
10348 
    None, # 0
10349 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10350 
  )
10351 
 
10352 
  def __init__(self, scx=None,):
10353 
    self.scx = scx
10354 
 
10355 
  def read(self, iprot):
10356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10358 
      return
10359 
    iprot.readStructBegin()
10360 
    while True:
10361 
      (fname, ftype, fid) = iprot.readFieldBegin()
10362 
      if ftype == TType.STOP:
10363 
        break
10364 
      if fid == 1:
10365 
        if ftype == TType.STRUCT:
10366 
          self.scx = ShoppingCartException()
10367 
          self.scx.read(iprot)
10368 
        else:
10369 
          iprot.skip(ftype)
10370 
      else:
10371 
        iprot.skip(ftype)
10372 
      iprot.readFieldEnd()
10373 
    iprot.readStructEnd()
10374 
 
10375 
  def write(self, oprot):
10376 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10377 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10378 
      return
10379 
    oprot.writeStructBegin('addItemToCart_result')
10380 
    if self.scx != None:
10381 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10382 
      self.scx.write(oprot)
10383 
      oprot.writeFieldEnd()
10384 
    oprot.writeFieldStop()
10385 
    oprot.writeStructEnd()
10386 
 
10387 
  def __repr__(self):
10388 
    L = ['%s=%r' % (key, value)
10389 
      for key, value in self.__dict__.iteritems()]
10390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10391 
 
10392 
  def __eq__(self, other):
10393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10394 
 
10395 
  def __ne__(self, other):
10396 
    return not (self == other)
10397 
 
10398 
class deleteItemFromCart_args:
10399 
  """
10400 
  Attributes:
10401 
   - cartId
10402 
   - itemId
10403 
  """
10404 
 
10405 
  thrift_spec = (
10406 
    None, # 0
10407 
    (1, TType.I64, 'cartId', None, None, ), # 1
10408 
    (2, TType.I64, 'itemId', None, None, ), # 2
10409 
  )
10410 
 
10411 
  def __init__(self, cartId=None, itemId=None,):
10412 
    self.cartId = cartId
10413 
    self.itemId = itemId
10414 
 
10415 
  def read(self, iprot):
10416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10418 
      return
10419 
    iprot.readStructBegin()
10420 
    while True:
10421 
      (fname, ftype, fid) = iprot.readFieldBegin()
10422 
      if ftype == TType.STOP:
10423 
        break
10424 
      if fid == 1:
10425 
        if ftype == TType.I64:
10426 
          self.cartId = iprot.readI64();
10427 
        else:
10428 
          iprot.skip(ftype)
10429 
      elif fid == 2:
10430 
        if ftype == TType.I64:
10431 
          self.itemId = iprot.readI64();
10432 
        else:
10433 
          iprot.skip(ftype)
10434 
      else:
10435 
        iprot.skip(ftype)
10436 
      iprot.readFieldEnd()
10437 
    iprot.readStructEnd()
10438 
 
10439 
  def write(self, oprot):
10440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10442 
      return
10443 
    oprot.writeStructBegin('deleteItemFromCart_args')
10444 
    if self.cartId != None:
10445 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10446 
      oprot.writeI64(self.cartId)
10447 
      oprot.writeFieldEnd()
10448 
    if self.itemId != None:
10449 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10450 
      oprot.writeI64(self.itemId)
10451 
      oprot.writeFieldEnd()
10452 
    oprot.writeFieldStop()
10453 
    oprot.writeStructEnd()
10454 
 
10455 
  def __repr__(self):
10456 
    L = ['%s=%r' % (key, value)
10457 
      for key, value in self.__dict__.iteritems()]
10458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10459 
 
10460 
  def __eq__(self, other):
10461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10462 
 
10463 
  def __ne__(self, other):
10464 
    return not (self == other)
10465 
 
10466 
class deleteItemFromCart_result:
10467 
  """
10468 
  Attributes:
10469 
   - scx
10470 
  """
10471 
 
10472 
  thrift_spec = (
10473 
    None, # 0
10474 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10475 
  )
10476 
 
10477 
  def __init__(self, scx=None,):
10478 
    self.scx = scx
10479 
 
10480 
  def read(self, iprot):
10481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10483 
      return
10484 
    iprot.readStructBegin()
10485 
    while True:
10486 
      (fname, ftype, fid) = iprot.readFieldBegin()
10487 
      if ftype == TType.STOP:
10488 
        break
10489 
      if fid == 1:
10490 
        if ftype == TType.STRUCT:
10491 
          self.scx = ShoppingCartException()
10492 
          self.scx.read(iprot)
10493 
        else:
10494 
          iprot.skip(ftype)
10495 
      else:
10496 
        iprot.skip(ftype)
10497 
      iprot.readFieldEnd()
10498 
    iprot.readStructEnd()
10499 
 
10500 
  def write(self, oprot):
10501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10503 
      return
10504 
    oprot.writeStructBegin('deleteItemFromCart_result')
10505 
    if self.scx != None:
10506 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10507 
      self.scx.write(oprot)
10508 
      oprot.writeFieldEnd()
10509 
    oprot.writeFieldStop()
10510 
    oprot.writeStructEnd()
10511 
 
10512 
  def __repr__(self):
10513 
    L = ['%s=%r' % (key, value)
10514 
      for key, value in self.__dict__.iteritems()]
10515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10516 
 
10517 
  def __eq__(self, other):
10518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10519 
 
10520 
  def __ne__(self, other):
10521 
    return not (self == other)
10522 
 
10523 
class changeQuantity_args:
10524 
  """
10525 
  Attributes:
10526 
   - cartId
10527 
   - itemId
10528 
   - quantity
10529 
  """
10530 
 
10531 
  thrift_spec = (
10532 
    None, # 0
10533 
    (1, TType.I64, 'cartId', None, None, ), # 1
10534 
    (2, TType.I64, 'itemId', None, None, ), # 2
10535 
    (3, TType.I64, 'quantity', None, None, ), # 3
10536 
  )
10537 
 
10538 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
10539 
    self.cartId = cartId
10540 
    self.itemId = itemId
10541 
    self.quantity = quantity
10542 
 
10543 
  def read(self, iprot):
10544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10546 
      return
10547 
    iprot.readStructBegin()
10548 
    while True:
10549 
      (fname, ftype, fid) = iprot.readFieldBegin()
10550 
      if ftype == TType.STOP:
10551 
        break
10552 
      if fid == 1:
10553 
        if ftype == TType.I64:
10554 
          self.cartId = iprot.readI64();
10555 
        else:
10556 
          iprot.skip(ftype)
10557 
      elif fid == 2:
10558 
        if ftype == TType.I64:
10559 
          self.itemId = iprot.readI64();
10560 
        else:
10561 
          iprot.skip(ftype)
10562 
      elif fid == 3:
10563 
        if ftype == TType.I64:
10564 
          self.quantity = iprot.readI64();
10565 
        else:
10566 
          iprot.skip(ftype)
10567 
      else:
10568 
        iprot.skip(ftype)
10569 
      iprot.readFieldEnd()
10570 
    iprot.readStructEnd()
10571 
 
10572 
  def write(self, oprot):
10573 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10574 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10575 
      return
10576 
    oprot.writeStructBegin('changeQuantity_args')
10577 
    if self.cartId != None:
10578 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10579 
      oprot.writeI64(self.cartId)
10580 
      oprot.writeFieldEnd()
10581 
    if self.itemId != None:
10582 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10583 
      oprot.writeI64(self.itemId)
10584 
      oprot.writeFieldEnd()
10585 
    if self.quantity != None:
10586 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10587 
      oprot.writeI64(self.quantity)
10588 
      oprot.writeFieldEnd()
10589 
    oprot.writeFieldStop()
10590 
    oprot.writeStructEnd()
10591 
 
10592 
  def __repr__(self):
10593 
    L = ['%s=%r' % (key, value)
10594 
      for key, value in self.__dict__.iteritems()]
10595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10596 
 
10597 
  def __eq__(self, other):
10598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10599 
 
10600 
  def __ne__(self, other):
10601 
    return not (self == other)
10602 
 
10603 
class changeQuantity_result:
10604 
  """
10605 
  Attributes:
10606 
   - scx
10607 
  """
10608 
 
10609 
  thrift_spec = (
10610 
    None, # 0
10611 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10612 
  )
10613 
 
10614 
  def __init__(self, scx=None,):
10615 
    self.scx = scx
10616 
 
10617 
  def read(self, iprot):
10618 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10619 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10620 
      return
10621 
    iprot.readStructBegin()
10622 
    while True:
10623 
      (fname, ftype, fid) = iprot.readFieldBegin()
10624 
      if ftype == TType.STOP:
10625 
        break
10626 
      if fid == 1:
10627 
        if ftype == TType.STRUCT:
10628 
          self.scx = ShoppingCartException()
10629 
          self.scx.read(iprot)
10630 
        else:
10631 
          iprot.skip(ftype)
10632 
      else:
10633 
        iprot.skip(ftype)
10634 
      iprot.readFieldEnd()
10635 
    iprot.readStructEnd()
10636 
 
10637 
  def write(self, oprot):
10638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10640 
      return
10641 
    oprot.writeStructBegin('changeQuantity_result')
10642 
    if self.scx != None:
10643 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10644 
      self.scx.write(oprot)
10645 
      oprot.writeFieldEnd()
10646 
    oprot.writeFieldStop()
10647 
    oprot.writeStructEnd()
10648 
 
10649 
  def __repr__(self):
10650 
    L = ['%s=%r' % (key, value)
10651 
      for key, value in self.__dict__.iteritems()]
10652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10653 
 
10654 
  def __eq__(self, other):
10655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10656 
 
10657 
  def __ne__(self, other):
10658 
    return not (self == other)
10659 
 
10660 
class changeItemStatus_args:
10661 
  """
10662 
  Attributes:
10663 
   - cartId
10664 
   - itemId
10665 
   - status
10666 
  """
10667 
 
10668 
  thrift_spec = (
10669 
    None, # 0
10670 
    (1, TType.I64, 'cartId', None, None, ), # 1
10671 
    (2, TType.I64, 'itemId', None, None, ), # 2
10672 
    (3, TType.I32, 'status', None, None, ), # 3
10673 
  )
10674 
 
10675 
  def __init__(self, cartId=None, itemId=None, status=None,):
10676 
    self.cartId = cartId
10677 
    self.itemId = itemId
10678 
    self.status = status
10679 
 
10680 
  def read(self, iprot):
10681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10683 
      return
10684 
    iprot.readStructBegin()
10685 
    while True:
10686 
      (fname, ftype, fid) = iprot.readFieldBegin()
10687 
      if ftype == TType.STOP:
10688 
        break
10689 
      if fid == 1:
10690 
        if ftype == TType.I64:
10691 
          self.cartId = iprot.readI64();
10692 
        else:
10693 
          iprot.skip(ftype)
10694 
      elif fid == 2:
10695 
        if ftype == TType.I64:
10696 
          self.itemId = iprot.readI64();
10697 
        else:
10698 
          iprot.skip(ftype)
10699 
      elif fid == 3:
10700 
        if ftype == TType.I32:
10701 
          self.status = iprot.readI32();
10702 
        else:
10703 
          iprot.skip(ftype)
10704 
      else:
10705 
        iprot.skip(ftype)
10706 
      iprot.readFieldEnd()
10707 
    iprot.readStructEnd()
10708 
 
10709 
  def write(self, oprot):
10710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10712 
      return
10713 
    oprot.writeStructBegin('changeItemStatus_args')
10714 
    if self.cartId != None:
10715 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10716 
      oprot.writeI64(self.cartId)
10717 
      oprot.writeFieldEnd()
10718 
    if self.itemId != None:
10719 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10720 
      oprot.writeI64(self.itemId)
10721 
      oprot.writeFieldEnd()
10722 
    if self.status != None:
10723 
      oprot.writeFieldBegin('status', TType.I32, 3)
10724 
      oprot.writeI32(self.status)
10725 
      oprot.writeFieldEnd()
10726 
    oprot.writeFieldStop()
10727 
    oprot.writeStructEnd()
10728 
 
10729 
  def __repr__(self):
10730 
    L = ['%s=%r' % (key, value)
10731 
      for key, value in self.__dict__.iteritems()]
10732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10733 
 
10734 
  def __eq__(self, other):
10735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10736 
 
10737 
  def __ne__(self, other):
10738 
    return not (self == other)
10739 
 
10740 
class changeItemStatus_result:
10741 
  """
10742 
  Attributes:
10743 
   - scx
10744 
  """
10745 
 
10746 
  thrift_spec = (
10747 
    None, # 0
10748 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10749 
  )
10750 
 
10751 
  def __init__(self, scx=None,):
10752 
    self.scx = scx
10753 
 
10754 
  def read(self, iprot):
10755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10757 
      return
10758 
    iprot.readStructBegin()
10759 
    while True:
10760 
      (fname, ftype, fid) = iprot.readFieldBegin()
10761 
      if ftype == TType.STOP:
10762 
        break
10763 
      if fid == 1:
10764 
        if ftype == TType.STRUCT:
10765 
          self.scx = ShoppingCartException()
10766 
          self.scx.read(iprot)
10767 
        else:
10768 
          iprot.skip(ftype)
10769 
      else:
10770 
        iprot.skip(ftype)
10771 
      iprot.readFieldEnd()
10772 
    iprot.readStructEnd()
10773 
 
10774 
  def write(self, oprot):
10775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10777 
      return
10778 
    oprot.writeStructBegin('changeItemStatus_result')
10779 
    if self.scx != None:
10780 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10781 
      self.scx.write(oprot)
10782 
      oprot.writeFieldEnd()
10783 
    oprot.writeFieldStop()
10784 
    oprot.writeStructEnd()
10785 
 
10786 
  def __repr__(self):
10787 
    L = ['%s=%r' % (key, value)
10788 
      for key, value in self.__dict__.iteritems()]
10789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10790 
 
10791 
  def __eq__(self, other):
10792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10793 
 
10794 
  def __ne__(self, other):
10795 
    return not (self == other)
10796 
 
10797 
class addAddressToCart_args:
10798 
  """
10799 
  Attributes:
10800 
   - cartId
10801 
   - addressId
10802 
  """
10803 
 
10804 
  thrift_spec = (
10805 
    None, # 0
10806 
    (1, TType.I64, 'cartId', None, None, ), # 1
10807 
    (2, TType.I64, 'addressId', None, None, ), # 2
10808 
  )
10809 
 
10810 
  def __init__(self, cartId=None, addressId=None,):
10811 
    self.cartId = cartId
10812 
    self.addressId = addressId
10813 
 
10814 
  def read(self, iprot):
10815 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10816 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10817 
      return
10818 
    iprot.readStructBegin()
10819 
    while True:
10820 
      (fname, ftype, fid) = iprot.readFieldBegin()
10821 
      if ftype == TType.STOP:
10822 
        break
10823 
      if fid == 1:
10824 
        if ftype == TType.I64:
10825 
          self.cartId = iprot.readI64();
10826 
        else:
10827 
          iprot.skip(ftype)
10828 
      elif fid == 2:
10829 
        if ftype == TType.I64:
10830 
          self.addressId = iprot.readI64();
10831 
        else:
10832 
          iprot.skip(ftype)
10833 
      else:
10834 
        iprot.skip(ftype)
10835 
      iprot.readFieldEnd()
10836 
    iprot.readStructEnd()
10837 
 
10838 
  def write(self, oprot):
10839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10841 
      return
10842 
    oprot.writeStructBegin('addAddressToCart_args')
10843 
    if self.cartId != None:
10844 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10845 
      oprot.writeI64(self.cartId)
10846 
      oprot.writeFieldEnd()
10847 
    if self.addressId != None:
10848 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
10849 
      oprot.writeI64(self.addressId)
10850 
      oprot.writeFieldEnd()
10851 
    oprot.writeFieldStop()
10852 
    oprot.writeStructEnd()
10853 
 
10854 
  def __repr__(self):
10855 
    L = ['%s=%r' % (key, value)
10856 
      for key, value in self.__dict__.iteritems()]
10857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10858 
 
10859 
  def __eq__(self, other):
10860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10861 
 
10862 
  def __ne__(self, other):
10863 
    return not (self == other)
10864 
 
10865 
class addAddressToCart_result:
575 chandransh 10866 
  """
10867 
  Attributes:
10868 
   - scx
10869 
  """
559 chandransh 10870 
 
10871 
  thrift_spec = (
575 chandransh 10872 
    None, # 0
10873 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 10874 
  )
10875 
 
575 chandransh 10876 
  def __init__(self, scx=None,):
10877 
    self.scx = scx
10878 
 
559 chandransh 10879 
  def read(self, iprot):
10880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10882 
      return
10883 
    iprot.readStructBegin()
10884 
    while True:
10885 
      (fname, ftype, fid) = iprot.readFieldBegin()
10886 
      if ftype == TType.STOP:
10887 
        break
575 chandransh 10888 
      if fid == 1:
10889 
        if ftype == TType.STRUCT:
10890 
          self.scx = ShoppingCartException()
10891 
          self.scx.read(iprot)
10892 
        else:
10893 
          iprot.skip(ftype)
559 chandransh 10894 
      else:
10895 
        iprot.skip(ftype)
10896 
      iprot.readFieldEnd()
10897 
    iprot.readStructEnd()
10898 
 
10899 
  def write(self, oprot):
10900 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10901 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10902 
      return
10903 
    oprot.writeStructBegin('addAddressToCart_result')
575 chandransh 10904 
    if self.scx != None:
10905 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10906 
      self.scx.write(oprot)
10907 
      oprot.writeFieldEnd()
559 chandransh 10908 
    oprot.writeFieldStop()
10909 
    oprot.writeStructEnd()
10910 
 
10911 
  def __repr__(self):
10912 
    L = ['%s=%r' % (key, value)
10913 
      for key, value in self.__dict__.iteritems()]
10914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10915 
 
10916 
  def __eq__(self, other):
10917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10918 
 
10919 
  def __ne__(self, other):
10920 
    return not (self == other)
10921 
 
1976 varun.gupt 10922 
class applyCouponToCart_args:
10923 
  """
10924 
  Attributes:
10925 
   - cartId
10926 
   - couponCode
10927 
   - totalPrice
10928 
   - discountedPrice
10929 
  """
10930 
 
10931 
  thrift_spec = (
10932 
    None, # 0
10933 
    (1, TType.I64, 'cartId', None, None, ), # 1
10934 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
10935 
    (3, TType.DOUBLE, 'totalPrice', None, None, ), # 3
10936 
    (4, TType.DOUBLE, 'discountedPrice', None, None, ), # 4
10937 
  )
10938 
 
10939 
  def __init__(self, cartId=None, couponCode=None, totalPrice=None, discountedPrice=None,):
10940 
    self.cartId = cartId
10941 
    self.couponCode = couponCode
10942 
    self.totalPrice = totalPrice
10943 
    self.discountedPrice = discountedPrice
10944 
 
10945 
  def read(self, iprot):
10946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10948 
      return
10949 
    iprot.readStructBegin()
10950 
    while True:
10951 
      (fname, ftype, fid) = iprot.readFieldBegin()
10952 
      if ftype == TType.STOP:
10953 
        break
10954 
      if fid == 1:
10955 
        if ftype == TType.I64:
10956 
          self.cartId = iprot.readI64();
10957 
        else:
10958 
          iprot.skip(ftype)
10959 
      elif fid == 2:
10960 
        if ftype == TType.STRING:
10961 
          self.couponCode = iprot.readString();
10962 
        else:
10963 
          iprot.skip(ftype)
10964 
      elif fid == 3:
10965 
        if ftype == TType.DOUBLE:
10966 
          self.totalPrice = iprot.readDouble();
10967 
        else:
10968 
          iprot.skip(ftype)
10969 
      elif fid == 4:
10970 
        if ftype == TType.DOUBLE:
10971 
          self.discountedPrice = iprot.readDouble();
10972 
        else:
10973 
          iprot.skip(ftype)
10974 
      else:
10975 
        iprot.skip(ftype)
10976 
      iprot.readFieldEnd()
10977 
    iprot.readStructEnd()
10978 
 
10979 
  def write(self, oprot):
10980 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10981 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10982 
      return
10983 
    oprot.writeStructBegin('applyCouponToCart_args')
10984 
    if self.cartId != None:
10985 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10986 
      oprot.writeI64(self.cartId)
10987 
      oprot.writeFieldEnd()
10988 
    if self.couponCode != None:
10989 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
10990 
      oprot.writeString(self.couponCode)
10991 
      oprot.writeFieldEnd()
10992 
    if self.totalPrice != None:
10993 
      oprot.writeFieldBegin('totalPrice', TType.DOUBLE, 3)
10994 
      oprot.writeDouble(self.totalPrice)
10995 
      oprot.writeFieldEnd()
10996 
    if self.discountedPrice != None:
10997 
      oprot.writeFieldBegin('discountedPrice', TType.DOUBLE, 4)
10998 
      oprot.writeDouble(self.discountedPrice)
10999 
      oprot.writeFieldEnd()
11000 
    oprot.writeFieldStop()
11001 
    oprot.writeStructEnd()
11002 
 
11003 
  def __repr__(self):
11004 
    L = ['%s=%r' % (key, value)
11005 
      for key, value in self.__dict__.iteritems()]
11006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11007 
 
11008 
  def __eq__(self, other):
11009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11010 
 
11011 
  def __ne__(self, other):
11012 
    return not (self == other)
11013 
 
11014 
class applyCouponToCart_result:
11015 
  """
11016 
  Attributes:
11017 
   - scx
11018 
  """
11019 
 
11020 
  thrift_spec = (
11021 
    None, # 0
11022 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11023 
  )
11024 
 
11025 
  def __init__(self, scx=None,):
11026 
    self.scx = scx
11027 
 
11028 
  def read(self, iprot):
11029 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11030 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11031 
      return
11032 
    iprot.readStructBegin()
11033 
    while True:
11034 
      (fname, ftype, fid) = iprot.readFieldBegin()
11035 
      if ftype == TType.STOP:
11036 
        break
11037 
      if fid == 1:
11038 
        if ftype == TType.STRUCT:
11039 
          self.scx = ShoppingCartException()
11040 
          self.scx.read(iprot)
11041 
        else:
11042 
          iprot.skip(ftype)
11043 
      else:
11044 
        iprot.skip(ftype)
11045 
      iprot.readFieldEnd()
11046 
    iprot.readStructEnd()
11047 
 
11048 
  def write(self, oprot):
11049 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11050 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11051 
      return
11052 
    oprot.writeStructBegin('applyCouponToCart_result')
11053 
    if self.scx != None:
11054 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11055 
      self.scx.write(oprot)
11056 
      oprot.writeFieldEnd()
11057 
    oprot.writeFieldStop()
11058 
    oprot.writeStructEnd()
11059 
 
11060 
  def __repr__(self):
11061 
    L = ['%s=%r' % (key, value)
11062 
      for key, value in self.__dict__.iteritems()]
11063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11064 
 
11065 
  def __eq__(self, other):
11066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11067 
 
11068 
  def __ne__(self, other):
11069 
    return not (self == other)
11070 
 
11071 
class removeCoupon_args:
11072 
  """
11073 
  Attributes:
11074 
   - cartId
11075 
  """
11076 
 
11077 
  thrift_spec = (
11078 
    None, # 0
11079 
    (1, TType.I64, 'cartId', None, None, ), # 1
11080 
  )
11081 
 
11082 
  def __init__(self, cartId=None,):
11083 
    self.cartId = cartId
11084 
 
11085 
  def read(self, iprot):
11086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11088 
      return
11089 
    iprot.readStructBegin()
11090 
    while True:
11091 
      (fname, ftype, fid) = iprot.readFieldBegin()
11092 
      if ftype == TType.STOP:
11093 
        break
11094 
      if fid == 1:
11095 
        if ftype == TType.I64:
11096 
          self.cartId = iprot.readI64();
11097 
        else:
11098 
          iprot.skip(ftype)
11099 
      else:
11100 
        iprot.skip(ftype)
11101 
      iprot.readFieldEnd()
11102 
    iprot.readStructEnd()
11103 
 
11104 
  def write(self, oprot):
11105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11107 
      return
11108 
    oprot.writeStructBegin('removeCoupon_args')
11109 
    if self.cartId != None:
11110 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11111 
      oprot.writeI64(self.cartId)
11112 
      oprot.writeFieldEnd()
11113 
    oprot.writeFieldStop()
11114 
    oprot.writeStructEnd()
11115 
 
11116 
  def __repr__(self):
11117 
    L = ['%s=%r' % (key, value)
11118 
      for key, value in self.__dict__.iteritems()]
11119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11120 
 
11121 
  def __eq__(self, other):
11122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11123 
 
11124 
  def __ne__(self, other):
11125 
    return not (self == other)
11126 
 
11127 
class removeCoupon_result:
11128 
  """
11129 
  Attributes:
11130 
   - scx
11131 
  """
11132 
 
11133 
  thrift_spec = (
11134 
    None, # 0
11135 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11136 
  )
11137 
 
11138 
  def __init__(self, scx=None,):
11139 
    self.scx = scx
11140 
 
11141 
  def read(self, iprot):
11142 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11143 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11144 
      return
11145 
    iprot.readStructBegin()
11146 
    while True:
11147 
      (fname, ftype, fid) = iprot.readFieldBegin()
11148 
      if ftype == TType.STOP:
11149 
        break
11150 
      if fid == 1:
11151 
        if ftype == TType.STRUCT:
11152 
          self.scx = ShoppingCartException()
11153 
          self.scx.read(iprot)
11154 
        else:
11155 
          iprot.skip(ftype)
11156 
      else:
11157 
        iprot.skip(ftype)
11158 
      iprot.readFieldEnd()
11159 
    iprot.readStructEnd()
11160 
 
11161 
  def write(self, oprot):
11162 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11163 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11164 
      return
11165 
    oprot.writeStructBegin('removeCoupon_result')
11166 
    if self.scx != None:
11167 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11168 
      self.scx.write(oprot)
11169 
      oprot.writeFieldEnd()
11170 
    oprot.writeFieldStop()
11171 
    oprot.writeStructEnd()
11172 
 
11173 
  def __repr__(self):
11174 
    L = ['%s=%r' % (key, value)
11175 
      for key, value in self.__dict__.iteritems()]
11176 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11177 
 
11178 
  def __eq__(self, other):
11179 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11180 
 
11181 
  def __ne__(self, other):
11182 
    return not (self == other)
11183 
 
690 chandransh 11184 
class createOrders_args:
559 chandransh 11185 
  """
11186 
  Attributes:
11187 
   - cartId
11188 
  """
11189 
 
11190 
  thrift_spec = (
11191 
    None, # 0
11192 
    (1, TType.I64, 'cartId', None, None, ), # 1
11193 
  )
11194 
 
11195 
  def __init__(self, cartId=None,):
11196 
    self.cartId = cartId
11197 
 
11198 
  def read(self, iprot):
11199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11201 
      return
11202 
    iprot.readStructBegin()
11203 
    while True:
11204 
      (fname, ftype, fid) = iprot.readFieldBegin()
11205 
      if ftype == TType.STOP:
11206 
        break
11207 
      if fid == 1:
11208 
        if ftype == TType.I64:
11209 
          self.cartId = iprot.readI64();
11210 
        else:
11211 
          iprot.skip(ftype)
11212 
      else:
11213 
        iprot.skip(ftype)
11214 
      iprot.readFieldEnd()
11215 
    iprot.readStructEnd()
11216 
 
11217 
  def write(self, oprot):
11218 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11219 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11220 
      return
690 chandransh 11221 
    oprot.writeStructBegin('createOrders_args')
559 chandransh 11222 
    if self.cartId != None:
11223 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11224 
      oprot.writeI64(self.cartId)
11225 
      oprot.writeFieldEnd()
11226 
    oprot.writeFieldStop()
11227 
    oprot.writeStructEnd()
11228 
 
11229 
  def __repr__(self):
11230 
    L = ['%s=%r' % (key, value)
11231 
      for key, value in self.__dict__.iteritems()]
11232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11233 
 
11234 
  def __eq__(self, other):
11235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11236 
 
11237 
  def __ne__(self, other):
11238 
    return not (self == other)
11239 
 
690 chandransh 11240 
class createOrders_result:
559 chandransh 11241 
  """
11242 
  Attributes:
94 ashish 11243 
   - success
559 chandransh 11244 
   - scx
94 ashish 11245 
  """
11246 
 
11247 
  thrift_spec = (
575 chandransh 11248 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 11249 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11250 
  )
11251 
 
559 chandransh 11252 
  def __init__(self, success=None, scx=None,):
94 ashish 11253 
    self.success = success
559 chandransh 11254 
    self.scx = scx
94 ashish 11255 
 
11256 
  def read(self, iprot):
11257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11259 
      return
11260 
    iprot.readStructBegin()
11261 
    while True:
11262 
      (fname, ftype, fid) = iprot.readFieldBegin()
11263 
      if ftype == TType.STOP:
11264 
        break
11265 
      if fid == 0:
575 chandransh 11266 
        if ftype == TType.I64:
11267 
          self.success = iprot.readI64();
94 ashish 11268 
        else:
11269 
          iprot.skip(ftype)
11270 
      elif fid == 1:
11271 
        if ftype == TType.STRUCT:
559 chandransh 11272 
          self.scx = ShoppingCartException()
11273 
          self.scx.read(iprot)
94 ashish 11274 
        else:
11275 
          iprot.skip(ftype)
11276 
      else:
11277 
        iprot.skip(ftype)
11278 
      iprot.readFieldEnd()
11279 
    iprot.readStructEnd()
11280 
 
11281 
  def write(self, oprot):
11282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11284 
      return
690 chandransh 11285 
    oprot.writeStructBegin('createOrders_result')
94 ashish 11286 
    if self.success != None:
575 chandransh 11287 
      oprot.writeFieldBegin('success', TType.I64, 0)
11288 
      oprot.writeI64(self.success)
94 ashish 11289 
      oprot.writeFieldEnd()
559 chandransh 11290 
    if self.scx != None:
11291 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11292 
      self.scx.write(oprot)
94 ashish 11293 
      oprot.writeFieldEnd()
11294 
    oprot.writeFieldStop()
11295 
    oprot.writeStructEnd()
11296 
 
11297 
  def __repr__(self):
11298 
    L = ['%s=%r' % (key, value)
11299 
      for key, value in self.__dict__.iteritems()]
11300 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11301 
 
11302 
  def __eq__(self, other):
11303 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11304 
 
11305 
  def __ne__(self, other):
11306 
    return not (self == other)
11307 
 
559 chandransh 11308 
class validateCart_args:
94 ashish 11309 
  """
11310 
  Attributes:
559 chandransh 11311 
   - cartId
94 ashish 11312 
  """
11313 
 
11314 
  thrift_spec = (
11315 
    None, # 0
559 chandransh 11316 
    (1, TType.I64, 'cartId', None, None, ), # 1
94 ashish 11317 
  )
11318 
 
559 chandransh 11319 
  def __init__(self, cartId=None,):
11320 
    self.cartId = cartId
94 ashish 11321 
 
11322 
  def read(self, iprot):
11323 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11324 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11325 
      return
11326 
    iprot.readStructBegin()
11327 
    while True:
11328 
      (fname, ftype, fid) = iprot.readFieldBegin()
11329 
      if ftype == TType.STOP:
11330 
        break
11331 
      if fid == 1:
11332 
        if ftype == TType.I64:
559 chandransh 11333 
          self.cartId = iprot.readI64();
94 ashish 11334 
        else:
11335 
          iprot.skip(ftype)
11336 
      else:
11337 
        iprot.skip(ftype)
11338 
      iprot.readFieldEnd()
11339 
    iprot.readStructEnd()
11340 
 
11341 
  def write(self, oprot):
11342 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11343 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11344 
      return
559 chandransh 11345 
    oprot.writeStructBegin('validateCart_args')
11346 
    if self.cartId != None:
11347 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11348 
      oprot.writeI64(self.cartId)
94 ashish 11349 
      oprot.writeFieldEnd()
11350 
    oprot.writeFieldStop()
11351 
    oprot.writeStructEnd()
11352 
 
11353 
  def __repr__(self):
11354 
    L = ['%s=%r' % (key, value)
11355 
      for key, value in self.__dict__.iteritems()]
11356 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11357 
 
11358 
  def __eq__(self, other):
11359 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11360 
 
11361 
  def __ne__(self, other):
11362 
    return not (self == other)
11363 
 
559 chandransh 11364 
class validateCart_result:
94 ashish 11365 
  """
11366 
  Attributes:
11367 
   - success
575 chandransh 11368 
   - scex
94 ashish 11369 
  """
11370 
 
11371 
  thrift_spec = (
1466 ankur.sing 11372 
    (0, TType.STRING, 'success', None, None, ), # 0
575 chandransh 11373 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11374 
  )
11375 
 
575 chandransh 11376 
  def __init__(self, success=None, scex=None,):
94 ashish 11377 
    self.success = success
575 chandransh 11378 
    self.scex = scex
94 ashish 11379 
 
11380 
  def read(self, iprot):
11381 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11382 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11383 
      return
11384 
    iprot.readStructBegin()
11385 
    while True:
11386 
      (fname, ftype, fid) = iprot.readFieldBegin()
11387 
      if ftype == TType.STOP:
11388 
        break
11389 
      if fid == 0:
1466 ankur.sing 11390 
        if ftype == TType.STRING:
11391 
          self.success = iprot.readString();
94 ashish 11392 
        else:
11393 
          iprot.skip(ftype)
575 chandransh 11394 
      elif fid == 1:
11395 
        if ftype == TType.STRUCT:
11396 
          self.scex = ShoppingCartException()
11397 
          self.scex.read(iprot)
11398 
        else:
11399 
          iprot.skip(ftype)
94 ashish 11400 
      else:
11401 
        iprot.skip(ftype)
11402 
      iprot.readFieldEnd()
11403 
    iprot.readStructEnd()
11404 
 
11405 
  def write(self, oprot):
11406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11408 
      return
559 chandransh 11409 
    oprot.writeStructBegin('validateCart_result')
94 ashish 11410 
    if self.success != None:
1466 ankur.sing 11411 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11412 
      oprot.writeString(self.success)
94 ashish 11413 
      oprot.writeFieldEnd()
575 chandransh 11414 
    if self.scex != None:
11415 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11416 
      self.scex.write(oprot)
11417 
      oprot.writeFieldEnd()
559 chandransh 11418 
    oprot.writeFieldStop()
11419 
    oprot.writeStructEnd()
11420 
 
11421 
  def __repr__(self):
11422 
    L = ['%s=%r' % (key, value)
11423 
      for key, value in self.__dict__.iteritems()]
11424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11425 
 
11426 
  def __eq__(self, other):
11427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11428 
 
11429 
  def __ne__(self, other):
11430 
    return not (self == other)
11431 
 
690 chandransh 11432 
class mergeCart_args:
575 chandransh 11433 
  """
11434 
  Attributes:
690 chandransh 11435 
   - fromCartId
11436 
   - toCartId
11437 
  """
11438 
 
11439 
  thrift_spec = (
11440 
    None, # 0
11441 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
11442 
    (2, TType.I64, 'toCartId', None, None, ), # 2
11443 
  )
11444 
 
11445 
  def __init__(self, fromCartId=None, toCartId=None,):
11446 
    self.fromCartId = fromCartId
11447 
    self.toCartId = toCartId
11448 
 
11449 
  def read(self, iprot):
11450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11452 
      return
11453 
    iprot.readStructBegin()
11454 
    while True:
11455 
      (fname, ftype, fid) = iprot.readFieldBegin()
11456 
      if ftype == TType.STOP:
11457 
        break
11458 
      if fid == 1:
11459 
        if ftype == TType.I64:
11460 
          self.fromCartId = iprot.readI64();
11461 
        else:
11462 
          iprot.skip(ftype)
11463 
      elif fid == 2:
11464 
        if ftype == TType.I64:
11465 
          self.toCartId = iprot.readI64();
11466 
        else:
11467 
          iprot.skip(ftype)
11468 
      else:
11469 
        iprot.skip(ftype)
11470 
      iprot.readFieldEnd()
11471 
    iprot.readStructEnd()
11472 
 
11473 
  def write(self, oprot):
11474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11476 
      return
11477 
    oprot.writeStructBegin('mergeCart_args')
11478 
    if self.fromCartId != None:
11479 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
11480 
      oprot.writeI64(self.fromCartId)
11481 
      oprot.writeFieldEnd()
11482 
    if self.toCartId != None:
11483 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
11484 
      oprot.writeI64(self.toCartId)
11485 
      oprot.writeFieldEnd()
11486 
    oprot.writeFieldStop()
11487 
    oprot.writeStructEnd()
11488 
 
11489 
  def __repr__(self):
11490 
    L = ['%s=%r' % (key, value)
11491 
      for key, value in self.__dict__.iteritems()]
11492 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11493 
 
11494 
  def __eq__(self, other):
11495 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11496 
 
11497 
  def __ne__(self, other):
11498 
    return not (self == other)
11499 
 
11500 
class mergeCart_result:
11501 
 
11502 
  thrift_spec = (
11503 
  )
11504 
 
11505 
  def read(self, iprot):
11506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11508 
      return
11509 
    iprot.readStructBegin()
11510 
    while True:
11511 
      (fname, ftype, fid) = iprot.readFieldBegin()
11512 
      if ftype == TType.STOP:
11513 
        break
11514 
      else:
11515 
        iprot.skip(ftype)
11516 
      iprot.readFieldEnd()
11517 
    iprot.readStructEnd()
11518 
 
11519 
  def write(self, oprot):
11520 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11521 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11522 
      return
11523 
    oprot.writeStructBegin('mergeCart_result')
11524 
    oprot.writeFieldStop()
11525 
    oprot.writeStructEnd()
11526 
 
11527 
  def __repr__(self):
11528 
    L = ['%s=%r' % (key, value)
11529 
      for key, value in self.__dict__.iteritems()]
11530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11531 
 
11532 
  def __eq__(self, other):
11533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11534 
 
11535 
  def __ne__(self, other):
11536 
    return not (self == other)
11537 
 
11538 
class checkOut_args:
11539 
  """
11540 
  Attributes:
575 chandransh 11541 
   - cartId
11542 
  """
11543 
 
11544 
  thrift_spec = (
11545 
    None, # 0
11546 
    (1, TType.I64, 'cartId', None, None, ), # 1
11547 
  )
11548 
 
11549 
  def __init__(self, cartId=None,):
11550 
    self.cartId = cartId
11551 
 
11552 
  def read(self, iprot):
11553 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11554 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11555 
      return
11556 
    iprot.readStructBegin()
11557 
    while True:
11558 
      (fname, ftype, fid) = iprot.readFieldBegin()
11559 
      if ftype == TType.STOP:
11560 
        break
11561 
      if fid == 1:
11562 
        if ftype == TType.I64:
11563 
          self.cartId = iprot.readI64();
11564 
        else:
11565 
          iprot.skip(ftype)
11566 
      else:
11567 
        iprot.skip(ftype)
11568 
      iprot.readFieldEnd()
11569 
    iprot.readStructEnd()
11570 
 
11571 
  def write(self, oprot):
11572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11574 
      return
690 chandransh 11575 
    oprot.writeStructBegin('checkOut_args')
575 chandransh 11576 
    if self.cartId != None:
11577 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11578 
      oprot.writeI64(self.cartId)
11579 
      oprot.writeFieldEnd()
11580 
    oprot.writeFieldStop()
11581 
    oprot.writeStructEnd()
11582 
 
11583 
  def __repr__(self):
11584 
    L = ['%s=%r' % (key, value)
11585 
      for key, value in self.__dict__.iteritems()]
11586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11587 
 
11588 
  def __eq__(self, other):
11589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11590 
 
11591 
  def __ne__(self, other):
11592 
    return not (self == other)
11593 
 
690 chandransh 11594 
class checkOut_result:
575 chandransh 11595 
  """
11596 
  Attributes:
11597 
   - success
11598 
   - scex
11599 
  """
11600 
 
11601 
  thrift_spec = (
11602 
    (0, TType.BOOL, 'success', None, None, ), # 0
11603 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11604 
  )
11605 
 
11606 
  def __init__(self, success=None, scex=None,):
11607 
    self.success = success
11608 
    self.scex = scex
11609 
 
11610 
  def read(self, iprot):
11611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11613 
      return
11614 
    iprot.readStructBegin()
11615 
    while True:
11616 
      (fname, ftype, fid) = iprot.readFieldBegin()
11617 
      if ftype == TType.STOP:
11618 
        break
11619 
      if fid == 0:
11620 
        if ftype == TType.BOOL:
11621 
          self.success = iprot.readBool();
11622 
        else:
11623 
          iprot.skip(ftype)
11624 
      elif fid == 1:
11625 
        if ftype == TType.STRUCT:
11626 
          self.scex = ShoppingCartException()
11627 
          self.scex.read(iprot)
11628 
        else:
11629 
          iprot.skip(ftype)
11630 
      else:
11631 
        iprot.skip(ftype)
11632 
      iprot.readFieldEnd()
11633 
    iprot.readStructEnd()
11634 
 
11635 
  def write(self, oprot):
11636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11638 
      return
690 chandransh 11639 
    oprot.writeStructBegin('checkOut_result')
575 chandransh 11640 
    if self.success != None:
11641 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11642 
      oprot.writeBool(self.success)
11643 
      oprot.writeFieldEnd()
11644 
    if self.scex != None:
11645 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11646 
      self.scex.write(oprot)
11647 
      oprot.writeFieldEnd()
11648 
    oprot.writeFieldStop()
11649 
    oprot.writeStructEnd()
11650 
 
11651 
  def __repr__(self):
11652 
    L = ['%s=%r' % (key, value)
11653 
      for key, value in self.__dict__.iteritems()]
11654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11655 
 
11656 
  def __eq__(self, other):
11657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11658 
 
11659 
  def __ne__(self, other):
11660 
    return not (self == other)
11661 
 
690 chandransh 11662 
class resetCart_args:
559 chandransh 11663 
  """
11664 
  Attributes:
690 chandransh 11665 
   - cartId
11666 
   - items
559 chandransh 11667 
  """
11668 
 
11669 
  thrift_spec = (
11670 
    None, # 0
690 chandransh 11671 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 11672 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 11673 
  )
11674 
 
690 chandransh 11675 
  def __init__(self, cartId=None, items=None,):
11676 
    self.cartId = cartId
11677 
    self.items = items
559 chandransh 11678 
 
11679 
  def read(self, iprot):
11680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11682 
      return
11683 
    iprot.readStructBegin()
11684 
    while True:
11685 
      (fname, ftype, fid) = iprot.readFieldBegin()
11686 
      if ftype == TType.STOP:
11687 
        break
11688 
      if fid == 1:
11689 
        if ftype == TType.I64:
690 chandransh 11690 
          self.cartId = iprot.readI64();
559 chandransh 11691 
        else:
11692 
          iprot.skip(ftype)
11693 
      elif fid == 2:
690 chandransh 11694 
        if ftype == TType.MAP:
11695 
          self.items = {}
1976 varun.gupt 11696 
          (_ktype120, _vtype121, _size119 ) = iprot.readMapBegin()
11697 
          for _i123 in xrange(_size119):
11698 
            _key124 = iprot.readI64();
11699 
            _val125 = iprot.readDouble();
11700 
            self.items[_key124] = _val125
690 chandransh 11701 
          iprot.readMapEnd()
559 chandransh 11702 
        else:
11703 
          iprot.skip(ftype)
11704 
      else:
11705 
        iprot.skip(ftype)
11706 
      iprot.readFieldEnd()
11707 
    iprot.readStructEnd()
11708 
 
11709 
  def write(self, oprot):
11710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11712 
      return
690 chandransh 11713 
    oprot.writeStructBegin('resetCart_args')
11714 
    if self.cartId != None:
11715 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11716 
      oprot.writeI64(self.cartId)
94 ashish 11717 
      oprot.writeFieldEnd()
690 chandransh 11718 
    if self.items != None:
11719 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 11720 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
1976 varun.gupt 11721 
      for kiter126,viter127 in self.items.items():
11722 
        oprot.writeI64(kiter126)
11723 
        oprot.writeDouble(viter127)
690 chandransh 11724 
      oprot.writeMapEnd()
559 chandransh 11725 
      oprot.writeFieldEnd()
94 ashish 11726 
    oprot.writeFieldStop()
11727 
    oprot.writeStructEnd()
11728 
 
11729 
  def __repr__(self):
11730 
    L = ['%s=%r' % (key, value)
11731 
      for key, value in self.__dict__.iteritems()]
11732 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11733 
 
11734 
  def __eq__(self, other):
11735 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11736 
 
11737 
  def __ne__(self, other):
11738 
    return not (self == other)
11739 
 
690 chandransh 11740 
class resetCart_result:
11741 
  """
11742 
  Attributes:
11743 
   - success
11744 
   - scex
11745 
  """
559 chandransh 11746 
 
11747 
  thrift_spec = (
690 chandransh 11748 
    (0, TType.BOOL, 'success', None, None, ), # 0
11749 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11750 
  )
11751 
 
690 chandransh 11752 
  def __init__(self, success=None, scex=None,):
11753 
    self.success = success
11754 
    self.scex = scex
11755 
 
559 chandransh 11756 
  def read(self, iprot):
11757 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11758 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11759 
      return
11760 
    iprot.readStructBegin()
11761 
    while True:
11762 
      (fname, ftype, fid) = iprot.readFieldBegin()
11763 
      if ftype == TType.STOP:
11764 
        break
690 chandransh 11765 
      if fid == 0:
11766 
        if ftype == TType.BOOL:
11767 
          self.success = iprot.readBool();
11768 
        else:
11769 
          iprot.skip(ftype)
11770 
      elif fid == 1:
11771 
        if ftype == TType.STRUCT:
11772 
          self.scex = ShoppingCartException()
11773 
          self.scex.read(iprot)
11774 
        else:
11775 
          iprot.skip(ftype)
559 chandransh 11776 
      else:
11777 
        iprot.skip(ftype)
11778 
      iprot.readFieldEnd()
11779 
    iprot.readStructEnd()
11780 
 
11781 
  def write(self, oprot):
11782 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11783 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11784 
      return
690 chandransh 11785 
    oprot.writeStructBegin('resetCart_result')
11786 
    if self.success != None:
11787 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11788 
      oprot.writeBool(self.success)
11789 
      oprot.writeFieldEnd()
11790 
    if self.scex != None:
11791 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11792 
      self.scex.write(oprot)
11793 
      oprot.writeFieldEnd()
559 chandransh 11794 
    oprot.writeFieldStop()
11795 
    oprot.writeStructEnd()
11796 
 
11797 
  def __repr__(self):
11798 
    L = ['%s=%r' % (key, value)
11799 
      for key, value in self.__dict__.iteritems()]
11800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11801 
 
11802 
  def __eq__(self, other):
11803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11804 
 
11805 
  def __ne__(self, other):
11806 
    return not (self == other)
11807 
 
772 rajveer 11808 
class getMyResearch_args:
94 ashish 11809 
  """
11810 
  Attributes:
559 chandransh 11811 
   - userId
11812 
  """
11813 
 
11814 
  thrift_spec = (
11815 
    None, # 0
772 rajveer 11816 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 11817 
  )
11818 
 
772 rajveer 11819 
  def __init__(self, userId=None,):
559 chandransh 11820 
    self.userId = userId
11821 
 
11822 
  def read(self, iprot):
11823 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11824 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11825 
      return
11826 
    iprot.readStructBegin()
11827 
    while True:
11828 
      (fname, ftype, fid) = iprot.readFieldBegin()
11829 
      if ftype == TType.STOP:
11830 
        break
11831 
      if fid == 1:
11832 
        if ftype == TType.I64:
11833 
          self.userId = iprot.readI64();
11834 
        else:
11835 
          iprot.skip(ftype)
11836 
      else:
11837 
        iprot.skip(ftype)
11838 
      iprot.readFieldEnd()
11839 
    iprot.readStructEnd()
11840 
 
11841 
  def write(self, oprot):
11842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11844 
      return
772 rajveer 11845 
    oprot.writeStructBegin('getMyResearch_args')
559 chandransh 11846 
    if self.userId != None:
772 rajveer 11847 
      oprot.writeFieldBegin('userId', TType.I64, 1)
559 chandransh 11848 
      oprot.writeI64(self.userId)
11849 
      oprot.writeFieldEnd()
11850 
    oprot.writeFieldStop()
11851 
    oprot.writeStructEnd()
11852 
 
11853 
  def __repr__(self):
11854 
    L = ['%s=%r' % (key, value)
11855 
      for key, value in self.__dict__.iteritems()]
11856 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11857 
 
11858 
  def __eq__(self, other):
11859 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11860 
 
11861 
  def __ne__(self, other):
11862 
    return not (self == other)
11863 
 
11864 
class getMyResearch_result:
94 ashish 11865 
  """
11866 
  Attributes:
11867 
   - success
559 chandransh 11868 
   - scx
94 ashish 11869 
  """
11870 
 
11871 
  thrift_spec = (
559 chandransh 11872 
    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
11873 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
94 ashish 11874 
  )
11875 
 
559 chandransh 11876 
  def __init__(self, success=None, scx=None,):
94 ashish 11877 
    self.success = success
559 chandransh 11878 
    self.scx = scx
94 ashish 11879 
 
11880 
  def read(self, iprot):
11881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11883 
      return
11884 
    iprot.readStructBegin()
11885 
    while True:
11886 
      (fname, ftype, fid) = iprot.readFieldBegin()
11887 
      if ftype == TType.STOP:
11888 
        break
11889 
      if fid == 0:
559 chandransh 11890 
        if ftype == TType.STRUCT:
11891 
          self.success = Widget()
11892 
          self.success.read(iprot)
94 ashish 11893 
        else:
11894 
          iprot.skip(ftype)
11895 
      elif fid == 1:
11896 
        if ftype == TType.STRUCT:
559 chandransh 11897 
          self.scx = WidgetException()
11898 
          self.scx.read(iprot)
94 ashish 11899 
        else:
11900 
          iprot.skip(ftype)
11901 
      else:
11902 
        iprot.skip(ftype)
11903 
      iprot.readFieldEnd()
11904 
    iprot.readStructEnd()
11905 
 
11906 
  def write(self, oprot):
11907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11909 
      return
559 chandransh 11910 
    oprot.writeStructBegin('getMyResearch_result')
94 ashish 11911 
    if self.success != None:
559 chandransh 11912 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11913 
      self.success.write(oprot)
94 ashish 11914 
      oprot.writeFieldEnd()
559 chandransh 11915 
    if self.scx != None:
11916 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11917 
      self.scx.write(oprot)
94 ashish 11918 
      oprot.writeFieldEnd()
11919 
    oprot.writeFieldStop()
11920 
    oprot.writeStructEnd()
11921 
 
11922 
  def __repr__(self):
11923 
    L = ['%s=%r' % (key, value)
11924 
      for key, value in self.__dict__.iteritems()]
11925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11926 
 
11927 
  def __eq__(self, other):
11928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11929 
 
11930 
  def __ne__(self, other):
11931 
    return not (self == other)
11932 
 
559 chandransh 11933 
class updateMyResearch_args:
94 ashish 11934 
  """
11935 
  Attributes:
772 rajveer 11936 
   - userId
11937 
   - itemId
94 ashish 11938 
  """
11939 
 
11940 
  thrift_spec = (
11941 
    None, # 0
772 rajveer 11942 
    (1, TType.I64, 'userId', None, None, ), # 1
11943 
    (2, TType.I64, 'itemId', None, None, ), # 2
94 ashish 11944 
  )
11945 
 
772 rajveer 11946 
  def __init__(self, userId=None, itemId=None,):
11947 
    self.userId = userId
11948 
    self.itemId = itemId
94 ashish 11949 
 
11950 
  def read(self, iprot):
11951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11953 
      return
11954 
    iprot.readStructBegin()
11955 
    while True:
11956 
      (fname, ftype, fid) = iprot.readFieldBegin()
11957 
      if ftype == TType.STOP:
11958 
        break
11959 
      if fid == 1:
11960 
        if ftype == TType.I64:
772 rajveer 11961 
          self.userId = iprot.readI64();
94 ashish 11962 
        else:
11963 
          iprot.skip(ftype)
11964 
      elif fid == 2:
559 chandransh 11965 
        if ftype == TType.I64:
772 rajveer 11966 
          self.itemId = iprot.readI64();
94 ashish 11967 
        else:
11968 
          iprot.skip(ftype)
11969 
      else:
11970 
        iprot.skip(ftype)
11971 
      iprot.readFieldEnd()
11972 
    iprot.readStructEnd()
11973 
 
11974 
  def write(self, oprot):
11975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11977 
      return
559 chandransh 11978 
    oprot.writeStructBegin('updateMyResearch_args')
772 rajveer 11979 
    if self.userId != None:
11980 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11981 
      oprot.writeI64(self.userId)
94 ashish 11982 
      oprot.writeFieldEnd()
772 rajveer 11983 
    if self.itemId != None:
11984 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11985 
      oprot.writeI64(self.itemId)
94 ashish 11986 
      oprot.writeFieldEnd()
11987 
    oprot.writeFieldStop()
11988 
    oprot.writeStructEnd()
11989 
 
11990 
  def __repr__(self):
11991 
    L = ['%s=%r' % (key, value)
11992 
      for key, value in self.__dict__.iteritems()]
11993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11994 
 
11995 
  def __eq__(self, other):
11996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11997 
 
11998 
  def __ne__(self, other):
11999 
    return not (self == other)
12000 
 
559 chandransh 12001 
class updateMyResearch_result:
94 ashish 12002 
  """
12003 
  Attributes:
12004 
   - success
559 chandransh 12005 
   - scx
94 ashish 12006 
  """
12007 
 
12008 
  thrift_spec = (
12009 
    (0, TType.BOOL, 'success', None, None, ), # 0
559 chandransh 12010 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
94 ashish 12011 
  )
12012 
 
559 chandransh 12013 
  def __init__(self, success=None, scx=None,):
94 ashish 12014 
    self.success = success
559 chandransh 12015 
    self.scx = scx
94 ashish 12016 
 
12017 
  def read(self, iprot):
12018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12020 
      return
12021 
    iprot.readStructBegin()
12022 
    while True:
12023 
      (fname, ftype, fid) = iprot.readFieldBegin()
12024 
      if ftype == TType.STOP:
12025 
        break
12026 
      if fid == 0:
12027 
        if ftype == TType.BOOL:
12028 
          self.success = iprot.readBool();
12029 
        else:
12030 
          iprot.skip(ftype)
12031 
      elif fid == 1:
12032 
        if ftype == TType.STRUCT:
559 chandransh 12033 
          self.scx = WidgetException()
12034 
          self.scx.read(iprot)
94 ashish 12035 
        else:
12036 
          iprot.skip(ftype)
12037 
      else:
12038 
        iprot.skip(ftype)
12039 
      iprot.readFieldEnd()
12040 
    iprot.readStructEnd()
12041 
 
12042 
  def write(self, oprot):
12043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12045 
      return
559 chandransh 12046 
    oprot.writeStructBegin('updateMyResearch_result')
94 ashish 12047 
    if self.success != None:
12048 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12049 
      oprot.writeBool(self.success)
12050 
      oprot.writeFieldEnd()
559 chandransh 12051 
    if self.scx != None:
12052 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12053 
      self.scx.write(oprot)
94 ashish 12054 
      oprot.writeFieldEnd()
12055 
    oprot.writeFieldStop()
12056 
    oprot.writeStructEnd()
12057 
 
12058 
  def __repr__(self):
12059 
    L = ['%s=%r' % (key, value)
12060 
      for key, value in self.__dict__.iteritems()]
12061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12062 
 
12063 
  def __eq__(self, other):
12064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12065 
 
12066 
  def __ne__(self, other):
12067 
    return not (self == other)
12068 
 
559 chandransh 12069 
class deleteItemFromMyResearch_args:
130 ashish 12070 
  """
12071 
  Attributes:
772 rajveer 12072 
   - userId
12073 
   - itemId
130 ashish 12074 
  """
94 ashish 12075 
 
130 ashish 12076 
  thrift_spec = (
12077 
    None, # 0
772 rajveer 12078 
    (1, TType.I64, 'userId', None, None, ), # 1
12079 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 12080 
  )
12081 
 
772 rajveer 12082 
  def __init__(self, userId=None, itemId=None,):
12083 
    self.userId = userId
12084 
    self.itemId = itemId
130 ashish 12085 
 
12086 
  def read(self, iprot):
12087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12089 
      return
12090 
    iprot.readStructBegin()
12091 
    while True:
12092 
      (fname, ftype, fid) = iprot.readFieldBegin()
12093 
      if ftype == TType.STOP:
12094 
        break
12095 
      if fid == 1:
12096 
        if ftype == TType.I64:
772 rajveer 12097 
          self.userId = iprot.readI64();
130 ashish 12098 
        else:
12099 
          iprot.skip(ftype)
559 chandransh 12100 
      elif fid == 2:
12101 
        if ftype == TType.I64:
772 rajveer 12102 
          self.itemId = iprot.readI64();
559 chandransh 12103 
        else:
12104 
          iprot.skip(ftype)
130 ashish 12105 
      else:
12106 
        iprot.skip(ftype)
12107 
      iprot.readFieldEnd()
12108 
    iprot.readStructEnd()
12109 
 
12110 
  def write(self, oprot):
12111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12113 
      return
559 chandransh 12114 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
772 rajveer 12115 
    if self.userId != None:
12116 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12117 
      oprot.writeI64(self.userId)
130 ashish 12118 
      oprot.writeFieldEnd()
772 rajveer 12119 
    if self.itemId != None:
12120 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12121 
      oprot.writeI64(self.itemId)
559 chandransh 12122 
      oprot.writeFieldEnd()
130 ashish 12123 
    oprot.writeFieldStop()
12124 
    oprot.writeStructEnd()
12125 
 
12126 
  def __repr__(self):
12127 
    L = ['%s=%r' % (key, value)
12128 
      for key, value in self.__dict__.iteritems()]
12129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12130 
 
12131 
  def __eq__(self, other):
12132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12133 
 
12134 
  def __ne__(self, other):
12135 
    return not (self == other)
12136 
 
559 chandransh 12137 
class deleteItemFromMyResearch_result:
130 ashish 12138 
  """
12139 
  Attributes:
559 chandransh 12140 
   - scx
12141 
  """
12142 
 
12143 
  thrift_spec = (
12144 
    None, # 0
12145 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
12146 
  )
12147 
 
12148 
  def __init__(self, scx=None,):
12149 
    self.scx = scx
12150 
 
12151 
  def read(self, iprot):
12152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12154 
      return
12155 
    iprot.readStructBegin()
12156 
    while True:
12157 
      (fname, ftype, fid) = iprot.readFieldBegin()
12158 
      if ftype == TType.STOP:
12159 
        break
12160 
      if fid == 1:
12161 
        if ftype == TType.STRUCT:
12162 
          self.scx = WidgetException()
12163 
          self.scx.read(iprot)
12164 
        else:
12165 
          iprot.skip(ftype)
12166 
      else:
12167 
        iprot.skip(ftype)
12168 
      iprot.readFieldEnd()
12169 
    iprot.readStructEnd()
12170 
 
12171 
  def write(self, oprot):
12172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12174 
      return
12175 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
12176 
    if self.scx != None:
12177 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12178 
      self.scx.write(oprot)
12179 
      oprot.writeFieldEnd()
12180 
    oprot.writeFieldStop()
12181 
    oprot.writeStructEnd()
12182 
 
12183 
  def __repr__(self):
12184 
    L = ['%s=%r' % (key, value)
12185 
      for key, value in self.__dict__.iteritems()]
12186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12187 
 
12188 
  def __eq__(self, other):
12189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12190 
 
12191 
  def __ne__(self, other):
12192 
    return not (self == other)
12193 
 
772 rajveer 12194 
class updateBrowseHistory_args:
559 chandransh 12195 
  """
12196 
  Attributes:
772 rajveer 12197 
   - userId
12198 
   - itemId
559 chandransh 12199 
  """
12200 
 
12201 
  thrift_spec = (
12202 
    None, # 0
772 rajveer 12203 
    (1, TType.I64, 'userId', None, None, ), # 1
12204 
    (2, TType.I64, 'itemId', None, None, ), # 2
559 chandransh 12205 
  )
12206 
 
772 rajveer 12207 
  def __init__(self, userId=None, itemId=None,):
12208 
    self.userId = userId
12209 
    self.itemId = itemId
559 chandransh 12210 
 
12211 
  def read(self, iprot):
12212 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12213 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12214 
      return
12215 
    iprot.readStructBegin()
12216 
    while True:
12217 
      (fname, ftype, fid) = iprot.readFieldBegin()
12218 
      if ftype == TType.STOP:
12219 
        break
12220 
      if fid == 1:
12221 
        if ftype == TType.I64:
772 rajveer 12222 
          self.userId = iprot.readI64();
559 chandransh 12223 
        else:
12224 
          iprot.skip(ftype)
12225 
      elif fid == 2:
12226 
        if ftype == TType.I64:
772 rajveer 12227 
          self.itemId = iprot.readI64();
559 chandransh 12228 
        else:
12229 
          iprot.skip(ftype)
12230 
      else:
12231 
        iprot.skip(ftype)
12232 
      iprot.readFieldEnd()
12233 
    iprot.readStructEnd()
12234 
 
12235 
  def write(self, oprot):
12236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12238 
      return
772 rajveer 12239 
    oprot.writeStructBegin('updateBrowseHistory_args')
12240 
    if self.userId != None:
12241 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12242 
      oprot.writeI64(self.userId)
559 chandransh 12243 
      oprot.writeFieldEnd()
772 rajveer 12244 
    if self.itemId != None:
12245 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12246 
      oprot.writeI64(self.itemId)
559 chandransh 12247 
      oprot.writeFieldEnd()
12248 
    oprot.writeFieldStop()
12249 
    oprot.writeStructEnd()
12250 
 
12251 
  def __repr__(self):
12252 
    L = ['%s=%r' % (key, value)
12253 
      for key, value in self.__dict__.iteritems()]
12254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12255 
 
12256 
  def __eq__(self, other):
12257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12258 
 
12259 
  def __ne__(self, other):
12260 
    return not (self == other)
12261 
 
772 rajveer 12262 
class updateBrowseHistory_result:
559 chandransh 12263 
 
12264 
  thrift_spec = (
12265 
  )
12266 
 
12267 
  def read(self, iprot):
12268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12270 
      return
12271 
    iprot.readStructBegin()
12272 
    while True:
12273 
      (fname, ftype, fid) = iprot.readFieldBegin()
12274 
      if ftype == TType.STOP:
12275 
        break
12276 
      else:
12277 
        iprot.skip(ftype)
12278 
      iprot.readFieldEnd()
12279 
    iprot.readStructEnd()
12280 
 
12281 
  def write(self, oprot):
12282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12284 
      return
772 rajveer 12285 
    oprot.writeStructBegin('updateBrowseHistory_result')
559 chandransh 12286 
    oprot.writeFieldStop()
12287 
    oprot.writeStructEnd()
12288 
 
12289 
  def __repr__(self):
12290 
    L = ['%s=%r' % (key, value)
12291 
      for key, value in self.__dict__.iteritems()]
12292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12293 
 
12294 
  def __eq__(self, other):
12295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12296 
 
12297 
  def __ne__(self, other):
12298 
    return not (self == other)
12299 
 
772 rajveer 12300 
class getBrowseHistory_args:
559 chandransh 12301 
  """
12302 
  Attributes:
772 rajveer 12303 
   - userId
559 chandransh 12304 
  """
12305 
 
12306 
  thrift_spec = (
12307 
    None, # 0
772 rajveer 12308 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 12309 
  )
12310 
 
772 rajveer 12311 
  def __init__(self, userId=None,):
12312 
    self.userId = userId
559 chandransh 12313 
 
12314 
  def read(self, iprot):
12315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12317 
      return
12318 
    iprot.readStructBegin()
12319 
    while True:
12320 
      (fname, ftype, fid) = iprot.readFieldBegin()
12321 
      if ftype == TType.STOP:
12322 
        break
12323 
      if fid == 1:
12324 
        if ftype == TType.I64:
772 rajveer 12325 
          self.userId = iprot.readI64();
559 chandransh 12326 
        else:
12327 
          iprot.skip(ftype)
12328 
      else:
12329 
        iprot.skip(ftype)
12330 
      iprot.readFieldEnd()
12331 
    iprot.readStructEnd()
12332 
 
12333 
  def write(self, oprot):
12334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12336 
      return
772 rajveer 12337 
    oprot.writeStructBegin('getBrowseHistory_args')
12338 
    if self.userId != None:
12339 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12340 
      oprot.writeI64(self.userId)
559 chandransh 12341 
      oprot.writeFieldEnd()
12342 
    oprot.writeFieldStop()
12343 
    oprot.writeStructEnd()
12344 
 
12345 
  def __repr__(self):
12346 
    L = ['%s=%r' % (key, value)
12347 
      for key, value in self.__dict__.iteritems()]
12348 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12349 
 
12350 
  def __eq__(self, other):
12351 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12352 
 
12353 
  def __ne__(self, other):
12354 
    return not (self == other)
12355 
 
772 rajveer 12356 
class getBrowseHistory_result:
559 chandransh 12357 
  """
12358 
  Attributes:
130 ashish 12359 
   - success
559 chandransh 12360 
   - scx
130 ashish 12361 
  """
12362 
 
12363 
  thrift_spec = (
772 rajveer 12364 
    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
559 chandransh 12365 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 12366 
  )
12367 
 
559 chandransh 12368 
  def __init__(self, success=None, scx=None,):
130 ashish 12369 
    self.success = success
559 chandransh 12370 
    self.scx = scx
130 ashish 12371 
 
12372 
  def read(self, iprot):
12373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12375 
      return
12376 
    iprot.readStructBegin()
12377 
    while True:
12378 
      (fname, ftype, fid) = iprot.readFieldBegin()
12379 
      if ftype == TType.STOP:
12380 
        break
12381 
      if fid == 0:
559 chandransh 12382 
        if ftype == TType.STRUCT:
772 rajveer 12383 
          self.success = Widget()
559 chandransh 12384 
          self.success.read(iprot)
130 ashish 12385 
        else:
12386 
          iprot.skip(ftype)
12387 
      elif fid == 1:
12388 
        if ftype == TType.STRUCT:
559 chandransh 12389 
          self.scx = WidgetException()
12390 
          self.scx.read(iprot)
130 ashish 12391 
        else:
12392 
          iprot.skip(ftype)
12393 
      else:
12394 
        iprot.skip(ftype)
12395 
      iprot.readFieldEnd()
12396 
    iprot.readStructEnd()
12397 
 
12398 
  def write(self, oprot):
12399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12401 
      return
772 rajveer 12402 
    oprot.writeStructBegin('getBrowseHistory_result')
130 ashish 12403 
    if self.success != None:
559 chandransh 12404 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12405 
      self.success.write(oprot)
130 ashish 12406 
      oprot.writeFieldEnd()
559 chandransh 12407 
    if self.scx != None:
12408 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12409 
      self.scx.write(oprot)
130 ashish 12410 
      oprot.writeFieldEnd()
12411 
    oprot.writeFieldStop()
12412 
    oprot.writeStructEnd()
12413 
 
12414 
  def __repr__(self):
12415 
    L = ['%s=%r' % (key, value)
12416 
      for key, value in self.__dict__.iteritems()]
12417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12418 
 
12419 
  def __eq__(self, other):
12420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12421 
 
12422 
  def __ne__(self, other):
12423 
    return not (self == other)
12424 
 
772 rajveer 12425 
class mergeBrowseHistory_args:
130 ashish 12426 
  """
12427 
  Attributes:
772 rajveer 12428 
   - fromUserId
12429 
   - toUserId
130 ashish 12430 
  """
12431 
 
12432 
  thrift_spec = (
12433 
    None, # 0
772 rajveer 12434 
    (1, TType.I64, 'fromUserId', None, None, ), # 1
12435 
    (2, TType.I64, 'toUserId', None, None, ), # 2
130 ashish 12436 
  )
12437 
 
772 rajveer 12438 
  def __init__(self, fromUserId=None, toUserId=None,):
12439 
    self.fromUserId = fromUserId
12440 
    self.toUserId = toUserId
130 ashish 12441 
 
12442 
  def read(self, iprot):
12443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12445 
      return
12446 
    iprot.readStructBegin()
12447 
    while True:
12448 
      (fname, ftype, fid) = iprot.readFieldBegin()
12449 
      if ftype == TType.STOP:
12450 
        break
12451 
      if fid == 1:
559 chandransh 12452 
        if ftype == TType.I64:
772 rajveer 12453 
          self.fromUserId = iprot.readI64();
130 ashish 12454 
        else:
12455 
          iprot.skip(ftype)
12456 
      elif fid == 2:
559 chandransh 12457 
        if ftype == TType.I64:
772 rajveer 12458 
          self.toUserId = iprot.readI64();
559 chandransh 12459 
        else:
12460 
          iprot.skip(ftype)
130 ashish 12461 
      else:
12462 
        iprot.skip(ftype)
12463 
      iprot.readFieldEnd()
12464 
    iprot.readStructEnd()
12465 
 
12466 
  def write(self, oprot):
12467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12469 
      return
772 rajveer 12470 
    oprot.writeStructBegin('mergeBrowseHistory_args')
12471 
    if self.fromUserId != None:
12472 
      oprot.writeFieldBegin('fromUserId', TType.I64, 1)
12473 
      oprot.writeI64(self.fromUserId)
130 ashish 12474 
      oprot.writeFieldEnd()
772 rajveer 12475 
    if self.toUserId != None:
12476 
      oprot.writeFieldBegin('toUserId', TType.I64, 2)
12477 
      oprot.writeI64(self.toUserId)
130 ashish 12478 
      oprot.writeFieldEnd()
12479 
    oprot.writeFieldStop()
12480 
    oprot.writeStructEnd()
12481 
 
12482 
  def __repr__(self):
12483 
    L = ['%s=%r' % (key, value)
12484 
      for key, value in self.__dict__.iteritems()]
12485 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12486 
 
12487 
  def __eq__(self, other):
12488 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12489 
 
12490 
  def __ne__(self, other):
12491 
    return not (self == other)
12492 
 
772 rajveer 12493 
class mergeBrowseHistory_result:
559 chandransh 12494 
 
12495 
  thrift_spec = (
12496 
  )
12497 
 
12498 
  def read(self, iprot):
12499 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12500 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12501 
      return
12502 
    iprot.readStructBegin()
12503 
    while True:
12504 
      (fname, ftype, fid) = iprot.readFieldBegin()
12505 
      if ftype == TType.STOP:
12506 
        break
12507 
      else:
12508 
        iprot.skip(ftype)
12509 
      iprot.readFieldEnd()
12510 
    iprot.readStructEnd()
12511 
 
12512 
  def write(self, oprot):
12513 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12514 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12515 
      return
772 rajveer 12516 
    oprot.writeStructBegin('mergeBrowseHistory_result')
559 chandransh 12517 
    oprot.writeFieldStop()
12518 
    oprot.writeStructEnd()
12519 
 
12520 
  def __repr__(self):
12521 
    L = ['%s=%r' % (key, value)
12522 
      for key, value in self.__dict__.iteritems()]
12523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12524 
 
12525 
  def __eq__(self, other):
12526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12527 
 
12528 
  def __ne__(self, other):
12529 
    return not (self == other)
12530 
 
1596 ankur.sing 12531 
class getUserCount_args:
12532 
  """
12533 
  Attributes:
12534 
   - userType
12535 
  """
559 chandransh 12536 
 
1596 ankur.sing 12537 
  thrift_spec = (
12538 
    None, # 0
12539 
    (1, TType.I32, 'userType', None, None, ), # 1
12540 
  )
12541 
 
12542 
  def __init__(self, userType=None,):
12543 
    self.userType = userType
12544 
 
12545 
  def read(self, iprot):
12546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12548 
      return
12549 
    iprot.readStructBegin()
12550 
    while True:
12551 
      (fname, ftype, fid) = iprot.readFieldBegin()
12552 
      if ftype == TType.STOP:
12553 
        break
12554 
      if fid == 1:
12555 
        if ftype == TType.I32:
12556 
          self.userType = iprot.readI32();
12557 
        else:
12558 
          iprot.skip(ftype)
12559 
      else:
12560 
        iprot.skip(ftype)
12561 
      iprot.readFieldEnd()
12562 
    iprot.readStructEnd()
12563 
 
12564 
  def write(self, oprot):
12565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12567 
      return
12568 
    oprot.writeStructBegin('getUserCount_args')
12569 
    if self.userType != None:
12570 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12571 
      oprot.writeI32(self.userType)
12572 
      oprot.writeFieldEnd()
12573 
    oprot.writeFieldStop()
12574 
    oprot.writeStructEnd()
12575 
 
12576 
  def __repr__(self):
12577 
    L = ['%s=%r' % (key, value)
12578 
      for key, value in self.__dict__.iteritems()]
12579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12580 
 
12581 
  def __eq__(self, other):
12582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12583 
 
12584 
  def __ne__(self, other):
12585 
    return not (self == other)
12586 
 
12587 
class getUserCount_result:
12588 
  """
12589 
  Attributes:
12590 
   - success
12591 
  """
12592 
 
12593 
  thrift_spec = (
12594 
    (0, TType.I64, 'success', None, None, ), # 0
12595 
  )
12596 
 
12597 
  def __init__(self, success=None,):
12598 
    self.success = success
12599 
 
12600 
  def read(self, iprot):
12601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12603 
      return
12604 
    iprot.readStructBegin()
12605 
    while True:
12606 
      (fname, ftype, fid) = iprot.readFieldBegin()
12607 
      if ftype == TType.STOP:
12608 
        break
12609 
      if fid == 0:
12610 
        if ftype == TType.I64:
12611 
          self.success = iprot.readI64();
12612 
        else:
12613 
          iprot.skip(ftype)
12614 
      else:
12615 
        iprot.skip(ftype)
12616 
      iprot.readFieldEnd()
12617 
    iprot.readStructEnd()
12618 
 
12619 
  def write(self, oprot):
12620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12622 
      return
12623 
    oprot.writeStructBegin('getUserCount_result')
12624 
    if self.success != None:
12625 
      oprot.writeFieldBegin('success', TType.I64, 0)
12626 
      oprot.writeI64(self.success)
12627 
      oprot.writeFieldEnd()
12628 
    oprot.writeFieldStop()
12629 
    oprot.writeStructEnd()
12630 
 
12631 
  def __repr__(self):
12632 
    L = ['%s=%r' % (key, value)
12633 
      for key, value in self.__dict__.iteritems()]
12634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12635 
 
12636 
  def __eq__(self, other):
12637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12638 
 
12639 
  def __ne__(self, other):
12640 
    return not (self == other)
12641 
 
1673 ankur.sing 12642 
class getAllUsers_args:
12643 
  """
12644 
  Attributes:
12645 
   - userType
1891 ankur.sing 12646 
   - startDate
12647 
   - endDate
1673 ankur.sing 12648 
  """
1596 ankur.sing 12649 
 
1673 ankur.sing 12650 
  thrift_spec = (
12651 
    None, # 0
12652 
    (1, TType.I32, 'userType', None, None, ), # 1
1891 ankur.sing 12653 
    (2, TType.I64, 'startDate', None, None, ), # 2
12654 
    (3, TType.I64, 'endDate', None, None, ), # 3
1673 ankur.sing 12655 
  )
12656 
 
1891 ankur.sing 12657 
  def __init__(self, userType=None, startDate=None, endDate=None,):
1673 ankur.sing 12658 
    self.userType = userType
1891 ankur.sing 12659 
    self.startDate = startDate
12660 
    self.endDate = endDate
1673 ankur.sing 12661 
 
12662 
  def read(self, iprot):
12663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12665 
      return
12666 
    iprot.readStructBegin()
12667 
    while True:
12668 
      (fname, ftype, fid) = iprot.readFieldBegin()
12669 
      if ftype == TType.STOP:
12670 
        break
12671 
      if fid == 1:
12672 
        if ftype == TType.I32:
12673 
          self.userType = iprot.readI32();
12674 
        else:
12675 
          iprot.skip(ftype)
1891 ankur.sing 12676 
      elif fid == 2:
12677 
        if ftype == TType.I64:
12678 
          self.startDate = iprot.readI64();
12679 
        else:
12680 
          iprot.skip(ftype)
12681 
      elif fid == 3:
12682 
        if ftype == TType.I64:
12683 
          self.endDate = iprot.readI64();
12684 
        else:
12685 
          iprot.skip(ftype)
1673 ankur.sing 12686 
      else:
12687 
        iprot.skip(ftype)
12688 
      iprot.readFieldEnd()
12689 
    iprot.readStructEnd()
12690 
 
12691 
  def write(self, oprot):
12692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12694 
      return
12695 
    oprot.writeStructBegin('getAllUsers_args')
12696 
    if self.userType != None:
12697 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12698 
      oprot.writeI32(self.userType)
12699 
      oprot.writeFieldEnd()
1891 ankur.sing 12700 
    if self.startDate != None:
12701 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
12702 
      oprot.writeI64(self.startDate)
12703 
      oprot.writeFieldEnd()
12704 
    if self.endDate != None:
12705 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
12706 
      oprot.writeI64(self.endDate)
12707 
      oprot.writeFieldEnd()
1673 ankur.sing 12708 
    oprot.writeFieldStop()
12709 
    oprot.writeStructEnd()
12710 
 
12711 
  def __repr__(self):
12712 
    L = ['%s=%r' % (key, value)
12713 
      for key, value in self.__dict__.iteritems()]
12714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12715 
 
12716 
  def __eq__(self, other):
12717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12718 
 
12719 
  def __ne__(self, other):
12720 
    return not (self == other)
12721 
 
12722 
class getAllUsers_result:
12723 
  """
12724 
  Attributes:
12725 
   - success
12726 
  """
12727 
 
12728 
  thrift_spec = (
12729 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
12730 
  )
12731 
 
12732 
  def __init__(self, success=None,):
12733 
    self.success = success
12734 
 
12735 
  def read(self, iprot):
12736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12738 
      return
12739 
    iprot.readStructBegin()
12740 
    while True:
12741 
      (fname, ftype, fid) = iprot.readFieldBegin()
12742 
      if ftype == TType.STOP:
12743 
        break
12744 
      if fid == 0:
12745 
        if ftype == TType.LIST:
12746 
          self.success = []
1976 varun.gupt 12747 
          (_etype131, _size128) = iprot.readListBegin()
12748 
          for _i132 in xrange(_size128):
12749 
            _elem133 = User()
12750 
            _elem133.read(iprot)
12751 
            self.success.append(_elem133)
1673 ankur.sing 12752 
          iprot.readListEnd()
12753 
        else:
12754 
          iprot.skip(ftype)
12755 
      else:
12756 
        iprot.skip(ftype)
12757 
      iprot.readFieldEnd()
12758 
    iprot.readStructEnd()
12759 
 
12760 
  def write(self, oprot):
12761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12763 
      return
12764 
    oprot.writeStructBegin('getAllUsers_result')
12765 
    if self.success != None:
12766 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12767 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 12768 
      for iter134 in self.success:
12769 
        iter134.write(oprot)
1673 ankur.sing 12770 
      oprot.writeListEnd()
12771 
      oprot.writeFieldEnd()
12772 
    oprot.writeFieldStop()
12773 
    oprot.writeStructEnd()
12774 
 
12775 
  def __repr__(self):
12776 
    L = ['%s=%r' % (key, value)
12777 
      for key, value in self.__dict__.iteritems()]
12778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12779 
 
12780 
  def __eq__(self, other):
12781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12782 
 
12783 
  def __ne__(self, other):
12784 
    return not (self == other)
12785 
 
12786