Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
2 
# Autogenerated by Thrift
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
from ttypes import *
9 
from thrift.Thrift import TProcessor
10 
from thrift.transport import TTransport
11 
from thrift.protocol import TBinaryProtocol
12 
try:
13 
  from thrift.protocol import fastbinary
14 
except:
15 
  fastbinary = None
16 
 
17 
 
18 
class Iface:
19 
  """
20 
  service
21 
  """
765 rajveer 22 
  def closeSession(self, ):
23 
    """
24 
    For closing the open session in sqlalchemy
25 
    """
26 
    pass
27 
 
559 chandransh 28 
  def createAnonymousUser(self, jsessionId):
94 ashish 29 
    """
30 
    Parameters:
559 chandransh 31 
     - jsessionId
94 ashish 32 
    """
33 
    pass
34 
 
559 chandransh 35 
  def getUserById(self, userId):
94 ashish 36 
    """
37 
    Parameters:
38 
     - userId
39 
    """
40 
    pass
41 
 
1491 vikas 42 
  def getUserByEmail(self, email):
43 
    """
44 
    Parameters:
45 
     - email
46 
    """
47 
    pass
48 
 
559 chandransh 49 
  def createUser(self, user):
94 ashish 50 
    """
51 
    Parameters:
559 chandransh 52 
     - user
94 ashish 53 
    """
54 
    pass
55 
 
559 chandransh 56 
  def updateUser(self, user):
94 ashish 57 
    """
58 
    Parameters:
559 chandransh 59 
     - user
94 ashish 60 
    """
61 
    pass
62 
 
559 chandransh 63 
  def deleteUser(self, userId):
94 ashish 64 
    """
65 
    Parameters:
66 
     - userId
67 
    """
68 
    pass
69 
 
559 chandransh 70 
  def getUserState(self, userId):
94 ashish 71 
    """
72 
    Parameters:
73 
     - userId
74 
    """
75 
    pass
76 
 
559 chandransh 77 
  def authenticateUser(self, email, password):
94 ashish 78 
    """
79 
    Parameters:
80 
     - email
81 
     - password
82 
    """
83 
    pass
84 
 
85 
  def userExists(self, email):
86 
    """
87 
    Parameters:
88 
     - email
89 
    """
90 
    pass
91 
 
567 rajveer 92 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 93 
    """
94 
    Parameters:
95 
     - userId
96 
     - address
513 rajveer 97 
     - setDefault
94 ashish 98 
    """
99 
    pass
100 
 
101 
  def removeAddressForUser(self, userid, addressId):
102 
    """
103 
    Parameters:
104 
     - userid
105 
     - addressId
106 
    """
107 
    pass
108 
 
109 
  def setUserAsLoggedIn(self, userId, timestamp):
110 
    """
111 
    Parameters:
112 
     - userId
113 
     - timestamp
114 
    """
115 
    pass
116 
 
117 
  def setUserAsLoggedOut(self, userid, timestamp):
118 
    """
119 
    Parameters:
120 
     - userid
121 
     - timestamp
122 
    """
123 
    pass
124 
 
504 rajveer 125 
  def setDefaultAddress(self, userid, addressId):
126 
    """
127 
    Parameters:
128 
     - userid
129 
     - addressId
130 
    """
131 
    pass
132 
 
594 rajveer 133 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 134 
    """
135 
    Parameters:
136 
     - userid
594 rajveer 137 
     - oldPassword
138 
     - newPassword
94 ashish 139 
    """
140 
    pass
141 
 
884 rajveer 142 
  def forgotPassword(self, email, newPassword):
581 rajveer 143 
    """
144 
    Parameters:
145 
     - email
884 rajveer 146 
     - newPassword
581 rajveer 147 
    """
148 
    pass
149 
 
594 rajveer 150 
  def getAllAddressesForUser(self, userId):
151 
    """
152 
    Parameters:
153 
     - userId
154 
    """
155 
    pass
156 
 
1894 vikas 157 
  def getAddressById(self, addressId):
158 
    """
159 
    Parameters:
160 
     - addressId
161 
    """
162 
    pass
163 
 
594 rajveer 164 
  def getDefaultAddressId(self, userId):
165 
    """
166 
    Parameters:
167 
     - userId
168 
    """
169 
    pass
170 
 
785 rajveer 171 
  def getDefaultPincode(self, userId):
172 
    """
173 
    Parameters:
174 
     - userId
175 
    """
176 
    pass
177 
 
1274 varun.gupt 178 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
179 
    """
180 
    Parameters:
181 
     - userId
182 
     - replyTo
183 
     - communicationType
184 
     - orderId
185 
     - airwaybillNo
186 
     - productName
187 
     - subject
188 
     - message
189 
    """
190 
    pass
191 
 
1590 varun.gupt 192 
  def getUserCommunicationById(self, id):
193 
    """
194 
    Parameters:
195 
     - id
196 
    """
197 
    pass
198 
 
199 
  def getUserCommunicationByUser(self, userId):
200 
    """
201 
    Parameters:
202 
     - userId
203 
    """
204 
    pass
205 
 
206 
  def getAllUserCommunications(self, ):
207 
    pass
208 
 
1859 vikas 209 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 210 
    """
211 
    Parameters:
212 
     - name
1859 vikas 213 
     - addedOn
1845 vikas 214 
    """
215 
    pass
216 
 
1899 vikas 217 
  def getAllMasterAffiliates(self, ):
218 
    pass
219 
 
1845 vikas 220 
  def getMasterAffiliateById(self, id):
221 
    """
222 
    Parameters:
223 
     - id
224 
    """
225 
    pass
226 
 
227 
  def getMasterAffiliateByName(self, name):
228 
    """
229 
    Parameters:
230 
     - name
231 
    """
232 
    pass
233 
 
1859 vikas 234 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 235 
    """
236 
    Parameters:
237 
     - name
238 
     - url
239 
     - masterAffiliateId
1859 vikas 240 
     - addedOn
1845 vikas 241 
    """
242 
    pass
243 
 
244 
  def getAffiliateById(self, id):
245 
    """
246 
    Parameters:
247 
     - id
248 
    """
249 
    pass
250 
 
251 
  def getAffiliateByName(self, name):
252 
    """
253 
    Parameters:
254 
     - name
255 
    """
256 
    pass
257 
 
1996 vikas 258 
  def getTrackerById(self, id):
1845 vikas 259 
    """
260 
    Parameters:
261 
     - id
262 
    """
263 
    pass
264 
 
1996 vikas 265 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 266 
    """
267 
    Parameters:
1996 vikas 268 
     - id
1845 vikas 269 
    """
270 
    pass
271 
 
1996 vikas 272 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 273 
    """
274 
    Parameters:
275 
     - affiliateId
276 
     - userId
277 
     - event
278 
     - url
279 
     - data
1859 vikas 280 
     - addedOn
1845 vikas 281 
    """
282 
    pass
283 
 
284 
  def getTrackLogById(self, id):
285 
    """
286 
    Parameters:
287 
     - id
288 
    """
289 
    pass
290 
 
1996 vikas 291 
  def getTrackLogsByAffiliate(self, affiliateId):
1845 vikas 292 
    """
293 
    Parameters:
1996 vikas 294 
     - affiliateId
1845 vikas 295 
    """
296 
    pass
297 
 
298 
  def getTrackLogsByUser(self, userId):
299 
    """
300 
    Parameters:
301 
     - userId
302 
    """
303 
    pass
304 
 
1996 vikas 305 
  def getTrackLogs(self, userId, event, url):
1845 vikas 306 
    """
307 
    Parameters:
308 
     - userId
309 
     - event
310 
     - url
311 
    """
312 
    pass
313 
 
559 chandransh 314 
  def createCart(self, userId):
94 ashish 315 
    """
316 
    Parameters:
559 chandransh 317 
     - userId
94 ashish 318 
    """
319 
    pass
320 
 
559 chandransh 321 
  def getCurrentCart(self, userId):
94 ashish 322 
    """
323 
    Parameters:
559 chandransh 324 
     - userId
94 ashish 325 
    """
326 
    pass
327 
 
559 chandransh 328 
  def getCart(self, cartId):
94 ashish 329 
    """
330 
    Parameters:
559 chandransh 331 
     - cartId
94 ashish 332 
    """
333 
    pass
334 
 
559 chandransh 335 
  def getCartsForUser(self, userId, status):
94 ashish 336 
    """
337 
    Parameters:
559 chandransh 338 
     - userId
339 
     - status
94 ashish 340 
    """
341 
    pass
342 
 
559 chandransh 343 
  def getCartsByStatus(self, status):
94 ashish 344 
    """
345 
    Parameters:
559 chandransh 346 
     - status
94 ashish 347 
    """
348 
    pass
349 
 
559 chandransh 350 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 351 
    """
352 
    Parameters:
559 chandransh 353 
     - from_time
354 
     - to_time
355 
     - status
94 ashish 356 
    """
357 
    pass
358 
 
559 chandransh 359 
  def changeCartStatus(self, cartId, status):
130 ashish 360 
    """
361 
    Parameters:
559 chandransh 362 
     - cartId
363 
     - status
130 ashish 364 
    """
365 
    pass
94 ashish 366 
 
559 chandransh 367 
  def addItemToCart(self, cartId, itemId, quantity):
130 ashish 368 
    """
369 
    Parameters:
559 chandransh 370 
     - cartId
371 
     - itemId
372 
     - quantity
130 ashish 373 
    """
374 
    pass
375 
 
559 chandransh 376 
  def deleteItemFromCart(self, cartId, itemId):
377 
    """
378 
    Parameters:
379 
     - cartId
380 
     - itemId
381 
    """
382 
    pass
130 ashish 383 
 
559 chandransh 384 
  def changeQuantity(self, cartId, itemId, quantity):
385 
    """
386 
    Parameters:
387 
     - cartId
388 
     - itemId
389 
     - quantity
390 
    """
391 
    pass
392 
 
393 
  def changeItemStatus(self, cartId, itemId, status):
394 
    """
395 
    Parameters:
396 
     - cartId
397 
     - itemId
398 
     - status
399 
    """
400 
    pass
401 
 
402 
  def addAddressToCart(self, cartId, addressId):
403 
    """
404 
    Parameters:
405 
     - cartId
406 
     - addressId
407 
    """
408 
    pass
409 
 
1976 varun.gupt 410 
  def applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
411 
    """
412 
    Parameters:
413 
     - cartId
414 
     - couponCode
415 
     - totalPrice
416 
     - discountedPrice
417 
    """
418 
    pass
419 
 
420 
  def removeCoupon(self, cartId):
421 
    """
422 
    Parameters:
423 
     - cartId
424 
    """
425 
    pass
426 
 
690 chandransh 427 
  def createOrders(self, cartId):
559 chandransh 428 
    """
690 chandransh 429 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
430 
 
559 chandransh 431 
    Parameters:
432 
     - cartId
433 
    """
434 
    pass
435 
 
436 
  def validateCart(self, cartId):
437 
    """
690 chandransh 438 
    Validates that:
439 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 440 
    2. All of the lines in the cart are active items.
690 chandransh 441 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 442 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 443 
 
559 chandransh 444 
    Parameters:
445 
     - cartId
446 
    """
447 
    pass
448 
 
690 chandransh 449 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 450 
    """
690 chandransh 451 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
452 
 
575 chandransh 453 
    Parameters:
690 chandransh 454 
     - fromCartId
455 
     - toCartId
456 
    """
457 
    pass
458 
 
459 
  def checkOut(self, cartId):
460 
    """
461 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
462 
 
463 
    Parameters:
575 chandransh 464 
     - cartId
465 
    """
466 
    pass
467 
 
690 chandransh 468 
  def resetCart(self, cartId, items):
559 chandransh 469 
    """
690 chandransh 470 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
471 
    This methods removes the specified quantiry of the specified item from the cart.
472 
 
559 chandransh 473 
    Parameters:
690 chandransh 474 
     - cartId
475 
     - items
559 chandransh 476 
    """
477 
    pass
478 
 
772 rajveer 479 
  def getMyResearch(self, userId):
559 chandransh 480 
    """
772 rajveer 481 
    Widgets
482 
 
559 chandransh 483 
    Parameters:
772 rajveer 484 
     - userId
559 chandransh 485 
    """
486 
    pass
487 
 
772 rajveer 488 
  def updateMyResearch(self, userId, itemId):
559 chandransh 489 
    """
490 
    Parameters:
772 rajveer 491 
     - userId
492 
     - itemId
559 chandransh 493 
    """
494 
    pass
495 
 
772 rajveer 496 
  def deleteItemFromMyResearch(self, userId, itemId):
559 chandransh 497 
    """
498 
    Parameters:
772 rajveer 499 
     - userId
500 
     - itemId
559 chandransh 501 
    """
502 
    pass
503 
 
772 rajveer 504 
  def updateBrowseHistory(self, userId, itemId):
559 chandransh 505 
    """
506 
    Parameters:
772 rajveer 507 
     - userId
508 
     - itemId
559 chandransh 509 
    """
510 
    pass
511 
 
772 rajveer 512 
  def getBrowseHistory(self, userId):
559 chandransh 513 
    """
514 
    Parameters:
515 
     - userId
516 
    """
517 
    pass
518 
 
772 rajveer 519 
  def mergeBrowseHistory(self, fromUserId, toUserId):
559 chandransh 520 
    """
521 
    Parameters:
772 rajveer 522 
     - fromUserId
523 
     - toUserId
559 chandransh 524 
    """
525 
    pass
526 
 
1596 ankur.sing 527 
  def getUserCount(self, userType):
528 
    """
529 
    Returns number of registered users.
530 
    If userType = null, then it returns count of all users, including anonymous
531 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
532 
    If userType = UserType.USER, then it returns count of non-anonymous users only
533 
 
534 
    Parameters:
535 
     - userType
536 
    """
537 
    pass
559 chandransh 538 
 
1891 ankur.sing 539 
  def getAllUsers(self, userType, startDate, endDate):
1673 ankur.sing 540 
    """
1891 ankur.sing 541 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
542 
    If any of startDate or endDate is -1, then that filter is ignored.
543 
    If userType is null, then returns all the users, irrespective of anonymous flag
1673 ankur.sing 544 
 
1891 ankur.sing 545 
 
1673 ankur.sing 546 
    Parameters:
547 
     - userType
1891 ankur.sing 548 
     - startDate
549 
     - endDate
1673 ankur.sing 550 
    """
551 
    pass
1596 ankur.sing 552 
 
1673 ankur.sing 553 
 
94 ashish 554 
class Client(Iface):
555 
  """
556 
  service
557 
  """
558 
  def __init__(self, iprot, oprot=None):
559 
    self._iprot = self._oprot = iprot
560 
    if oprot != None:
561 
      self._oprot = oprot
562 
    self._seqid = 0
563 
 
765 rajveer 564 
  def closeSession(self, ):
565 
    """
566 
    For closing the open session in sqlalchemy
567 
    """
568 
    self.send_closeSession()
569 
    self.recv_closeSession()
570 
 
571 
  def send_closeSession(self, ):
572 
    self._oprot.writeMessageBegin('closeSession', TMessageType.CALL, self._seqid)
573 
    args = closeSession_args()
574 
    args.write(self._oprot)
575 
    self._oprot.writeMessageEnd()
576 
    self._oprot.trans.flush()
577 
 
578 
  def recv_closeSession(self, ):
579 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
580 
    if mtype == TMessageType.EXCEPTION:
581 
      x = TApplicationException()
582 
      x.read(self._iprot)
583 
      self._iprot.readMessageEnd()
584 
      raise x
585 
    result = closeSession_result()
586 
    result.read(self._iprot)
587 
    self._iprot.readMessageEnd()
588 
    return
589 
 
559 chandransh 590 
  def createAnonymousUser(self, jsessionId):
94 ashish 591 
    """
592 
    Parameters:
559 chandransh 593 
     - jsessionId
94 ashish 594 
    """
559 chandransh 595 
    self.send_createAnonymousUser(jsessionId)
596 
    return self.recv_createAnonymousUser()
94 ashish 597 
 
559 chandransh 598 
  def send_createAnonymousUser(self, jsessionId):
599 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
600 
    args = createAnonymousUser_args()
601 
    args.jsessionId = jsessionId
94 ashish 602 
    args.write(self._oprot)
603 
    self._oprot.writeMessageEnd()
604 
    self._oprot.trans.flush()
605 
 
559 chandransh 606 
  def recv_createAnonymousUser(self, ):
94 ashish 607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
608 
    if mtype == TMessageType.EXCEPTION:
609 
      x = TApplicationException()
610 
      x.read(self._iprot)
611 
      self._iprot.readMessageEnd()
612 
      raise x
559 chandransh 613 
    result = createAnonymousUser_result()
94 ashish 614 
    result.read(self._iprot)
615 
    self._iprot.readMessageEnd()
616 
    if result.success != None:
617 
      return result.success
559 chandransh 618 
    if result.ucex != None:
619 
      raise result.ucex
620 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 621 
 
559 chandransh 622 
  def getUserById(self, userId):
94 ashish 623 
    """
624 
    Parameters:
625 
     - userId
626 
    """
559 chandransh 627 
    self.send_getUserById(userId)
628 
    return self.recv_getUserById()
94 ashish 629 
 
559 chandransh 630 
  def send_getUserById(self, userId):
631 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
632 
    args = getUserById_args()
94 ashish 633 
    args.userId = userId
634 
    args.write(self._oprot)
635 
    self._oprot.writeMessageEnd()
636 
    self._oprot.trans.flush()
637 
 
559 chandransh 638 
  def recv_getUserById(self, ):
94 ashish 639 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
640 
    if mtype == TMessageType.EXCEPTION:
641 
      x = TApplicationException()
642 
      x.read(self._iprot)
643 
      self._iprot.readMessageEnd()
644 
      raise x
559 chandransh 645 
    result = getUserById_result()
94 ashish 646 
    result.read(self._iprot)
647 
    self._iprot.readMessageEnd()
648 
    if result.success != None:
649 
      return result.success
559 chandransh 650 
    if result.ucex != None:
651 
      raise result.ucex
652 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 653 
 
1491 vikas 654 
  def getUserByEmail(self, email):
655 
    """
656 
    Parameters:
657 
     - email
658 
    """
659 
    self.send_getUserByEmail(email)
660 
    return self.recv_getUserByEmail()
661 
 
662 
  def send_getUserByEmail(self, email):
663 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
664 
    args = getUserByEmail_args()
665 
    args.email = email
666 
    args.write(self._oprot)
667 
    self._oprot.writeMessageEnd()
668 
    self._oprot.trans.flush()
669 
 
670 
  def recv_getUserByEmail(self, ):
671 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
672 
    if mtype == TMessageType.EXCEPTION:
673 
      x = TApplicationException()
674 
      x.read(self._iprot)
675 
      self._iprot.readMessageEnd()
676 
      raise x
677 
    result = getUserByEmail_result()
678 
    result.read(self._iprot)
679 
    self._iprot.readMessageEnd()
680 
    if result.success != None:
681 
      return result.success
682 
    if result.ucex != None:
683 
      raise result.ucex
684 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
685 
 
559 chandransh 686 
  def createUser(self, user):
94 ashish 687 
    """
688 
    Parameters:
559 chandransh 689 
     - user
94 ashish 690 
    """
559 chandransh 691 
    self.send_createUser(user)
692 
    return self.recv_createUser()
94 ashish 693 
 
559 chandransh 694 
  def send_createUser(self, user):
695 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
696 
    args = createUser_args()
697 
    args.user = user
94 ashish 698 
    args.write(self._oprot)
699 
    self._oprot.writeMessageEnd()
700 
    self._oprot.trans.flush()
701 
 
559 chandransh 702 
  def recv_createUser(self, ):
94 ashish 703 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
704 
    if mtype == TMessageType.EXCEPTION:
705 
      x = TApplicationException()
706 
      x.read(self._iprot)
707 
      self._iprot.readMessageEnd()
708 
      raise x
559 chandransh 709 
    result = createUser_result()
94 ashish 710 
    result.read(self._iprot)
711 
    self._iprot.readMessageEnd()
712 
    if result.success != None:
713 
      return result.success
559 chandransh 714 
    if result.ucex != None:
715 
      raise result.ucex
716 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 717 
 
559 chandransh 718 
  def updateUser(self, user):
94 ashish 719 
    """
720 
    Parameters:
559 chandransh 721 
     - user
94 ashish 722 
    """
559 chandransh 723 
    self.send_updateUser(user)
724 
    return self.recv_updateUser()
94 ashish 725 
 
559 chandransh 726 
  def send_updateUser(self, user):
727 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
728 
    args = updateUser_args()
729 
    args.user = user
94 ashish 730 
    args.write(self._oprot)
731 
    self._oprot.writeMessageEnd()
732 
    self._oprot.trans.flush()
733 
 
559 chandransh 734 
  def recv_updateUser(self, ):
94 ashish 735 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
736 
    if mtype == TMessageType.EXCEPTION:
737 
      x = TApplicationException()
738 
      x.read(self._iprot)
739 
      self._iprot.readMessageEnd()
740 
      raise x
559 chandransh 741 
    result = updateUser_result()
94 ashish 742 
    result.read(self._iprot)
743 
    self._iprot.readMessageEnd()
744 
    if result.success != None:
745 
      return result.success
559 chandransh 746 
    if result.ucex != None:
747 
      raise result.ucex
748 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 749 
 
559 chandransh 750 
  def deleteUser(self, userId):
94 ashish 751 
    """
752 
    Parameters:
753 
     - userId
754 
    """
559 chandransh 755 
    self.send_deleteUser(userId)
756 
    return self.recv_deleteUser()
94 ashish 757 
 
559 chandransh 758 
  def send_deleteUser(self, userId):
759 
    self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
760 
    args = deleteUser_args()
94 ashish 761 
    args.userId = userId
762 
    args.write(self._oprot)
763 
    self._oprot.writeMessageEnd()
764 
    self._oprot.trans.flush()
765 
 
559 chandransh 766 
  def recv_deleteUser(self, ):
94 ashish 767 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
768 
    if mtype == TMessageType.EXCEPTION:
769 
      x = TApplicationException()
770 
      x.read(self._iprot)
771 
      self._iprot.readMessageEnd()
772 
      raise x
559 chandransh 773 
    result = deleteUser_result()
94 ashish 774 
    result.read(self._iprot)
775 
    self._iprot.readMessageEnd()
776 
    if result.success != None:
777 
      return result.success
559 chandransh 778 
    if result.ucex != None:
779 
      raise result.ucex
780 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
94 ashish 781 
 
559 chandransh 782 
  def getUserState(self, userId):
94 ashish 783 
    """
784 
    Parameters:
785 
     - userId
786 
    """
559 chandransh 787 
    self.send_getUserState(userId)
788 
    return self.recv_getUserState()
94 ashish 789 
 
559 chandransh 790 
  def send_getUserState(self, userId):
791 
    self._oprot.writeMessageBegin('getUserState', TMessageType.CALL, self._seqid)
792 
    args = getUserState_args()
94 ashish 793 
    args.userId = userId
794 
    args.write(self._oprot)
795 
    self._oprot.writeMessageEnd()
796 
    self._oprot.trans.flush()
797 
 
559 chandransh 798 
  def recv_getUserState(self, ):
94 ashish 799 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
800 
    if mtype == TMessageType.EXCEPTION:
801 
      x = TApplicationException()
802 
      x.read(self._iprot)
803 
      self._iprot.readMessageEnd()
804 
      raise x
559 chandransh 805 
    result = getUserState_result()
94 ashish 806 
    result.read(self._iprot)
807 
    self._iprot.readMessageEnd()
808 
    if result.success != None:
809 
      return result.success
559 chandransh 810 
    if result.ucex != None:
811 
      raise result.ucex
812 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserState failed: unknown result");
94 ashish 813 
 
559 chandransh 814 
  def authenticateUser(self, email, password):
94 ashish 815 
    """
816 
    Parameters:
817 
     - email
818 
     - password
819 
    """
559 chandransh 820 
    self.send_authenticateUser(email, password)
122 ashish 821 
    return self.recv_authenticateUser()
822 
 
559 chandransh 823 
  def send_authenticateUser(self, email, password):
122 ashish 824 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
825 
    args = authenticateUser_args()
559 chandransh 826 
    args.email = email
122 ashish 827 
    args.password = password
828 
    args.write(self._oprot)
829 
    self._oprot.writeMessageEnd()
830 
    self._oprot.trans.flush()
831 
 
832 
  def recv_authenticateUser(self, ):
833 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
834 
    if mtype == TMessageType.EXCEPTION:
835 
      x = TApplicationException()
836 
      x.read(self._iprot)
837 
      self._iprot.readMessageEnd()
838 
      raise x
839 
    result = authenticateUser_result()
840 
    result.read(self._iprot)
841 
    self._iprot.readMessageEnd()
842 
    if result.success != None:
843 
      return result.success
559 chandransh 844 
    if result.auex != None:
845 
      raise result.auex
122 ashish 846 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
847 
 
94 ashish 848 
  def userExists(self, email):
849 
    """
850 
    Parameters:
851 
     - email
852 
    """
853 
    self.send_userExists(email)
854 
    return self.recv_userExists()
855 
 
856 
  def send_userExists(self, email):
857 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
858 
    args = userExists_args()
859 
    args.email = email
860 
    args.write(self._oprot)
861 
    self._oprot.writeMessageEnd()
862 
    self._oprot.trans.flush()
863 
 
864 
  def recv_userExists(self, ):
865 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
866 
    if mtype == TMessageType.EXCEPTION:
867 
      x = TApplicationException()
868 
      x.read(self._iprot)
869 
      self._iprot.readMessageEnd()
870 
      raise x
871 
    result = userExists_result()
872 
    result.read(self._iprot)
873 
    self._iprot.readMessageEnd()
874 
    if result.success != None:
875 
      return result.success
876 
    if result.ucx != None:
877 
      raise result.ucx
878 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
879 
 
567 rajveer 880 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 881 
    """
882 
    Parameters:
883 
     - userId
884 
     - address
513 rajveer 885 
     - setDefault
94 ashish 886 
    """
567 rajveer 887 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 888 
    return self.recv_addAddressForUser()
889 
 
567 rajveer 890 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 891 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
892 
    args = addAddressForUser_args()
559 chandransh 893 
    args.userId = userId
94 ashish 894 
    args.address = address
513 rajveer 895 
    args.setDefault = setDefault
94 ashish 896 
    args.write(self._oprot)
897 
    self._oprot.writeMessageEnd()
898 
    self._oprot.trans.flush()
899 
 
900 
  def recv_addAddressForUser(self, ):
901 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
902 
    if mtype == TMessageType.EXCEPTION:
903 
      x = TApplicationException()
904 
      x.read(self._iprot)
905 
      self._iprot.readMessageEnd()
906 
      raise x
907 
    result = addAddressForUser_result()
908 
    result.read(self._iprot)
909 
    self._iprot.readMessageEnd()
910 
    if result.success != None:
911 
      return result.success
912 
    if result.ucx != None:
913 
      raise result.ucx
914 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
915 
 
916 
  def removeAddressForUser(self, userid, addressId):
917 
    """
918 
    Parameters:
919 
     - userid
920 
     - addressId
921 
    """
922 
    self.send_removeAddressForUser(userid, addressId)
923 
    return self.recv_removeAddressForUser()
924 
 
925 
  def send_removeAddressForUser(self, userid, addressId):
926 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
927 
    args = removeAddressForUser_args()
928 
    args.userid = userid
929 
    args.addressId = addressId
930 
    args.write(self._oprot)
931 
    self._oprot.writeMessageEnd()
932 
    self._oprot.trans.flush()
933 
 
934 
  def recv_removeAddressForUser(self, ):
935 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
936 
    if mtype == TMessageType.EXCEPTION:
937 
      x = TApplicationException()
938 
      x.read(self._iprot)
939 
      self._iprot.readMessageEnd()
940 
      raise x
941 
    result = removeAddressForUser_result()
942 
    result.read(self._iprot)
943 
    self._iprot.readMessageEnd()
944 
    if result.success != None:
945 
      return result.success
946 
    if result.ucx != None:
947 
      raise result.ucx
948 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
949 
 
950 
  def setUserAsLoggedIn(self, userId, timestamp):
951 
    """
952 
    Parameters:
953 
     - userId
954 
     - timestamp
955 
    """
956 
    self.send_setUserAsLoggedIn(userId, timestamp)
957 
    return self.recv_setUserAsLoggedIn()
958 
 
959 
  def send_setUserAsLoggedIn(self, userId, timestamp):
960 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
961 
    args = setUserAsLoggedIn_args()
962 
    args.userId = userId
963 
    args.timestamp = timestamp
964 
    args.write(self._oprot)
965 
    self._oprot.writeMessageEnd()
966 
    self._oprot.trans.flush()
967 
 
968 
  def recv_setUserAsLoggedIn(self, ):
969 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
970 
    if mtype == TMessageType.EXCEPTION:
971 
      x = TApplicationException()
972 
      x.read(self._iprot)
973 
      self._iprot.readMessageEnd()
974 
      raise x
975 
    result = setUserAsLoggedIn_result()
976 
    result.read(self._iprot)
977 
    self._iprot.readMessageEnd()
978 
    if result.success != None:
979 
      return result.success
980 
    if result.ucx != None:
981 
      raise result.ucx
982 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
983 
 
984 
  def setUserAsLoggedOut(self, userid, timestamp):
985 
    """
986 
    Parameters:
987 
     - userid
988 
     - timestamp
989 
    """
990 
    self.send_setUserAsLoggedOut(userid, timestamp)
991 
    return self.recv_setUserAsLoggedOut()
992 
 
993 
  def send_setUserAsLoggedOut(self, userid, timestamp):
994 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
995 
    args = setUserAsLoggedOut_args()
996 
    args.userid = userid
997 
    args.timestamp = timestamp
998 
    args.write(self._oprot)
999 
    self._oprot.writeMessageEnd()
1000 
    self._oprot.trans.flush()
1001 
 
1002 
  def recv_setUserAsLoggedOut(self, ):
1003 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1004 
    if mtype == TMessageType.EXCEPTION:
1005 
      x = TApplicationException()
1006 
      x.read(self._iprot)
1007 
      self._iprot.readMessageEnd()
1008 
      raise x
1009 
    result = setUserAsLoggedOut_result()
1010 
    result.read(self._iprot)
1011 
    self._iprot.readMessageEnd()
1012 
    if result.success != None:
1013 
      return result.success
1014 
    if result.ucx != None:
1015 
      raise result.ucx
1016 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1017 
 
504 rajveer 1018 
  def setDefaultAddress(self, userid, addressId):
1019 
    """
1020 
    Parameters:
1021 
     - userid
1022 
     - addressId
1023 
    """
1024 
    self.send_setDefaultAddress(userid, addressId)
1025 
    return self.recv_setDefaultAddress()
1026 
 
1027 
  def send_setDefaultAddress(self, userid, addressId):
1028 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1029 
    args = setDefaultAddress_args()
1030 
    args.userid = userid
1031 
    args.addressId = addressId
1032 
    args.write(self._oprot)
1033 
    self._oprot.writeMessageEnd()
1034 
    self._oprot.trans.flush()
1035 
 
1036 
  def recv_setDefaultAddress(self, ):
1037 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1038 
    if mtype == TMessageType.EXCEPTION:
1039 
      x = TApplicationException()
1040 
      x.read(self._iprot)
1041 
      self._iprot.readMessageEnd()
1042 
      raise x
1043 
    result = setDefaultAddress_result()
1044 
    result.read(self._iprot)
1045 
    self._iprot.readMessageEnd()
1046 
    if result.success != None:
1047 
      return result.success
1048 
    if result.ucx != None:
1049 
      raise result.ucx
1050 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1051 
 
594 rajveer 1052 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1053 
    """
1054 
    Parameters:
1055 
     - userid
594 rajveer 1056 
     - oldPassword
1057 
     - newPassword
94 ashish 1058 
    """
594 rajveer 1059 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1060 
    return self.recv_updatePassword()
1061 
 
594 rajveer 1062 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1063 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1064 
    args = updatePassword_args()
1065 
    args.userid = userid
594 rajveer 1066 
    args.oldPassword = oldPassword
1067 
    args.newPassword = newPassword
94 ashish 1068 
    args.write(self._oprot)
1069 
    self._oprot.writeMessageEnd()
1070 
    self._oprot.trans.flush()
1071 
 
1072 
  def recv_updatePassword(self, ):
1073 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1074 
    if mtype == TMessageType.EXCEPTION:
1075 
      x = TApplicationException()
1076 
      x.read(self._iprot)
1077 
      self._iprot.readMessageEnd()
1078 
      raise x
1079 
    result = updatePassword_result()
1080 
    result.read(self._iprot)
1081 
    self._iprot.readMessageEnd()
1082 
    if result.success != None:
1083 
      return result.success
1084 
    if result.ucx != None:
1085 
      raise result.ucx
1086 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1087 
 
884 rajveer 1088 
  def forgotPassword(self, email, newPassword):
581 rajveer 1089 
    """
1090 
    Parameters:
1091 
     - email
884 rajveer 1092 
     - newPassword
581 rajveer 1093 
    """
884 rajveer 1094 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1095 
    return self.recv_forgotPassword()
1096 
 
884 rajveer 1097 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1098 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1099 
    args = forgotPassword_args()
1100 
    args.email = email
884 rajveer 1101 
    args.newPassword = newPassword
581 rajveer 1102 
    args.write(self._oprot)
1103 
    self._oprot.writeMessageEnd()
1104 
    self._oprot.trans.flush()
1105 
 
1106 
  def recv_forgotPassword(self, ):
1107 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1108 
    if mtype == TMessageType.EXCEPTION:
1109 
      x = TApplicationException()
1110 
      x.read(self._iprot)
1111 
      self._iprot.readMessageEnd()
1112 
      raise x
1113 
    result = forgotPassword_result()
1114 
    result.read(self._iprot)
1115 
    self._iprot.readMessageEnd()
1116 
    if result.success != None:
1117 
      return result.success
1118 
    if result.ucx != None:
1119 
      raise result.ucx
1120 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1121 
 
594 rajveer 1122 
  def getAllAddressesForUser(self, userId):
1123 
    """
1124 
    Parameters:
1125 
     - userId
1126 
    """
1127 
    self.send_getAllAddressesForUser(userId)
1128 
    return self.recv_getAllAddressesForUser()
1129 
 
1130 
  def send_getAllAddressesForUser(self, userId):
1131 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1132 
    args = getAllAddressesForUser_args()
1133 
    args.userId = userId
1134 
    args.write(self._oprot)
1135 
    self._oprot.writeMessageEnd()
1136 
    self._oprot.trans.flush()
1137 
 
1138 
  def recv_getAllAddressesForUser(self, ):
1139 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1140 
    if mtype == TMessageType.EXCEPTION:
1141 
      x = TApplicationException()
1142 
      x.read(self._iprot)
1143 
      self._iprot.readMessageEnd()
1144 
      raise x
1145 
    result = getAllAddressesForUser_result()
1146 
    result.read(self._iprot)
1147 
    self._iprot.readMessageEnd()
1148 
    if result.success != None:
1149 
      return result.success
1150 
    if result.ucx != None:
1151 
      raise result.ucx
1152 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1153 
 
1894 vikas 1154 
  def getAddressById(self, addressId):
1155 
    """
1156 
    Parameters:
1157 
     - addressId
1158 
    """
1159 
    self.send_getAddressById(addressId)
1160 
    return self.recv_getAddressById()
1161 
 
1162 
  def send_getAddressById(self, addressId):
1163 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1164 
    args = getAddressById_args()
1165 
    args.addressId = addressId
1166 
    args.write(self._oprot)
1167 
    self._oprot.writeMessageEnd()
1168 
    self._oprot.trans.flush()
1169 
 
1170 
  def recv_getAddressById(self, ):
1171 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1172 
    if mtype == TMessageType.EXCEPTION:
1173 
      x = TApplicationException()
1174 
      x.read(self._iprot)
1175 
      self._iprot.readMessageEnd()
1176 
      raise x
1177 
    result = getAddressById_result()
1178 
    result.read(self._iprot)
1179 
    self._iprot.readMessageEnd()
1180 
    if result.success != None:
1181 
      return result.success
1182 
    if result.ucx != None:
1183 
      raise result.ucx
1184 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1185 
 
594 rajveer 1186 
  def getDefaultAddressId(self, userId):
1187 
    """
1188 
    Parameters:
1189 
     - userId
1190 
    """
1191 
    self.send_getDefaultAddressId(userId)
1192 
    return self.recv_getDefaultAddressId()
1193 
 
1194 
  def send_getDefaultAddressId(self, userId):
1195 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1196 
    args = getDefaultAddressId_args()
1197 
    args.userId = userId
1198 
    args.write(self._oprot)
1199 
    self._oprot.writeMessageEnd()
1200 
    self._oprot.trans.flush()
1201 
 
1202 
  def recv_getDefaultAddressId(self, ):
1203 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1204 
    if mtype == TMessageType.EXCEPTION:
1205 
      x = TApplicationException()
1206 
      x.read(self._iprot)
1207 
      self._iprot.readMessageEnd()
1208 
      raise x
1209 
    result = getDefaultAddressId_result()
1210 
    result.read(self._iprot)
1211 
    self._iprot.readMessageEnd()
1212 
    if result.success != None:
1213 
      return result.success
1214 
    if result.ucx != None:
1215 
      raise result.ucx
1216 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1217 
 
785 rajveer 1218 
  def getDefaultPincode(self, userId):
1219 
    """
1220 
    Parameters:
1221 
     - userId
1222 
    """
1223 
    self.send_getDefaultPincode(userId)
1224 
    return self.recv_getDefaultPincode()
1225 
 
1226 
  def send_getDefaultPincode(self, userId):
1227 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1228 
    args = getDefaultPincode_args()
1229 
    args.userId = userId
1230 
    args.write(self._oprot)
1231 
    self._oprot.writeMessageEnd()
1232 
    self._oprot.trans.flush()
1233 
 
1234 
  def recv_getDefaultPincode(self, ):
1235 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1236 
    if mtype == TMessageType.EXCEPTION:
1237 
      x = TApplicationException()
1238 
      x.read(self._iprot)
1239 
      self._iprot.readMessageEnd()
1240 
      raise x
1241 
    result = getDefaultPincode_result()
1242 
    result.read(self._iprot)
1243 
    self._iprot.readMessageEnd()
1244 
    if result.success != None:
1245 
      return result.success
1246 
    if result.ucx != None:
1247 
      raise result.ucx
1248 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1249 
 
1274 varun.gupt 1250 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1251 
    """
1252 
    Parameters:
1253 
     - userId
1254 
     - replyTo
1255 
     - communicationType
1256 
     - orderId
1257 
     - airwaybillNo
1258 
     - productName
1259 
     - subject
1260 
     - message
1261 
    """
1262 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1263 
    return self.recv_saveUserCommunication()
1264 
 
1265 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1266 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1267 
    args = saveUserCommunication_args()
1268 
    args.userId = userId
1269 
    args.replyTo = replyTo
1270 
    args.communicationType = communicationType
1271 
    args.orderId = orderId
1272 
    args.airwaybillNo = airwaybillNo
1273 
    args.productName = productName
1274 
    args.subject = subject
1275 
    args.message = message
1276 
    args.write(self._oprot)
1277 
    self._oprot.writeMessageEnd()
1278 
    self._oprot.trans.flush()
1279 
 
1280 
  def recv_saveUserCommunication(self, ):
1281 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1282 
    if mtype == TMessageType.EXCEPTION:
1283 
      x = TApplicationException()
1284 
      x.read(self._iprot)
1285 
      self._iprot.readMessageEnd()
1286 
      raise x
1287 
    result = saveUserCommunication_result()
1288 
    result.read(self._iprot)
1289 
    self._iprot.readMessageEnd()
1290 
    if result.success != None:
1291 
      return result.success
1292 
    if result.ucx != None:
1293 
      raise result.ucx
1294 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1295 
 
1590 varun.gupt 1296 
  def getUserCommunicationById(self, id):
1297 
    """
1298 
    Parameters:
1299 
     - id
1300 
    """
1301 
    self.send_getUserCommunicationById(id)
1302 
    return self.recv_getUserCommunicationById()
1303 
 
1304 
  def send_getUserCommunicationById(self, id):
1305 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1306 
    args = getUserCommunicationById_args()
1307 
    args.id = id
1308 
    args.write(self._oprot)
1309 
    self._oprot.writeMessageEnd()
1310 
    self._oprot.trans.flush()
1311 
 
1312 
  def recv_getUserCommunicationById(self, ):
1313 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1314 
    if mtype == TMessageType.EXCEPTION:
1315 
      x = TApplicationException()
1316 
      x.read(self._iprot)
1317 
      self._iprot.readMessageEnd()
1318 
      raise x
1319 
    result = getUserCommunicationById_result()
1320 
    result.read(self._iprot)
1321 
    self._iprot.readMessageEnd()
1322 
    if result.success != None:
1323 
      return result.success
1324 
    if result.ucx != None:
1325 
      raise result.ucx
1326 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1327 
 
1328 
  def getUserCommunicationByUser(self, userId):
1329 
    """
1330 
    Parameters:
1331 
     - userId
1332 
    """
1333 
    self.send_getUserCommunicationByUser(userId)
1334 
    return self.recv_getUserCommunicationByUser()
1335 
 
1336 
  def send_getUserCommunicationByUser(self, userId):
1337 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1338 
    args = getUserCommunicationByUser_args()
1339 
    args.userId = userId
1340 
    args.write(self._oprot)
1341 
    self._oprot.writeMessageEnd()
1342 
    self._oprot.trans.flush()
1343 
 
1344 
  def recv_getUserCommunicationByUser(self, ):
1345 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1346 
    if mtype == TMessageType.EXCEPTION:
1347 
      x = TApplicationException()
1348 
      x.read(self._iprot)
1349 
      self._iprot.readMessageEnd()
1350 
      raise x
1351 
    result = getUserCommunicationByUser_result()
1352 
    result.read(self._iprot)
1353 
    self._iprot.readMessageEnd()
1354 
    if result.success != None:
1355 
      return result.success
1356 
    if result.ucx != None:
1357 
      raise result.ucx
1358 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1359 
 
1360 
  def getAllUserCommunications(self, ):
1361 
    self.send_getAllUserCommunications()
1362 
    return self.recv_getAllUserCommunications()
1363 
 
1364 
  def send_getAllUserCommunications(self, ):
1365 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1366 
    args = getAllUserCommunications_args()
1367 
    args.write(self._oprot)
1368 
    self._oprot.writeMessageEnd()
1369 
    self._oprot.trans.flush()
1370 
 
1371 
  def recv_getAllUserCommunications(self, ):
1372 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1373 
    if mtype == TMessageType.EXCEPTION:
1374 
      x = TApplicationException()
1375 
      x.read(self._iprot)
1376 
      self._iprot.readMessageEnd()
1377 
      raise x
1378 
    result = getAllUserCommunications_result()
1379 
    result.read(self._iprot)
1380 
    self._iprot.readMessageEnd()
1381 
    if result.success != None:
1382 
      return result.success
1383 
    if result.ucx != None:
1384 
      raise result.ucx
1385 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1386 
 
1859 vikas 1387 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1388 
    """
1389 
    Parameters:
1390 
     - name
1859 vikas 1391 
     - addedOn
1845 vikas 1392 
    """
1859 vikas 1393 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1394 
    return self.recv_createMasterAffiliate()
1395 
 
1859 vikas 1396 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1397 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1398 
    args = createMasterAffiliate_args()
1399 
    args.name = name
1859 vikas 1400 
    args.addedOn = addedOn
1845 vikas 1401 
    args.write(self._oprot)
1402 
    self._oprot.writeMessageEnd()
1403 
    self._oprot.trans.flush()
1404 
 
1405 
  def recv_createMasterAffiliate(self, ):
1406 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1407 
    if mtype == TMessageType.EXCEPTION:
1408 
      x = TApplicationException()
1409 
      x.read(self._iprot)
1410 
      self._iprot.readMessageEnd()
1411 
      raise x
1412 
    result = createMasterAffiliate_result()
1413 
    result.read(self._iprot)
1414 
    self._iprot.readMessageEnd()
1415 
    if result.success != None:
1416 
      return result.success
1417 
    if result.utx != None:
1418 
      raise result.utx
1419 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1420 
 
1899 vikas 1421 
  def getAllMasterAffiliates(self, ):
1422 
    self.send_getAllMasterAffiliates()
1423 
    return self.recv_getAllMasterAffiliates()
1424 
 
1425 
  def send_getAllMasterAffiliates(self, ):
1426 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1427 
    args = getAllMasterAffiliates_args()
1428 
    args.write(self._oprot)
1429 
    self._oprot.writeMessageEnd()
1430 
    self._oprot.trans.flush()
1431 
 
1432 
  def recv_getAllMasterAffiliates(self, ):
1433 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1434 
    if mtype == TMessageType.EXCEPTION:
1435 
      x = TApplicationException()
1436 
      x.read(self._iprot)
1437 
      self._iprot.readMessageEnd()
1438 
      raise x
1439 
    result = getAllMasterAffiliates_result()
1440 
    result.read(self._iprot)
1441 
    self._iprot.readMessageEnd()
1442 
    if result.success != None:
1443 
      return result.success
1444 
    if result.utx != None:
1445 
      raise result.utx
1446 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1447 
 
1845 vikas 1448 
  def getMasterAffiliateById(self, id):
1449 
    """
1450 
    Parameters:
1451 
     - id
1452 
    """
1453 
    self.send_getMasterAffiliateById(id)
1454 
    return self.recv_getMasterAffiliateById()
1455 
 
1456 
  def send_getMasterAffiliateById(self, id):
1457 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1458 
    args = getMasterAffiliateById_args()
1459 
    args.id = id
1460 
    args.write(self._oprot)
1461 
    self._oprot.writeMessageEnd()
1462 
    self._oprot.trans.flush()
1463 
 
1464 
  def recv_getMasterAffiliateById(self, ):
1465 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1466 
    if mtype == TMessageType.EXCEPTION:
1467 
      x = TApplicationException()
1468 
      x.read(self._iprot)
1469 
      self._iprot.readMessageEnd()
1470 
      raise x
1471 
    result = getMasterAffiliateById_result()
1472 
    result.read(self._iprot)
1473 
    self._iprot.readMessageEnd()
1474 
    if result.success != None:
1475 
      return result.success
1476 
    if result.utx != None:
1477 
      raise result.utx
1478 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1479 
 
1480 
  def getMasterAffiliateByName(self, name):
1481 
    """
1482 
    Parameters:
1483 
     - name
1484 
    """
1485 
    self.send_getMasterAffiliateByName(name)
1486 
    return self.recv_getMasterAffiliateByName()
1487 
 
1488 
  def send_getMasterAffiliateByName(self, name):
1489 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1490 
    args = getMasterAffiliateByName_args()
1491 
    args.name = name
1492 
    args.write(self._oprot)
1493 
    self._oprot.writeMessageEnd()
1494 
    self._oprot.trans.flush()
1495 
 
1496 
  def recv_getMasterAffiliateByName(self, ):
1497 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1498 
    if mtype == TMessageType.EXCEPTION:
1499 
      x = TApplicationException()
1500 
      x.read(self._iprot)
1501 
      self._iprot.readMessageEnd()
1502 
      raise x
1503 
    result = getMasterAffiliateByName_result()
1504 
    result.read(self._iprot)
1505 
    self._iprot.readMessageEnd()
1506 
    if result.success != None:
1507 
      return result.success
1508 
    if result.utx != None:
1509 
      raise result.utx
1510 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1511 
 
1859 vikas 1512 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1513 
    """
1514 
    Parameters:
1515 
     - name
1516 
     - url
1517 
     - masterAffiliateId
1859 vikas 1518 
     - addedOn
1845 vikas 1519 
    """
1859 vikas 1520 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1521 
    return self.recv_createAffiliate()
1522 
 
1859 vikas 1523 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1524 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1525 
    args = createAffiliate_args()
1526 
    args.name = name
1527 
    args.url = url
1528 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1529 
    args.addedOn = addedOn
1845 vikas 1530 
    args.write(self._oprot)
1531 
    self._oprot.writeMessageEnd()
1532 
    self._oprot.trans.flush()
1533 
 
1534 
  def recv_createAffiliate(self, ):
1535 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1536 
    if mtype == TMessageType.EXCEPTION:
1537 
      x = TApplicationException()
1538 
      x.read(self._iprot)
1539 
      self._iprot.readMessageEnd()
1540 
      raise x
1541 
    result = createAffiliate_result()
1542 
    result.read(self._iprot)
1543 
    self._iprot.readMessageEnd()
1544 
    if result.success != None:
1545 
      return result.success
1546 
    if result.utx != None:
1547 
      raise result.utx
1548 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1549 
 
1550 
  def getAffiliateById(self, id):
1551 
    """
1552 
    Parameters:
1553 
     - id
1554 
    """
1555 
    self.send_getAffiliateById(id)
1556 
    return self.recv_getAffiliateById()
1557 
 
1558 
  def send_getAffiliateById(self, id):
1559 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1560 
    args = getAffiliateById_args()
1561 
    args.id = id
1562 
    args.write(self._oprot)
1563 
    self._oprot.writeMessageEnd()
1564 
    self._oprot.trans.flush()
1565 
 
1566 
  def recv_getAffiliateById(self, ):
1567 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1568 
    if mtype == TMessageType.EXCEPTION:
1569 
      x = TApplicationException()
1570 
      x.read(self._iprot)
1571 
      self._iprot.readMessageEnd()
1572 
      raise x
1573 
    result = getAffiliateById_result()
1574 
    result.read(self._iprot)
1575 
    self._iprot.readMessageEnd()
1576 
    if result.success != None:
1577 
      return result.success
1578 
    if result.utx != None:
1579 
      raise result.utx
1580 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1581 
 
1582 
  def getAffiliateByName(self, name):
1583 
    """
1584 
    Parameters:
1585 
     - name
1586 
    """
1587 
    self.send_getAffiliateByName(name)
1588 
    return self.recv_getAffiliateByName()
1589 
 
1590 
  def send_getAffiliateByName(self, name):
1591 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1592 
    args = getAffiliateByName_args()
1593 
    args.name = name
1594 
    args.write(self._oprot)
1595 
    self._oprot.writeMessageEnd()
1596 
    self._oprot.trans.flush()
1597 
 
1598 
  def recv_getAffiliateByName(self, ):
1599 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1600 
    if mtype == TMessageType.EXCEPTION:
1601 
      x = TApplicationException()
1602 
      x.read(self._iprot)
1603 
      self._iprot.readMessageEnd()
1604 
      raise x
1605 
    result = getAffiliateByName_result()
1606 
    result.read(self._iprot)
1607 
    self._iprot.readMessageEnd()
1608 
    if result.success != None:
1609 
      return result.success
1610 
    if result.utx != None:
1611 
      raise result.utx
1612 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1613 
 
1996 vikas 1614 
  def getTrackerById(self, id):
1845 vikas 1615 
    """
1616 
    Parameters:
1617 
     - id
1618 
    """
1996 vikas 1619 
    self.send_getTrackerById(id)
1845 vikas 1620 
    return self.recv_getTrackerById()
1621 
 
1996 vikas 1622 
  def send_getTrackerById(self, id):
1845 vikas 1623 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1624 
    args = getTrackerById_args()
1996 vikas 1625 
    args.id = id
1845 vikas 1626 
    args.write(self._oprot)
1627 
    self._oprot.writeMessageEnd()
1628 
    self._oprot.trans.flush()
1629 
 
1630 
  def recv_getTrackerById(self, ):
1631 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1632 
    if mtype == TMessageType.EXCEPTION:
1633 
      x = TApplicationException()
1634 
      x.read(self._iprot)
1635 
      self._iprot.readMessageEnd()
1636 
      raise x
1637 
    result = getTrackerById_result()
1638 
    result.read(self._iprot)
1639 
    self._iprot.readMessageEnd()
1640 
    if result.success != None:
1641 
      return result.success
1642 
    if result.utx != None:
1643 
      raise result.utx
1644 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1645 
 
1996 vikas 1646 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1647 
    """
1648 
    Parameters:
1996 vikas 1649 
     - id
1845 vikas 1650 
    """
1996 vikas 1651 
    self.send_getAffiliatesByMasterAffiliate(id)
1652 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1653 
 
1996 vikas 1654 
  def send_getAffiliatesByMasterAffiliate(self, id):
1655 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1656 
    args = getAffiliatesByMasterAffiliate_args()
1657 
    args.id = id
1845 vikas 1658 
    args.write(self._oprot)
1659 
    self._oprot.writeMessageEnd()
1660 
    self._oprot.trans.flush()
1661 
 
1996 vikas 1662 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1663 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1664 
    if mtype == TMessageType.EXCEPTION:
1665 
      x = TApplicationException()
1666 
      x.read(self._iprot)
1667 
      self._iprot.readMessageEnd()
1668 
      raise x
1996 vikas 1669 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1670 
    result.read(self._iprot)
1671 
    self._iprot.readMessageEnd()
1672 
    if result.success != None:
1673 
      return result.success
1674 
    if result.utx != None:
1675 
      raise result.utx
1996 vikas 1676 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1677 
 
1996 vikas 1678 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1679 
    """
1680 
    Parameters:
1996 vikas 1681 
     - affiliateId
1845 vikas 1682 
     - userId
1683 
     - event
1684 
     - url
1685 
     - data
1859 vikas 1686 
     - addedOn
1845 vikas 1687 
    """
1996 vikas 1688 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1689 
    return self.recv_addTrackLog()
1690 
 
1996 vikas 1691 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1692 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1693 
    args = addTrackLog_args()
1996 vikas 1694 
    args.affiliateId = affiliateId
1845 vikas 1695 
    args.userId = userId
1696 
    args.event = event
1697 
    args.url = url
1698 
    args.data = data
1859 vikas 1699 
    args.addedOn = addedOn
1845 vikas 1700 
    args.write(self._oprot)
1701 
    self._oprot.writeMessageEnd()
1702 
    self._oprot.trans.flush()
1703 
 
1704 
  def recv_addTrackLog(self, ):
1705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1706 
    if mtype == TMessageType.EXCEPTION:
1707 
      x = TApplicationException()
1708 
      x.read(self._iprot)
1709 
      self._iprot.readMessageEnd()
1710 
      raise x
1711 
    result = addTrackLog_result()
1712 
    result.read(self._iprot)
1713 
    self._iprot.readMessageEnd()
1714 
    if result.success != None:
1715 
      return result.success
1716 
    if result.utx != None:
1717 
      raise result.utx
1718 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1719 
 
1720 
  def getTrackLogById(self, id):
1721 
    """
1722 
    Parameters:
1723 
     - id
1724 
    """
1725 
    self.send_getTrackLogById(id)
1726 
    return self.recv_getTrackLogById()
1727 
 
1728 
  def send_getTrackLogById(self, id):
1729 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1730 
    args = getTrackLogById_args()
1731 
    args.id = id
1732 
    args.write(self._oprot)
1733 
    self._oprot.writeMessageEnd()
1734 
    self._oprot.trans.flush()
1735 
 
1736 
  def recv_getTrackLogById(self, ):
1737 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1738 
    if mtype == TMessageType.EXCEPTION:
1739 
      x = TApplicationException()
1740 
      x.read(self._iprot)
1741 
      self._iprot.readMessageEnd()
1742 
      raise x
1743 
    result = getTrackLogById_result()
1744 
    result.read(self._iprot)
1745 
    self._iprot.readMessageEnd()
1746 
    if result.success != None:
1747 
      return result.success
1748 
    if result.utx != None:
1749 
      raise result.utx
1750 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1751 
 
1996 vikas 1752 
  def getTrackLogsByAffiliate(self, affiliateId):
1845 vikas 1753 
    """
1754 
    Parameters:
1996 vikas 1755 
     - affiliateId
1845 vikas 1756 
    """
1996 vikas 1757 
    self.send_getTrackLogsByAffiliate(affiliateId)
1758 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 1759 
 
1996 vikas 1760 
  def send_getTrackLogsByAffiliate(self, affiliateId):
1761 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
1762 
    args = getTrackLogsByAffiliate_args()
1763 
    args.affiliateId = affiliateId
1845 vikas 1764 
    args.write(self._oprot)
1765 
    self._oprot.writeMessageEnd()
1766 
    self._oprot.trans.flush()
1767 
 
1996 vikas 1768 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 1769 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1770 
    if mtype == TMessageType.EXCEPTION:
1771 
      x = TApplicationException()
1772 
      x.read(self._iprot)
1773 
      self._iprot.readMessageEnd()
1774 
      raise x
1996 vikas 1775 
    result = getTrackLogsByAffiliate_result()
1845 vikas 1776 
    result.read(self._iprot)
1777 
    self._iprot.readMessageEnd()
1778 
    if result.success != None:
1779 
      return result.success
1780 
    if result.utx != None:
1781 
      raise result.utx
1996 vikas 1782 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 1783 
 
1784 
  def getTrackLogsByUser(self, userId):
1785 
    """
1786 
    Parameters:
1787 
     - userId
1788 
    """
1789 
    self.send_getTrackLogsByUser(userId)
1790 
    return self.recv_getTrackLogsByUser()
1791 
 
1792 
  def send_getTrackLogsByUser(self, userId):
1793 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
1794 
    args = getTrackLogsByUser_args()
1795 
    args.userId = userId
1796 
    args.write(self._oprot)
1797 
    self._oprot.writeMessageEnd()
1798 
    self._oprot.trans.flush()
1799 
 
1800 
  def recv_getTrackLogsByUser(self, ):
1801 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1802 
    if mtype == TMessageType.EXCEPTION:
1803 
      x = TApplicationException()
1804 
      x.read(self._iprot)
1805 
      self._iprot.readMessageEnd()
1806 
      raise x
1807 
    result = getTrackLogsByUser_result()
1808 
    result.read(self._iprot)
1809 
    self._iprot.readMessageEnd()
1810 
    if result.success != None:
1811 
      return result.success
1812 
    if result.utx != None:
1813 
      raise result.utx
1814 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
1815 
 
1996 vikas 1816 
  def getTrackLogs(self, userId, event, url):
1845 vikas 1817 
    """
1818 
    Parameters:
1819 
     - userId
1820 
     - event
1821 
     - url
1822 
    """
1996 vikas 1823 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 1824 
    return self.recv_getTrackLogs()
1825 
 
1996 vikas 1826 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 1827 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
1828 
    args = getTrackLogs_args()
1829 
    args.userId = userId
1830 
    args.event = event
1831 
    args.url = url
1832 
    args.write(self._oprot)
1833 
    self._oprot.writeMessageEnd()
1834 
    self._oprot.trans.flush()
1835 
 
1836 
  def recv_getTrackLogs(self, ):
1837 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1838 
    if mtype == TMessageType.EXCEPTION:
1839 
      x = TApplicationException()
1840 
      x.read(self._iprot)
1841 
      self._iprot.readMessageEnd()
1842 
      raise x
1843 
    result = getTrackLogs_result()
1844 
    result.read(self._iprot)
1845 
    self._iprot.readMessageEnd()
1846 
    if result.success != None:
1847 
      return result.success
1848 
    if result.utx != None:
1849 
      raise result.utx
1850 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
1851 
 
559 chandransh 1852 
  def createCart(self, userId):
94 ashish 1853 
    """
1854 
    Parameters:
559 chandransh 1855 
     - userId
94 ashish 1856 
    """
559 chandransh 1857 
    self.send_createCart(userId)
1858 
    return self.recv_createCart()
94 ashish 1859 
 
559 chandransh 1860 
  def send_createCart(self, userId):
1861 
    self._oprot.writeMessageBegin('createCart', TMessageType.CALL, self._seqid)
1862 
    args = createCart_args()
1863 
    args.userId = userId
94 ashish 1864 
    args.write(self._oprot)
1865 
    self._oprot.writeMessageEnd()
1866 
    self._oprot.trans.flush()
1867 
 
559 chandransh 1868 
  def recv_createCart(self, ):
94 ashish 1869 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1870 
    if mtype == TMessageType.EXCEPTION:
1871 
      x = TApplicationException()
1872 
      x.read(self._iprot)
1873 
      self._iprot.readMessageEnd()
1874 
      raise x
559 chandransh 1875 
    result = createCart_result()
94 ashish 1876 
    result.read(self._iprot)
1877 
    self._iprot.readMessageEnd()
1878 
    if result.success != None:
1879 
      return result.success
559 chandransh 1880 
    if result.scx != None:
1881 
      raise result.scx
1882 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createCart failed: unknown result");
94 ashish 1883 
 
559 chandransh 1884 
  def getCurrentCart(self, userId):
94 ashish 1885 
    """
1886 
    Parameters:
559 chandransh 1887 
     - userId
94 ashish 1888 
    """
559 chandransh 1889 
    self.send_getCurrentCart(userId)
1890 
    return self.recv_getCurrentCart()
94 ashish 1891 
 
559 chandransh 1892 
  def send_getCurrentCart(self, userId):
1893 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
1894 
    args = getCurrentCart_args()
1895 
    args.userId = userId
94 ashish 1896 
    args.write(self._oprot)
1897 
    self._oprot.writeMessageEnd()
1898 
    self._oprot.trans.flush()
1899 
 
559 chandransh 1900 
  def recv_getCurrentCart(self, ):
94 ashish 1901 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1902 
    if mtype == TMessageType.EXCEPTION:
1903 
      x = TApplicationException()
1904 
      x.read(self._iprot)
1905 
      self._iprot.readMessageEnd()
1906 
      raise x
559 chandransh 1907 
    result = getCurrentCart_result()
94 ashish 1908 
    result.read(self._iprot)
1909 
    self._iprot.readMessageEnd()
1910 
    if result.success != None:
1911 
      return result.success
559 chandransh 1912 
    if result.scx != None:
1913 
      raise result.scx
1914 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 1915 
 
559 chandransh 1916 
  def getCart(self, cartId):
94 ashish 1917 
    """
1918 
    Parameters:
559 chandransh 1919 
     - cartId
94 ashish 1920 
    """
559 chandransh 1921 
    self.send_getCart(cartId)
1922 
    return self.recv_getCart()
94 ashish 1923 
 
559 chandransh 1924 
  def send_getCart(self, cartId):
1925 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
1926 
    args = getCart_args()
1927 
    args.cartId = cartId
94 ashish 1928 
    args.write(self._oprot)
1929 
    self._oprot.writeMessageEnd()
1930 
    self._oprot.trans.flush()
1931 
 
559 chandransh 1932 
  def recv_getCart(self, ):
94 ashish 1933 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1934 
    if mtype == TMessageType.EXCEPTION:
1935 
      x = TApplicationException()
1936 
      x.read(self._iprot)
1937 
      self._iprot.readMessageEnd()
1938 
      raise x
559 chandransh 1939 
    result = getCart_result()
94 ashish 1940 
    result.read(self._iprot)
1941 
    self._iprot.readMessageEnd()
1942 
    if result.success != None:
1943 
      return result.success
559 chandransh 1944 
    if result.scx != None:
1945 
      raise result.scx
1946 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 1947 
 
559 chandransh 1948 
  def getCartsForUser(self, userId, status):
94 ashish 1949 
    """
1950 
    Parameters:
559 chandransh 1951 
     - userId
1952 
     - status
94 ashish 1953 
    """
559 chandransh 1954 
    self.send_getCartsForUser(userId, status)
1955 
    return self.recv_getCartsForUser()
94 ashish 1956 
 
559 chandransh 1957 
  def send_getCartsForUser(self, userId, status):
1958 
    self._oprot.writeMessageBegin('getCartsForUser', TMessageType.CALL, self._seqid)
1959 
    args = getCartsForUser_args()
1960 
    args.userId = userId
1961 
    args.status = status
94 ashish 1962 
    args.write(self._oprot)
1963 
    self._oprot.writeMessageEnd()
1964 
    self._oprot.trans.flush()
1965 
 
559 chandransh 1966 
  def recv_getCartsForUser(self, ):
94 ashish 1967 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1968 
    if mtype == TMessageType.EXCEPTION:
1969 
      x = TApplicationException()
1970 
      x.read(self._iprot)
1971 
      self._iprot.readMessageEnd()
1972 
      raise x
559 chandransh 1973 
    result = getCartsForUser_result()
94 ashish 1974 
    result.read(self._iprot)
1975 
    self._iprot.readMessageEnd()
1976 
    if result.success != None:
1977 
      return result.success
559 chandransh 1978 
    if result.scx != None:
1979 
      raise result.scx
1980 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsForUser failed: unknown result");
94 ashish 1981 
 
559 chandransh 1982 
  def getCartsByStatus(self, status):
94 ashish 1983 
    """
1984 
    Parameters:
559 chandransh 1985 
     - status
94 ashish 1986 
    """
559 chandransh 1987 
    self.send_getCartsByStatus(status)
1988 
    return self.recv_getCartsByStatus()
94 ashish 1989 
 
559 chandransh 1990 
  def send_getCartsByStatus(self, status):
1991 
    self._oprot.writeMessageBegin('getCartsByStatus', TMessageType.CALL, self._seqid)
1992 
    args = getCartsByStatus_args()
1993 
    args.status = status
94 ashish 1994 
    args.write(self._oprot)
1995 
    self._oprot.writeMessageEnd()
1996 
    self._oprot.trans.flush()
1997 
 
559 chandransh 1998 
  def recv_getCartsByStatus(self, ):
94 ashish 1999 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2000 
    if mtype == TMessageType.EXCEPTION:
2001 
      x = TApplicationException()
2002 
      x.read(self._iprot)
2003 
      self._iprot.readMessageEnd()
2004 
      raise x
559 chandransh 2005 
    result = getCartsByStatus_result()
94 ashish 2006 
    result.read(self._iprot)
2007 
    self._iprot.readMessageEnd()
2008 
    if result.success != None:
2009 
      return result.success
559 chandransh 2010 
    if result.scx != None:
2011 
      raise result.scx
2012 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByStatus failed: unknown result");
94 ashish 2013 
 
559 chandransh 2014 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2015 
    """
2016 
    Parameters:
559 chandransh 2017 
     - from_time
2018 
     - to_time
2019 
     - status
94 ashish 2020 
    """
559 chandransh 2021 
    self.send_getCartsByTime(from_time, to_time, status)
2022 
    return self.recv_getCartsByTime()
94 ashish 2023 
 
559 chandransh 2024 
  def send_getCartsByTime(self, from_time, to_time, status):
2025 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2026 
    args = getCartsByTime_args()
2027 
    args.from_time = from_time
2028 
    args.to_time = to_time
2029 
    args.status = status
94 ashish 2030 
    args.write(self._oprot)
2031 
    self._oprot.writeMessageEnd()
2032 
    self._oprot.trans.flush()
2033 
 
559 chandransh 2034 
  def recv_getCartsByTime(self, ):
94 ashish 2035 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2036 
    if mtype == TMessageType.EXCEPTION:
2037 
      x = TApplicationException()
2038 
      x.read(self._iprot)
2039 
      self._iprot.readMessageEnd()
2040 
      raise x
559 chandransh 2041 
    result = getCartsByTime_result()
94 ashish 2042 
    result.read(self._iprot)
2043 
    self._iprot.readMessageEnd()
2044 
    if result.success != None:
2045 
      return result.success
559 chandransh 2046 
    if result.scx != None:
2047 
      raise result.scx
2048 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2049 
 
559 chandransh 2050 
  def changeCartStatus(self, cartId, status):
130 ashish 2051 
    """
2052 
    Parameters:
559 chandransh 2053 
     - cartId
2054 
     - status
130 ashish 2055 
    """
559 chandransh 2056 
    self.send_changeCartStatus(cartId, status)
2057 
    self.recv_changeCartStatus()
94 ashish 2058 
 
559 chandransh 2059 
  def send_changeCartStatus(self, cartId, status):
2060 
    self._oprot.writeMessageBegin('changeCartStatus', TMessageType.CALL, self._seqid)
2061 
    args = changeCartStatus_args()
2062 
    args.cartId = cartId
2063 
    args.status = status
130 ashish 2064 
    args.write(self._oprot)
2065 
    self._oprot.writeMessageEnd()
2066 
    self._oprot.trans.flush()
2067 
 
559 chandransh 2068 
  def recv_changeCartStatus(self, ):
130 ashish 2069 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2070 
    if mtype == TMessageType.EXCEPTION:
2071 
      x = TApplicationException()
2072 
      x.read(self._iprot)
2073 
      self._iprot.readMessageEnd()
2074 
      raise x
559 chandransh 2075 
    result = changeCartStatus_result()
130 ashish 2076 
    result.read(self._iprot)
2077 
    self._iprot.readMessageEnd()
559 chandransh 2078 
    if result.scx != None:
2079 
      raise result.scx
2080 
    return
2081 
 
2082 
  def addItemToCart(self, cartId, itemId, quantity):
2083 
    """
2084 
    Parameters:
2085 
     - cartId
2086 
     - itemId
2087 
     - quantity
2088 
    """
2089 
    self.send_addItemToCart(cartId, itemId, quantity)
2035 rajveer 2090 
    return self.recv_addItemToCart()
559 chandransh 2091 
 
2092 
  def send_addItemToCart(self, cartId, itemId, quantity):
2093 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2094 
    args = addItemToCart_args()
2095 
    args.cartId = cartId
2096 
    args.itemId = itemId
2097 
    args.quantity = quantity
2098 
    args.write(self._oprot)
2099 
    self._oprot.writeMessageEnd()
2100 
    self._oprot.trans.flush()
2101 
 
2102 
  def recv_addItemToCart(self, ):
2103 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2104 
    if mtype == TMessageType.EXCEPTION:
2105 
      x = TApplicationException()
2106 
      x.read(self._iprot)
2107 
      self._iprot.readMessageEnd()
2108 
      raise x
2109 
    result = addItemToCart_result()
2110 
    result.read(self._iprot)
2111 
    self._iprot.readMessageEnd()
2035 rajveer 2112 
    if result.success != None:
2113 
      return result.success
559 chandransh 2114 
    if result.scx != None:
2115 
      raise result.scx
2035 rajveer 2116 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2117 
 
2118 
  def deleteItemFromCart(self, cartId, itemId):
2119 
    """
2120 
    Parameters:
2121 
     - cartId
2122 
     - itemId
2123 
    """
2124 
    self.send_deleteItemFromCart(cartId, itemId)
2125 
    self.recv_deleteItemFromCart()
2126 
 
2127 
  def send_deleteItemFromCart(self, cartId, itemId):
2128 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2129 
    args = deleteItemFromCart_args()
2130 
    args.cartId = cartId
2131 
    args.itemId = itemId
2132 
    args.write(self._oprot)
2133 
    self._oprot.writeMessageEnd()
2134 
    self._oprot.trans.flush()
2135 
 
2136 
  def recv_deleteItemFromCart(self, ):
2137 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2138 
    if mtype == TMessageType.EXCEPTION:
2139 
      x = TApplicationException()
2140 
      x.read(self._iprot)
2141 
      self._iprot.readMessageEnd()
2142 
      raise x
2143 
    result = deleteItemFromCart_result()
2144 
    result.read(self._iprot)
2145 
    self._iprot.readMessageEnd()
2146 
    if result.scx != None:
2147 
      raise result.scx
2148 
    return
2149 
 
2150 
  def changeQuantity(self, cartId, itemId, quantity):
2151 
    """
2152 
    Parameters:
2153 
     - cartId
2154 
     - itemId
2155 
     - quantity
2156 
    """
2157 
    self.send_changeQuantity(cartId, itemId, quantity)
2158 
    self.recv_changeQuantity()
2159 
 
2160 
  def send_changeQuantity(self, cartId, itemId, quantity):
2161 
    self._oprot.writeMessageBegin('changeQuantity', TMessageType.CALL, self._seqid)
2162 
    args = changeQuantity_args()
2163 
    args.cartId = cartId
2164 
    args.itemId = itemId
2165 
    args.quantity = quantity
2166 
    args.write(self._oprot)
2167 
    self._oprot.writeMessageEnd()
2168 
    self._oprot.trans.flush()
2169 
 
2170 
  def recv_changeQuantity(self, ):
2171 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2172 
    if mtype == TMessageType.EXCEPTION:
2173 
      x = TApplicationException()
2174 
      x.read(self._iprot)
2175 
      self._iprot.readMessageEnd()
2176 
      raise x
2177 
    result = changeQuantity_result()
2178 
    result.read(self._iprot)
2179 
    self._iprot.readMessageEnd()
2180 
    if result.scx != None:
2181 
      raise result.scx
2182 
    return
2183 
 
2184 
  def changeItemStatus(self, cartId, itemId, status):
2185 
    """
2186 
    Parameters:
2187 
     - cartId
2188 
     - itemId
2189 
     - status
2190 
    """
2191 
    self.send_changeItemStatus(cartId, itemId, status)
2192 
    self.recv_changeItemStatus()
2193 
 
2194 
  def send_changeItemStatus(self, cartId, itemId, status):
2195 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
2196 
    args = changeItemStatus_args()
2197 
    args.cartId = cartId
2198 
    args.itemId = itemId
2199 
    args.status = status
2200 
    args.write(self._oprot)
2201 
    self._oprot.writeMessageEnd()
2202 
    self._oprot.trans.flush()
2203 
 
2204 
  def recv_changeItemStatus(self, ):
2205 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2206 
    if mtype == TMessageType.EXCEPTION:
2207 
      x = TApplicationException()
2208 
      x.read(self._iprot)
2209 
      self._iprot.readMessageEnd()
2210 
      raise x
2211 
    result = changeItemStatus_result()
2212 
    result.read(self._iprot)
2213 
    self._iprot.readMessageEnd()
2214 
    if result.scx != None:
2215 
      raise result.scx
2216 
    return
2217 
 
2218 
  def addAddressToCart(self, cartId, addressId):
2219 
    """
2220 
    Parameters:
2221 
     - cartId
2222 
     - addressId
2223 
    """
2224 
    self.send_addAddressToCart(cartId, addressId)
2225 
    self.recv_addAddressToCart()
2226 
 
2227 
  def send_addAddressToCart(self, cartId, addressId):
2228 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2229 
    args = addAddressToCart_args()
2230 
    args.cartId = cartId
2231 
    args.addressId = addressId
2232 
    args.write(self._oprot)
2233 
    self._oprot.writeMessageEnd()
2234 
    self._oprot.trans.flush()
2235 
 
2236 
  def recv_addAddressToCart(self, ):
2237 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2238 
    if mtype == TMessageType.EXCEPTION:
2239 
      x = TApplicationException()
2240 
      x.read(self._iprot)
2241 
      self._iprot.readMessageEnd()
2242 
      raise x
2243 
    result = addAddressToCart_result()
2244 
    result.read(self._iprot)
2245 
    self._iprot.readMessageEnd()
575 chandransh 2246 
    if result.scx != None:
2247 
      raise result.scx
559 chandransh 2248 
    return
2249 
 
1976 varun.gupt 2250 
  def applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
2251 
    """
2252 
    Parameters:
2253 
     - cartId
2254 
     - couponCode
2255 
     - totalPrice
2256 
     - discountedPrice
2257 
    """
2258 
    self.send_applyCouponToCart(cartId, couponCode, totalPrice, discountedPrice)
2259 
    self.recv_applyCouponToCart()
2260 
 
2261 
  def send_applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
2262 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2263 
    args = applyCouponToCart_args()
2264 
    args.cartId = cartId
2265 
    args.couponCode = couponCode
2266 
    args.totalPrice = totalPrice
2267 
    args.discountedPrice = discountedPrice
2268 
    args.write(self._oprot)
2269 
    self._oprot.writeMessageEnd()
2270 
    self._oprot.trans.flush()
2271 
 
2272 
  def recv_applyCouponToCart(self, ):
2273 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2274 
    if mtype == TMessageType.EXCEPTION:
2275 
      x = TApplicationException()
2276 
      x.read(self._iprot)
2277 
      self._iprot.readMessageEnd()
2278 
      raise x
2279 
    result = applyCouponToCart_result()
2280 
    result.read(self._iprot)
2281 
    self._iprot.readMessageEnd()
2282 
    if result.scx != None:
2283 
      raise result.scx
2284 
    return
2285 
 
2286 
  def removeCoupon(self, cartId):
2287 
    """
2288 
    Parameters:
2289 
     - cartId
2290 
    """
2291 
    self.send_removeCoupon(cartId)
2292 
    self.recv_removeCoupon()
2293 
 
2294 
  def send_removeCoupon(self, cartId):
2295 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2296 
    args = removeCoupon_args()
2297 
    args.cartId = cartId
2298 
    args.write(self._oprot)
2299 
    self._oprot.writeMessageEnd()
2300 
    self._oprot.trans.flush()
2301 
 
2302 
  def recv_removeCoupon(self, ):
2303 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2304 
    if mtype == TMessageType.EXCEPTION:
2305 
      x = TApplicationException()
2306 
      x.read(self._iprot)
2307 
      self._iprot.readMessageEnd()
2308 
      raise x
2309 
    result = removeCoupon_result()
2310 
    result.read(self._iprot)
2311 
    self._iprot.readMessageEnd()
2312 
    if result.scx != None:
2313 
      raise result.scx
2314 
    return
2315 
 
690 chandransh 2316 
  def createOrders(self, cartId):
559 chandransh 2317 
    """
690 chandransh 2318 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
2319 
 
559 chandransh 2320 
    Parameters:
2321 
     - cartId
2322 
    """
690 chandransh 2323 
    self.send_createOrders(cartId)
2324 
    return self.recv_createOrders()
559 chandransh 2325 
 
690 chandransh 2326 
  def send_createOrders(self, cartId):
2327 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2328 
    args = createOrders_args()
559 chandransh 2329 
    args.cartId = cartId
2330 
    args.write(self._oprot)
2331 
    self._oprot.writeMessageEnd()
2332 
    self._oprot.trans.flush()
2333 
 
690 chandransh 2334 
  def recv_createOrders(self, ):
559 chandransh 2335 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2336 
    if mtype == TMessageType.EXCEPTION:
2337 
      x = TApplicationException()
2338 
      x.read(self._iprot)
2339 
      self._iprot.readMessageEnd()
2340 
      raise x
690 chandransh 2341 
    result = createOrders_result()
559 chandransh 2342 
    result.read(self._iprot)
2343 
    self._iprot.readMessageEnd()
130 ashish 2344 
    if result.success != None:
2345 
      return result.success
559 chandransh 2346 
    if result.scx != None:
2347 
      raise result.scx
690 chandransh 2348 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2349 
 
559 chandransh 2350 
  def validateCart(self, cartId):
130 ashish 2351 
    """
690 chandransh 2352 
    Validates that:
2353 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2354 
    2. All of the lines in the cart are active items.
690 chandransh 2355 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2356 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 2357 
 
130 ashish 2358 
    Parameters:
559 chandransh 2359 
     - cartId
130 ashish 2360 
    """
559 chandransh 2361 
    self.send_validateCart(cartId)
2362 
    return self.recv_validateCart()
130 ashish 2363 
 
559 chandransh 2364 
  def send_validateCart(self, cartId):
2365 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2366 
    args = validateCart_args()
2367 
    args.cartId = cartId
130 ashish 2368 
    args.write(self._oprot)
2369 
    self._oprot.writeMessageEnd()
2370 
    self._oprot.trans.flush()
2371 
 
559 chandransh 2372 
  def recv_validateCart(self, ):
130 ashish 2373 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2374 
    if mtype == TMessageType.EXCEPTION:
2375 
      x = TApplicationException()
2376 
      x.read(self._iprot)
2377 
      self._iprot.readMessageEnd()
2378 
      raise x
559 chandransh 2379 
    result = validateCart_result()
130 ashish 2380 
    result.read(self._iprot)
2381 
    self._iprot.readMessageEnd()
2382 
    if result.success != None:
2383 
      return result.success
575 chandransh 2384 
    if result.scex != None:
2385 
      raise result.scex
559 chandransh 2386 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2387 
 
690 chandransh 2388 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2389 
    """
690 chandransh 2390 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
2391 
 
575 chandransh 2392 
    Parameters:
690 chandransh 2393 
     - fromCartId
2394 
     - toCartId
2395 
    """
2396 
    self.send_mergeCart(fromCartId, toCartId)
2397 
    self.recv_mergeCart()
2398 
 
2399 
  def send_mergeCart(self, fromCartId, toCartId):
2400 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2401 
    args = mergeCart_args()
2402 
    args.fromCartId = fromCartId
2403 
    args.toCartId = toCartId
2404 
    args.write(self._oprot)
2405 
    self._oprot.writeMessageEnd()
2406 
    self._oprot.trans.flush()
2407 
 
2408 
  def recv_mergeCart(self, ):
2409 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2410 
    if mtype == TMessageType.EXCEPTION:
2411 
      x = TApplicationException()
2412 
      x.read(self._iprot)
2413 
      self._iprot.readMessageEnd()
2414 
      raise x
2415 
    result = mergeCart_result()
2416 
    result.read(self._iprot)
2417 
    self._iprot.readMessageEnd()
2418 
    return
2419 
 
2420 
  def checkOut(self, cartId):
2421 
    """
2422 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
2423 
 
2424 
    Parameters:
575 chandransh 2425 
     - cartId
2426 
    """
690 chandransh 2427 
    self.send_checkOut(cartId)
2428 
    return self.recv_checkOut()
575 chandransh 2429 
 
690 chandransh 2430 
  def send_checkOut(self, cartId):
2431 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2432 
    args = checkOut_args()
575 chandransh 2433 
    args.cartId = cartId
2434 
    args.write(self._oprot)
2435 
    self._oprot.writeMessageEnd()
2436 
    self._oprot.trans.flush()
2437 
 
690 chandransh 2438 
  def recv_checkOut(self, ):
575 chandransh 2439 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2440 
    if mtype == TMessageType.EXCEPTION:
2441 
      x = TApplicationException()
2442 
      x.read(self._iprot)
2443 
      self._iprot.readMessageEnd()
2444 
      raise x
690 chandransh 2445 
    result = checkOut_result()
575 chandransh 2446 
    result.read(self._iprot)
2447 
    self._iprot.readMessageEnd()
2448 
    if result.success != None:
2449 
      return result.success
2450 
    if result.scex != None:
2451 
      raise result.scex
690 chandransh 2452 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2453 
 
690 chandransh 2454 
  def resetCart(self, cartId, items):
559 chandransh 2455 
    """
690 chandransh 2456 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2457 
    This methods removes the specified quantiry of the specified item from the cart.
2458 
 
559 chandransh 2459 
    Parameters:
690 chandransh 2460 
     - cartId
2461 
     - items
559 chandransh 2462 
    """
690 chandransh 2463 
    self.send_resetCart(cartId, items)
2464 
    return self.recv_resetCart()
130 ashish 2465 
 
690 chandransh 2466 
  def send_resetCart(self, cartId, items):
2467 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2468 
    args = resetCart_args()
2469 
    args.cartId = cartId
2470 
    args.items = items
559 chandransh 2471 
    args.write(self._oprot)
2472 
    self._oprot.writeMessageEnd()
2473 
    self._oprot.trans.flush()
2474 
 
690 chandransh 2475 
  def recv_resetCart(self, ):
559 chandransh 2476 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2477 
    if mtype == TMessageType.EXCEPTION:
2478 
      x = TApplicationException()
2479 
      x.read(self._iprot)
2480 
      self._iprot.readMessageEnd()
2481 
      raise x
690 chandransh 2482 
    result = resetCart_result()
559 chandransh 2483 
    result.read(self._iprot)
2484 
    self._iprot.readMessageEnd()
690 chandransh 2485 
    if result.success != None:
2486 
      return result.success
2487 
    if result.scex != None:
2488 
      raise result.scex
2489 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2490 
 
772 rajveer 2491 
  def getMyResearch(self, userId):
559 chandransh 2492 
    """
772 rajveer 2493 
    Widgets
2494 
 
559 chandransh 2495 
    Parameters:
2496 
     - userId
2497 
    """
772 rajveer 2498 
    self.send_getMyResearch(userId)
559 chandransh 2499 
    return self.recv_getMyResearch()
2500 
 
772 rajveer 2501 
  def send_getMyResearch(self, userId):
559 chandransh 2502 
    self._oprot.writeMessageBegin('getMyResearch', TMessageType.CALL, self._seqid)
2503 
    args = getMyResearch_args()
772 rajveer 2504 
    args.userId = userId
559 chandransh 2505 
    args.write(self._oprot)
2506 
    self._oprot.writeMessageEnd()
2507 
    self._oprot.trans.flush()
2508 
 
2509 
  def recv_getMyResearch(self, ):
2510 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2511 
    if mtype == TMessageType.EXCEPTION:
2512 
      x = TApplicationException()
2513 
      x.read(self._iprot)
2514 
      self._iprot.readMessageEnd()
2515 
      raise x
2516 
    result = getMyResearch_result()
2517 
    result.read(self._iprot)
2518 
    self._iprot.readMessageEnd()
2519 
    if result.success != None:
2520 
      return result.success
2521 
    if result.scx != None:
2522 
      raise result.scx
2523 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearch failed: unknown result");
2524 
 
772 rajveer 2525 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2526 
    """
2527 
    Parameters:
772 rajveer 2528 
     - userId
2529 
     - itemId
559 chandransh 2530 
    """
772 rajveer 2531 
    self.send_updateMyResearch(userId, itemId)
559 chandransh 2532 
    return self.recv_updateMyResearch()
2533 
 
772 rajveer 2534 
  def send_updateMyResearch(self, userId, itemId):
559 chandransh 2535 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2536 
    args = updateMyResearch_args()
772 rajveer 2537 
    args.userId = userId
2538 
    args.itemId = itemId
559 chandransh 2539 
    args.write(self._oprot)
2540 
    self._oprot.writeMessageEnd()
2541 
    self._oprot.trans.flush()
2542 
 
2543 
  def recv_updateMyResearch(self, ):
2544 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2545 
    if mtype == TMessageType.EXCEPTION:
2546 
      x = TApplicationException()
2547 
      x.read(self._iprot)
2548 
      self._iprot.readMessageEnd()
2549 
      raise x
2550 
    result = updateMyResearch_result()
2551 
    result.read(self._iprot)
2552 
    self._iprot.readMessageEnd()
2553 
    if result.success != None:
2554 
      return result.success
2555 
    if result.scx != None:
2556 
      raise result.scx
2557 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
2558 
 
772 rajveer 2559 
  def deleteItemFromMyResearch(self, userId, itemId):
559 chandransh 2560 
    """
2561 
    Parameters:
772 rajveer 2562 
     - userId
2563 
     - itemId
559 chandransh 2564 
    """
772 rajveer 2565 
    self.send_deleteItemFromMyResearch(userId, itemId)
559 chandransh 2566 
    self.recv_deleteItemFromMyResearch()
2567 
 
772 rajveer 2568 
  def send_deleteItemFromMyResearch(self, userId, itemId):
559 chandransh 2569 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2570 
    args = deleteItemFromMyResearch_args()
772 rajveer 2571 
    args.userId = userId
2572 
    args.itemId = itemId
559 chandransh 2573 
    args.write(self._oprot)
2574 
    self._oprot.writeMessageEnd()
2575 
    self._oprot.trans.flush()
2576 
 
2577 
  def recv_deleteItemFromMyResearch(self, ):
2578 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2579 
    if mtype == TMessageType.EXCEPTION:
2580 
      x = TApplicationException()
2581 
      x.read(self._iprot)
2582 
      self._iprot.readMessageEnd()
2583 
      raise x
2584 
    result = deleteItemFromMyResearch_result()
2585 
    result.read(self._iprot)
2586 
    self._iprot.readMessageEnd()
2587 
    if result.scx != None:
2588 
      raise result.scx
2589 
    return
2590 
 
772 rajveer 2591 
  def updateBrowseHistory(self, userId, itemId):
559 chandransh 2592 
    """
2593 
    Parameters:
772 rajveer 2594 
     - userId
2595 
     - itemId
559 chandransh 2596 
    """
772 rajveer 2597 
    self.send_updateBrowseHistory(userId, itemId)
2598 
    self.recv_updateBrowseHistory()
559 chandransh 2599 
 
772 rajveer 2600 
  def send_updateBrowseHistory(self, userId, itemId):
2601 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2602 
    args = updateBrowseHistory_args()
2603 
    args.userId = userId
2604 
    args.itemId = itemId
559 chandransh 2605 
    args.write(self._oprot)
2606 
    self._oprot.writeMessageEnd()
2607 
    self._oprot.trans.flush()
2608 
 
772 rajveer 2609 
  def recv_updateBrowseHistory(self, ):
559 chandransh 2610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2611 
    if mtype == TMessageType.EXCEPTION:
2612 
      x = TApplicationException()
2613 
      x.read(self._iprot)
2614 
      self._iprot.readMessageEnd()
2615 
      raise x
772 rajveer 2616 
    result = updateBrowseHistory_result()
559 chandransh 2617 
    result.read(self._iprot)
2618 
    self._iprot.readMessageEnd()
2619 
    return
2620 
 
772 rajveer 2621 
  def getBrowseHistory(self, userId):
559 chandransh 2622 
    """
2623 
    Parameters:
772 rajveer 2624 
     - userId
559 chandransh 2625 
    """
772 rajveer 2626 
    self.send_getBrowseHistory(userId)
2627 
    return self.recv_getBrowseHistory()
559 chandransh 2628 
 
772 rajveer 2629 
  def send_getBrowseHistory(self, userId):
2630 
    self._oprot.writeMessageBegin('getBrowseHistory', TMessageType.CALL, self._seqid)
2631 
    args = getBrowseHistory_args()
2632 
    args.userId = userId
559 chandransh 2633 
    args.write(self._oprot)
2634 
    self._oprot.writeMessageEnd()
2635 
    self._oprot.trans.flush()
2636 
 
772 rajveer 2637 
  def recv_getBrowseHistory(self, ):
559 chandransh 2638 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2639 
    if mtype == TMessageType.EXCEPTION:
2640 
      x = TApplicationException()
2641 
      x.read(self._iprot)
2642 
      self._iprot.readMessageEnd()
2643 
      raise x
772 rajveer 2644 
    result = getBrowseHistory_result()
559 chandransh 2645 
    result.read(self._iprot)
2646 
    self._iprot.readMessageEnd()
2647 
    if result.success != None:
2648 
      return result.success
2649 
    if result.scx != None:
2650 
      raise result.scx
772 rajveer 2651 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistory failed: unknown result");
559 chandransh 2652 
 
772 rajveer 2653 
  def mergeBrowseHistory(self, fromUserId, toUserId):
559 chandransh 2654 
    """
2655 
    Parameters:
772 rajveer 2656 
     - fromUserId
2657 
     - toUserId
559 chandransh 2658 
    """
772 rajveer 2659 
    self.send_mergeBrowseHistory(fromUserId, toUserId)
2660 
    self.recv_mergeBrowseHistory()
559 chandransh 2661 
 
772 rajveer 2662 
  def send_mergeBrowseHistory(self, fromUserId, toUserId):
2663 
    self._oprot.writeMessageBegin('mergeBrowseHistory', TMessageType.CALL, self._seqid)
2664 
    args = mergeBrowseHistory_args()
2665 
    args.fromUserId = fromUserId
2666 
    args.toUserId = toUserId
559 chandransh 2667 
    args.write(self._oprot)
2668 
    self._oprot.writeMessageEnd()
2669 
    self._oprot.trans.flush()
2670 
 
772 rajveer 2671 
  def recv_mergeBrowseHistory(self, ):
559 chandransh 2672 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2673 
    if mtype == TMessageType.EXCEPTION:
2674 
      x = TApplicationException()
2675 
      x.read(self._iprot)
2676 
      self._iprot.readMessageEnd()
2677 
      raise x
772 rajveer 2678 
    result = mergeBrowseHistory_result()
559 chandransh 2679 
    result.read(self._iprot)
2680 
    self._iprot.readMessageEnd()
2681 
    return
2682 
 
1596 ankur.sing 2683 
  def getUserCount(self, userType):
2684 
    """
2685 
    Returns number of registered users.
2686 
    If userType = null, then it returns count of all users, including anonymous
2687 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2688 
    If userType = UserType.USER, then it returns count of non-anonymous users only
2689 
 
2690 
    Parameters:
2691 
     - userType
2692 
    """
2693 
    self.send_getUserCount(userType)
2694 
    return self.recv_getUserCount()
559 chandransh 2695 
 
1596 ankur.sing 2696 
  def send_getUserCount(self, userType):
2697 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2698 
    args = getUserCount_args()
2699 
    args.userType = userType
2700 
    args.write(self._oprot)
2701 
    self._oprot.writeMessageEnd()
2702 
    self._oprot.trans.flush()
2703 
 
2704 
  def recv_getUserCount(self, ):
2705 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2706 
    if mtype == TMessageType.EXCEPTION:
2707 
      x = TApplicationException()
2708 
      x.read(self._iprot)
2709 
      self._iprot.readMessageEnd()
2710 
      raise x
2711 
    result = getUserCount_result()
2712 
    result.read(self._iprot)
2713 
    self._iprot.readMessageEnd()
2714 
    if result.success != None:
2715 
      return result.success
2716 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
2717 
 
1891 ankur.sing 2718 
  def getAllUsers(self, userType, startDate, endDate):
1673 ankur.sing 2719 
    """
1891 ankur.sing 2720 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2721 
    If any of startDate or endDate is -1, then that filter is ignored.
2722 
    If userType is null, then returns all the users, irrespective of anonymous flag
1673 ankur.sing 2723 
 
1891 ankur.sing 2724 
 
1673 ankur.sing 2725 
    Parameters:
2726 
     - userType
1891 ankur.sing 2727 
     - startDate
2728 
     - endDate
1673 ankur.sing 2729 
    """
1891 ankur.sing 2730 
    self.send_getAllUsers(userType, startDate, endDate)
1673 ankur.sing 2731 
    return self.recv_getAllUsers()
1596 ankur.sing 2732 
 
1891 ankur.sing 2733 
  def send_getAllUsers(self, userType, startDate, endDate):
1673 ankur.sing 2734 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2735 
    args = getAllUsers_args()
2736 
    args.userType = userType
1891 ankur.sing 2737 
    args.startDate = startDate
2738 
    args.endDate = endDate
1673 ankur.sing 2739 
    args.write(self._oprot)
2740 
    self._oprot.writeMessageEnd()
2741 
    self._oprot.trans.flush()
2742 
 
2743 
  def recv_getAllUsers(self, ):
2744 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2745 
    if mtype == TMessageType.EXCEPTION:
2746 
      x = TApplicationException()
2747 
      x.read(self._iprot)
2748 
      self._iprot.readMessageEnd()
2749 
      raise x
2750 
    result = getAllUsers_result()
2751 
    result.read(self._iprot)
2752 
    self._iprot.readMessageEnd()
2753 
    if result.success != None:
2754 
      return result.success
2755 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
2756 
 
2757 
 
94 ashish 2758 
class Processor(Iface, TProcessor):
2759 
  def __init__(self, handler):
2760 
    self._handler = handler
2761 
    self._processMap = {}
765 rajveer 2762 
    self._processMap["closeSession"] = Processor.process_closeSession
559 chandransh 2763 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
2764 
    self._processMap["getUserById"] = Processor.process_getUserById
1491 vikas 2765 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
559 chandransh 2766 
    self._processMap["createUser"] = Processor.process_createUser
2767 
    self._processMap["updateUser"] = Processor.process_updateUser
2768 
    self._processMap["deleteUser"] = Processor.process_deleteUser
2769 
    self._processMap["getUserState"] = Processor.process_getUserState
122 ashish 2770 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 2771 
    self._processMap["userExists"] = Processor.process_userExists
2772 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
2773 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
2774 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
2775 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 2776 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 2777 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 2778 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 2779 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 2780 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 2781 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 2782 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 2783 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 2784 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
2785 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
2786 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
1845 vikas 2787 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 2788 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 2789 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
2790 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
2791 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
2792 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
2793 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 2794 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 2795 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
2796 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
2797 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 2798 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 2799 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
2800 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 2801 
    self._processMap["createCart"] = Processor.process_createCart
2802 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
2803 
    self._processMap["getCart"] = Processor.process_getCart
2804 
    self._processMap["getCartsForUser"] = Processor.process_getCartsForUser
2805 
    self._processMap["getCartsByStatus"] = Processor.process_getCartsByStatus
2806 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
2807 
    self._processMap["changeCartStatus"] = Processor.process_changeCartStatus
2808 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
2809 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
2810 
    self._processMap["changeQuantity"] = Processor.process_changeQuantity
2811 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
2812 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
1976 varun.gupt 2813 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
2814 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
690 chandransh 2815 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 2816 
    self._processMap["validateCart"] = Processor.process_validateCart
2817 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 2818 
    self._processMap["checkOut"] = Processor.process_checkOut
2819 
    self._processMap["resetCart"] = Processor.process_resetCart
559 chandransh 2820 
    self._processMap["getMyResearch"] = Processor.process_getMyResearch
2821 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
2822 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
2823 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
2824 
    self._processMap["getBrowseHistory"] = Processor.process_getBrowseHistory
772 rajveer 2825 
    self._processMap["mergeBrowseHistory"] = Processor.process_mergeBrowseHistory
1596 ankur.sing 2826 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 2827 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
94 ashish 2828 
 
2829 
  def process(self, iprot, oprot):
2830 
    (name, type, seqid) = iprot.readMessageBegin()
2831 
    if name not in self._processMap:
2832 
      iprot.skip(TType.STRUCT)
2833 
      iprot.readMessageEnd()
2834 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
2835 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
2836 
      x.write(oprot)
2837 
      oprot.writeMessageEnd()
2838 
      oprot.trans.flush()
2839 
      return
2840 
    else:
2841 
      self._processMap[name](self, seqid, iprot, oprot)
2842 
    return True
2843 
 
765 rajveer 2844 
  def process_closeSession(self, seqid, iprot, oprot):
2845 
    args = closeSession_args()
2846 
    args.read(iprot)
2847 
    iprot.readMessageEnd()
2848 
    result = closeSession_result()
2849 
    self._handler.closeSession()
2850 
    oprot.writeMessageBegin("closeSession", TMessageType.REPLY, seqid)
2851 
    result.write(oprot)
2852 
    oprot.writeMessageEnd()
2853 
    oprot.trans.flush()
2854 
 
559 chandransh 2855 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
2856 
    args = createAnonymousUser_args()
94 ashish 2857 
    args.read(iprot)
2858 
    iprot.readMessageEnd()
559 chandransh 2859 
    result = createAnonymousUser_result()
94 ashish 2860 
    try:
559 chandransh 2861 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
2862 
    except UserContextException, ucex:
2863 
      result.ucex = ucex
2864 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 2865 
    result.write(oprot)
2866 
    oprot.writeMessageEnd()
2867 
    oprot.trans.flush()
2868 
 
559 chandransh 2869 
  def process_getUserById(self, seqid, iprot, oprot):
2870 
    args = getUserById_args()
94 ashish 2871 
    args.read(iprot)
2872 
    iprot.readMessageEnd()
559 chandransh 2873 
    result = getUserById_result()
94 ashish 2874 
    try:
559 chandransh 2875 
      result.success = self._handler.getUserById(args.userId)
2876 
    except UserContextException, ucex:
2877 
      result.ucex = ucex
2878 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 2879 
    result.write(oprot)
2880 
    oprot.writeMessageEnd()
2881 
    oprot.trans.flush()
2882 
 
1491 vikas 2883 
  def process_getUserByEmail(self, seqid, iprot, oprot):
2884 
    args = getUserByEmail_args()
2885 
    args.read(iprot)
2886 
    iprot.readMessageEnd()
2887 
    result = getUserByEmail_result()
2888 
    try:
2889 
      result.success = self._handler.getUserByEmail(args.email)
2890 
    except UserContextException, ucex:
2891 
      result.ucex = ucex
2892 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
2893 
    result.write(oprot)
2894 
    oprot.writeMessageEnd()
2895 
    oprot.trans.flush()
2896 
 
559 chandransh 2897 
  def process_createUser(self, seqid, iprot, oprot):
2898 
    args = createUser_args()
94 ashish 2899 
    args.read(iprot)
2900 
    iprot.readMessageEnd()
559 chandransh 2901 
    result = createUser_result()
94 ashish 2902 
    try:
559 chandransh 2903 
      result.success = self._handler.createUser(args.user)
2904 
    except UserContextException, ucex:
2905 
      result.ucex = ucex
2906 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 2907 
    result.write(oprot)
2908 
    oprot.writeMessageEnd()
2909 
    oprot.trans.flush()
2910 
 
559 chandransh 2911 
  def process_updateUser(self, seqid, iprot, oprot):
2912 
    args = updateUser_args()
94 ashish 2913 
    args.read(iprot)
2914 
    iprot.readMessageEnd()
559 chandransh 2915 
    result = updateUser_result()
94 ashish 2916 
    try:
559 chandransh 2917 
      result.success = self._handler.updateUser(args.user)
2918 
    except UserContextException, ucex:
2919 
      result.ucex = ucex
2920 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 2921 
    result.write(oprot)
2922 
    oprot.writeMessageEnd()
2923 
    oprot.trans.flush()
2924 
 
559 chandransh 2925 
  def process_deleteUser(self, seqid, iprot, oprot):
2926 
    args = deleteUser_args()
94 ashish 2927 
    args.read(iprot)
2928 
    iprot.readMessageEnd()
559 chandransh 2929 
    result = deleteUser_result()
94 ashish 2930 
    try:
559 chandransh 2931 
      result.success = self._handler.deleteUser(args.userId)
2932 
    except UserContextException, ucex:
2933 
      result.ucex = ucex
2934 
    oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
94 ashish 2935 
    result.write(oprot)
2936 
    oprot.writeMessageEnd()
2937 
    oprot.trans.flush()
2938 
 
559 chandransh 2939 
  def process_getUserState(self, seqid, iprot, oprot):
2940 
    args = getUserState_args()
94 ashish 2941 
    args.read(iprot)
2942 
    iprot.readMessageEnd()
559 chandransh 2943 
    result = getUserState_result()
94 ashish 2944 
    try:
559 chandransh 2945 
      result.success = self._handler.getUserState(args.userId)
2946 
    except UserContextException, ucex:
2947 
      result.ucex = ucex
2948 
    oprot.writeMessageBegin("getUserState", TMessageType.REPLY, seqid)
94 ashish 2949 
    result.write(oprot)
2950 
    oprot.writeMessageEnd()
2951 
    oprot.trans.flush()
2952 
 
122 ashish 2953 
  def process_authenticateUser(self, seqid, iprot, oprot):
2954 
    args = authenticateUser_args()
2955 
    args.read(iprot)
2956 
    iprot.readMessageEnd()
2957 
    result = authenticateUser_result()
2958 
    try:
559 chandransh 2959 
      result.success = self._handler.authenticateUser(args.email, args.password)
2960 
    except AuthenticationException, auex:
2961 
      result.auex = auex
122 ashish 2962 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
2963 
    result.write(oprot)
2964 
    oprot.writeMessageEnd()
2965 
    oprot.trans.flush()
2966 
 
94 ashish 2967 
  def process_userExists(self, seqid, iprot, oprot):
2968 
    args = userExists_args()
2969 
    args.read(iprot)
2970 
    iprot.readMessageEnd()
2971 
    result = userExists_result()
2972 
    try:
2973 
      result.success = self._handler.userExists(args.email)
2974 
    except UserContextException, ucx:
2975 
      result.ucx = ucx
2976 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
2977 
    result.write(oprot)
2978 
    oprot.writeMessageEnd()
2979 
    oprot.trans.flush()
2980 
 
2981 
  def process_addAddressForUser(self, seqid, iprot, oprot):
2982 
    args = addAddressForUser_args()
2983 
    args.read(iprot)
2984 
    iprot.readMessageEnd()
2985 
    result = addAddressForUser_result()
2986 
    try:
567 rajveer 2987 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 2988 
    except UserContextException, ucx:
2989 
      result.ucx = ucx
2990 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
2991 
    result.write(oprot)
2992 
    oprot.writeMessageEnd()
2993 
    oprot.trans.flush()
2994 
 
2995 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
2996 
    args = removeAddressForUser_args()
2997 
    args.read(iprot)
2998 
    iprot.readMessageEnd()
2999 
    result = removeAddressForUser_result()
3000 
    try:
3001 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
3002 
    except UserContextException, ucx:
3003 
      result.ucx = ucx
3004 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
3005 
    result.write(oprot)
3006 
    oprot.writeMessageEnd()
3007 
    oprot.trans.flush()
3008 
 
3009 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
3010 
    args = setUserAsLoggedIn_args()
3011 
    args.read(iprot)
3012 
    iprot.readMessageEnd()
3013 
    result = setUserAsLoggedIn_result()
3014 
    try:
3015 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
3016 
    except UserContextException, ucx:
3017 
      result.ucx = ucx
3018 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
3019 
    result.write(oprot)
3020 
    oprot.writeMessageEnd()
3021 
    oprot.trans.flush()
3022 
 
3023 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
3024 
    args = setUserAsLoggedOut_args()
3025 
    args.read(iprot)
3026 
    iprot.readMessageEnd()
3027 
    result = setUserAsLoggedOut_result()
3028 
    try:
3029 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
3030 
    except UserContextException, ucx:
3031 
      result.ucx = ucx
3032 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
3033 
    result.write(oprot)
3034 
    oprot.writeMessageEnd()
3035 
    oprot.trans.flush()
3036 
 
504 rajveer 3037 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
3038 
    args = setDefaultAddress_args()
3039 
    args.read(iprot)
3040 
    iprot.readMessageEnd()
3041 
    result = setDefaultAddress_result()
3042 
    try:
3043 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
3044 
    except UserContextException, ucx:
3045 
      result.ucx = ucx
3046 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
3047 
    result.write(oprot)
3048 
    oprot.writeMessageEnd()
3049 
    oprot.trans.flush()
3050 
 
94 ashish 3051 
  def process_updatePassword(self, seqid, iprot, oprot):
3052 
    args = updatePassword_args()
3053 
    args.read(iprot)
3054 
    iprot.readMessageEnd()
3055 
    result = updatePassword_result()
3056 
    try:
594 rajveer 3057 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 3058 
    except UserContextException, ucx:
3059 
      result.ucx = ucx
3060 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
3061 
    result.write(oprot)
3062 
    oprot.writeMessageEnd()
3063 
    oprot.trans.flush()
3064 
 
581 rajveer 3065 
  def process_forgotPassword(self, seqid, iprot, oprot):
3066 
    args = forgotPassword_args()
3067 
    args.read(iprot)
3068 
    iprot.readMessageEnd()
3069 
    result = forgotPassword_result()
3070 
    try:
884 rajveer 3071 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 3072 
    except UserContextException, ucx:
3073 
      result.ucx = ucx
3074 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
3075 
    result.write(oprot)
3076 
    oprot.writeMessageEnd()
3077 
    oprot.trans.flush()
3078 
 
594 rajveer 3079 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
3080 
    args = getAllAddressesForUser_args()
3081 
    args.read(iprot)
3082 
    iprot.readMessageEnd()
3083 
    result = getAllAddressesForUser_result()
3084 
    try:
3085 
      result.success = self._handler.getAllAddressesForUser(args.userId)
3086 
    except UserContextException, ucx:
3087 
      result.ucx = ucx
3088 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
3089 
    result.write(oprot)
3090 
    oprot.writeMessageEnd()
3091 
    oprot.trans.flush()
3092 
 
1894 vikas 3093 
  def process_getAddressById(self, seqid, iprot, oprot):
3094 
    args = getAddressById_args()
3095 
    args.read(iprot)
3096 
    iprot.readMessageEnd()
3097 
    result = getAddressById_result()
3098 
    try:
3099 
      result.success = self._handler.getAddressById(args.addressId)
3100 
    except UserContextException, ucx:
3101 
      result.ucx = ucx
3102 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
3103 
    result.write(oprot)
3104 
    oprot.writeMessageEnd()
3105 
    oprot.trans.flush()
3106 
 
594 rajveer 3107 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
3108 
    args = getDefaultAddressId_args()
3109 
    args.read(iprot)
3110 
    iprot.readMessageEnd()
3111 
    result = getDefaultAddressId_result()
3112 
    try:
3113 
      result.success = self._handler.getDefaultAddressId(args.userId)
3114 
    except UserContextException, ucx:
3115 
      result.ucx = ucx
3116 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
3117 
    result.write(oprot)
3118 
    oprot.writeMessageEnd()
3119 
    oprot.trans.flush()
3120 
 
785 rajveer 3121 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
3122 
    args = getDefaultPincode_args()
3123 
    args.read(iprot)
3124 
    iprot.readMessageEnd()
3125 
    result = getDefaultPincode_result()
3126 
    try:
3127 
      result.success = self._handler.getDefaultPincode(args.userId)
3128 
    except UserContextException, ucx:
3129 
      result.ucx = ucx
3130 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
3131 
    result.write(oprot)
3132 
    oprot.writeMessageEnd()
3133 
    oprot.trans.flush()
3134 
 
1274 varun.gupt 3135 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
3136 
    args = saveUserCommunication_args()
3137 
    args.read(iprot)
3138 
    iprot.readMessageEnd()
3139 
    result = saveUserCommunication_result()
3140 
    try:
3141 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
3142 
    except UserCommunicationException, ucx:
3143 
      result.ucx = ucx
3144 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
3145 
    result.write(oprot)
3146 
    oprot.writeMessageEnd()
3147 
    oprot.trans.flush()
3148 
 
1590 varun.gupt 3149 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
3150 
    args = getUserCommunicationById_args()
3151 
    args.read(iprot)
3152 
    iprot.readMessageEnd()
3153 
    result = getUserCommunicationById_result()
3154 
    try:
3155 
      result.success = self._handler.getUserCommunicationById(args.id)
3156 
    except UserCommunicationException, ucx:
3157 
      result.ucx = ucx
3158 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
3159 
    result.write(oprot)
3160 
    oprot.writeMessageEnd()
3161 
    oprot.trans.flush()
3162 
 
3163 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
3164 
    args = getUserCommunicationByUser_args()
3165 
    args.read(iprot)
3166 
    iprot.readMessageEnd()
3167 
    result = getUserCommunicationByUser_result()
3168 
    try:
3169 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
3170 
    except UserCommunicationException, ucx:
3171 
      result.ucx = ucx
3172 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
3173 
    result.write(oprot)
3174 
    oprot.writeMessageEnd()
3175 
    oprot.trans.flush()
3176 
 
3177 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
3178 
    args = getAllUserCommunications_args()
3179 
    args.read(iprot)
3180 
    iprot.readMessageEnd()
3181 
    result = getAllUserCommunications_result()
3182 
    try:
3183 
      result.success = self._handler.getAllUserCommunications()
3184 
    except UserCommunicationException, ucx:
3185 
      result.ucx = ucx
3186 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
3187 
    result.write(oprot)
3188 
    oprot.writeMessageEnd()
3189 
    oprot.trans.flush()
3190 
 
1845 vikas 3191 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
3192 
    args = createMasterAffiliate_args()
3193 
    args.read(iprot)
3194 
    iprot.readMessageEnd()
3195 
    result = createMasterAffiliate_result()
3196 
    try:
1859 vikas 3197 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 3198 
    except UserAffiliateException, utx:
1845 vikas 3199 
      result.utx = utx
3200 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
3201 
    result.write(oprot)
3202 
    oprot.writeMessageEnd()
3203 
    oprot.trans.flush()
3204 
 
1899 vikas 3205 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
3206 
    args = getAllMasterAffiliates_args()
3207 
    args.read(iprot)
3208 
    iprot.readMessageEnd()
3209 
    result = getAllMasterAffiliates_result()
3210 
    try:
3211 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 3212 
    except UserAffiliateException, utx:
1899 vikas 3213 
      result.utx = utx
3214 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
3215 
    result.write(oprot)
3216 
    oprot.writeMessageEnd()
3217 
    oprot.trans.flush()
3218 
 
1845 vikas 3219 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
3220 
    args = getMasterAffiliateById_args()
3221 
    args.read(iprot)
3222 
    iprot.readMessageEnd()
3223 
    result = getMasterAffiliateById_result()
3224 
    try:
3225 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 3226 
    except UserAffiliateException, utx:
1845 vikas 3227 
      result.utx = utx
3228 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
3229 
    result.write(oprot)
3230 
    oprot.writeMessageEnd()
3231 
    oprot.trans.flush()
3232 
 
3233 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
3234 
    args = getMasterAffiliateByName_args()
3235 
    args.read(iprot)
3236 
    iprot.readMessageEnd()
3237 
    result = getMasterAffiliateByName_result()
3238 
    try:
3239 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 3240 
    except UserAffiliateException, utx:
1845 vikas 3241 
      result.utx = utx
3242 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
3243 
    result.write(oprot)
3244 
    oprot.writeMessageEnd()
3245 
    oprot.trans.flush()
3246 
 
3247 
  def process_createAffiliate(self, seqid, iprot, oprot):
3248 
    args = createAffiliate_args()
3249 
    args.read(iprot)
3250 
    iprot.readMessageEnd()
3251 
    result = createAffiliate_result()
3252 
    try:
1859 vikas 3253 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 3254 
    except UserAffiliateException, utx:
1845 vikas 3255 
      result.utx = utx
3256 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
3257 
    result.write(oprot)
3258 
    oprot.writeMessageEnd()
3259 
    oprot.trans.flush()
3260 
 
3261 
  def process_getAffiliateById(self, seqid, iprot, oprot):
3262 
    args = getAffiliateById_args()
3263 
    args.read(iprot)
3264 
    iprot.readMessageEnd()
3265 
    result = getAffiliateById_result()
3266 
    try:
3267 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 3268 
    except UserAffiliateException, utx:
1845 vikas 3269 
      result.utx = utx
3270 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
3271 
    result.write(oprot)
3272 
    oprot.writeMessageEnd()
3273 
    oprot.trans.flush()
3274 
 
3275 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
3276 
    args = getAffiliateByName_args()
3277 
    args.read(iprot)
3278 
    iprot.readMessageEnd()
3279 
    result = getAffiliateByName_result()
3280 
    try:
3281 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 3282 
    except UserAffiliateException, utx:
1845 vikas 3283 
      result.utx = utx
3284 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
3285 
    result.write(oprot)
3286 
    oprot.writeMessageEnd()
3287 
    oprot.trans.flush()
3288 
 
3289 
  def process_getTrackerById(self, seqid, iprot, oprot):
3290 
    args = getTrackerById_args()
3291 
    args.read(iprot)
3292 
    iprot.readMessageEnd()
3293 
    result = getTrackerById_result()
3294 
    try:
1996 vikas 3295 
      result.success = self._handler.getTrackerById(args.id)
3296 
    except UserAffiliateException, utx:
1845 vikas 3297 
      result.utx = utx
3298 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
3299 
    result.write(oprot)
3300 
    oprot.writeMessageEnd()
3301 
    oprot.trans.flush()
3302 
 
1996 vikas 3303 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
3304 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 3305 
    args.read(iprot)
3306 
    iprot.readMessageEnd()
1996 vikas 3307 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 3308 
    try:
1996 vikas 3309 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
3310 
    except UserAffiliateException, utx:
1845 vikas 3311 
      result.utx = utx
1996 vikas 3312 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3313 
    result.write(oprot)
3314 
    oprot.writeMessageEnd()
3315 
    oprot.trans.flush()
3316 
 
3317 
  def process_addTrackLog(self, seqid, iprot, oprot):
3318 
    args = addTrackLog_args()
3319 
    args.read(iprot)
3320 
    iprot.readMessageEnd()
3321 
    result = addTrackLog_result()
3322 
    try:
1996 vikas 3323 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
3324 
    except UserAffiliateException, utx:
1845 vikas 3325 
      result.utx = utx
3326 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
3327 
    result.write(oprot)
3328 
    oprot.writeMessageEnd()
3329 
    oprot.trans.flush()
3330 
 
3331 
  def process_getTrackLogById(self, seqid, iprot, oprot):
3332 
    args = getTrackLogById_args()
3333 
    args.read(iprot)
3334 
    iprot.readMessageEnd()
3335 
    result = getTrackLogById_result()
3336 
    try:
3337 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 3338 
    except UserAffiliateException, utx:
1845 vikas 3339 
      result.utx = utx
3340 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
3341 
    result.write(oprot)
3342 
    oprot.writeMessageEnd()
3343 
    oprot.trans.flush()
3344 
 
1996 vikas 3345 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
3346 
    args = getTrackLogsByAffiliate_args()
1845 vikas 3347 
    args.read(iprot)
3348 
    iprot.readMessageEnd()
1996 vikas 3349 
    result = getTrackLogsByAffiliate_result()
1845 vikas 3350 
    try:
1996 vikas 3351 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId)
3352 
    except UserAffiliateException, utx:
1845 vikas 3353 
      result.utx = utx
1996 vikas 3354 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3355 
    result.write(oprot)
3356 
    oprot.writeMessageEnd()
3357 
    oprot.trans.flush()
3358 
 
3359 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
3360 
    args = getTrackLogsByUser_args()
3361 
    args.read(iprot)
3362 
    iprot.readMessageEnd()
3363 
    result = getTrackLogsByUser_result()
3364 
    try:
3365 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 3366 
    except UserAffiliateException, utx:
1845 vikas 3367 
      result.utx = utx
3368 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
3369 
    result.write(oprot)
3370 
    oprot.writeMessageEnd()
3371 
    oprot.trans.flush()
3372 
 
3373 
  def process_getTrackLogs(self, seqid, iprot, oprot):
3374 
    args = getTrackLogs_args()
3375 
    args.read(iprot)
3376 
    iprot.readMessageEnd()
3377 
    result = getTrackLogs_result()
3378 
    try:
1996 vikas 3379 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
3380 
    except UserAffiliateException, utx:
1845 vikas 3381 
      result.utx = utx
3382 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
3383 
    result.write(oprot)
3384 
    oprot.writeMessageEnd()
3385 
    oprot.trans.flush()
3386 
 
559 chandransh 3387 
  def process_createCart(self, seqid, iprot, oprot):
3388 
    args = createCart_args()
94 ashish 3389 
    args.read(iprot)
3390 
    iprot.readMessageEnd()
559 chandransh 3391 
    result = createCart_result()
94 ashish 3392 
    try:
559 chandransh 3393 
      result.success = self._handler.createCart(args.userId)
3394 
    except ShoppingCartException, scx:
3395 
      result.scx = scx
3396 
    oprot.writeMessageBegin("createCart", TMessageType.REPLY, seqid)
94 ashish 3397 
    result.write(oprot)
3398 
    oprot.writeMessageEnd()
3399 
    oprot.trans.flush()
3400 
 
559 chandransh 3401 
  def process_getCurrentCart(self, seqid, iprot, oprot):
3402 
    args = getCurrentCart_args()
94 ashish 3403 
    args.read(iprot)
3404 
    iprot.readMessageEnd()
559 chandransh 3405 
    result = getCurrentCart_result()
94 ashish 3406 
    try:
559 chandransh 3407 
      result.success = self._handler.getCurrentCart(args.userId)
3408 
    except ShoppingCartException, scx:
3409 
      result.scx = scx
3410 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 3411 
    result.write(oprot)
3412 
    oprot.writeMessageEnd()
3413 
    oprot.trans.flush()
3414 
 
559 chandransh 3415 
  def process_getCart(self, seqid, iprot, oprot):
3416 
    args = getCart_args()
94 ashish 3417 
    args.read(iprot)
3418 
    iprot.readMessageEnd()
559 chandransh 3419 
    result = getCart_result()
94 ashish 3420 
    try:
559 chandransh 3421 
      result.success = self._handler.getCart(args.cartId)
3422 
    except ShoppingCartException, scx:
3423 
      result.scx = scx
3424 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 3425 
    result.write(oprot)
3426 
    oprot.writeMessageEnd()
3427 
    oprot.trans.flush()
3428 
 
559 chandransh 3429 
  def process_getCartsForUser(self, seqid, iprot, oprot):
3430 
    args = getCartsForUser_args()
94 ashish 3431 
    args.read(iprot)
3432 
    iprot.readMessageEnd()
559 chandransh 3433 
    result = getCartsForUser_result()
94 ashish 3434 
    try:
559 chandransh 3435 
      result.success = self._handler.getCartsForUser(args.userId, args.status)
3436 
    except ShoppingCartException, scx:
3437 
      result.scx = scx
3438 
    oprot.writeMessageBegin("getCartsForUser", TMessageType.REPLY, seqid)
94 ashish 3439 
    result.write(oprot)
3440 
    oprot.writeMessageEnd()
3441 
    oprot.trans.flush()
3442 
 
559 chandransh 3443 
  def process_getCartsByStatus(self, seqid, iprot, oprot):
3444 
    args = getCartsByStatus_args()
94 ashish 3445 
    args.read(iprot)
3446 
    iprot.readMessageEnd()
559 chandransh 3447 
    result = getCartsByStatus_result()
94 ashish 3448 
    try:
559 chandransh 3449 
      result.success = self._handler.getCartsByStatus(args.status)
3450 
    except ShoppingCartException, scx:
3451 
      result.scx = scx
3452 
    oprot.writeMessageBegin("getCartsByStatus", TMessageType.REPLY, seqid)
94 ashish 3453 
    result.write(oprot)
3454 
    oprot.writeMessageEnd()
3455 
    oprot.trans.flush()
3456 
 
559 chandransh 3457 
  def process_getCartsByTime(self, seqid, iprot, oprot):
3458 
    args = getCartsByTime_args()
94 ashish 3459 
    args.read(iprot)
3460 
    iprot.readMessageEnd()
559 chandransh 3461 
    result = getCartsByTime_result()
94 ashish 3462 
    try:
559 chandransh 3463 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
3464 
    except ShoppingCartException, scx:
3465 
      result.scx = scx
3466 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 3467 
    result.write(oprot)
3468 
    oprot.writeMessageEnd()
3469 
    oprot.trans.flush()
3470 
 
559 chandransh 3471 
  def process_changeCartStatus(self, seqid, iprot, oprot):
3472 
    args = changeCartStatus_args()
130 ashish 3473 
    args.read(iprot)
3474 
    iprot.readMessageEnd()
559 chandransh 3475 
    result = changeCartStatus_result()
130 ashish 3476 
    try:
559 chandransh 3477 
      self._handler.changeCartStatus(args.cartId, args.status)
3478 
    except ShoppingCartException, scx:
3479 
      result.scx = scx
3480 
    oprot.writeMessageBegin("changeCartStatus", TMessageType.REPLY, seqid)
130 ashish 3481 
    result.write(oprot)
3482 
    oprot.writeMessageEnd()
3483 
    oprot.trans.flush()
94 ashish 3484 
 
559 chandransh 3485 
  def process_addItemToCart(self, seqid, iprot, oprot):
3486 
    args = addItemToCart_args()
130 ashish 3487 
    args.read(iprot)
3488 
    iprot.readMessageEnd()
559 chandransh 3489 
    result = addItemToCart_result()
130 ashish 3490 
    try:
2035 rajveer 3491 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity)
559 chandransh 3492 
    except ShoppingCartException, scx:
3493 
      result.scx = scx
3494 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 3495 
    result.write(oprot)
3496 
    oprot.writeMessageEnd()
3497 
    oprot.trans.flush()
3498 
 
559 chandransh 3499 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
3500 
    args = deleteItemFromCart_args()
3501 
    args.read(iprot)
3502 
    iprot.readMessageEnd()
3503 
    result = deleteItemFromCart_result()
3504 
    try:
3505 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
3506 
    except ShoppingCartException, scx:
3507 
      result.scx = scx
3508 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
3509 
    result.write(oprot)
3510 
    oprot.writeMessageEnd()
3511 
    oprot.trans.flush()
130 ashish 3512 
 
559 chandransh 3513 
  def process_changeQuantity(self, seqid, iprot, oprot):
3514 
    args = changeQuantity_args()
3515 
    args.read(iprot)
3516 
    iprot.readMessageEnd()
3517 
    result = changeQuantity_result()
3518 
    try:
3519 
      self._handler.changeQuantity(args.cartId, args.itemId, args.quantity)
3520 
    except ShoppingCartException, scx:
3521 
      result.scx = scx
3522 
    oprot.writeMessageBegin("changeQuantity", TMessageType.REPLY, seqid)
3523 
    result.write(oprot)
3524 
    oprot.writeMessageEnd()
3525 
    oprot.trans.flush()
3526 
 
3527 
  def process_changeItemStatus(self, seqid, iprot, oprot):
3528 
    args = changeItemStatus_args()
3529 
    args.read(iprot)
3530 
    iprot.readMessageEnd()
3531 
    result = changeItemStatus_result()
3532 
    try:
3533 
      self._handler.changeItemStatus(args.cartId, args.itemId, args.status)
3534 
    except ShoppingCartException, scx:
3535 
      result.scx = scx
3536 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
3537 
    result.write(oprot)
3538 
    oprot.writeMessageEnd()
3539 
    oprot.trans.flush()
3540 
 
3541 
  def process_addAddressToCart(self, seqid, iprot, oprot):
3542 
    args = addAddressToCart_args()
3543 
    args.read(iprot)
3544 
    iprot.readMessageEnd()
3545 
    result = addAddressToCart_result()
575 chandransh 3546 
    try:
3547 
      self._handler.addAddressToCart(args.cartId, args.addressId)
3548 
    except ShoppingCartException, scx:
3549 
      result.scx = scx
559 chandransh 3550 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
3551 
    result.write(oprot)
3552 
    oprot.writeMessageEnd()
3553 
    oprot.trans.flush()
3554 
 
1976 varun.gupt 3555 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
3556 
    args = applyCouponToCart_args()
3557 
    args.read(iprot)
3558 
    iprot.readMessageEnd()
3559 
    result = applyCouponToCart_result()
3560 
    try:
3561 
      self._handler.applyCouponToCart(args.cartId, args.couponCode, args.totalPrice, args.discountedPrice)
3562 
    except ShoppingCartException, scx:
3563 
      result.scx = scx
3564 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
3565 
    result.write(oprot)
3566 
    oprot.writeMessageEnd()
3567 
    oprot.trans.flush()
3568 
 
3569 
  def process_removeCoupon(self, seqid, iprot, oprot):
3570 
    args = removeCoupon_args()
3571 
    args.read(iprot)
3572 
    iprot.readMessageEnd()
3573 
    result = removeCoupon_result()
3574 
    try:
3575 
      self._handler.removeCoupon(args.cartId)
3576 
    except ShoppingCartException, scx:
3577 
      result.scx = scx
3578 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
3579 
    result.write(oprot)
3580 
    oprot.writeMessageEnd()
3581 
    oprot.trans.flush()
3582 
 
690 chandransh 3583 
  def process_createOrders(self, seqid, iprot, oprot):
3584 
    args = createOrders_args()
559 chandransh 3585 
    args.read(iprot)
3586 
    iprot.readMessageEnd()
690 chandransh 3587 
    result = createOrders_result()
559 chandransh 3588 
    try:
690 chandransh 3589 
      result.success = self._handler.createOrders(args.cartId)
559 chandransh 3590 
    except ShoppingCartException, scx:
3591 
      result.scx = scx
690 chandransh 3592 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 3593 
    result.write(oprot)
3594 
    oprot.writeMessageEnd()
3595 
    oprot.trans.flush()
3596 
 
3597 
  def process_validateCart(self, seqid, iprot, oprot):
3598 
    args = validateCart_args()
3599 
    args.read(iprot)
3600 
    iprot.readMessageEnd()
3601 
    result = validateCart_result()
575 chandransh 3602 
    try:
3603 
      result.success = self._handler.validateCart(args.cartId)
3604 
    except ShoppingCartException, scex:
3605 
      result.scex = scex
559 chandransh 3606 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
3607 
    result.write(oprot)
3608 
    oprot.writeMessageEnd()
3609 
    oprot.trans.flush()
3610 
 
690 chandransh 3611 
  def process_mergeCart(self, seqid, iprot, oprot):
3612 
    args = mergeCart_args()
575 chandransh 3613 
    args.read(iprot)
3614 
    iprot.readMessageEnd()
690 chandransh 3615 
    result = mergeCart_result()
3616 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
3617 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
3618 
    result.write(oprot)
3619 
    oprot.writeMessageEnd()
3620 
    oprot.trans.flush()
3621 
 
3622 
  def process_checkOut(self, seqid, iprot, oprot):
3623 
    args = checkOut_args()
3624 
    args.read(iprot)
3625 
    iprot.readMessageEnd()
3626 
    result = checkOut_result()
575 chandransh 3627 
    try:
690 chandransh 3628 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 3629 
    except ShoppingCartException, scex:
3630 
      result.scex = scex
690 chandransh 3631 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 3632 
    result.write(oprot)
3633 
    oprot.writeMessageEnd()
3634 
    oprot.trans.flush()
3635 
 
690 chandransh 3636 
  def process_resetCart(self, seqid, iprot, oprot):
3637 
    args = resetCart_args()
559 chandransh 3638 
    args.read(iprot)
3639 
    iprot.readMessageEnd()
690 chandransh 3640 
    result = resetCart_result()
3641 
    try:
3642 
      result.success = self._handler.resetCart(args.cartId, args.items)
3643 
    except ShoppingCartException, scex:
3644 
      result.scex = scex
3645 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 3646 
    result.write(oprot)
3647 
    oprot.writeMessageEnd()
3648 
    oprot.trans.flush()
3649 
 
3650 
  def process_getMyResearch(self, seqid, iprot, oprot):
3651 
    args = getMyResearch_args()
3652 
    args.read(iprot)
3653 
    iprot.readMessageEnd()
3654 
    result = getMyResearch_result()
3655 
    try:
772 rajveer 3656 
      result.success = self._handler.getMyResearch(args.userId)
559 chandransh 3657 
    except WidgetException, scx:
3658 
      result.scx = scx
3659 
    oprot.writeMessageBegin("getMyResearch", TMessageType.REPLY, seqid)
3660 
    result.write(oprot)
3661 
    oprot.writeMessageEnd()
3662 
    oprot.trans.flush()
3663 
 
3664 
  def process_updateMyResearch(self, seqid, iprot, oprot):
3665 
    args = updateMyResearch_args()
3666 
    args.read(iprot)
3667 
    iprot.readMessageEnd()
3668 
    result = updateMyResearch_result()
3669 
    try:
772 rajveer 3670 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
559 chandransh 3671 
    except WidgetException, scx:
3672 
      result.scx = scx
3673 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
3674 
    result.write(oprot)
3675 
    oprot.writeMessageEnd()
3676 
    oprot.trans.flush()
3677 
 
3678 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
3679 
    args = deleteItemFromMyResearch_args()
3680 
    args.read(iprot)
3681 
    iprot.readMessageEnd()
3682 
    result = deleteItemFromMyResearch_result()
3683 
    try:
772 rajveer 3684 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
559 chandransh 3685 
    except WidgetException, scx:
3686 
      result.scx = scx
3687 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
3688 
    result.write(oprot)
3689 
    oprot.writeMessageEnd()
3690 
    oprot.trans.flush()
3691 
 
3692 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
3693 
    args = updateBrowseHistory_args()
3694 
    args.read(iprot)
3695 
    iprot.readMessageEnd()
3696 
    result = updateBrowseHistory_result()
772 rajveer 3697 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
559 chandransh 3698 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
3699 
    result.write(oprot)
3700 
    oprot.writeMessageEnd()
3701 
    oprot.trans.flush()
3702 
 
3703 
  def process_getBrowseHistory(self, seqid, iprot, oprot):
3704 
    args = getBrowseHistory_args()
3705 
    args.read(iprot)
3706 
    iprot.readMessageEnd()
3707 
    result = getBrowseHistory_result()
3708 
    try:
772 rajveer 3709 
      result.success = self._handler.getBrowseHistory(args.userId)
559 chandransh 3710 
    except WidgetException, scx:
3711 
      result.scx = scx
3712 
    oprot.writeMessageBegin("getBrowseHistory", TMessageType.REPLY, seqid)
3713 
    result.write(oprot)
3714 
    oprot.writeMessageEnd()
3715 
    oprot.trans.flush()
3716 
 
772 rajveer 3717 
  def process_mergeBrowseHistory(self, seqid, iprot, oprot):
3718 
    args = mergeBrowseHistory_args()
3719 
    args.read(iprot)
3720 
    iprot.readMessageEnd()
3721 
    result = mergeBrowseHistory_result()
3722 
    self._handler.mergeBrowseHistory(args.fromUserId, args.toUserId)
3723 
    oprot.writeMessageBegin("mergeBrowseHistory", TMessageType.REPLY, seqid)
3724 
    result.write(oprot)
3725 
    oprot.writeMessageEnd()
3726 
    oprot.trans.flush()
559 chandransh 3727 
 
1596 ankur.sing 3728 
  def process_getUserCount(self, seqid, iprot, oprot):
3729 
    args = getUserCount_args()
3730 
    args.read(iprot)
3731 
    iprot.readMessageEnd()
3732 
    result = getUserCount_result()
3733 
    result.success = self._handler.getUserCount(args.userType)
3734 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
3735 
    result.write(oprot)
3736 
    oprot.writeMessageEnd()
3737 
    oprot.trans.flush()
772 rajveer 3738 
 
1673 ankur.sing 3739 
  def process_getAllUsers(self, seqid, iprot, oprot):
3740 
    args = getAllUsers_args()
3741 
    args.read(iprot)
3742 
    iprot.readMessageEnd()
3743 
    result = getAllUsers_result()
1891 ankur.sing 3744 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
1673 ankur.sing 3745 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
3746 
    result.write(oprot)
3747 
    oprot.writeMessageEnd()
3748 
    oprot.trans.flush()
1596 ankur.sing 3749 
 
1673 ankur.sing 3750 
 
94 ashish 3751 
# HELPER FUNCTIONS AND STRUCTURES
3752 
 
765 rajveer 3753 
class closeSession_args:
3754 
 
3755 
  thrift_spec = (
3756 
  )
3757 
 
3758 
  def read(self, iprot):
3759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3761 
      return
3762 
    iprot.readStructBegin()
3763 
    while True:
3764 
      (fname, ftype, fid) = iprot.readFieldBegin()
3765 
      if ftype == TType.STOP:
3766 
        break
3767 
      else:
3768 
        iprot.skip(ftype)
3769 
      iprot.readFieldEnd()
3770 
    iprot.readStructEnd()
3771 
 
3772 
  def write(self, oprot):
3773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3775 
      return
3776 
    oprot.writeStructBegin('closeSession_args')
3777 
    oprot.writeFieldStop()
3778 
    oprot.writeStructEnd()
3779 
 
3780 
  def __repr__(self):
3781 
    L = ['%s=%r' % (key, value)
3782 
      for key, value in self.__dict__.iteritems()]
3783 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3784 
 
3785 
  def __eq__(self, other):
3786 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3787 
 
3788 
  def __ne__(self, other):
3789 
    return not (self == other)
3790 
 
3791 
class closeSession_result:
3792 
 
3793 
  thrift_spec = (
3794 
  )
3795 
 
3796 
  def read(self, iprot):
3797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3799 
      return
3800 
    iprot.readStructBegin()
3801 
    while True:
3802 
      (fname, ftype, fid) = iprot.readFieldBegin()
3803 
      if ftype == TType.STOP:
3804 
        break
3805 
      else:
3806 
        iprot.skip(ftype)
3807 
      iprot.readFieldEnd()
3808 
    iprot.readStructEnd()
3809 
 
3810 
  def write(self, oprot):
3811 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3812 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3813 
      return
3814 
    oprot.writeStructBegin('closeSession_result')
3815 
    oprot.writeFieldStop()
3816 
    oprot.writeStructEnd()
3817 
 
3818 
  def __repr__(self):
3819 
    L = ['%s=%r' % (key, value)
3820 
      for key, value in self.__dict__.iteritems()]
3821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3822 
 
3823 
  def __eq__(self, other):
3824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3825 
 
3826 
  def __ne__(self, other):
3827 
    return not (self == other)
3828 
 
559 chandransh 3829 
class createAnonymousUser_args:
94 ashish 3830 
  """
3831 
  Attributes:
559 chandransh 3832 
   - jsessionId
94 ashish 3833 
  """
3834 
 
3835 
  thrift_spec = (
3836 
    None, # 0
559 chandransh 3837 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 3838 
  )
3839 
 
559 chandransh 3840 
  def __init__(self, jsessionId=None,):
3841 
    self.jsessionId = jsessionId
94 ashish 3842 
 
3843 
  def read(self, iprot):
3844 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3845 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3846 
      return
3847 
    iprot.readStructBegin()
3848 
    while True:
3849 
      (fname, ftype, fid) = iprot.readFieldBegin()
3850 
      if ftype == TType.STOP:
3851 
        break
3852 
      if fid == 1:
559 chandransh 3853 
        if ftype == TType.STRING:
3854 
          self.jsessionId = iprot.readString();
94 ashish 3855 
        else:
3856 
          iprot.skip(ftype)
3857 
      else:
3858 
        iprot.skip(ftype)
3859 
      iprot.readFieldEnd()
3860 
    iprot.readStructEnd()
3861 
 
3862 
  def write(self, oprot):
3863 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3864 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3865 
      return
559 chandransh 3866 
    oprot.writeStructBegin('createAnonymousUser_args')
3867 
    if self.jsessionId != None:
3868 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
3869 
      oprot.writeString(self.jsessionId)
94 ashish 3870 
      oprot.writeFieldEnd()
3871 
    oprot.writeFieldStop()
3872 
    oprot.writeStructEnd()
3873 
 
3874 
  def __repr__(self):
3875 
    L = ['%s=%r' % (key, value)
3876 
      for key, value in self.__dict__.iteritems()]
3877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3878 
 
3879 
  def __eq__(self, other):
3880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3881 
 
3882 
  def __ne__(self, other):
3883 
    return not (self == other)
3884 
 
559 chandransh 3885 
class createAnonymousUser_result:
94 ashish 3886 
  """
3887 
  Attributes:
3888 
   - success
559 chandransh 3889 
   - ucex
94 ashish 3890 
  """
3891 
 
3892 
  thrift_spec = (
559 chandransh 3893 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
3894 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 3895 
  )
3896 
 
559 chandransh 3897 
  def __init__(self, success=None, ucex=None,):
94 ashish 3898 
    self.success = success
559 chandransh 3899 
    self.ucex = ucex
94 ashish 3900 
 
3901 
  def read(self, iprot):
3902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3904 
      return
3905 
    iprot.readStructBegin()
3906 
    while True:
3907 
      (fname, ftype, fid) = iprot.readFieldBegin()
3908 
      if ftype == TType.STOP:
3909 
        break
3910 
      if fid == 0:
3911 
        if ftype == TType.STRUCT:
559 chandransh 3912 
          self.success = User()
94 ashish 3913 
          self.success.read(iprot)
3914 
        else:
3915 
          iprot.skip(ftype)
3916 
      elif fid == 1:
3917 
        if ftype == TType.STRUCT:
559 chandransh 3918 
          self.ucex = UserContextException()
3919 
          self.ucex.read(iprot)
94 ashish 3920 
        else:
3921 
          iprot.skip(ftype)
3922 
      else:
3923 
        iprot.skip(ftype)
3924 
      iprot.readFieldEnd()
3925 
    iprot.readStructEnd()
3926 
 
3927 
  def write(self, oprot):
3928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3930 
      return
559 chandransh 3931 
    oprot.writeStructBegin('createAnonymousUser_result')
94 ashish 3932 
    if self.success != None:
3933 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3934 
      self.success.write(oprot)
3935 
      oprot.writeFieldEnd()
559 chandransh 3936 
    if self.ucex != None:
3937 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
3938 
      self.ucex.write(oprot)
94 ashish 3939 
      oprot.writeFieldEnd()
3940 
    oprot.writeFieldStop()
3941 
    oprot.writeStructEnd()
3942 
 
3943 
  def __repr__(self):
3944 
    L = ['%s=%r' % (key, value)
3945 
      for key, value in self.__dict__.iteritems()]
3946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3947 
 
3948 
  def __eq__(self, other):
3949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3950 
 
3951 
  def __ne__(self, other):
3952 
    return not (self == other)
3953 
 
559 chandransh 3954 
class getUserById_args:
94 ashish 3955 
  """
3956 
  Attributes:
3957 
   - userId
3958 
  """
3959 
 
3960 
  thrift_spec = (
3961 
    None, # 0
3962 
    (1, TType.I64, 'userId', None, None, ), # 1
3963 
  )
3964 
 
559 chandransh 3965 
  def __init__(self, userId=None,):
94 ashish 3966 
    self.userId = userId
3967 
 
3968 
  def read(self, iprot):
3969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3971 
      return
3972 
    iprot.readStructBegin()
3973 
    while True:
3974 
      (fname, ftype, fid) = iprot.readFieldBegin()
3975 
      if ftype == TType.STOP:
3976 
        break
3977 
      if fid == 1:
3978 
        if ftype == TType.I64:
3979 
          self.userId = iprot.readI64();
3980 
        else:
3981 
          iprot.skip(ftype)
3982 
      else:
3983 
        iprot.skip(ftype)
3984 
      iprot.readFieldEnd()
3985 
    iprot.readStructEnd()
3986 
 
3987 
  def write(self, oprot):
3988 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3989 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3990 
      return
559 chandransh 3991 
    oprot.writeStructBegin('getUserById_args')
94 ashish 3992 
    if self.userId != None:
3993 
      oprot.writeFieldBegin('userId', TType.I64, 1)
3994 
      oprot.writeI64(self.userId)
3995 
      oprot.writeFieldEnd()
3996 
    oprot.writeFieldStop()
3997 
    oprot.writeStructEnd()
3998 
 
3999 
  def __repr__(self):
4000 
    L = ['%s=%r' % (key, value)
4001 
      for key, value in self.__dict__.iteritems()]
4002 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4003 
 
4004 
  def __eq__(self, other):
4005 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4006 
 
4007 
  def __ne__(self, other):
4008 
    return not (self == other)
4009 
 
559 chandransh 4010 
class getUserById_result:
94 ashish 4011 
  """
4012 
  Attributes:
4013 
   - success
559 chandransh 4014 
   - ucex
94 ashish 4015 
  """
4016 
 
4017 
  thrift_spec = (
559 chandransh 4018 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4019 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4020 
  )
4021 
 
559 chandransh 4022 
  def __init__(self, success=None, ucex=None,):
94 ashish 4023 
    self.success = success
559 chandransh 4024 
    self.ucex = ucex
94 ashish 4025 
 
4026 
  def read(self, iprot):
4027 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4028 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4029 
      return
4030 
    iprot.readStructBegin()
4031 
    while True:
4032 
      (fname, ftype, fid) = iprot.readFieldBegin()
4033 
      if ftype == TType.STOP:
4034 
        break
4035 
      if fid == 0:
4036 
        if ftype == TType.STRUCT:
559 chandransh 4037 
          self.success = User()
94 ashish 4038 
          self.success.read(iprot)
4039 
        else:
4040 
          iprot.skip(ftype)
4041 
      elif fid == 1:
4042 
        if ftype == TType.STRUCT:
559 chandransh 4043 
          self.ucex = UserContextException()
4044 
          self.ucex.read(iprot)
94 ashish 4045 
        else:
4046 
          iprot.skip(ftype)
4047 
      else:
4048 
        iprot.skip(ftype)
4049 
      iprot.readFieldEnd()
4050 
    iprot.readStructEnd()
4051 
 
4052 
  def write(self, oprot):
4053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4055 
      return
559 chandransh 4056 
    oprot.writeStructBegin('getUserById_result')
94 ashish 4057 
    if self.success != None:
4058 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4059 
      self.success.write(oprot)
4060 
      oprot.writeFieldEnd()
559 chandransh 4061 
    if self.ucex != None:
4062 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4063 
      self.ucex.write(oprot)
94 ashish 4064 
      oprot.writeFieldEnd()
4065 
    oprot.writeFieldStop()
4066 
    oprot.writeStructEnd()
4067 
 
4068 
  def __repr__(self):
4069 
    L = ['%s=%r' % (key, value)
4070 
      for key, value in self.__dict__.iteritems()]
4071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4072 
 
4073 
  def __eq__(self, other):
4074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4075 
 
4076 
  def __ne__(self, other):
4077 
    return not (self == other)
4078 
 
1491 vikas 4079 
class getUserByEmail_args:
4080 
  """
4081 
  Attributes:
4082 
   - email
4083 
  """
4084 
 
4085 
  thrift_spec = (
4086 
    None, # 0
4087 
    (1, TType.STRING, 'email', None, None, ), # 1
4088 
  )
4089 
 
4090 
  def __init__(self, email=None,):
4091 
    self.email = email
4092 
 
4093 
  def read(self, iprot):
4094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4096 
      return
4097 
    iprot.readStructBegin()
4098 
    while True:
4099 
      (fname, ftype, fid) = iprot.readFieldBegin()
4100 
      if ftype == TType.STOP:
4101 
        break
4102 
      if fid == 1:
4103 
        if ftype == TType.STRING:
4104 
          self.email = iprot.readString();
4105 
        else:
4106 
          iprot.skip(ftype)
4107 
      else:
4108 
        iprot.skip(ftype)
4109 
      iprot.readFieldEnd()
4110 
    iprot.readStructEnd()
4111 
 
4112 
  def write(self, oprot):
4113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4115 
      return
4116 
    oprot.writeStructBegin('getUserByEmail_args')
4117 
    if self.email != None:
4118 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4119 
      oprot.writeString(self.email)
4120 
      oprot.writeFieldEnd()
4121 
    oprot.writeFieldStop()
4122 
    oprot.writeStructEnd()
4123 
 
4124 
  def __repr__(self):
4125 
    L = ['%s=%r' % (key, value)
4126 
      for key, value in self.__dict__.iteritems()]
4127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4128 
 
4129 
  def __eq__(self, other):
4130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4131 
 
4132 
  def __ne__(self, other):
4133 
    return not (self == other)
4134 
 
4135 
class getUserByEmail_result:
4136 
  """
4137 
  Attributes:
4138 
   - success
4139 
   - ucex
4140 
  """
4141 
 
4142 
  thrift_spec = (
4143 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4144 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4145 
  )
4146 
 
4147 
  def __init__(self, success=None, ucex=None,):
4148 
    self.success = success
4149 
    self.ucex = ucex
4150 
 
4151 
  def read(self, iprot):
4152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4154 
      return
4155 
    iprot.readStructBegin()
4156 
    while True:
4157 
      (fname, ftype, fid) = iprot.readFieldBegin()
4158 
      if ftype == TType.STOP:
4159 
        break
4160 
      if fid == 0:
4161 
        if ftype == TType.STRUCT:
4162 
          self.success = User()
4163 
          self.success.read(iprot)
4164 
        else:
4165 
          iprot.skip(ftype)
4166 
      elif fid == 1:
4167 
        if ftype == TType.STRUCT:
4168 
          self.ucex = UserContextException()
4169 
          self.ucex.read(iprot)
4170 
        else:
4171 
          iprot.skip(ftype)
4172 
      else:
4173 
        iprot.skip(ftype)
4174 
      iprot.readFieldEnd()
4175 
    iprot.readStructEnd()
4176 
 
4177 
  def write(self, oprot):
4178 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4179 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4180 
      return
4181 
    oprot.writeStructBegin('getUserByEmail_result')
4182 
    if self.success != None:
4183 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4184 
      self.success.write(oprot)
4185 
      oprot.writeFieldEnd()
4186 
    if self.ucex != None:
4187 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4188 
      self.ucex.write(oprot)
4189 
      oprot.writeFieldEnd()
4190 
    oprot.writeFieldStop()
4191 
    oprot.writeStructEnd()
4192 
 
4193 
  def __repr__(self):
4194 
    L = ['%s=%r' % (key, value)
4195 
      for key, value in self.__dict__.iteritems()]
4196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4197 
 
4198 
  def __eq__(self, other):
4199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4200 
 
4201 
  def __ne__(self, other):
4202 
    return not (self == other)
4203 
 
559 chandransh 4204 
class createUser_args:
94 ashish 4205 
  """
4206 
  Attributes:
559 chandransh 4207 
   - user
94 ashish 4208 
  """
4209 
 
4210 
  thrift_spec = (
4211 
    None, # 0
559 chandransh 4212 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4213 
  )
4214 
 
559 chandransh 4215 
  def __init__(self, user=None,):
4216 
    self.user = user
94 ashish 4217 
 
4218 
  def read(self, iprot):
4219 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4220 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4221 
      return
4222 
    iprot.readStructBegin()
4223 
    while True:
4224 
      (fname, ftype, fid) = iprot.readFieldBegin()
4225 
      if ftype == TType.STOP:
4226 
        break
4227 
      if fid == 1:
559 chandransh 4228 
        if ftype == TType.STRUCT:
4229 
          self.user = User()
4230 
          self.user.read(iprot)
94 ashish 4231 
        else:
4232 
          iprot.skip(ftype)
4233 
      else:
4234 
        iprot.skip(ftype)
4235 
      iprot.readFieldEnd()
4236 
    iprot.readStructEnd()
4237 
 
4238 
  def write(self, oprot):
4239 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4240 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4241 
      return
559 chandransh 4242 
    oprot.writeStructBegin('createUser_args')
4243 
    if self.user != None:
4244 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4245 
      self.user.write(oprot)
94 ashish 4246 
      oprot.writeFieldEnd()
4247 
    oprot.writeFieldStop()
4248 
    oprot.writeStructEnd()
4249 
 
4250 
  def __repr__(self):
4251 
    L = ['%s=%r' % (key, value)
4252 
      for key, value in self.__dict__.iteritems()]
4253 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4254 
 
4255 
  def __eq__(self, other):
4256 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4257 
 
4258 
  def __ne__(self, other):
4259 
    return not (self == other)
4260 
 
559 chandransh 4261 
class createUser_result:
94 ashish 4262 
  """
4263 
  Attributes:
4264 
   - success
559 chandransh 4265 
   - ucex
94 ashish 4266 
  """
4267 
 
4268 
  thrift_spec = (
559 chandransh 4269 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4270 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4271 
  )
4272 
 
559 chandransh 4273 
  def __init__(self, success=None, ucex=None,):
94 ashish 4274 
    self.success = success
559 chandransh 4275 
    self.ucex = ucex
94 ashish 4276 
 
4277 
  def read(self, iprot):
4278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4280 
      return
4281 
    iprot.readStructBegin()
4282 
    while True:
4283 
      (fname, ftype, fid) = iprot.readFieldBegin()
4284 
      if ftype == TType.STOP:
4285 
        break
4286 
      if fid == 0:
4287 
        if ftype == TType.STRUCT:
559 chandransh 4288 
          self.success = User()
94 ashish 4289 
          self.success.read(iprot)
4290 
        else:
4291 
          iprot.skip(ftype)
4292 
      elif fid == 1:
4293 
        if ftype == TType.STRUCT:
559 chandransh 4294 
          self.ucex = UserContextException()
4295 
          self.ucex.read(iprot)
94 ashish 4296 
        else:
4297 
          iprot.skip(ftype)
4298 
      else:
4299 
        iprot.skip(ftype)
4300 
      iprot.readFieldEnd()
4301 
    iprot.readStructEnd()
4302 
 
4303 
  def write(self, oprot):
4304 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4305 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4306 
      return
559 chandransh 4307 
    oprot.writeStructBegin('createUser_result')
94 ashish 4308 
    if self.success != None:
4309 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4310 
      self.success.write(oprot)
4311 
      oprot.writeFieldEnd()
559 chandransh 4312 
    if self.ucex != None:
4313 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4314 
      self.ucex.write(oprot)
94 ashish 4315 
      oprot.writeFieldEnd()
4316 
    oprot.writeFieldStop()
4317 
    oprot.writeStructEnd()
4318 
 
4319 
  def __repr__(self):
4320 
    L = ['%s=%r' % (key, value)
4321 
      for key, value in self.__dict__.iteritems()]
4322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4323 
 
4324 
  def __eq__(self, other):
4325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4326 
 
4327 
  def __ne__(self, other):
4328 
    return not (self == other)
4329 
 
559 chandransh 4330 
class updateUser_args:
94 ashish 4331 
  """
4332 
  Attributes:
559 chandransh 4333 
   - user
94 ashish 4334 
  """
4335 
 
4336 
  thrift_spec = (
4337 
    None, # 0
559 chandransh 4338 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4339 
  )
4340 
 
559 chandransh 4341 
  def __init__(self, user=None,):
4342 
    self.user = user
94 ashish 4343 
 
4344 
  def read(self, iprot):
4345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4347 
      return
4348 
    iprot.readStructBegin()
4349 
    while True:
4350 
      (fname, ftype, fid) = iprot.readFieldBegin()
4351 
      if ftype == TType.STOP:
4352 
        break
4353 
      if fid == 1:
559 chandransh 4354 
        if ftype == TType.STRUCT:
4355 
          self.user = User()
4356 
          self.user.read(iprot)
94 ashish 4357 
        else:
4358 
          iprot.skip(ftype)
4359 
      else:
4360 
        iprot.skip(ftype)
4361 
      iprot.readFieldEnd()
4362 
    iprot.readStructEnd()
4363 
 
4364 
  def write(self, oprot):
4365 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4366 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4367 
      return
559 chandransh 4368 
    oprot.writeStructBegin('updateUser_args')
4369 
    if self.user != None:
4370 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4371 
      self.user.write(oprot)
94 ashish 4372 
      oprot.writeFieldEnd()
4373 
    oprot.writeFieldStop()
4374 
    oprot.writeStructEnd()
4375 
 
4376 
  def __repr__(self):
4377 
    L = ['%s=%r' % (key, value)
4378 
      for key, value in self.__dict__.iteritems()]
4379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4380 
 
4381 
  def __eq__(self, other):
4382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4383 
 
4384 
  def __ne__(self, other):
4385 
    return not (self == other)
4386 
 
559 chandransh 4387 
class updateUser_result:
94 ashish 4388 
  """
4389 
  Attributes:
4390 
   - success
559 chandransh 4391 
   - ucex
94 ashish 4392 
  """
4393 
 
4394 
  thrift_spec = (
559 chandransh 4395 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4396 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4397 
  )
4398 
 
559 chandransh 4399 
  def __init__(self, success=None, ucex=None,):
94 ashish 4400 
    self.success = success
559 chandransh 4401 
    self.ucex = ucex
94 ashish 4402 
 
4403 
  def read(self, iprot):
4404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4406 
      return
4407 
    iprot.readStructBegin()
4408 
    while True:
4409 
      (fname, ftype, fid) = iprot.readFieldBegin()
4410 
      if ftype == TType.STOP:
4411 
        break
4412 
      if fid == 0:
4413 
        if ftype == TType.STRUCT:
559 chandransh 4414 
          self.success = User()
94 ashish 4415 
          self.success.read(iprot)
4416 
        else:
4417 
          iprot.skip(ftype)
4418 
      elif fid == 1:
4419 
        if ftype == TType.STRUCT:
559 chandransh 4420 
          self.ucex = UserContextException()
4421 
          self.ucex.read(iprot)
94 ashish 4422 
        else:
4423 
          iprot.skip(ftype)
4424 
      else:
4425 
        iprot.skip(ftype)
4426 
      iprot.readFieldEnd()
4427 
    iprot.readStructEnd()
4428 
 
4429 
  def write(self, oprot):
4430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4432 
      return
559 chandransh 4433 
    oprot.writeStructBegin('updateUser_result')
94 ashish 4434 
    if self.success != None:
4435 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4436 
      self.success.write(oprot)
4437 
      oprot.writeFieldEnd()
559 chandransh 4438 
    if self.ucex != None:
4439 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4440 
      self.ucex.write(oprot)
94 ashish 4441 
      oprot.writeFieldEnd()
4442 
    oprot.writeFieldStop()
4443 
    oprot.writeStructEnd()
4444 
 
4445 
  def __repr__(self):
4446 
    L = ['%s=%r' % (key, value)
4447 
      for key, value in self.__dict__.iteritems()]
4448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4449 
 
4450 
  def __eq__(self, other):
4451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4452 
 
4453 
  def __ne__(self, other):
4454 
    return not (self == other)
4455 
 
559 chandransh 4456 
class deleteUser_args:
94 ashish 4457 
  """
4458 
  Attributes:
4459 
   - userId
4460 
  """
4461 
 
4462 
  thrift_spec = (
4463 
    None, # 0
4464 
    (1, TType.I64, 'userId', None, None, ), # 1
4465 
  )
4466 
 
559 chandransh 4467 
  def __init__(self, userId=None,):
94 ashish 4468 
    self.userId = userId
4469 
 
4470 
  def read(self, iprot):
4471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4473 
      return
4474 
    iprot.readStructBegin()
4475 
    while True:
4476 
      (fname, ftype, fid) = iprot.readFieldBegin()
4477 
      if ftype == TType.STOP:
4478 
        break
4479 
      if fid == 1:
4480 
        if ftype == TType.I64:
4481 
          self.userId = iprot.readI64();
4482 
        else:
4483 
          iprot.skip(ftype)
4484 
      else:
4485 
        iprot.skip(ftype)
4486 
      iprot.readFieldEnd()
4487 
    iprot.readStructEnd()
4488 
 
4489 
  def write(self, oprot):
4490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4492 
      return
559 chandransh 4493 
    oprot.writeStructBegin('deleteUser_args')
94 ashish 4494 
    if self.userId != None:
4495 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4496 
      oprot.writeI64(self.userId)
4497 
      oprot.writeFieldEnd()
4498 
    oprot.writeFieldStop()
4499 
    oprot.writeStructEnd()
4500 
 
4501 
  def __repr__(self):
4502 
    L = ['%s=%r' % (key, value)
4503 
      for key, value in self.__dict__.iteritems()]
4504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4505 
 
4506 
  def __eq__(self, other):
4507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4508 
 
4509 
  def __ne__(self, other):
4510 
    return not (self == other)
4511 
 
559 chandransh 4512 
class deleteUser_result:
94 ashish 4513 
  """
4514 
  Attributes:
4515 
   - success
559 chandransh 4516 
   - ucex
94 ashish 4517 
  """
4518 
 
4519 
  thrift_spec = (
559 chandransh 4520 
    (0, TType.BOOL, 'success', None, None, ), # 0
4521 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4522 
  )
4523 
 
559 chandransh 4524 
  def __init__(self, success=None, ucex=None,):
94 ashish 4525 
    self.success = success
559 chandransh 4526 
    self.ucex = ucex
94 ashish 4527 
 
4528 
  def read(self, iprot):
4529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4531 
      return
4532 
    iprot.readStructBegin()
4533 
    while True:
4534 
      (fname, ftype, fid) = iprot.readFieldBegin()
4535 
      if ftype == TType.STOP:
4536 
        break
4537 
      if fid == 0:
559 chandransh 4538 
        if ftype == TType.BOOL:
4539 
          self.success = iprot.readBool();
94 ashish 4540 
        else:
4541 
          iprot.skip(ftype)
4542 
      elif fid == 1:
4543 
        if ftype == TType.STRUCT:
559 chandransh 4544 
          self.ucex = UserContextException()
4545 
          self.ucex.read(iprot)
94 ashish 4546 
        else:
4547 
          iprot.skip(ftype)
4548 
      else:
4549 
        iprot.skip(ftype)
4550 
      iprot.readFieldEnd()
4551 
    iprot.readStructEnd()
4552 
 
4553 
  def write(self, oprot):
4554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4556 
      return
559 chandransh 4557 
    oprot.writeStructBegin('deleteUser_result')
94 ashish 4558 
    if self.success != None:
559 chandransh 4559 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4560 
      oprot.writeBool(self.success)
94 ashish 4561 
      oprot.writeFieldEnd()
559 chandransh 4562 
    if self.ucex != None:
4563 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4564 
      self.ucex.write(oprot)
94 ashish 4565 
      oprot.writeFieldEnd()
4566 
    oprot.writeFieldStop()
4567 
    oprot.writeStructEnd()
4568 
 
4569 
  def __repr__(self):
4570 
    L = ['%s=%r' % (key, value)
4571 
      for key, value in self.__dict__.iteritems()]
4572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4573 
 
4574 
  def __eq__(self, other):
4575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4576 
 
4577 
  def __ne__(self, other):
4578 
    return not (self == other)
4579 
 
559 chandransh 4580 
class getUserState_args:
94 ashish 4581 
  """
4582 
  Attributes:
4583 
   - userId
4584 
  """
4585 
 
4586 
  thrift_spec = (
4587 
    None, # 0
4588 
    (1, TType.I64, 'userId', None, None, ), # 1
4589 
  )
4590 
 
559 chandransh 4591 
  def __init__(self, userId=None,):
94 ashish 4592 
    self.userId = userId
4593 
 
4594 
  def read(self, iprot):
4595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4597 
      return
4598 
    iprot.readStructBegin()
4599 
    while True:
4600 
      (fname, ftype, fid) = iprot.readFieldBegin()
4601 
      if ftype == TType.STOP:
4602 
        break
4603 
      if fid == 1:
4604 
        if ftype == TType.I64:
4605 
          self.userId = iprot.readI64();
4606 
        else:
4607 
          iprot.skip(ftype)
4608 
      else:
4609 
        iprot.skip(ftype)
4610 
      iprot.readFieldEnd()
4611 
    iprot.readStructEnd()
4612 
 
4613 
  def write(self, oprot):
4614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4616 
      return
559 chandransh 4617 
    oprot.writeStructBegin('getUserState_args')
94 ashish 4618 
    if self.userId != None:
4619 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4620 
      oprot.writeI64(self.userId)
4621 
      oprot.writeFieldEnd()
4622 
    oprot.writeFieldStop()
4623 
    oprot.writeStructEnd()
4624 
 
4625 
  def __repr__(self):
4626 
    L = ['%s=%r' % (key, value)
4627 
      for key, value in self.__dict__.iteritems()]
4628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4629 
 
4630 
  def __eq__(self, other):
4631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4632 
 
4633 
  def __ne__(self, other):
4634 
    return not (self == other)
4635 
 
559 chandransh 4636 
class getUserState_result:
94 ashish 4637 
  """
4638 
  Attributes:
4639 
   - success
559 chandransh 4640 
   - ucex
94 ashish 4641 
  """
4642 
 
4643 
  thrift_spec = (
559 chandransh 4644 
    (0, TType.STRUCT, 'success', (UserState, UserState.thrift_spec), None, ), # 0
4645 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4646 
  )
4647 
 
559 chandransh 4648 
  def __init__(self, success=None, ucex=None,):
94 ashish 4649 
    self.success = success
559 chandransh 4650 
    self.ucex = ucex
94 ashish 4651 
 
4652 
  def read(self, iprot):
4653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4655 
      return
4656 
    iprot.readStructBegin()
4657 
    while True:
4658 
      (fname, ftype, fid) = iprot.readFieldBegin()
4659 
      if ftype == TType.STOP:
4660 
        break
4661 
      if fid == 0:
4662 
        if ftype == TType.STRUCT:
559 chandransh 4663 
          self.success = UserState()
94 ashish 4664 
          self.success.read(iprot)
4665 
        else:
4666 
          iprot.skip(ftype)
4667 
      elif fid == 1:
4668 
        if ftype == TType.STRUCT:
559 chandransh 4669 
          self.ucex = UserContextException()
4670 
          self.ucex.read(iprot)
94 ashish 4671 
        else:
4672 
          iprot.skip(ftype)
4673 
      else:
4674 
        iprot.skip(ftype)
4675 
      iprot.readFieldEnd()
4676 
    iprot.readStructEnd()
4677 
 
4678 
  def write(self, oprot):
4679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4681 
      return
559 chandransh 4682 
    oprot.writeStructBegin('getUserState_result')
94 ashish 4683 
    if self.success != None:
4684 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4685 
      self.success.write(oprot)
4686 
      oprot.writeFieldEnd()
559 chandransh 4687 
    if self.ucex != None:
4688 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4689 
      self.ucex.write(oprot)
94 ashish 4690 
      oprot.writeFieldEnd()
4691 
    oprot.writeFieldStop()
4692 
    oprot.writeStructEnd()
4693 
 
4694 
  def __repr__(self):
4695 
    L = ['%s=%r' % (key, value)
4696 
      for key, value in self.__dict__.iteritems()]
4697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4698 
 
4699 
  def __eq__(self, other):
4700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4701 
 
4702 
  def __ne__(self, other):
4703 
    return not (self == other)
4704 
 
559 chandransh 4705 
class authenticateUser_args:
94 ashish 4706 
  """
4707 
  Attributes:
4708 
   - email
4709 
   - password
4710 
  """
4711 
 
4712 
  thrift_spec = (
4713 
    None, # 0
4714 
    (1, TType.STRING, 'email', None, None, ), # 1
4715 
    (2, TType.STRING, 'password', None, None, ), # 2
4716 
  )
4717 
 
4718 
  def __init__(self, email=None, password=None,):
4719 
    self.email = email
4720 
    self.password = password
4721 
 
4722 
  def read(self, iprot):
4723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4725 
      return
4726 
    iprot.readStructBegin()
4727 
    while True:
4728 
      (fname, ftype, fid) = iprot.readFieldBegin()
4729 
      if ftype == TType.STOP:
4730 
        break
4731 
      if fid == 1:
4732 
        if ftype == TType.STRING:
4733 
          self.email = iprot.readString();
4734 
        else:
4735 
          iprot.skip(ftype)
4736 
      elif fid == 2:
4737 
        if ftype == TType.STRING:
4738 
          self.password = iprot.readString();
4739 
        else:
4740 
          iprot.skip(ftype)
4741 
      else:
4742 
        iprot.skip(ftype)
4743 
      iprot.readFieldEnd()
4744 
    iprot.readStructEnd()
4745 
 
4746 
  def write(self, oprot):
4747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4749 
      return
559 chandransh 4750 
    oprot.writeStructBegin('authenticateUser_args')
94 ashish 4751 
    if self.email != None:
4752 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4753 
      oprot.writeString(self.email)
4754 
      oprot.writeFieldEnd()
4755 
    if self.password != None:
4756 
      oprot.writeFieldBegin('password', TType.STRING, 2)
4757 
      oprot.writeString(self.password)
4758 
      oprot.writeFieldEnd()
4759 
    oprot.writeFieldStop()
4760 
    oprot.writeStructEnd()
4761 
 
4762 
  def __repr__(self):
4763 
    L = ['%s=%r' % (key, value)
4764 
      for key, value in self.__dict__.iteritems()]
4765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4766 
 
4767 
  def __eq__(self, other):
4768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4769 
 
4770 
  def __ne__(self, other):
4771 
    return not (self == other)
4772 
 
559 chandransh 4773 
class authenticateUser_result:
94 ashish 4774 
  """
4775 
  Attributes:
4776 
   - success
559 chandransh 4777 
   - auex
94 ashish 4778 
  """
4779 
 
4780 
  thrift_spec = (
559 chandransh 4781 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4782 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 4783 
  )
4784 
 
559 chandransh 4785 
  def __init__(self, success=None, auex=None,):
94 ashish 4786 
    self.success = success
559 chandransh 4787 
    self.auex = auex
94 ashish 4788 
 
4789 
  def read(self, iprot):
4790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4792 
      return
4793 
    iprot.readStructBegin()
4794 
    while True:
4795 
      (fname, ftype, fid) = iprot.readFieldBegin()
4796 
      if ftype == TType.STOP:
4797 
        break
4798 
      if fid == 0:
4799 
        if ftype == TType.STRUCT:
559 chandransh 4800 
          self.success = User()
94 ashish 4801 
          self.success.read(iprot)
4802 
        else:
4803 
          iprot.skip(ftype)
4804 
      elif fid == 1:
4805 
        if ftype == TType.STRUCT:
559 chandransh 4806 
          self.auex = AuthenticationException()
4807 
          self.auex.read(iprot)
94 ashish 4808 
        else:
4809 
          iprot.skip(ftype)
4810 
      else:
4811 
        iprot.skip(ftype)
4812 
      iprot.readFieldEnd()
4813 
    iprot.readStructEnd()
4814 
 
4815 
  def write(self, oprot):
4816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4818 
      return
559 chandransh 4819 
    oprot.writeStructBegin('authenticateUser_result')
94 ashish 4820 
    if self.success != None:
4821 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4822 
      self.success.write(oprot)
4823 
      oprot.writeFieldEnd()
559 chandransh 4824 
    if self.auex != None:
4825 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
4826 
      self.auex.write(oprot)
94 ashish 4827 
      oprot.writeFieldEnd()
4828 
    oprot.writeFieldStop()
4829 
    oprot.writeStructEnd()
4830 
 
4831 
  def __repr__(self):
4832 
    L = ['%s=%r' % (key, value)
4833 
      for key, value in self.__dict__.iteritems()]
4834 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4835 
 
4836 
  def __eq__(self, other):
4837 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4838 
 
4839 
  def __ne__(self, other):
4840 
    return not (self == other)
4841 
 
559 chandransh 4842 
class userExists_args:
122 ashish 4843 
  """
4844 
  Attributes:
559 chandransh 4845 
   - email
122 ashish 4846 
  """
4847 
 
4848 
  thrift_spec = (
4849 
    None, # 0
559 chandransh 4850 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 4851 
  )
4852 
 
559 chandransh 4853 
  def __init__(self, email=None,):
4854 
    self.email = email
122 ashish 4855 
 
4856 
  def read(self, iprot):
4857 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4858 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4859 
      return
4860 
    iprot.readStructBegin()
4861 
    while True:
4862 
      (fname, ftype, fid) = iprot.readFieldBegin()
4863 
      if ftype == TType.STOP:
4864 
        break
4865 
      if fid == 1:
4866 
        if ftype == TType.STRING:
559 chandransh 4867 
          self.email = iprot.readString();
122 ashish 4868 
        else:
4869 
          iprot.skip(ftype)
559 chandransh 4870 
      else:
4871 
        iprot.skip(ftype)
4872 
      iprot.readFieldEnd()
4873 
    iprot.readStructEnd()
4874 
 
4875 
  def write(self, oprot):
4876 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4877 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4878 
      return
4879 
    oprot.writeStructBegin('userExists_args')
4880 
    if self.email != None:
4881 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4882 
      oprot.writeString(self.email)
4883 
      oprot.writeFieldEnd()
4884 
    oprot.writeFieldStop()
4885 
    oprot.writeStructEnd()
4886 
 
4887 
  def __repr__(self):
4888 
    L = ['%s=%r' % (key, value)
4889 
      for key, value in self.__dict__.iteritems()]
4890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4891 
 
4892 
  def __eq__(self, other):
4893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4894 
 
4895 
  def __ne__(self, other):
4896 
    return not (self == other)
4897 
 
4898 
class userExists_result:
4899 
  """
4900 
  Attributes:
4901 
   - success
4902 
   - ucx
4903 
  """
4904 
 
4905 
  thrift_spec = (
4906 
    (0, TType.BOOL, 'success', None, None, ), # 0
4907 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4908 
  )
4909 
 
4910 
  def __init__(self, success=None, ucx=None,):
4911 
    self.success = success
4912 
    self.ucx = ucx
4913 
 
4914 
  def read(self, iprot):
4915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4917 
      return
4918 
    iprot.readStructBegin()
4919 
    while True:
4920 
      (fname, ftype, fid) = iprot.readFieldBegin()
4921 
      if ftype == TType.STOP:
4922 
        break
4923 
      if fid == 0:
4924 
        if ftype == TType.BOOL:
4925 
          self.success = iprot.readBool();
4926 
        else:
4927 
          iprot.skip(ftype)
4928 
      elif fid == 1:
4929 
        if ftype == TType.STRUCT:
4930 
          self.ucx = UserContextException()
4931 
          self.ucx.read(iprot)
4932 
        else:
4933 
          iprot.skip(ftype)
4934 
      else:
4935 
        iprot.skip(ftype)
4936 
      iprot.readFieldEnd()
4937 
    iprot.readStructEnd()
4938 
 
4939 
  def write(self, oprot):
4940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4942 
      return
4943 
    oprot.writeStructBegin('userExists_result')
4944 
    if self.success != None:
4945 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4946 
      oprot.writeBool(self.success)
4947 
      oprot.writeFieldEnd()
4948 
    if self.ucx != None:
4949 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4950 
      self.ucx.write(oprot)
4951 
      oprot.writeFieldEnd()
4952 
    oprot.writeFieldStop()
4953 
    oprot.writeStructEnd()
4954 
 
4955 
  def __repr__(self):
4956 
    L = ['%s=%r' % (key, value)
4957 
      for key, value in self.__dict__.iteritems()]
4958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4959 
 
4960 
  def __eq__(self, other):
4961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4962 
 
4963 
  def __ne__(self, other):
4964 
    return not (self == other)
4965 
 
4966 
class addAddressForUser_args:
4967 
  """
4968 
  Attributes:
4969 
   - userId
4970 
   - address
4971 
   - setDefault
4972 
  """
4973 
 
4974 
  thrift_spec = (
4975 
    None, # 0
4976 
    (1, TType.I64, 'userId', None, None, ), # 1
4977 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 4978 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 4979 
  )
4980 
 
567 rajveer 4981 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 4982 
    self.userId = userId
4983 
    self.address = address
4984 
    self.setDefault = setDefault
4985 
 
4986 
  def read(self, iprot):
4987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4989 
      return
4990 
    iprot.readStructBegin()
4991 
    while True:
4992 
      (fname, ftype, fid) = iprot.readFieldBegin()
4993 
      if ftype == TType.STOP:
4994 
        break
4995 
      if fid == 1:
4996 
        if ftype == TType.I64:
4997 
          self.userId = iprot.readI64();
4998 
        else:
4999 
          iprot.skip(ftype)
122 ashish 5000 
      elif fid == 2:
559 chandransh 5001 
        if ftype == TType.STRUCT:
5002 
          self.address = Address()
5003 
          self.address.read(iprot)
122 ashish 5004 
        else:
5005 
          iprot.skip(ftype)
5006 
      elif fid == 3:
5007 
        if ftype == TType.BOOL:
559 chandransh 5008 
          self.setDefault = iprot.readBool();
122 ashish 5009 
        else:
5010 
          iprot.skip(ftype)
5011 
      else:
5012 
        iprot.skip(ftype)
5013 
      iprot.readFieldEnd()
5014 
    iprot.readStructEnd()
5015 
 
5016 
  def write(self, oprot):
5017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5019 
      return
559 chandransh 5020 
    oprot.writeStructBegin('addAddressForUser_args')
5021 
    if self.userId != None:
5022 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5023 
      oprot.writeI64(self.userId)
122 ashish 5024 
      oprot.writeFieldEnd()
559 chandransh 5025 
    if self.address != None:
5026 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
5027 
      self.address.write(oprot)
122 ashish 5028 
      oprot.writeFieldEnd()
559 chandransh 5029 
    if self.setDefault != None:
567 rajveer 5030 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 5031 
      oprot.writeBool(self.setDefault)
5032 
      oprot.writeFieldEnd()
122 ashish 5033 
    oprot.writeFieldStop()
5034 
    oprot.writeStructEnd()
5035 
 
5036 
  def __repr__(self):
5037 
    L = ['%s=%r' % (key, value)
5038 
      for key, value in self.__dict__.iteritems()]
5039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5040 
 
5041 
  def __eq__(self, other):
5042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5043 
 
5044 
  def __ne__(self, other):
5045 
    return not (self == other)
5046 
 
559 chandransh 5047 
class addAddressForUser_result:
122 ashish 5048 
  """
5049 
  Attributes:
5050 
   - success
559 chandransh 5051 
   - ucx
122 ashish 5052 
  """
5053 
 
5054 
  thrift_spec = (
567 rajveer 5055 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 5056 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 5057 
  )
5058 
 
559 chandransh 5059 
  def __init__(self, success=None, ucx=None,):
122 ashish 5060 
    self.success = success
559 chandransh 5061 
    self.ucx = ucx
122 ashish 5062 
 
5063 
  def read(self, iprot):
5064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5066 
      return
5067 
    iprot.readStructBegin()
5068 
    while True:
5069 
      (fname, ftype, fid) = iprot.readFieldBegin()
5070 
      if ftype == TType.STOP:
5071 
        break
5072 
      if fid == 0:
567 rajveer 5073 
        if ftype == TType.I64:
5074 
          self.success = iprot.readI64();
122 ashish 5075 
        else:
5076 
          iprot.skip(ftype)
5077 
      elif fid == 1:
5078 
        if ftype == TType.STRUCT:
559 chandransh 5079 
          self.ucx = UserContextException()
5080 
          self.ucx.read(iprot)
122 ashish 5081 
        else:
5082 
          iprot.skip(ftype)
5083 
      else:
5084 
        iprot.skip(ftype)
5085 
      iprot.readFieldEnd()
5086 
    iprot.readStructEnd()
5087 
 
5088 
  def write(self, oprot):
5089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5091 
      return
559 chandransh 5092 
    oprot.writeStructBegin('addAddressForUser_result')
122 ashish 5093 
    if self.success != None:
567 rajveer 5094 
      oprot.writeFieldBegin('success', TType.I64, 0)
5095 
      oprot.writeI64(self.success)
122 ashish 5096 
      oprot.writeFieldEnd()
559 chandransh 5097 
    if self.ucx != None:
5098 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5099 
      self.ucx.write(oprot)
122 ashish 5100 
      oprot.writeFieldEnd()
5101 
    oprot.writeFieldStop()
5102 
    oprot.writeStructEnd()
5103 
 
5104 
  def __repr__(self):
5105 
    L = ['%s=%r' % (key, value)
5106 
      for key, value in self.__dict__.iteritems()]
5107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5108 
 
5109 
  def __eq__(self, other):
5110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5111 
 
5112 
  def __ne__(self, other):
5113 
    return not (self == other)
5114 
 
559 chandransh 5115 
class removeAddressForUser_args:
94 ashish 5116 
  """
5117 
  Attributes:
559 chandransh 5118 
   - userid
5119 
   - addressId
94 ashish 5120 
  """
5121 
 
5122 
  thrift_spec = (
5123 
    None, # 0
559 chandransh 5124 
    (1, TType.I64, 'userid', None, None, ), # 1
5125 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 5126 
  )
5127 
 
559 chandransh 5128 
  def __init__(self, userid=None, addressId=None,):
5129 
    self.userid = userid
5130 
    self.addressId = addressId
94 ashish 5131 
 
5132 
  def read(self, iprot):
5133 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5134 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5135 
      return
5136 
    iprot.readStructBegin()
5137 
    while True:
5138 
      (fname, ftype, fid) = iprot.readFieldBegin()
5139 
      if ftype == TType.STOP:
5140 
        break
5141 
      if fid == 1:
559 chandransh 5142 
        if ftype == TType.I64:
5143 
          self.userid = iprot.readI64();
94 ashish 5144 
        else:
5145 
          iprot.skip(ftype)
559 chandransh 5146 
      elif fid == 2:
5147 
        if ftype == TType.I64:
5148 
          self.addressId = iprot.readI64();
5149 
        else:
5150 
          iprot.skip(ftype)
94 ashish 5151 
      else:
5152 
        iprot.skip(ftype)
5153 
      iprot.readFieldEnd()
5154 
    iprot.readStructEnd()
5155 
 
5156 
  def write(self, oprot):
5157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5159 
      return
559 chandransh 5160 
    oprot.writeStructBegin('removeAddressForUser_args')
5161 
    if self.userid != None:
5162 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5163 
      oprot.writeI64(self.userid)
94 ashish 5164 
      oprot.writeFieldEnd()
559 chandransh 5165 
    if self.addressId != None:
5166 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5167 
      oprot.writeI64(self.addressId)
5168 
      oprot.writeFieldEnd()
94 ashish 5169 
    oprot.writeFieldStop()
5170 
    oprot.writeStructEnd()
5171 
 
5172 
  def __repr__(self):
5173 
    L = ['%s=%r' % (key, value)
5174 
      for key, value in self.__dict__.iteritems()]
5175 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5176 
 
5177 
  def __eq__(self, other):
5178 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5179 
 
5180 
  def __ne__(self, other):
5181 
    return not (self == other)
5182 
 
559 chandransh 5183 
class removeAddressForUser_result:
94 ashish 5184 
  """
5185 
  Attributes:
5186 
   - success
5187 
   - ucx
5188 
  """
5189 
 
5190 
  thrift_spec = (
5191 
    (0, TType.BOOL, 'success', None, None, ), # 0
5192 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5193 
  )
5194 
 
5195 
  def __init__(self, success=None, ucx=None,):
5196 
    self.success = success
5197 
    self.ucx = ucx
5198 
 
5199 
  def read(self, iprot):
5200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5202 
      return
5203 
    iprot.readStructBegin()
5204 
    while True:
5205 
      (fname, ftype, fid) = iprot.readFieldBegin()
5206 
      if ftype == TType.STOP:
5207 
        break
5208 
      if fid == 0:
5209 
        if ftype == TType.BOOL:
5210 
          self.success = iprot.readBool();
5211 
        else:
5212 
          iprot.skip(ftype)
5213 
      elif fid == 1:
5214 
        if ftype == TType.STRUCT:
5215 
          self.ucx = UserContextException()
5216 
          self.ucx.read(iprot)
5217 
        else:
5218 
          iprot.skip(ftype)
5219 
      else:
5220 
        iprot.skip(ftype)
5221 
      iprot.readFieldEnd()
5222 
    iprot.readStructEnd()
5223 
 
5224 
  def write(self, oprot):
5225 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5226 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5227 
      return
559 chandransh 5228 
    oprot.writeStructBegin('removeAddressForUser_result')
94 ashish 5229 
    if self.success != None:
5230 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5231 
      oprot.writeBool(self.success)
5232 
      oprot.writeFieldEnd()
5233 
    if self.ucx != None:
5234 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5235 
      self.ucx.write(oprot)
5236 
      oprot.writeFieldEnd()
5237 
    oprot.writeFieldStop()
5238 
    oprot.writeStructEnd()
5239 
 
5240 
  def __repr__(self):
5241 
    L = ['%s=%r' % (key, value)
5242 
      for key, value in self.__dict__.iteritems()]
5243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5244 
 
5245 
  def __eq__(self, other):
5246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5247 
 
5248 
  def __ne__(self, other):
5249 
    return not (self == other)
5250 
 
559 chandransh 5251 
class setUserAsLoggedIn_args:
94 ashish 5252 
  """
5253 
  Attributes:
559 chandransh 5254 
   - userId
94 ashish 5255 
   - timestamp
5256 
  """
5257 
 
5258 
  thrift_spec = (
5259 
    None, # 0
559 chandransh 5260 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 5261 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5262 
  )
5263 
 
559 chandransh 5264 
  def __init__(self, userId=None, timestamp=None,):
5265 
    self.userId = userId
94 ashish 5266 
    self.timestamp = timestamp
5267 
 
5268 
  def read(self, iprot):
5269 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5270 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5271 
      return
5272 
    iprot.readStructBegin()
5273 
    while True:
5274 
      (fname, ftype, fid) = iprot.readFieldBegin()
5275 
      if ftype == TType.STOP:
5276 
        break
5277 
      if fid == 1:
559 chandransh 5278 
        if ftype == TType.I64:
5279 
          self.userId = iprot.readI64();
94 ashish 5280 
        else:
5281 
          iprot.skip(ftype)
5282 
      elif fid == 2:
5283 
        if ftype == TType.I64:
5284 
          self.timestamp = iprot.readI64();
5285 
        else:
5286 
          iprot.skip(ftype)
5287 
      else:
5288 
        iprot.skip(ftype)
5289 
      iprot.readFieldEnd()
5290 
    iprot.readStructEnd()
5291 
 
5292 
  def write(self, oprot):
5293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5295 
      return
559 chandransh 5296 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
5297 
    if self.userId != None:
5298 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5299 
      oprot.writeI64(self.userId)
94 ashish 5300 
      oprot.writeFieldEnd()
5301 
    if self.timestamp != None:
5302 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5303 
      oprot.writeI64(self.timestamp)
5304 
      oprot.writeFieldEnd()
5305 
    oprot.writeFieldStop()
5306 
    oprot.writeStructEnd()
5307 
 
5308 
  def __repr__(self):
5309 
    L = ['%s=%r' % (key, value)
5310 
      for key, value in self.__dict__.iteritems()]
5311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5312 
 
5313 
  def __eq__(self, other):
5314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5315 
 
5316 
  def __ne__(self, other):
5317 
    return not (self == other)
5318 
 
559 chandransh 5319 
class setUserAsLoggedIn_result:
94 ashish 5320 
  """
5321 
  Attributes:
5322 
   - success
5323 
   - ucx
5324 
  """
5325 
 
5326 
  thrift_spec = (
5327 
    (0, TType.BOOL, 'success', None, None, ), # 0
5328 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5329 
  )
5330 
 
5331 
  def __init__(self, success=None, ucx=None,):
5332 
    self.success = success
5333 
    self.ucx = ucx
5334 
 
5335 
  def read(self, iprot):
5336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5338 
      return
5339 
    iprot.readStructBegin()
5340 
    while True:
5341 
      (fname, ftype, fid) = iprot.readFieldBegin()
5342 
      if ftype == TType.STOP:
5343 
        break
5344 
      if fid == 0:
5345 
        if ftype == TType.BOOL:
5346 
          self.success = iprot.readBool();
5347 
        else:
5348 
          iprot.skip(ftype)
5349 
      elif fid == 1:
5350 
        if ftype == TType.STRUCT:
5351 
          self.ucx = UserContextException()
5352 
          self.ucx.read(iprot)
5353 
        else:
5354 
          iprot.skip(ftype)
5355 
      else:
5356 
        iprot.skip(ftype)
5357 
      iprot.readFieldEnd()
5358 
    iprot.readStructEnd()
5359 
 
5360 
  def write(self, oprot):
5361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5363 
      return
559 chandransh 5364 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
94 ashish 5365 
    if self.success != None:
5366 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5367 
      oprot.writeBool(self.success)
5368 
      oprot.writeFieldEnd()
5369 
    if self.ucx != None:
5370 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5371 
      self.ucx.write(oprot)
5372 
      oprot.writeFieldEnd()
5373 
    oprot.writeFieldStop()
5374 
    oprot.writeStructEnd()
5375 
 
5376 
  def __repr__(self):
5377 
    L = ['%s=%r' % (key, value)
5378 
      for key, value in self.__dict__.iteritems()]
5379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5380 
 
5381 
  def __eq__(self, other):
5382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5383 
 
5384 
  def __ne__(self, other):
5385 
    return not (self == other)
5386 
 
559 chandransh 5387 
class setUserAsLoggedOut_args:
94 ashish 5388 
  """
5389 
  Attributes:
5390 
   - userid
5391 
   - timestamp
5392 
  """
5393 
 
5394 
  thrift_spec = (
5395 
    None, # 0
559 chandransh 5396 
    (1, TType.I64, 'userid', None, None, ), # 1
5397 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 5398 
  )
5399 
 
559 chandransh 5400 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 5401 
    self.userid = userid
5402 
    self.timestamp = timestamp
5403 
 
5404 
  def read(self, iprot):
5405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5407 
      return
5408 
    iprot.readStructBegin()
5409 
    while True:
5410 
      (fname, ftype, fid) = iprot.readFieldBegin()
5411 
      if ftype == TType.STOP:
5412 
        break
5413 
      if fid == 1:
5414 
        if ftype == TType.I64:
5415 
          self.userid = iprot.readI64();
5416 
        else:
5417 
          iprot.skip(ftype)
559 chandransh 5418 
      elif fid == 2:
94 ashish 5419 
        if ftype == TType.I64:
5420 
          self.timestamp = iprot.readI64();
5421 
        else:
5422 
          iprot.skip(ftype)
5423 
      else:
5424 
        iprot.skip(ftype)
5425 
      iprot.readFieldEnd()
5426 
    iprot.readStructEnd()
5427 
 
5428 
  def write(self, oprot):
5429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5431 
      return
559 chandransh 5432 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
94 ashish 5433 
    if self.userid != None:
559 chandransh 5434 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 5435 
      oprot.writeI64(self.userid)
5436 
      oprot.writeFieldEnd()
5437 
    if self.timestamp != None:
559 chandransh 5438 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 5439 
      oprot.writeI64(self.timestamp)
5440 
      oprot.writeFieldEnd()
5441 
    oprot.writeFieldStop()
5442 
    oprot.writeStructEnd()
5443 
 
5444 
  def __repr__(self):
5445 
    L = ['%s=%r' % (key, value)
5446 
      for key, value in self.__dict__.iteritems()]
5447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5448 
 
5449 
  def __eq__(self, other):
5450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5451 
 
5452 
  def __ne__(self, other):
5453 
    return not (self == other)
5454 
 
559 chandransh 5455 
class setUserAsLoggedOut_result:
94 ashish 5456 
  """
5457 
  Attributes:
5458 
   - success
5459 
   - ucx
5460 
  """
5461 
 
5462 
  thrift_spec = (
5463 
    (0, TType.BOOL, 'success', None, None, ), # 0
5464 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5465 
  )
5466 
 
5467 
  def __init__(self, success=None, ucx=None,):
5468 
    self.success = success
5469 
    self.ucx = ucx
5470 
 
5471 
  def read(self, iprot):
5472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5474 
      return
5475 
    iprot.readStructBegin()
5476 
    while True:
5477 
      (fname, ftype, fid) = iprot.readFieldBegin()
5478 
      if ftype == TType.STOP:
5479 
        break
5480 
      if fid == 0:
5481 
        if ftype == TType.BOOL:
5482 
          self.success = iprot.readBool();
5483 
        else:
5484 
          iprot.skip(ftype)
5485 
      elif fid == 1:
5486 
        if ftype == TType.STRUCT:
5487 
          self.ucx = UserContextException()
5488 
          self.ucx.read(iprot)
5489 
        else:
5490 
          iprot.skip(ftype)
5491 
      else:
5492 
        iprot.skip(ftype)
5493 
      iprot.readFieldEnd()
5494 
    iprot.readStructEnd()
5495 
 
5496 
  def write(self, oprot):
5497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5499 
      return
559 chandransh 5500 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
94 ashish 5501 
    if self.success != None:
5502 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5503 
      oprot.writeBool(self.success)
5504 
      oprot.writeFieldEnd()
5505 
    if self.ucx != None:
5506 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5507 
      self.ucx.write(oprot)
5508 
      oprot.writeFieldEnd()
5509 
    oprot.writeFieldStop()
5510 
    oprot.writeStructEnd()
5511 
 
5512 
  def __repr__(self):
5513 
    L = ['%s=%r' % (key, value)
5514 
      for key, value in self.__dict__.iteritems()]
5515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5516 
 
5517 
  def __eq__(self, other):
5518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5519 
 
5520 
  def __ne__(self, other):
5521 
    return not (self == other)
5522 
 
559 chandransh 5523 
class setDefaultAddress_args:
94 ashish 5524 
  """
5525 
  Attributes:
5526 
   - userid
5527 
   - addressId
5528 
  """
5529 
 
5530 
  thrift_spec = (
5531 
    None, # 0
5532 
    (1, TType.I64, 'userid', None, None, ), # 1
5533 
    (2, TType.I64, 'addressId', None, None, ), # 2
5534 
  )
5535 
 
5536 
  def __init__(self, userid=None, addressId=None,):
5537 
    self.userid = userid
5538 
    self.addressId = addressId
5539 
 
5540 
  def read(self, iprot):
5541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5543 
      return
5544 
    iprot.readStructBegin()
5545 
    while True:
5546 
      (fname, ftype, fid) = iprot.readFieldBegin()
5547 
      if ftype == TType.STOP:
5548 
        break
5549 
      if fid == 1:
5550 
        if ftype == TType.I64:
5551 
          self.userid = iprot.readI64();
5552 
        else:
5553 
          iprot.skip(ftype)
5554 
      elif fid == 2:
5555 
        if ftype == TType.I64:
5556 
          self.addressId = iprot.readI64();
5557 
        else:
5558 
          iprot.skip(ftype)
5559 
      else:
5560 
        iprot.skip(ftype)
5561 
      iprot.readFieldEnd()
5562 
    iprot.readStructEnd()
5563 
 
5564 
  def write(self, oprot):
5565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5567 
      return
559 chandransh 5568 
    oprot.writeStructBegin('setDefaultAddress_args')
94 ashish 5569 
    if self.userid != None:
5570 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5571 
      oprot.writeI64(self.userid)
5572 
      oprot.writeFieldEnd()
5573 
    if self.addressId != None:
5574 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5575 
      oprot.writeI64(self.addressId)
5576 
      oprot.writeFieldEnd()
5577 
    oprot.writeFieldStop()
5578 
    oprot.writeStructEnd()
5579 
 
5580 
  def __repr__(self):
5581 
    L = ['%s=%r' % (key, value)
5582 
      for key, value in self.__dict__.iteritems()]
5583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5584 
 
5585 
  def __eq__(self, other):
5586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5587 
 
5588 
  def __ne__(self, other):
5589 
    return not (self == other)
5590 
 
559 chandransh 5591 
class setDefaultAddress_result:
94 ashish 5592 
  """
5593 
  Attributes:
5594 
   - success
5595 
   - ucx
5596 
  """
5597 
 
5598 
  thrift_spec = (
5599 
    (0, TType.BOOL, 'success', None, None, ), # 0
5600 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5601 
  )
5602 
 
5603 
  def __init__(self, success=None, ucx=None,):
5604 
    self.success = success
5605 
    self.ucx = ucx
5606 
 
5607 
  def read(self, iprot):
5608 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5609 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5610 
      return
5611 
    iprot.readStructBegin()
5612 
    while True:
5613 
      (fname, ftype, fid) = iprot.readFieldBegin()
5614 
      if ftype == TType.STOP:
5615 
        break
5616 
      if fid == 0:
5617 
        if ftype == TType.BOOL:
5618 
          self.success = iprot.readBool();
5619 
        else:
5620 
          iprot.skip(ftype)
5621 
      elif fid == 1:
5622 
        if ftype == TType.STRUCT:
5623 
          self.ucx = UserContextException()
5624 
          self.ucx.read(iprot)
5625 
        else:
5626 
          iprot.skip(ftype)
5627 
      else:
5628 
        iprot.skip(ftype)
5629 
      iprot.readFieldEnd()
5630 
    iprot.readStructEnd()
5631 
 
5632 
  def write(self, oprot):
5633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5635 
      return
559 chandransh 5636 
    oprot.writeStructBegin('setDefaultAddress_result')
94 ashish 5637 
    if self.success != None:
5638 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5639 
      oprot.writeBool(self.success)
5640 
      oprot.writeFieldEnd()
5641 
    if self.ucx != None:
5642 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5643 
      self.ucx.write(oprot)
5644 
      oprot.writeFieldEnd()
5645 
    oprot.writeFieldStop()
5646 
    oprot.writeStructEnd()
5647 
 
5648 
  def __repr__(self):
5649 
    L = ['%s=%r' % (key, value)
5650 
      for key, value in self.__dict__.iteritems()]
5651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5652 
 
5653 
  def __eq__(self, other):
5654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5655 
 
5656 
  def __ne__(self, other):
5657 
    return not (self == other)
5658 
 
559 chandransh 5659 
class updatePassword_args:
94 ashish 5660 
  """
5661 
  Attributes:
559 chandransh 5662 
   - userid
594 rajveer 5663 
   - oldPassword
5664 
   - newPassword
94 ashish 5665 
  """
5666 
 
5667 
  thrift_spec = (
5668 
    None, # 0
559 chandransh 5669 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 5670 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
5671 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 5672 
  )
5673 
 
594 rajveer 5674 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 5675 
    self.userid = userid
594 rajveer 5676 
    self.oldPassword = oldPassword
5677 
    self.newPassword = newPassword
94 ashish 5678 
 
5679 
  def read(self, iprot):
5680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5682 
      return
5683 
    iprot.readStructBegin()
5684 
    while True:
5685 
      (fname, ftype, fid) = iprot.readFieldBegin()
5686 
      if ftype == TType.STOP:
5687 
        break
5688 
      if fid == 1:
5689 
        if ftype == TType.I64:
559 chandransh 5690 
          self.userid = iprot.readI64();
94 ashish 5691 
        else:
5692 
          iprot.skip(ftype)
5693 
      elif fid == 2:
559 chandransh 5694 
        if ftype == TType.STRING:
594 rajveer 5695 
          self.oldPassword = iprot.readString();
94 ashish 5696 
        else:
5697 
          iprot.skip(ftype)
594 rajveer 5698 
      elif fid == 3:
5699 
        if ftype == TType.STRING:
5700 
          self.newPassword = iprot.readString();
5701 
        else:
5702 
          iprot.skip(ftype)
94 ashish 5703 
      else:
5704 
        iprot.skip(ftype)
5705 
      iprot.readFieldEnd()
5706 
    iprot.readStructEnd()
5707 
 
5708 
  def write(self, oprot):
5709 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5710 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5711 
      return
559 chandransh 5712 
    oprot.writeStructBegin('updatePassword_args')
5713 
    if self.userid != None:
5714 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5715 
      oprot.writeI64(self.userid)
94 ashish 5716 
      oprot.writeFieldEnd()
594 rajveer 5717 
    if self.oldPassword != None:
5718 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
5719 
      oprot.writeString(self.oldPassword)
94 ashish 5720 
      oprot.writeFieldEnd()
594 rajveer 5721 
    if self.newPassword != None:
5722 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
5723 
      oprot.writeString(self.newPassword)
5724 
      oprot.writeFieldEnd()
94 ashish 5725 
    oprot.writeFieldStop()
5726 
    oprot.writeStructEnd()
5727 
 
5728 
  def __repr__(self):
5729 
    L = ['%s=%r' % (key, value)
5730 
      for key, value in self.__dict__.iteritems()]
5731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5732 
 
5733 
  def __eq__(self, other):
5734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5735 
 
5736 
  def __ne__(self, other):
5737 
    return not (self == other)
5738 
 
559 chandransh 5739 
class updatePassword_result:
94 ashish 5740 
  """
5741 
  Attributes:
5742 
   - success
5743 
   - ucx
5744 
  """
5745 
 
5746 
  thrift_spec = (
5747 
    (0, TType.BOOL, 'success', None, None, ), # 0
5748 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5749 
  )
5750 
 
5751 
  def __init__(self, success=None, ucx=None,):
5752 
    self.success = success
5753 
    self.ucx = ucx
5754 
 
5755 
  def read(self, iprot):
5756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5758 
      return
5759 
    iprot.readStructBegin()
5760 
    while True:
5761 
      (fname, ftype, fid) = iprot.readFieldBegin()
5762 
      if ftype == TType.STOP:
5763 
        break
5764 
      if fid == 0:
5765 
        if ftype == TType.BOOL:
5766 
          self.success = iprot.readBool();
5767 
        else:
5768 
          iprot.skip(ftype)
5769 
      elif fid == 1:
5770 
        if ftype == TType.STRUCT:
5771 
          self.ucx = UserContextException()
5772 
          self.ucx.read(iprot)
5773 
        else:
5774 
          iprot.skip(ftype)
5775 
      else:
5776 
        iprot.skip(ftype)
5777 
      iprot.readFieldEnd()
5778 
    iprot.readStructEnd()
5779 
 
5780 
  def write(self, oprot):
5781 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5782 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5783 
      return
559 chandransh 5784 
    oprot.writeStructBegin('updatePassword_result')
94 ashish 5785 
    if self.success != None:
5786 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5787 
      oprot.writeBool(self.success)
5788 
      oprot.writeFieldEnd()
5789 
    if self.ucx != None:
5790 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5791 
      self.ucx.write(oprot)
5792 
      oprot.writeFieldEnd()
5793 
    oprot.writeFieldStop()
5794 
    oprot.writeStructEnd()
5795 
 
5796 
  def __repr__(self):
5797 
    L = ['%s=%r' % (key, value)
5798 
      for key, value in self.__dict__.iteritems()]
5799 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5800 
 
5801 
  def __eq__(self, other):
5802 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5803 
 
5804 
  def __ne__(self, other):
5805 
    return not (self == other)
5806 
 
581 rajveer 5807 
class forgotPassword_args:
5808 
  """
5809 
  Attributes:
5810 
   - email
884 rajveer 5811 
   - newPassword
581 rajveer 5812 
  """
5813 
 
5814 
  thrift_spec = (
5815 
    None, # 0
5816 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 5817 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 5818 
  )
5819 
 
884 rajveer 5820 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 5821 
    self.email = email
884 rajveer 5822 
    self.newPassword = newPassword
581 rajveer 5823 
 
5824 
  def read(self, iprot):
5825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5827 
      return
5828 
    iprot.readStructBegin()
5829 
    while True:
5830 
      (fname, ftype, fid) = iprot.readFieldBegin()
5831 
      if ftype == TType.STOP:
5832 
        break
5833 
      if fid == 1:
5834 
        if ftype == TType.STRING:
5835 
          self.email = iprot.readString();
5836 
        else:
5837 
          iprot.skip(ftype)
884 rajveer 5838 
      elif fid == 2:
5839 
        if ftype == TType.STRING:
5840 
          self.newPassword = iprot.readString();
5841 
        else:
5842 
          iprot.skip(ftype)
581 rajveer 5843 
      else:
5844 
        iprot.skip(ftype)
5845 
      iprot.readFieldEnd()
5846 
    iprot.readStructEnd()
5847 
 
5848 
  def write(self, oprot):
5849 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5850 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5851 
      return
5852 
    oprot.writeStructBegin('forgotPassword_args')
5853 
    if self.email != None:
5854 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5855 
      oprot.writeString(self.email)
5856 
      oprot.writeFieldEnd()
884 rajveer 5857 
    if self.newPassword != None:
5858 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
5859 
      oprot.writeString(self.newPassword)
5860 
      oprot.writeFieldEnd()
581 rajveer 5861 
    oprot.writeFieldStop()
5862 
    oprot.writeStructEnd()
5863 
 
5864 
  def __repr__(self):
5865 
    L = ['%s=%r' % (key, value)
5866 
      for key, value in self.__dict__.iteritems()]
5867 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5868 
 
5869 
  def __eq__(self, other):
5870 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5871 
 
5872 
  def __ne__(self, other):
5873 
    return not (self == other)
5874 
 
5875 
class forgotPassword_result:
5876 
  """
5877 
  Attributes:
5878 
   - success
5879 
   - ucx
5880 
  """
5881 
 
5882 
  thrift_spec = (
5883 
    (0, TType.BOOL, 'success', None, None, ), # 0
5884 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5885 
  )
5886 
 
5887 
  def __init__(self, success=None, ucx=None,):
5888 
    self.success = success
5889 
    self.ucx = ucx
5890 
 
5891 
  def read(self, iprot):
5892 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5893 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5894 
      return
5895 
    iprot.readStructBegin()
5896 
    while True:
5897 
      (fname, ftype, fid) = iprot.readFieldBegin()
5898 
      if ftype == TType.STOP:
5899 
        break
5900 
      if fid == 0:
5901 
        if ftype == TType.BOOL:
5902 
          self.success = iprot.readBool();
5903 
        else:
5904 
          iprot.skip(ftype)
5905 
      elif fid == 1:
5906 
        if ftype == TType.STRUCT:
5907 
          self.ucx = UserContextException()
5908 
          self.ucx.read(iprot)
5909 
        else:
5910 
          iprot.skip(ftype)
5911 
      else:
5912 
        iprot.skip(ftype)
5913 
      iprot.readFieldEnd()
5914 
    iprot.readStructEnd()
5915 
 
5916 
  def write(self, oprot):
5917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5919 
      return
5920 
    oprot.writeStructBegin('forgotPassword_result')
5921 
    if self.success != None:
5922 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5923 
      oprot.writeBool(self.success)
5924 
      oprot.writeFieldEnd()
5925 
    if self.ucx != None:
5926 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5927 
      self.ucx.write(oprot)
5928 
      oprot.writeFieldEnd()
5929 
    oprot.writeFieldStop()
5930 
    oprot.writeStructEnd()
5931 
 
5932 
  def __repr__(self):
5933 
    L = ['%s=%r' % (key, value)
5934 
      for key, value in self.__dict__.iteritems()]
5935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5936 
 
5937 
  def __eq__(self, other):
5938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5939 
 
5940 
  def __ne__(self, other):
5941 
    return not (self == other)
5942 
 
594 rajveer 5943 
class getAllAddressesForUser_args:
5944 
  """
5945 
  Attributes:
5946 
   - userId
5947 
  """
5948 
 
5949 
  thrift_spec = (
5950 
    None, # 0
5951 
    (1, TType.I64, 'userId', None, None, ), # 1
5952 
  )
5953 
 
5954 
  def __init__(self, userId=None,):
5955 
    self.userId = userId
5956 
 
5957 
  def read(self, iprot):
5958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5960 
      return
5961 
    iprot.readStructBegin()
5962 
    while True:
5963 
      (fname, ftype, fid) = iprot.readFieldBegin()
5964 
      if ftype == TType.STOP:
5965 
        break
5966 
      if fid == 1:
5967 
        if ftype == TType.I64:
5968 
          self.userId = iprot.readI64();
5969 
        else:
5970 
          iprot.skip(ftype)
5971 
      else:
5972 
        iprot.skip(ftype)
5973 
      iprot.readFieldEnd()
5974 
    iprot.readStructEnd()
5975 
 
5976 
  def write(self, oprot):
5977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5979 
      return
5980 
    oprot.writeStructBegin('getAllAddressesForUser_args')
5981 
    if self.userId != None:
5982 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5983 
      oprot.writeI64(self.userId)
5984 
      oprot.writeFieldEnd()
5985 
    oprot.writeFieldStop()
5986 
    oprot.writeStructEnd()
5987 
 
5988 
  def __repr__(self):
5989 
    L = ['%s=%r' % (key, value)
5990 
      for key, value in self.__dict__.iteritems()]
5991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5992 
 
5993 
  def __eq__(self, other):
5994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5995 
 
5996 
  def __ne__(self, other):
5997 
    return not (self == other)
5998 
 
5999 
class getAllAddressesForUser_result:
6000 
  """
6001 
  Attributes:
6002 
   - success
6003 
   - ucx
6004 
  """
6005 
 
6006 
  thrift_spec = (
6007 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
6008 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6009 
  )
6010 
 
6011 
  def __init__(self, success=None, ucx=None,):
6012 
    self.success = success
6013 
    self.ucx = ucx
6014 
 
6015 
  def read(self, iprot):
6016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6018 
      return
6019 
    iprot.readStructBegin()
6020 
    while True:
6021 
      (fname, ftype, fid) = iprot.readFieldBegin()
6022 
      if ftype == TType.STOP:
6023 
        break
6024 
      if fid == 0:
6025 
        if ftype == TType.LIST:
6026 
          self.success = []
1976 varun.gupt 6027 
          (_etype38, _size35) = iprot.readListBegin()
6028 
          for _i39 in xrange(_size35):
6029 
            _elem40 = Address()
6030 
            _elem40.read(iprot)
6031 
            self.success.append(_elem40)
594 rajveer 6032 
          iprot.readListEnd()
6033 
        else:
6034 
          iprot.skip(ftype)
6035 
      elif fid == 1:
6036 
        if ftype == TType.STRUCT:
6037 
          self.ucx = UserContextException()
6038 
          self.ucx.read(iprot)
6039 
        else:
6040 
          iprot.skip(ftype)
6041 
      else:
6042 
        iprot.skip(ftype)
6043 
      iprot.readFieldEnd()
6044 
    iprot.readStructEnd()
6045 
 
6046 
  def write(self, oprot):
6047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6049 
      return
6050 
    oprot.writeStructBegin('getAllAddressesForUser_result')
6051 
    if self.success != None:
6052 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6053 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 6054 
      for iter41 in self.success:
6055 
        iter41.write(oprot)
594 rajveer 6056 
      oprot.writeListEnd()
6057 
      oprot.writeFieldEnd()
6058 
    if self.ucx != None:
6059 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6060 
      self.ucx.write(oprot)
6061 
      oprot.writeFieldEnd()
6062 
    oprot.writeFieldStop()
6063 
    oprot.writeStructEnd()
6064 
 
6065 
  def __repr__(self):
6066 
    L = ['%s=%r' % (key, value)
6067 
      for key, value in self.__dict__.iteritems()]
6068 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6069 
 
6070 
  def __eq__(self, other):
6071 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6072 
 
6073 
  def __ne__(self, other):
6074 
    return not (self == other)
6075 
 
1894 vikas 6076 
class getAddressById_args:
6077 
  """
6078 
  Attributes:
6079 
   - addressId
6080 
  """
6081 
 
6082 
  thrift_spec = (
6083 
    None, # 0
6084 
    (1, TType.I64, 'addressId', None, None, ), # 1
6085 
  )
6086 
 
6087 
  def __init__(self, addressId=None,):
6088 
    self.addressId = addressId
6089 
 
6090 
  def read(self, iprot):
6091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6093 
      return
6094 
    iprot.readStructBegin()
6095 
    while True:
6096 
      (fname, ftype, fid) = iprot.readFieldBegin()
6097 
      if ftype == TType.STOP:
6098 
        break
6099 
      if fid == 1:
6100 
        if ftype == TType.I64:
6101 
          self.addressId = iprot.readI64();
6102 
        else:
6103 
          iprot.skip(ftype)
6104 
      else:
6105 
        iprot.skip(ftype)
6106 
      iprot.readFieldEnd()
6107 
    iprot.readStructEnd()
6108 
 
6109 
  def write(self, oprot):
6110 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6111 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6112 
      return
6113 
    oprot.writeStructBegin('getAddressById_args')
6114 
    if self.addressId != None:
6115 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
6116 
      oprot.writeI64(self.addressId)
6117 
      oprot.writeFieldEnd()
6118 
    oprot.writeFieldStop()
6119 
    oprot.writeStructEnd()
6120 
 
6121 
  def __repr__(self):
6122 
    L = ['%s=%r' % (key, value)
6123 
      for key, value in self.__dict__.iteritems()]
6124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6125 
 
6126 
  def __eq__(self, other):
6127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6128 
 
6129 
  def __ne__(self, other):
6130 
    return not (self == other)
6131 
 
6132 
class getAddressById_result:
6133 
  """
6134 
  Attributes:
6135 
   - success
6136 
   - ucx
6137 
  """
6138 
 
6139 
  thrift_spec = (
6140 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
6141 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6142 
  )
6143 
 
6144 
  def __init__(self, success=None, ucx=None,):
6145 
    self.success = success
6146 
    self.ucx = ucx
6147 
 
6148 
  def read(self, iprot):
6149 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6150 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6151 
      return
6152 
    iprot.readStructBegin()
6153 
    while True:
6154 
      (fname, ftype, fid) = iprot.readFieldBegin()
6155 
      if ftype == TType.STOP:
6156 
        break
6157 
      if fid == 0:
6158 
        if ftype == TType.STRUCT:
6159 
          self.success = Address()
6160 
          self.success.read(iprot)
6161 
        else:
6162 
          iprot.skip(ftype)
6163 
      elif fid == 1:
6164 
        if ftype == TType.STRUCT:
6165 
          self.ucx = UserContextException()
6166 
          self.ucx.read(iprot)
6167 
        else:
6168 
          iprot.skip(ftype)
6169 
      else:
6170 
        iprot.skip(ftype)
6171 
      iprot.readFieldEnd()
6172 
    iprot.readStructEnd()
6173 
 
6174 
  def write(self, oprot):
6175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6177 
      return
6178 
    oprot.writeStructBegin('getAddressById_result')
6179 
    if self.success != None:
6180 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6181 
      self.success.write(oprot)
6182 
      oprot.writeFieldEnd()
6183 
    if self.ucx != None:
6184 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6185 
      self.ucx.write(oprot)
6186 
      oprot.writeFieldEnd()
6187 
    oprot.writeFieldStop()
6188 
    oprot.writeStructEnd()
6189 
 
6190 
  def __repr__(self):
6191 
    L = ['%s=%r' % (key, value)
6192 
      for key, value in self.__dict__.iteritems()]
6193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6194 
 
6195 
  def __eq__(self, other):
6196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6197 
 
6198 
  def __ne__(self, other):
6199 
    return not (self == other)
6200 
 
594 rajveer 6201 
class getDefaultAddressId_args:
6202 
  """
6203 
  Attributes:
6204 
   - userId
6205 
  """
6206 
 
6207 
  thrift_spec = (
6208 
    None, # 0
6209 
    (1, TType.I64, 'userId', None, None, ), # 1
6210 
  )
6211 
 
6212 
  def __init__(self, userId=None,):
6213 
    self.userId = userId
6214 
 
6215 
  def read(self, iprot):
6216 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6217 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6218 
      return
6219 
    iprot.readStructBegin()
6220 
    while True:
6221 
      (fname, ftype, fid) = iprot.readFieldBegin()
6222 
      if ftype == TType.STOP:
6223 
        break
6224 
      if fid == 1:
6225 
        if ftype == TType.I64:
6226 
          self.userId = iprot.readI64();
6227 
        else:
6228 
          iprot.skip(ftype)
6229 
      else:
6230 
        iprot.skip(ftype)
6231 
      iprot.readFieldEnd()
6232 
    iprot.readStructEnd()
6233 
 
6234 
  def write(self, oprot):
6235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6237 
      return
6238 
    oprot.writeStructBegin('getDefaultAddressId_args')
6239 
    if self.userId != None:
6240 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6241 
      oprot.writeI64(self.userId)
6242 
      oprot.writeFieldEnd()
6243 
    oprot.writeFieldStop()
6244 
    oprot.writeStructEnd()
6245 
 
6246 
  def __repr__(self):
6247 
    L = ['%s=%r' % (key, value)
6248 
      for key, value in self.__dict__.iteritems()]
6249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6250 
 
6251 
  def __eq__(self, other):
6252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6253 
 
6254 
  def __ne__(self, other):
6255 
    return not (self == other)
6256 
 
6257 
class getDefaultAddressId_result:
6258 
  """
6259 
  Attributes:
6260 
   - success
6261 
   - ucx
6262 
  """
6263 
 
6264 
  thrift_spec = (
6265 
    (0, TType.I64, 'success', None, None, ), # 0
6266 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6267 
  )
6268 
 
6269 
  def __init__(self, success=None, ucx=None,):
6270 
    self.success = success
6271 
    self.ucx = ucx
6272 
 
6273 
  def read(self, iprot):
6274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6276 
      return
6277 
    iprot.readStructBegin()
6278 
    while True:
6279 
      (fname, ftype, fid) = iprot.readFieldBegin()
6280 
      if ftype == TType.STOP:
6281 
        break
6282 
      if fid == 0:
6283 
        if ftype == TType.I64:
6284 
          self.success = iprot.readI64();
6285 
        else:
6286 
          iprot.skip(ftype)
6287 
      elif fid == 1:
6288 
        if ftype == TType.STRUCT:
6289 
          self.ucx = UserContextException()
6290 
          self.ucx.read(iprot)
6291 
        else:
6292 
          iprot.skip(ftype)
6293 
      else:
6294 
        iprot.skip(ftype)
6295 
      iprot.readFieldEnd()
6296 
    iprot.readStructEnd()
6297 
 
6298 
  def write(self, oprot):
6299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6301 
      return
6302 
    oprot.writeStructBegin('getDefaultAddressId_result')
6303 
    if self.success != None:
6304 
      oprot.writeFieldBegin('success', TType.I64, 0)
6305 
      oprot.writeI64(self.success)
6306 
      oprot.writeFieldEnd()
6307 
    if self.ucx != None:
6308 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6309 
      self.ucx.write(oprot)
6310 
      oprot.writeFieldEnd()
6311 
    oprot.writeFieldStop()
6312 
    oprot.writeStructEnd()
6313 
 
6314 
  def __repr__(self):
6315 
    L = ['%s=%r' % (key, value)
6316 
      for key, value in self.__dict__.iteritems()]
6317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6318 
 
6319 
  def __eq__(self, other):
6320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6321 
 
6322 
  def __ne__(self, other):
6323 
    return not (self == other)
6324 
 
785 rajveer 6325 
class getDefaultPincode_args:
6326 
  """
6327 
  Attributes:
6328 
   - userId
6329 
  """
6330 
 
6331 
  thrift_spec = (
6332 
    None, # 0
6333 
    (1, TType.I64, 'userId', None, None, ), # 1
6334 
  )
6335 
 
6336 
  def __init__(self, userId=None,):
6337 
    self.userId = userId
6338 
 
6339 
  def read(self, iprot):
6340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6342 
      return
6343 
    iprot.readStructBegin()
6344 
    while True:
6345 
      (fname, ftype, fid) = iprot.readFieldBegin()
6346 
      if ftype == TType.STOP:
6347 
        break
6348 
      if fid == 1:
6349 
        if ftype == TType.I64:
6350 
          self.userId = iprot.readI64();
6351 
        else:
6352 
          iprot.skip(ftype)
6353 
      else:
6354 
        iprot.skip(ftype)
6355 
      iprot.readFieldEnd()
6356 
    iprot.readStructEnd()
6357 
 
6358 
  def write(self, oprot):
6359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6361 
      return
6362 
    oprot.writeStructBegin('getDefaultPincode_args')
6363 
    if self.userId != None:
6364 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6365 
      oprot.writeI64(self.userId)
6366 
      oprot.writeFieldEnd()
6367 
    oprot.writeFieldStop()
6368 
    oprot.writeStructEnd()
6369 
 
6370 
  def __repr__(self):
6371 
    L = ['%s=%r' % (key, value)
6372 
      for key, value in self.__dict__.iteritems()]
6373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6374 
 
6375 
  def __eq__(self, other):
6376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6377 
 
6378 
  def __ne__(self, other):
6379 
    return not (self == other)
6380 
 
6381 
class getDefaultPincode_result:
6382 
  """
6383 
  Attributes:
6384 
   - success
6385 
   - ucx
6386 
  """
6387 
 
6388 
  thrift_spec = (
6389 
    (0, TType.STRING, 'success', None, None, ), # 0
6390 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6391 
  )
6392 
 
6393 
  def __init__(self, success=None, ucx=None,):
6394 
    self.success = success
6395 
    self.ucx = ucx
6396 
 
6397 
  def read(self, iprot):
6398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6400 
      return
6401 
    iprot.readStructBegin()
6402 
    while True:
6403 
      (fname, ftype, fid) = iprot.readFieldBegin()
6404 
      if ftype == TType.STOP:
6405 
        break
6406 
      if fid == 0:
6407 
        if ftype == TType.STRING:
6408 
          self.success = iprot.readString();
6409 
        else:
6410 
          iprot.skip(ftype)
6411 
      elif fid == 1:
6412 
        if ftype == TType.STRUCT:
6413 
          self.ucx = UserContextException()
6414 
          self.ucx.read(iprot)
6415 
        else:
6416 
          iprot.skip(ftype)
6417 
      else:
6418 
        iprot.skip(ftype)
6419 
      iprot.readFieldEnd()
6420 
    iprot.readStructEnd()
6421 
 
6422 
  def write(self, oprot):
6423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6425 
      return
6426 
    oprot.writeStructBegin('getDefaultPincode_result')
6427 
    if self.success != None:
6428 
      oprot.writeFieldBegin('success', TType.STRING, 0)
6429 
      oprot.writeString(self.success)
6430 
      oprot.writeFieldEnd()
6431 
    if self.ucx != None:
6432 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6433 
      self.ucx.write(oprot)
6434 
      oprot.writeFieldEnd()
6435 
    oprot.writeFieldStop()
6436 
    oprot.writeStructEnd()
6437 
 
6438 
  def __repr__(self):
6439 
    L = ['%s=%r' % (key, value)
6440 
      for key, value in self.__dict__.iteritems()]
6441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6442 
 
6443 
  def __eq__(self, other):
6444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6445 
 
6446 
  def __ne__(self, other):
6447 
    return not (self == other)
6448 
 
1274 varun.gupt 6449 
class saveUserCommunication_args:
6450 
  """
6451 
  Attributes:
6452 
   - userId
6453 
   - replyTo
6454 
   - communicationType
6455 
   - orderId
6456 
   - airwaybillNo
6457 
   - productName
6458 
   - subject
6459 
   - message
6460 
  """
6461 
 
6462 
  thrift_spec = (
6463 
    None, # 0
6464 
    (1, TType.I64, 'userId', None, None, ), # 1
6465 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
6466 
    (3, TType.I64, 'communicationType', None, None, ), # 3
6467 
    (4, TType.I64, 'orderId', None, None, ), # 4
6468 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
6469 
    (6, TType.STRING, 'productName', None, None, ), # 6
6470 
    (7, TType.STRING, 'subject', None, None, ), # 7
6471 
    (8, TType.STRING, 'message', None, None, ), # 8
6472 
  )
6473 
 
6474 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
6475 
    self.userId = userId
6476 
    self.replyTo = replyTo
6477 
    self.communicationType = communicationType
6478 
    self.orderId = orderId
6479 
    self.airwaybillNo = airwaybillNo
6480 
    self.productName = productName
6481 
    self.subject = subject
6482 
    self.message = message
6483 
 
6484 
  def read(self, iprot):
6485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6487 
      return
6488 
    iprot.readStructBegin()
6489 
    while True:
6490 
      (fname, ftype, fid) = iprot.readFieldBegin()
6491 
      if ftype == TType.STOP:
6492 
        break
6493 
      if fid == 1:
6494 
        if ftype == TType.I64:
6495 
          self.userId = iprot.readI64();
6496 
        else:
6497 
          iprot.skip(ftype)
6498 
      elif fid == 2:
6499 
        if ftype == TType.STRING:
6500 
          self.replyTo = iprot.readString();
6501 
        else:
6502 
          iprot.skip(ftype)
6503 
      elif fid == 3:
6504 
        if ftype == TType.I64:
6505 
          self.communicationType = iprot.readI64();
6506 
        else:
6507 
          iprot.skip(ftype)
6508 
      elif fid == 4:
6509 
        if ftype == TType.I64:
6510 
          self.orderId = iprot.readI64();
6511 
        else:
6512 
          iprot.skip(ftype)
6513 
      elif fid == 5:
6514 
        if ftype == TType.STRING:
6515 
          self.airwaybillNo = iprot.readString();
6516 
        else:
6517 
          iprot.skip(ftype)
6518 
      elif fid == 6:
6519 
        if ftype == TType.STRING:
6520 
          self.productName = iprot.readString();
6521 
        else:
6522 
          iprot.skip(ftype)
6523 
      elif fid == 7:
6524 
        if ftype == TType.STRING:
6525 
          self.subject = iprot.readString();
6526 
        else:
6527 
          iprot.skip(ftype)
6528 
      elif fid == 8:
6529 
        if ftype == TType.STRING:
6530 
          self.message = iprot.readString();
6531 
        else:
6532 
          iprot.skip(ftype)
6533 
      else:
6534 
        iprot.skip(ftype)
6535 
      iprot.readFieldEnd()
6536 
    iprot.readStructEnd()
6537 
 
6538 
  def write(self, oprot):
6539 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6540 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6541 
      return
6542 
    oprot.writeStructBegin('saveUserCommunication_args')
6543 
    if self.userId != None:
6544 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6545 
      oprot.writeI64(self.userId)
6546 
      oprot.writeFieldEnd()
6547 
    if self.replyTo != None:
6548 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
6549 
      oprot.writeString(self.replyTo)
6550 
      oprot.writeFieldEnd()
6551 
    if self.communicationType != None:
6552 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
6553 
      oprot.writeI64(self.communicationType)
6554 
      oprot.writeFieldEnd()
6555 
    if self.orderId != None:
6556 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
6557 
      oprot.writeI64(self.orderId)
6558 
      oprot.writeFieldEnd()
6559 
    if self.airwaybillNo != None:
6560 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
6561 
      oprot.writeString(self.airwaybillNo)
6562 
      oprot.writeFieldEnd()
6563 
    if self.productName != None:
6564 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
6565 
      oprot.writeString(self.productName)
6566 
      oprot.writeFieldEnd()
6567 
    if self.subject != None:
6568 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
6569 
      oprot.writeString(self.subject)
6570 
      oprot.writeFieldEnd()
6571 
    if self.message != None:
6572 
      oprot.writeFieldBegin('message', TType.STRING, 8)
6573 
      oprot.writeString(self.message)
6574 
      oprot.writeFieldEnd()
6575 
    oprot.writeFieldStop()
6576 
    oprot.writeStructEnd()
6577 
 
6578 
  def __repr__(self):
6579 
    L = ['%s=%r' % (key, value)
6580 
      for key, value in self.__dict__.iteritems()]
6581 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6582 
 
6583 
  def __eq__(self, other):
6584 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6585 
 
6586 
  def __ne__(self, other):
6587 
    return not (self == other)
6588 
 
6589 
class saveUserCommunication_result:
6590 
  """
6591 
  Attributes:
6592 
   - success
6593 
   - ucx
6594 
  """
6595 
 
6596 
  thrift_spec = (
6597 
    (0, TType.BOOL, 'success', None, None, ), # 0
6598 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6599 
  )
6600 
 
6601 
  def __init__(self, success=None, ucx=None,):
6602 
    self.success = success
6603 
    self.ucx = ucx
6604 
 
6605 
  def read(self, iprot):
6606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6608 
      return
6609 
    iprot.readStructBegin()
6610 
    while True:
6611 
      (fname, ftype, fid) = iprot.readFieldBegin()
6612 
      if ftype == TType.STOP:
6613 
        break
6614 
      if fid == 0:
6615 
        if ftype == TType.BOOL:
6616 
          self.success = iprot.readBool();
6617 
        else:
6618 
          iprot.skip(ftype)
6619 
      elif fid == 1:
6620 
        if ftype == TType.STRUCT:
6621 
          self.ucx = UserCommunicationException()
6622 
          self.ucx.read(iprot)
6623 
        else:
6624 
          iprot.skip(ftype)
6625 
      else:
6626 
        iprot.skip(ftype)
6627 
      iprot.readFieldEnd()
6628 
    iprot.readStructEnd()
6629 
 
6630 
  def write(self, oprot):
6631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6633 
      return
6634 
    oprot.writeStructBegin('saveUserCommunication_result')
6635 
    if self.success != None:
6636 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6637 
      oprot.writeBool(self.success)
6638 
      oprot.writeFieldEnd()
6639 
    if self.ucx != None:
6640 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6641 
      self.ucx.write(oprot)
6642 
      oprot.writeFieldEnd()
6643 
    oprot.writeFieldStop()
6644 
    oprot.writeStructEnd()
6645 
 
6646 
  def __repr__(self):
6647 
    L = ['%s=%r' % (key, value)
6648 
      for key, value in self.__dict__.iteritems()]
6649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6650 
 
6651 
  def __eq__(self, other):
6652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6653 
 
6654 
  def __ne__(self, other):
6655 
    return not (self == other)
6656 
 
1590 varun.gupt 6657 
class getUserCommunicationById_args:
6658 
  """
6659 
  Attributes:
6660 
   - id
6661 
  """
6662 
 
6663 
  thrift_spec = (
6664 
    None, # 0
6665 
    (1, TType.I64, 'id', None, None, ), # 1
6666 
  )
6667 
 
6668 
  def __init__(self, id=None,):
6669 
    self.id = id
6670 
 
6671 
  def read(self, iprot):
6672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6674 
      return
6675 
    iprot.readStructBegin()
6676 
    while True:
6677 
      (fname, ftype, fid) = iprot.readFieldBegin()
6678 
      if ftype == TType.STOP:
6679 
        break
6680 
      if fid == 1:
6681 
        if ftype == TType.I64:
6682 
          self.id = iprot.readI64();
6683 
        else:
6684 
          iprot.skip(ftype)
6685 
      else:
6686 
        iprot.skip(ftype)
6687 
      iprot.readFieldEnd()
6688 
    iprot.readStructEnd()
6689 
 
6690 
  def write(self, oprot):
6691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6693 
      return
6694 
    oprot.writeStructBegin('getUserCommunicationById_args')
6695 
    if self.id != None:
6696 
      oprot.writeFieldBegin('id', TType.I64, 1)
6697 
      oprot.writeI64(self.id)
6698 
      oprot.writeFieldEnd()
6699 
    oprot.writeFieldStop()
6700 
    oprot.writeStructEnd()
6701 
 
6702 
  def __repr__(self):
6703 
    L = ['%s=%r' % (key, value)
6704 
      for key, value in self.__dict__.iteritems()]
6705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6706 
 
6707 
  def __eq__(self, other):
6708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6709 
 
6710 
  def __ne__(self, other):
6711 
    return not (self == other)
6712 
 
6713 
class getUserCommunicationById_result:
6714 
  """
6715 
  Attributes:
6716 
   - success
6717 
   - ucx
6718 
  """
6719 
 
6720 
  thrift_spec = (
6721 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
6722 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6723 
  )
6724 
 
6725 
  def __init__(self, success=None, ucx=None,):
6726 
    self.success = success
6727 
    self.ucx = ucx
6728 
 
6729 
  def read(self, iprot):
6730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6732 
      return
6733 
    iprot.readStructBegin()
6734 
    while True:
6735 
      (fname, ftype, fid) = iprot.readFieldBegin()
6736 
      if ftype == TType.STOP:
6737 
        break
6738 
      if fid == 0:
6739 
        if ftype == TType.STRUCT:
6740 
          self.success = UserCommunication()
6741 
          self.success.read(iprot)
6742 
        else:
6743 
          iprot.skip(ftype)
6744 
      elif fid == 1:
6745 
        if ftype == TType.STRUCT:
6746 
          self.ucx = UserCommunicationException()
6747 
          self.ucx.read(iprot)
6748 
        else:
6749 
          iprot.skip(ftype)
6750 
      else:
6751 
        iprot.skip(ftype)
6752 
      iprot.readFieldEnd()
6753 
    iprot.readStructEnd()
6754 
 
6755 
  def write(self, oprot):
6756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6758 
      return
6759 
    oprot.writeStructBegin('getUserCommunicationById_result')
6760 
    if self.success != None:
6761 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6762 
      self.success.write(oprot)
6763 
      oprot.writeFieldEnd()
6764 
    if self.ucx != None:
6765 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6766 
      self.ucx.write(oprot)
6767 
      oprot.writeFieldEnd()
6768 
    oprot.writeFieldStop()
6769 
    oprot.writeStructEnd()
6770 
 
6771 
  def __repr__(self):
6772 
    L = ['%s=%r' % (key, value)
6773 
      for key, value in self.__dict__.iteritems()]
6774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6775 
 
6776 
  def __eq__(self, other):
6777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6778 
 
6779 
  def __ne__(self, other):
6780 
    return not (self == other)
6781 
 
6782 
class getUserCommunicationByUser_args:
6783 
  """
6784 
  Attributes:
6785 
   - userId
6786 
  """
6787 
 
6788 
  thrift_spec = (
6789 
    None, # 0
6790 
    (1, TType.I64, 'userId', None, None, ), # 1
6791 
  )
6792 
 
6793 
  def __init__(self, userId=None,):
6794 
    self.userId = userId
6795 
 
6796 
  def read(self, iprot):
6797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6799 
      return
6800 
    iprot.readStructBegin()
6801 
    while True:
6802 
      (fname, ftype, fid) = iprot.readFieldBegin()
6803 
      if ftype == TType.STOP:
6804 
        break
6805 
      if fid == 1:
6806 
        if ftype == TType.I64:
6807 
          self.userId = iprot.readI64();
6808 
        else:
6809 
          iprot.skip(ftype)
6810 
      else:
6811 
        iprot.skip(ftype)
6812 
      iprot.readFieldEnd()
6813 
    iprot.readStructEnd()
6814 
 
6815 
  def write(self, oprot):
6816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6818 
      return
6819 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
6820 
    if self.userId != None:
6821 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6822 
      oprot.writeI64(self.userId)
6823 
      oprot.writeFieldEnd()
6824 
    oprot.writeFieldStop()
6825 
    oprot.writeStructEnd()
6826 
 
6827 
  def __repr__(self):
6828 
    L = ['%s=%r' % (key, value)
6829 
      for key, value in self.__dict__.iteritems()]
6830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6831 
 
6832 
  def __eq__(self, other):
6833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6834 
 
6835 
  def __ne__(self, other):
6836 
    return not (self == other)
6837 
 
6838 
class getUserCommunicationByUser_result:
6839 
  """
6840 
  Attributes:
6841 
   - success
6842 
   - ucx
6843 
  """
6844 
 
6845 
  thrift_spec = (
6846 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
6847 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6848 
  )
6849 
 
6850 
  def __init__(self, success=None, ucx=None,):
6851 
    self.success = success
6852 
    self.ucx = ucx
6853 
 
6854 
  def read(self, iprot):
6855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6857 
      return
6858 
    iprot.readStructBegin()
6859 
    while True:
6860 
      (fname, ftype, fid) = iprot.readFieldBegin()
6861 
      if ftype == TType.STOP:
6862 
        break
6863 
      if fid == 0:
6864 
        if ftype == TType.LIST:
6865 
          self.success = []
1976 varun.gupt 6866 
          (_etype45, _size42) = iprot.readListBegin()
6867 
          for _i46 in xrange(_size42):
6868 
            _elem47 = UserCommunication()
6869 
            _elem47.read(iprot)
6870 
            self.success.append(_elem47)
1590 varun.gupt 6871 
          iprot.readListEnd()
6872 
        else:
6873 
          iprot.skip(ftype)
6874 
      elif fid == 1:
6875 
        if ftype == TType.STRUCT:
6876 
          self.ucx = UserCommunicationException()
6877 
          self.ucx.read(iprot)
6878 
        else:
6879 
          iprot.skip(ftype)
6880 
      else:
6881 
        iprot.skip(ftype)
6882 
      iprot.readFieldEnd()
6883 
    iprot.readStructEnd()
6884 
 
6885 
  def write(self, oprot):
6886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6888 
      return
6889 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
6890 
    if self.success != None:
6891 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6892 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 6893 
      for iter48 in self.success:
6894 
        iter48.write(oprot)
1590 varun.gupt 6895 
      oprot.writeListEnd()
6896 
      oprot.writeFieldEnd()
6897 
    if self.ucx != None:
6898 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6899 
      self.ucx.write(oprot)
6900 
      oprot.writeFieldEnd()
6901 
    oprot.writeFieldStop()
6902 
    oprot.writeStructEnd()
6903 
 
6904 
  def __repr__(self):
6905 
    L = ['%s=%r' % (key, value)
6906 
      for key, value in self.__dict__.iteritems()]
6907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6908 
 
6909 
  def __eq__(self, other):
6910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6911 
 
6912 
  def __ne__(self, other):
6913 
    return not (self == other)
6914 
 
6915 
class getAllUserCommunications_args:
6916 
 
6917 
  thrift_spec = (
6918 
  )
6919 
 
6920 
  def read(self, iprot):
6921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6923 
      return
6924 
    iprot.readStructBegin()
6925 
    while True:
6926 
      (fname, ftype, fid) = iprot.readFieldBegin()
6927 
      if ftype == TType.STOP:
6928 
        break
6929 
      else:
6930 
        iprot.skip(ftype)
6931 
      iprot.readFieldEnd()
6932 
    iprot.readStructEnd()
6933 
 
6934 
  def write(self, oprot):
6935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6937 
      return
6938 
    oprot.writeStructBegin('getAllUserCommunications_args')
6939 
    oprot.writeFieldStop()
6940 
    oprot.writeStructEnd()
6941 
 
6942 
  def __repr__(self):
6943 
    L = ['%s=%r' % (key, value)
6944 
      for key, value in self.__dict__.iteritems()]
6945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6946 
 
6947 
  def __eq__(self, other):
6948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6949 
 
6950 
  def __ne__(self, other):
6951 
    return not (self == other)
6952 
 
6953 
class getAllUserCommunications_result:
6954 
  """
6955 
  Attributes:
6956 
   - success
6957 
   - ucx
6958 
  """
6959 
 
6960 
  thrift_spec = (
6961 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
6962 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6963 
  )
6964 
 
6965 
  def __init__(self, success=None, ucx=None,):
6966 
    self.success = success
6967 
    self.ucx = ucx
6968 
 
6969 
  def read(self, iprot):
6970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6972 
      return
6973 
    iprot.readStructBegin()
6974 
    while True:
6975 
      (fname, ftype, fid) = iprot.readFieldBegin()
6976 
      if ftype == TType.STOP:
6977 
        break
6978 
      if fid == 0:
6979 
        if ftype == TType.LIST:
6980 
          self.success = []
1976 varun.gupt 6981 
          (_etype52, _size49) = iprot.readListBegin()
6982 
          for _i53 in xrange(_size49):
6983 
            _elem54 = UserCommunication()
6984 
            _elem54.read(iprot)
6985 
            self.success.append(_elem54)
1590 varun.gupt 6986 
          iprot.readListEnd()
6987 
        else:
6988 
          iprot.skip(ftype)
6989 
      elif fid == 1:
6990 
        if ftype == TType.STRUCT:
6991 
          self.ucx = UserCommunicationException()
6992 
          self.ucx.read(iprot)
6993 
        else:
6994 
          iprot.skip(ftype)
6995 
      else:
6996 
        iprot.skip(ftype)
6997 
      iprot.readFieldEnd()
6998 
    iprot.readStructEnd()
6999 
 
7000 
  def write(self, oprot):
7001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7003 
      return
7004 
    oprot.writeStructBegin('getAllUserCommunications_result')
7005 
    if self.success != None:
7006 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7007 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 7008 
      for iter55 in self.success:
7009 
        iter55.write(oprot)
1590 varun.gupt 7010 
      oprot.writeListEnd()
7011 
      oprot.writeFieldEnd()
7012 
    if self.ucx != None:
7013 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7014 
      self.ucx.write(oprot)
7015 
      oprot.writeFieldEnd()
7016 
    oprot.writeFieldStop()
7017 
    oprot.writeStructEnd()
7018 
 
7019 
  def __repr__(self):
7020 
    L = ['%s=%r' % (key, value)
7021 
      for key, value in self.__dict__.iteritems()]
7022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7023 
 
7024 
  def __eq__(self, other):
7025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7026 
 
7027 
  def __ne__(self, other):
7028 
    return not (self == other)
7029 
 
1845 vikas 7030 
class createMasterAffiliate_args:
7031 
  """
7032 
  Attributes:
7033 
   - name
1859 vikas 7034 
   - addedOn
1845 vikas 7035 
  """
7036 
 
7037 
  thrift_spec = (
7038 
    None, # 0
7039 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 7040 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 7041 
  )
7042 
 
1859 vikas 7043 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 7044 
    self.name = name
1859 vikas 7045 
    self.addedOn = addedOn
1845 vikas 7046 
 
7047 
  def read(self, iprot):
7048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7050 
      return
7051 
    iprot.readStructBegin()
7052 
    while True:
7053 
      (fname, ftype, fid) = iprot.readFieldBegin()
7054 
      if ftype == TType.STOP:
7055 
        break
7056 
      if fid == 1:
7057 
        if ftype == TType.STRING:
7058 
          self.name = iprot.readString();
7059 
        else:
7060 
          iprot.skip(ftype)
1859 vikas 7061 
      elif fid == 2:
7062 
        if ftype == TType.I64:
7063 
          self.addedOn = iprot.readI64();
7064 
        else:
7065 
          iprot.skip(ftype)
1845 vikas 7066 
      else:
7067 
        iprot.skip(ftype)
7068 
      iprot.readFieldEnd()
7069 
    iprot.readStructEnd()
7070 
 
7071 
  def write(self, oprot):
7072 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7073 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7074 
      return
7075 
    oprot.writeStructBegin('createMasterAffiliate_args')
7076 
    if self.name != None:
7077 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7078 
      oprot.writeString(self.name)
7079 
      oprot.writeFieldEnd()
1859 vikas 7080 
    if self.addedOn != None:
7081 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
7082 
      oprot.writeI64(self.addedOn)
7083 
      oprot.writeFieldEnd()
1845 vikas 7084 
    oprot.writeFieldStop()
7085 
    oprot.writeStructEnd()
7086 
 
7087 
  def __repr__(self):
7088 
    L = ['%s=%r' % (key, value)
7089 
      for key, value in self.__dict__.iteritems()]
7090 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7091 
 
7092 
  def __eq__(self, other):
7093 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7094 
 
7095 
  def __ne__(self, other):
7096 
    return not (self == other)
7097 
 
7098 
class createMasterAffiliate_result:
7099 
  """
7100 
  Attributes:
7101 
   - success
7102 
   - utx
7103 
  """
7104 
 
7105 
  thrift_spec = (
7106 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7107 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7108 
  )
7109 
 
7110 
  def __init__(self, success=None, utx=None,):
7111 
    self.success = success
7112 
    self.utx = utx
7113 
 
7114 
  def read(self, iprot):
7115 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7116 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7117 
      return
7118 
    iprot.readStructBegin()
7119 
    while True:
7120 
      (fname, ftype, fid) = iprot.readFieldBegin()
7121 
      if ftype == TType.STOP:
7122 
        break
7123 
      if fid == 0:
7124 
        if ftype == TType.STRUCT:
7125 
          self.success = MasterAffiliate()
7126 
          self.success.read(iprot)
7127 
        else:
7128 
          iprot.skip(ftype)
7129 
      elif fid == 1:
7130 
        if ftype == TType.STRUCT:
1996 vikas 7131 
          self.utx = UserAffiliateException()
1845 vikas 7132 
          self.utx.read(iprot)
7133 
        else:
7134 
          iprot.skip(ftype)
7135 
      else:
7136 
        iprot.skip(ftype)
7137 
      iprot.readFieldEnd()
7138 
    iprot.readStructEnd()
7139 
 
7140 
  def write(self, oprot):
7141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7143 
      return
7144 
    oprot.writeStructBegin('createMasterAffiliate_result')
7145 
    if self.success != None:
7146 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7147 
      self.success.write(oprot)
7148 
      oprot.writeFieldEnd()
7149 
    if self.utx != None:
7150 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7151 
      self.utx.write(oprot)
7152 
      oprot.writeFieldEnd()
7153 
    oprot.writeFieldStop()
7154 
    oprot.writeStructEnd()
7155 
 
7156 
  def __repr__(self):
7157 
    L = ['%s=%r' % (key, value)
7158 
      for key, value in self.__dict__.iteritems()]
7159 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7160 
 
7161 
  def __eq__(self, other):
7162 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7163 
 
7164 
  def __ne__(self, other):
7165 
    return not (self == other)
7166 
 
1899 vikas 7167 
class getAllMasterAffiliates_args:
7168 
 
7169 
  thrift_spec = (
7170 
  )
7171 
 
7172 
  def read(self, iprot):
7173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7175 
      return
7176 
    iprot.readStructBegin()
7177 
    while True:
7178 
      (fname, ftype, fid) = iprot.readFieldBegin()
7179 
      if ftype == TType.STOP:
7180 
        break
7181 
      else:
7182 
        iprot.skip(ftype)
7183 
      iprot.readFieldEnd()
7184 
    iprot.readStructEnd()
7185 
 
7186 
  def write(self, oprot):
7187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7189 
      return
7190 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
7191 
    oprot.writeFieldStop()
7192 
    oprot.writeStructEnd()
7193 
 
7194 
  def __repr__(self):
7195 
    L = ['%s=%r' % (key, value)
7196 
      for key, value in self.__dict__.iteritems()]
7197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7198 
 
7199 
  def __eq__(self, other):
7200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7201 
 
7202 
  def __ne__(self, other):
7203 
    return not (self == other)
7204 
 
7205 
class getAllMasterAffiliates_result:
7206 
  """
7207 
  Attributes:
7208 
   - success
7209 
   - utx
7210 
  """
7211 
 
7212 
  thrift_spec = (
7213 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 7214 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 7215 
  )
7216 
 
7217 
  def __init__(self, success=None, utx=None,):
7218 
    self.success = success
7219 
    self.utx = utx
7220 
 
7221 
  def read(self, iprot):
7222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7224 
      return
7225 
    iprot.readStructBegin()
7226 
    while True:
7227 
      (fname, ftype, fid) = iprot.readFieldBegin()
7228 
      if ftype == TType.STOP:
7229 
        break
7230 
      if fid == 0:
7231 
        if ftype == TType.LIST:
7232 
          self.success = []
1976 varun.gupt 7233 
          (_etype59, _size56) = iprot.readListBegin()
7234 
          for _i60 in xrange(_size56):
7235 
            _elem61 = MasterAffiliate()
7236 
            _elem61.read(iprot)
7237 
            self.success.append(_elem61)
1899 vikas 7238 
          iprot.readListEnd()
7239 
        else:
7240 
          iprot.skip(ftype)
7241 
      elif fid == 1:
7242 
        if ftype == TType.STRUCT:
1996 vikas 7243 
          self.utx = UserAffiliateException()
1899 vikas 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('getAllMasterAffiliates_result')
7257 
    if self.success != None:
7258 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7259 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 7260 
      for iter62 in self.success:
7261 
        iter62.write(oprot)
1899 vikas 7262 
      oprot.writeListEnd()
7263 
      oprot.writeFieldEnd()
7264 
    if self.utx != None:
7265 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7266 
      self.utx.write(oprot)
7267 
      oprot.writeFieldEnd()
7268 
    oprot.writeFieldStop()
7269 
    oprot.writeStructEnd()
7270 
 
7271 
  def __repr__(self):
7272 
    L = ['%s=%r' % (key, value)
7273 
      for key, value in self.__dict__.iteritems()]
7274 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7275 
 
7276 
  def __eq__(self, other):
7277 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7278 
 
7279 
  def __ne__(self, other):
7280 
    return not (self == other)
7281 
 
1845 vikas 7282 
class getMasterAffiliateById_args:
7283 
  """
7284 
  Attributes:
7285 
   - id
7286 
  """
7287 
 
7288 
  thrift_spec = (
7289 
    None, # 0
7290 
    (1, TType.I64, 'id', None, None, ), # 1
7291 
  )
7292 
 
7293 
  def __init__(self, id=None,):
7294 
    self.id = id
7295 
 
7296 
  def read(self, iprot):
7297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7299 
      return
7300 
    iprot.readStructBegin()
7301 
    while True:
7302 
      (fname, ftype, fid) = iprot.readFieldBegin()
7303 
      if ftype == TType.STOP:
7304 
        break
7305 
      if fid == 1:
7306 
        if ftype == TType.I64:
7307 
          self.id = iprot.readI64();
7308 
        else:
7309 
          iprot.skip(ftype)
7310 
      else:
7311 
        iprot.skip(ftype)
7312 
      iprot.readFieldEnd()
7313 
    iprot.readStructEnd()
7314 
 
7315 
  def write(self, oprot):
7316 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7317 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7318 
      return
7319 
    oprot.writeStructBegin('getMasterAffiliateById_args')
7320 
    if self.id != None:
7321 
      oprot.writeFieldBegin('id', TType.I64, 1)
7322 
      oprot.writeI64(self.id)
7323 
      oprot.writeFieldEnd()
7324 
    oprot.writeFieldStop()
7325 
    oprot.writeStructEnd()
7326 
 
7327 
  def __repr__(self):
7328 
    L = ['%s=%r' % (key, value)
7329 
      for key, value in self.__dict__.iteritems()]
7330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7331 
 
7332 
  def __eq__(self, other):
7333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7334 
 
7335 
  def __ne__(self, other):
7336 
    return not (self == other)
7337 
 
7338 
class getMasterAffiliateById_result:
7339 
  """
7340 
  Attributes:
7341 
   - success
7342 
   - utx
7343 
  """
7344 
 
7345 
  thrift_spec = (
7346 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7347 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7348 
  )
7349 
 
7350 
  def __init__(self, success=None, utx=None,):
7351 
    self.success = success
7352 
    self.utx = utx
7353 
 
7354 
  def read(self, iprot):
7355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7357 
      return
7358 
    iprot.readStructBegin()
7359 
    while True:
7360 
      (fname, ftype, fid) = iprot.readFieldBegin()
7361 
      if ftype == TType.STOP:
7362 
        break
7363 
      if fid == 0:
7364 
        if ftype == TType.STRUCT:
7365 
          self.success = MasterAffiliate()
7366 
          self.success.read(iprot)
7367 
        else:
7368 
          iprot.skip(ftype)
7369 
      elif fid == 1:
7370 
        if ftype == TType.STRUCT:
1996 vikas 7371 
          self.utx = UserAffiliateException()
1845 vikas 7372 
          self.utx.read(iprot)
7373 
        else:
7374 
          iprot.skip(ftype)
7375 
      else:
7376 
        iprot.skip(ftype)
7377 
      iprot.readFieldEnd()
7378 
    iprot.readStructEnd()
7379 
 
7380 
  def write(self, oprot):
7381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7383 
      return
7384 
    oprot.writeStructBegin('getMasterAffiliateById_result')
7385 
    if self.success != None:
7386 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7387 
      self.success.write(oprot)
7388 
      oprot.writeFieldEnd()
7389 
    if self.utx != None:
7390 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7391 
      self.utx.write(oprot)
7392 
      oprot.writeFieldEnd()
7393 
    oprot.writeFieldStop()
7394 
    oprot.writeStructEnd()
7395 
 
7396 
  def __repr__(self):
7397 
    L = ['%s=%r' % (key, value)
7398 
      for key, value in self.__dict__.iteritems()]
7399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7400 
 
7401 
  def __eq__(self, other):
7402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7403 
 
7404 
  def __ne__(self, other):
7405 
    return not (self == other)
7406 
 
7407 
class getMasterAffiliateByName_args:
7408 
  """
7409 
  Attributes:
7410 
   - name
7411 
  """
7412 
 
7413 
  thrift_spec = (
7414 
    None, # 0
7415 
    (1, TType.STRING, 'name', None, None, ), # 1
7416 
  )
7417 
 
7418 
  def __init__(self, name=None,):
7419 
    self.name = name
7420 
 
7421 
  def read(self, iprot):
7422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7424 
      return
7425 
    iprot.readStructBegin()
7426 
    while True:
7427 
      (fname, ftype, fid) = iprot.readFieldBegin()
7428 
      if ftype == TType.STOP:
7429 
        break
7430 
      if fid == 1:
7431 
        if ftype == TType.STRING:
7432 
          self.name = iprot.readString();
7433 
        else:
7434 
          iprot.skip(ftype)
7435 
      else:
7436 
        iprot.skip(ftype)
7437 
      iprot.readFieldEnd()
7438 
    iprot.readStructEnd()
7439 
 
7440 
  def write(self, oprot):
7441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7443 
      return
7444 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
7445 
    if self.name != None:
7446 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7447 
      oprot.writeString(self.name)
7448 
      oprot.writeFieldEnd()
7449 
    oprot.writeFieldStop()
7450 
    oprot.writeStructEnd()
7451 
 
7452 
  def __repr__(self):
7453 
    L = ['%s=%r' % (key, value)
7454 
      for key, value in self.__dict__.iteritems()]
7455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7456 
 
7457 
  def __eq__(self, other):
7458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7459 
 
7460 
  def __ne__(self, other):
7461 
    return not (self == other)
7462 
 
7463 
class getMasterAffiliateByName_result:
7464 
  """
7465 
  Attributes:
7466 
   - success
7467 
   - utx
7468 
  """
7469 
 
7470 
  thrift_spec = (
7471 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7472 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7473 
  )
7474 
 
7475 
  def __init__(self, success=None, utx=None,):
7476 
    self.success = success
7477 
    self.utx = utx
7478 
 
7479 
  def read(self, iprot):
7480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7482 
      return
7483 
    iprot.readStructBegin()
7484 
    while True:
7485 
      (fname, ftype, fid) = iprot.readFieldBegin()
7486 
      if ftype == TType.STOP:
7487 
        break
7488 
      if fid == 0:
7489 
        if ftype == TType.STRUCT:
7490 
          self.success = MasterAffiliate()
7491 
          self.success.read(iprot)
7492 
        else:
7493 
          iprot.skip(ftype)
7494 
      elif fid == 1:
7495 
        if ftype == TType.STRUCT:
1996 vikas 7496 
          self.utx = UserAffiliateException()
1845 vikas 7497 
          self.utx.read(iprot)
7498 
        else:
7499 
          iprot.skip(ftype)
7500 
      else:
7501 
        iprot.skip(ftype)
7502 
      iprot.readFieldEnd()
7503 
    iprot.readStructEnd()
7504 
 
7505 
  def write(self, oprot):
7506 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7507 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7508 
      return
7509 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
7510 
    if self.success != None:
7511 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7512 
      self.success.write(oprot)
7513 
      oprot.writeFieldEnd()
7514 
    if self.utx != None:
7515 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7516 
      self.utx.write(oprot)
7517 
      oprot.writeFieldEnd()
7518 
    oprot.writeFieldStop()
7519 
    oprot.writeStructEnd()
7520 
 
7521 
  def __repr__(self):
7522 
    L = ['%s=%r' % (key, value)
7523 
      for key, value in self.__dict__.iteritems()]
7524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7525 
 
7526 
  def __eq__(self, other):
7527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7528 
 
7529 
  def __ne__(self, other):
7530 
    return not (self == other)
7531 
 
7532 
class createAffiliate_args:
7533 
  """
7534 
  Attributes:
7535 
   - name
7536 
   - url
7537 
   - masterAffiliateId
1859 vikas 7538 
   - addedOn
1845 vikas 7539 
  """
7540 
 
7541 
  thrift_spec = (
7542 
    None, # 0
7543 
    (1, TType.STRING, 'name', None, None, ), # 1
7544 
    (2, TType.STRING, 'url', None, None, ), # 2
7545 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 7546 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 7547 
  )
7548 
 
1859 vikas 7549 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 7550 
    self.name = name
7551 
    self.url = url
7552 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 7553 
    self.addedOn = addedOn
1845 vikas 7554 
 
7555 
  def read(self, iprot):
7556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7558 
      return
7559 
    iprot.readStructBegin()
7560 
    while True:
7561 
      (fname, ftype, fid) = iprot.readFieldBegin()
7562 
      if ftype == TType.STOP:
7563 
        break
7564 
      if fid == 1:
7565 
        if ftype == TType.STRING:
7566 
          self.name = iprot.readString();
7567 
        else:
7568 
          iprot.skip(ftype)
7569 
      elif fid == 2:
7570 
        if ftype == TType.STRING:
7571 
          self.url = iprot.readString();
7572 
        else:
7573 
          iprot.skip(ftype)
7574 
      elif fid == 3:
7575 
        if ftype == TType.I64:
7576 
          self.masterAffiliateId = iprot.readI64();
7577 
        else:
7578 
          iprot.skip(ftype)
1859 vikas 7579 
      elif fid == 4:
7580 
        if ftype == TType.I64:
7581 
          self.addedOn = iprot.readI64();
7582 
        else:
7583 
          iprot.skip(ftype)
1845 vikas 7584 
      else:
7585 
        iprot.skip(ftype)
7586 
      iprot.readFieldEnd()
7587 
    iprot.readStructEnd()
7588 
 
7589 
  def write(self, oprot):
7590 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7591 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7592 
      return
7593 
    oprot.writeStructBegin('createAffiliate_args')
7594 
    if self.name != None:
7595 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7596 
      oprot.writeString(self.name)
7597 
      oprot.writeFieldEnd()
7598 
    if self.url != None:
7599 
      oprot.writeFieldBegin('url', TType.STRING, 2)
7600 
      oprot.writeString(self.url)
7601 
      oprot.writeFieldEnd()
7602 
    if self.masterAffiliateId != None:
7603 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
7604 
      oprot.writeI64(self.masterAffiliateId)
7605 
      oprot.writeFieldEnd()
1859 vikas 7606 
    if self.addedOn != None:
7607 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
7608 
      oprot.writeI64(self.addedOn)
7609 
      oprot.writeFieldEnd()
1845 vikas 7610 
    oprot.writeFieldStop()
7611 
    oprot.writeStructEnd()
7612 
 
7613 
  def __repr__(self):
7614 
    L = ['%s=%r' % (key, value)
7615 
      for key, value in self.__dict__.iteritems()]
7616 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7617 
 
7618 
  def __eq__(self, other):
7619 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7620 
 
7621 
  def __ne__(self, other):
7622 
    return not (self == other)
7623 
 
7624 
class createAffiliate_result:
7625 
  """
7626 
  Attributes:
7627 
   - success
7628 
   - utx
7629 
  """
7630 
 
7631 
  thrift_spec = (
7632 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 7633 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7634 
  )
7635 
 
7636 
  def __init__(self, success=None, utx=None,):
7637 
    self.success = success
7638 
    self.utx = utx
7639 
 
7640 
  def read(self, iprot):
7641 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7642 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7643 
      return
7644 
    iprot.readStructBegin()
7645 
    while True:
7646 
      (fname, ftype, fid) = iprot.readFieldBegin()
7647 
      if ftype == TType.STOP:
7648 
        break
7649 
      if fid == 0:
7650 
        if ftype == TType.STRUCT:
7651 
          self.success = Affiliate()
7652 
          self.success.read(iprot)
7653 
        else:
7654 
          iprot.skip(ftype)
7655 
      elif fid == 1:
7656 
        if ftype == TType.STRUCT:
1996 vikas 7657 
          self.utx = UserAffiliateException()
1845 vikas 7658 
          self.utx.read(iprot)
7659 
        else:
7660 
          iprot.skip(ftype)
7661 
      else:
7662 
        iprot.skip(ftype)
7663 
      iprot.readFieldEnd()
7664 
    iprot.readStructEnd()
7665 
 
7666 
  def write(self, oprot):
7667 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7668 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7669 
      return
7670 
    oprot.writeStructBegin('createAffiliate_result')
7671 
    if self.success != None:
7672 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7673 
      self.success.write(oprot)
7674 
      oprot.writeFieldEnd()
7675 
    if self.utx != None:
7676 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7677 
      self.utx.write(oprot)
7678 
      oprot.writeFieldEnd()
7679 
    oprot.writeFieldStop()
7680 
    oprot.writeStructEnd()
7681 
 
7682 
  def __repr__(self):
7683 
    L = ['%s=%r' % (key, value)
7684 
      for key, value in self.__dict__.iteritems()]
7685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7686 
 
7687 
  def __eq__(self, other):
7688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7689 
 
7690 
  def __ne__(self, other):
7691 
    return not (self == other)
7692 
 
7693 
class getAffiliateById_args:
7694 
  """
7695 
  Attributes:
7696 
   - id
7697 
  """
7698 
 
7699 
  thrift_spec = (
7700 
    None, # 0
7701 
    (1, TType.I64, 'id', None, None, ), # 1
7702 
  )
7703 
 
7704 
  def __init__(self, id=None,):
7705 
    self.id = id
7706 
 
7707 
  def read(self, iprot):
7708 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7709 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7710 
      return
7711 
    iprot.readStructBegin()
7712 
    while True:
7713 
      (fname, ftype, fid) = iprot.readFieldBegin()
7714 
      if ftype == TType.STOP:
7715 
        break
7716 
      if fid == 1:
7717 
        if ftype == TType.I64:
7718 
          self.id = iprot.readI64();
7719 
        else:
7720 
          iprot.skip(ftype)
7721 
      else:
7722 
        iprot.skip(ftype)
7723 
      iprot.readFieldEnd()
7724 
    iprot.readStructEnd()
7725 
 
7726 
  def write(self, oprot):
7727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7729 
      return
7730 
    oprot.writeStructBegin('getAffiliateById_args')
7731 
    if self.id != None:
7732 
      oprot.writeFieldBegin('id', TType.I64, 1)
7733 
      oprot.writeI64(self.id)
7734 
      oprot.writeFieldEnd()
7735 
    oprot.writeFieldStop()
7736 
    oprot.writeStructEnd()
7737 
 
7738 
  def __repr__(self):
7739 
    L = ['%s=%r' % (key, value)
7740 
      for key, value in self.__dict__.iteritems()]
7741 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7742 
 
7743 
  def __eq__(self, other):
7744 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7745 
 
7746 
  def __ne__(self, other):
7747 
    return not (self == other)
7748 
 
7749 
class getAffiliateById_result:
7750 
  """
7751 
  Attributes:
7752 
   - success
7753 
   - utx
7754 
  """
7755 
 
7756 
  thrift_spec = (
7757 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 7758 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7759 
  )
7760 
 
7761 
  def __init__(self, success=None, utx=None,):
7762 
    self.success = success
7763 
    self.utx = utx
7764 
 
7765 
  def read(self, iprot):
7766 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7767 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7768 
      return
7769 
    iprot.readStructBegin()
7770 
    while True:
7771 
      (fname, ftype, fid) = iprot.readFieldBegin()
7772 
      if ftype == TType.STOP:
7773 
        break
7774 
      if fid == 0:
7775 
        if ftype == TType.STRUCT:
7776 
          self.success = Affiliate()
7777 
          self.success.read(iprot)
7778 
        else:
7779 
          iprot.skip(ftype)
7780 
      elif fid == 1:
7781 
        if ftype == TType.STRUCT:
1996 vikas 7782 
          self.utx = UserAffiliateException()
1845 vikas 7783 
          self.utx.read(iprot)
7784 
        else:
7785 
          iprot.skip(ftype)
7786 
      else:
7787 
        iprot.skip(ftype)
7788 
      iprot.readFieldEnd()
7789 
    iprot.readStructEnd()
7790 
 
7791 
  def write(self, oprot):
7792 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7793 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7794 
      return
7795 
    oprot.writeStructBegin('getAffiliateById_result')
7796 
    if self.success != None:
7797 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7798 
      self.success.write(oprot)
7799 
      oprot.writeFieldEnd()
7800 
    if self.utx != None:
7801 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7802 
      self.utx.write(oprot)
7803 
      oprot.writeFieldEnd()
7804 
    oprot.writeFieldStop()
7805 
    oprot.writeStructEnd()
7806 
 
7807 
  def __repr__(self):
7808 
    L = ['%s=%r' % (key, value)
7809 
      for key, value in self.__dict__.iteritems()]
7810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7811 
 
7812 
  def __eq__(self, other):
7813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7814 
 
7815 
  def __ne__(self, other):
7816 
    return not (self == other)
7817 
 
7818 
class getAffiliateByName_args:
7819 
  """
7820 
  Attributes:
7821 
   - name
7822 
  """
7823 
 
7824 
  thrift_spec = (
7825 
    None, # 0
7826 
    (1, TType.STRING, 'name', None, None, ), # 1
7827 
  )
7828 
 
7829 
  def __init__(self, name=None,):
7830 
    self.name = name
7831 
 
7832 
  def read(self, iprot):
7833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7835 
      return
7836 
    iprot.readStructBegin()
7837 
    while True:
7838 
      (fname, ftype, fid) = iprot.readFieldBegin()
7839 
      if ftype == TType.STOP:
7840 
        break
7841 
      if fid == 1:
7842 
        if ftype == TType.STRING:
7843 
          self.name = iprot.readString();
7844 
        else:
7845 
          iprot.skip(ftype)
7846 
      else:
7847 
        iprot.skip(ftype)
7848 
      iprot.readFieldEnd()
7849 
    iprot.readStructEnd()
7850 
 
7851 
  def write(self, oprot):
7852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7854 
      return
7855 
    oprot.writeStructBegin('getAffiliateByName_args')
7856 
    if self.name != None:
7857 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7858 
      oprot.writeString(self.name)
7859 
      oprot.writeFieldEnd()
7860 
    oprot.writeFieldStop()
7861 
    oprot.writeStructEnd()
7862 
 
7863 
  def __repr__(self):
7864 
    L = ['%s=%r' % (key, value)
7865 
      for key, value in self.__dict__.iteritems()]
7866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7867 
 
7868 
  def __eq__(self, other):
7869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7870 
 
7871 
  def __ne__(self, other):
7872 
    return not (self == other)
7873 
 
7874 
class getAffiliateByName_result:
7875 
  """
7876 
  Attributes:
7877 
   - success
7878 
   - utx
7879 
  """
7880 
 
7881 
  thrift_spec = (
7882 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 7883 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7884 
  )
7885 
 
7886 
  def __init__(self, success=None, utx=None,):
7887 
    self.success = success
7888 
    self.utx = utx
7889 
 
7890 
  def read(self, iprot):
7891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7893 
      return
7894 
    iprot.readStructBegin()
7895 
    while True:
7896 
      (fname, ftype, fid) = iprot.readFieldBegin()
7897 
      if ftype == TType.STOP:
7898 
        break
7899 
      if fid == 0:
7900 
        if ftype == TType.STRUCT:
7901 
          self.success = Affiliate()
7902 
          self.success.read(iprot)
7903 
        else:
7904 
          iprot.skip(ftype)
7905 
      elif fid == 1:
7906 
        if ftype == TType.STRUCT:
1996 vikas 7907 
          self.utx = UserAffiliateException()
1845 vikas 7908 
          self.utx.read(iprot)
7909 
        else:
7910 
          iprot.skip(ftype)
7911 
      else:
7912 
        iprot.skip(ftype)
7913 
      iprot.readFieldEnd()
7914 
    iprot.readStructEnd()
7915 
 
7916 
  def write(self, oprot):
7917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7919 
      return
7920 
    oprot.writeStructBegin('getAffiliateByName_result')
7921 
    if self.success != None:
7922 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7923 
      self.success.write(oprot)
7924 
      oprot.writeFieldEnd()
7925 
    if self.utx != None:
7926 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7927 
      self.utx.write(oprot)
7928 
      oprot.writeFieldEnd()
7929 
    oprot.writeFieldStop()
7930 
    oprot.writeStructEnd()
7931 
 
7932 
  def __repr__(self):
7933 
    L = ['%s=%r' % (key, value)
7934 
      for key, value in self.__dict__.iteritems()]
7935 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7936 
 
7937 
  def __eq__(self, other):
7938 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7939 
 
7940 
  def __ne__(self, other):
7941 
    return not (self == other)
7942 
 
1996 vikas 7943 
class getTrackerById_args:
1845 vikas 7944 
  """
7945 
  Attributes:
7946 
   - id
7947 
  """
7948 
 
7949 
  thrift_spec = (
7950 
    None, # 0
7951 
    (1, TType.I64, 'id', None, None, ), # 1
7952 
  )
7953 
 
7954 
  def __init__(self, id=None,):
7955 
    self.id = id
7956 
 
7957 
  def read(self, iprot):
7958 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7959 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7960 
      return
7961 
    iprot.readStructBegin()
7962 
    while True:
7963 
      (fname, ftype, fid) = iprot.readFieldBegin()
7964 
      if ftype == TType.STOP:
7965 
        break
7966 
      if fid == 1:
7967 
        if ftype == TType.I64:
7968 
          self.id = iprot.readI64();
7969 
        else:
7970 
          iprot.skip(ftype)
7971 
      else:
7972 
        iprot.skip(ftype)
7973 
      iprot.readFieldEnd()
7974 
    iprot.readStructEnd()
7975 
 
7976 
  def write(self, oprot):
7977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7979 
      return
1996 vikas 7980 
    oprot.writeStructBegin('getTrackerById_args')
1845 vikas 7981 
    if self.id != None:
7982 
      oprot.writeFieldBegin('id', TType.I64, 1)
7983 
      oprot.writeI64(self.id)
7984 
      oprot.writeFieldEnd()
7985 
    oprot.writeFieldStop()
7986 
    oprot.writeStructEnd()
7987 
 
7988 
  def __repr__(self):
7989 
    L = ['%s=%r' % (key, value)
7990 
      for key, value in self.__dict__.iteritems()]
7991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7992 
 
7993 
  def __eq__(self, other):
7994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7995 
 
7996 
  def __ne__(self, other):
7997 
    return not (self == other)
7998 
 
7999 
class getTrackerById_result:
8000 
  """
8001 
  Attributes:
8002 
   - success
8003 
   - utx
8004 
  """
8005 
 
8006 
  thrift_spec = (
8007 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 8008 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8009 
  )
8010 
 
8011 
  def __init__(self, success=None, utx=None,):
8012 
    self.success = success
8013 
    self.utx = utx
8014 
 
8015 
  def read(self, iprot):
8016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8018 
      return
8019 
    iprot.readStructBegin()
8020 
    while True:
8021 
      (fname, ftype, fid) = iprot.readFieldBegin()
8022 
      if ftype == TType.STOP:
8023 
        break
8024 
      if fid == 0:
8025 
        if ftype == TType.STRUCT:
8026 
          self.success = Tracker()
8027 
          self.success.read(iprot)
8028 
        else:
8029 
          iprot.skip(ftype)
8030 
      elif fid == 1:
8031 
        if ftype == TType.STRUCT:
1996 vikas 8032 
          self.utx = UserAffiliateException()
1845 vikas 8033 
          self.utx.read(iprot)
8034 
        else:
8035 
          iprot.skip(ftype)
8036 
      else:
8037 
        iprot.skip(ftype)
8038 
      iprot.readFieldEnd()
8039 
    iprot.readStructEnd()
8040 
 
8041 
  def write(self, oprot):
8042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8044 
      return
8045 
    oprot.writeStructBegin('getTrackerById_result')
8046 
    if self.success != None:
8047 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8048 
      self.success.write(oprot)
8049 
      oprot.writeFieldEnd()
8050 
    if self.utx != None:
8051 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8052 
      self.utx.write(oprot)
8053 
      oprot.writeFieldEnd()
8054 
    oprot.writeFieldStop()
8055 
    oprot.writeStructEnd()
8056 
 
8057 
  def __repr__(self):
8058 
    L = ['%s=%r' % (key, value)
8059 
      for key, value in self.__dict__.iteritems()]
8060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8061 
 
8062 
  def __eq__(self, other):
8063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8064 
 
8065 
  def __ne__(self, other):
8066 
    return not (self == other)
8067 
 
1996 vikas 8068 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 8069 
  """
8070 
  Attributes:
1996 vikas 8071 
   - id
1845 vikas 8072 
  """
8073 
 
8074 
  thrift_spec = (
8075 
    None, # 0
1996 vikas 8076 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 8077 
  )
8078 
 
1996 vikas 8079 
  def __init__(self, id=None,):
8080 
    self.id = id
1845 vikas 8081 
 
8082 
  def read(self, iprot):
8083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8085 
      return
8086 
    iprot.readStructBegin()
8087 
    while True:
8088 
      (fname, ftype, fid) = iprot.readFieldBegin()
8089 
      if ftype == TType.STOP:
8090 
        break
8091 
      if fid == 1:
8092 
        if ftype == TType.I64:
1996 vikas 8093 
          self.id = iprot.readI64();
1845 vikas 8094 
        else:
8095 
          iprot.skip(ftype)
8096 
      else:
8097 
        iprot.skip(ftype)
8098 
      iprot.readFieldEnd()
8099 
    iprot.readStructEnd()
8100 
 
8101 
  def write(self, oprot):
8102 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8103 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8104 
      return
1996 vikas 8105 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
8106 
    if self.id != None:
8107 
      oprot.writeFieldBegin('id', TType.I64, 1)
8108 
      oprot.writeI64(self.id)
1845 vikas 8109 
      oprot.writeFieldEnd()
8110 
    oprot.writeFieldStop()
8111 
    oprot.writeStructEnd()
8112 
 
8113 
  def __repr__(self):
8114 
    L = ['%s=%r' % (key, value)
8115 
      for key, value in self.__dict__.iteritems()]
8116 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8117 
 
8118 
  def __eq__(self, other):
8119 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8120 
 
8121 
  def __ne__(self, other):
8122 
    return not (self == other)
8123 
 
1996 vikas 8124 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 8125 
  """
8126 
  Attributes:
8127 
   - success
8128 
   - utx
8129 
  """
8130 
 
8131 
  thrift_spec = (
1996 vikas 8132 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
8133 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8134 
  )
8135 
 
8136 
  def __init__(self, success=None, utx=None,):
8137 
    self.success = success
8138 
    self.utx = utx
8139 
 
8140 
  def read(self, iprot):
8141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8143 
      return
8144 
    iprot.readStructBegin()
8145 
    while True:
8146 
      (fname, ftype, fid) = iprot.readFieldBegin()
8147 
      if ftype == TType.STOP:
8148 
        break
8149 
      if fid == 0:
8150 
        if ftype == TType.LIST:
8151 
          self.success = []
1996 vikas 8152 
          (_etype66, _size63) = iprot.readListBegin()
8153 
          for _i67 in xrange(_size63):
8154 
            _elem68 = Affiliate()
8155 
            _elem68.read(iprot)
8156 
            self.success.append(_elem68)
1845 vikas 8157 
          iprot.readListEnd()
8158 
        else:
8159 
          iprot.skip(ftype)
8160 
      elif fid == 1:
8161 
        if ftype == TType.STRUCT:
1996 vikas 8162 
          self.utx = UserAffiliateException()
1845 vikas 8163 
          self.utx.read(iprot)
8164 
        else:
8165 
          iprot.skip(ftype)
8166 
      else:
8167 
        iprot.skip(ftype)
8168 
      iprot.readFieldEnd()
8169 
    iprot.readStructEnd()
8170 
 
8171 
  def write(self, oprot):
8172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8174 
      return
1996 vikas 8175 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
1845 vikas 8176 
    if self.success != None:
8177 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8178 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 8179 
      for iter69 in self.success:
8180 
        iter69.write(oprot)
1845 vikas 8181 
      oprot.writeListEnd()
8182 
      oprot.writeFieldEnd()
8183 
    if self.utx != None:
8184 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8185 
      self.utx.write(oprot)
8186 
      oprot.writeFieldEnd()
8187 
    oprot.writeFieldStop()
8188 
    oprot.writeStructEnd()
8189 
 
8190 
  def __repr__(self):
8191 
    L = ['%s=%r' % (key, value)
8192 
      for key, value in self.__dict__.iteritems()]
8193 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8194 
 
8195 
  def __eq__(self, other):
8196 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8197 
 
8198 
  def __ne__(self, other):
8199 
    return not (self == other)
8200 
 
8201 
class addTrackLog_args:
8202 
  """
8203 
  Attributes:
1996 vikas 8204 
   - affiliateId
1845 vikas 8205 
   - userId
8206 
   - event
8207 
   - url
8208 
   - data
1859 vikas 8209 
   - addedOn
1845 vikas 8210 
  """
8211 
 
8212 
  thrift_spec = (
8213 
    None, # 0
1996 vikas 8214 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 8215 
    (2, TType.I64, 'userId', None, None, ), # 2
8216 
    (3, TType.STRING, 'event', None, None, ), # 3
8217 
    (4, TType.STRING, 'url', None, None, ), # 4
8218 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 8219 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 8220 
  )
8221 
 
1996 vikas 8222 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
8223 
    self.affiliateId = affiliateId
1845 vikas 8224 
    self.userId = userId
8225 
    self.event = event
8226 
    self.url = url
8227 
    self.data = data
1859 vikas 8228 
    self.addedOn = addedOn
1845 vikas 8229 
 
8230 
  def read(self, iprot):
8231 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8232 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8233 
      return
8234 
    iprot.readStructBegin()
8235 
    while True:
8236 
      (fname, ftype, fid) = iprot.readFieldBegin()
8237 
      if ftype == TType.STOP:
8238 
        break
8239 
      if fid == 1:
8240 
        if ftype == TType.I64:
1996 vikas 8241 
          self.affiliateId = iprot.readI64();
1845 vikas 8242 
        else:
8243 
          iprot.skip(ftype)
8244 
      elif fid == 2:
8245 
        if ftype == TType.I64:
8246 
          self.userId = iprot.readI64();
8247 
        else:
8248 
          iprot.skip(ftype)
8249 
      elif fid == 3:
8250 
        if ftype == TType.STRING:
8251 
          self.event = iprot.readString();
8252 
        else:
8253 
          iprot.skip(ftype)
8254 
      elif fid == 4:
8255 
        if ftype == TType.STRING:
8256 
          self.url = iprot.readString();
8257 
        else:
8258 
          iprot.skip(ftype)
8259 
      elif fid == 5:
8260 
        if ftype == TType.STRING:
8261 
          self.data = iprot.readString();
8262 
        else:
8263 
          iprot.skip(ftype)
1859 vikas 8264 
      elif fid == 6:
8265 
        if ftype == TType.I64:
8266 
          self.addedOn = iprot.readI64();
8267 
        else:
8268 
          iprot.skip(ftype)
1845 vikas 8269 
      else:
8270 
        iprot.skip(ftype)
8271 
      iprot.readFieldEnd()
8272 
    iprot.readStructEnd()
8273 
 
8274 
  def write(self, oprot):
8275 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8276 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8277 
      return
8278 
    oprot.writeStructBegin('addTrackLog_args')
1996 vikas 8279 
    if self.affiliateId != None:
8280 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
8281 
      oprot.writeI64(self.affiliateId)
1845 vikas 8282 
      oprot.writeFieldEnd()
8283 
    if self.userId != None:
8284 
      oprot.writeFieldBegin('userId', TType.I64, 2)
8285 
      oprot.writeI64(self.userId)
8286 
      oprot.writeFieldEnd()
8287 
    if self.event != None:
8288 
      oprot.writeFieldBegin('event', TType.STRING, 3)
8289 
      oprot.writeString(self.event)
8290 
      oprot.writeFieldEnd()
8291 
    if self.url != None:
8292 
      oprot.writeFieldBegin('url', TType.STRING, 4)
8293 
      oprot.writeString(self.url)
8294 
      oprot.writeFieldEnd()
8295 
    if self.data != None:
8296 
      oprot.writeFieldBegin('data', TType.STRING, 5)
8297 
      oprot.writeString(self.data)
8298 
      oprot.writeFieldEnd()
1859 vikas 8299 
    if self.addedOn != None:
8300 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
8301 
      oprot.writeI64(self.addedOn)
8302 
      oprot.writeFieldEnd()
1845 vikas 8303 
    oprot.writeFieldStop()
8304 
    oprot.writeStructEnd()
8305 
 
8306 
  def __repr__(self):
8307 
    L = ['%s=%r' % (key, value)
8308 
      for key, value in self.__dict__.iteritems()]
8309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8310 
 
8311 
  def __eq__(self, other):
8312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8313 
 
8314 
  def __ne__(self, other):
8315 
    return not (self == other)
8316 
 
8317 
class addTrackLog_result:
8318 
  """
8319 
  Attributes:
8320 
   - success
8321 
   - utx
8322 
  """
8323 
 
8324 
  thrift_spec = (
8325 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 8326 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8327 
  )
8328 
 
8329 
  def __init__(self, success=None, utx=None,):
8330 
    self.success = success
8331 
    self.utx = utx
8332 
 
8333 
  def read(self, iprot):
8334 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8335 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8336 
      return
8337 
    iprot.readStructBegin()
8338 
    while True:
8339 
      (fname, ftype, fid) = iprot.readFieldBegin()
8340 
      if ftype == TType.STOP:
8341 
        break
8342 
      if fid == 0:
8343 
        if ftype == TType.I64:
8344 
          self.success = iprot.readI64();
8345 
        else:
8346 
          iprot.skip(ftype)
8347 
      elif fid == 1:
8348 
        if ftype == TType.STRUCT:
1996 vikas 8349 
          self.utx = UserAffiliateException()
1845 vikas 8350 
          self.utx.read(iprot)
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('addTrackLog_result')
8363 
    if self.success != None:
8364 
      oprot.writeFieldBegin('success', TType.I64, 0)
8365 
      oprot.writeI64(self.success)
8366 
      oprot.writeFieldEnd()
8367 
    if self.utx != None:
8368 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8369 
      self.utx.write(oprot)
8370 
      oprot.writeFieldEnd()
8371 
    oprot.writeFieldStop()
8372 
    oprot.writeStructEnd()
8373 
 
8374 
  def __repr__(self):
8375 
    L = ['%s=%r' % (key, value)
8376 
      for key, value in self.__dict__.iteritems()]
8377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8378 
 
8379 
  def __eq__(self, other):
8380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8381 
 
8382 
  def __ne__(self, other):
8383 
    return not (self == other)
8384 
 
8385 
class getTrackLogById_args:
8386 
  """
8387 
  Attributes:
8388 
   - id
8389 
  """
8390 
 
8391 
  thrift_spec = (
8392 
    None, # 0
8393 
    (1, TType.I64, 'id', None, None, ), # 1
8394 
  )
8395 
 
8396 
  def __init__(self, id=None,):
8397 
    self.id = id
8398 
 
8399 
  def read(self, iprot):
8400 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8401 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8402 
      return
8403 
    iprot.readStructBegin()
8404 
    while True:
8405 
      (fname, ftype, fid) = iprot.readFieldBegin()
8406 
      if ftype == TType.STOP:
8407 
        break
8408 
      if fid == 1:
8409 
        if ftype == TType.I64:
8410 
          self.id = iprot.readI64();
8411 
        else:
8412 
          iprot.skip(ftype)
8413 
      else:
8414 
        iprot.skip(ftype)
8415 
      iprot.readFieldEnd()
8416 
    iprot.readStructEnd()
8417 
 
8418 
  def write(self, oprot):
8419 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8420 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8421 
      return
8422 
    oprot.writeStructBegin('getTrackLogById_args')
8423 
    if self.id != None:
8424 
      oprot.writeFieldBegin('id', TType.I64, 1)
8425 
      oprot.writeI64(self.id)
8426 
      oprot.writeFieldEnd()
8427 
    oprot.writeFieldStop()
8428 
    oprot.writeStructEnd()
8429 
 
8430 
  def __repr__(self):
8431 
    L = ['%s=%r' % (key, value)
8432 
      for key, value in self.__dict__.iteritems()]
8433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8434 
 
8435 
  def __eq__(self, other):
8436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8437 
 
8438 
  def __ne__(self, other):
8439 
    return not (self == other)
8440 
 
8441 
class getTrackLogById_result:
8442 
  """
8443 
  Attributes:
8444 
   - success
8445 
   - utx
8446 
  """
8447 
 
8448 
  thrift_spec = (
8449 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 8450 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8451 
  )
8452 
 
8453 
  def __init__(self, success=None, utx=None,):
8454 
    self.success = success
8455 
    self.utx = utx
8456 
 
8457 
  def read(self, iprot):
8458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8460 
      return
8461 
    iprot.readStructBegin()
8462 
    while True:
8463 
      (fname, ftype, fid) = iprot.readFieldBegin()
8464 
      if ftype == TType.STOP:
8465 
        break
8466 
      if fid == 0:
8467 
        if ftype == TType.STRUCT:
8468 
          self.success = TrackLog()
8469 
          self.success.read(iprot)
8470 
        else:
8471 
          iprot.skip(ftype)
8472 
      elif fid == 1:
8473 
        if ftype == TType.STRUCT:
1996 vikas 8474 
          self.utx = UserAffiliateException()
1845 vikas 8475 
          self.utx.read(iprot)
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('getTrackLogById_result')
8488 
    if self.success != None:
8489 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8490 
      self.success.write(oprot)
8491 
      oprot.writeFieldEnd()
8492 
    if self.utx != None:
8493 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8494 
      self.utx.write(oprot)
8495 
      oprot.writeFieldEnd()
8496 
    oprot.writeFieldStop()
8497 
    oprot.writeStructEnd()
8498 
 
8499 
  def __repr__(self):
8500 
    L = ['%s=%r' % (key, value)
8501 
      for key, value in self.__dict__.iteritems()]
8502 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8503 
 
8504 
  def __eq__(self, other):
8505 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8506 
 
8507 
  def __ne__(self, other):
8508 
    return not (self == other)
8509 
 
1996 vikas 8510 
class getTrackLogsByAffiliate_args:
1845 vikas 8511 
  """
8512 
  Attributes:
1996 vikas 8513 
   - affiliateId
1845 vikas 8514 
  """
8515 
 
8516 
  thrift_spec = (
8517 
    None, # 0
1996 vikas 8518 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 8519 
  )
8520 
 
1996 vikas 8521 
  def __init__(self, affiliateId=None,):
8522 
    self.affiliateId = affiliateId
1845 vikas 8523 
 
8524 
  def read(self, iprot):
8525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8527 
      return
8528 
    iprot.readStructBegin()
8529 
    while True:
8530 
      (fname, ftype, fid) = iprot.readFieldBegin()
8531 
      if ftype == TType.STOP:
8532 
        break
8533 
      if fid == 1:
8534 
        if ftype == TType.I64:
1996 vikas 8535 
          self.affiliateId = iprot.readI64();
1845 vikas 8536 
        else:
8537 
          iprot.skip(ftype)
8538 
      else:
8539 
        iprot.skip(ftype)
8540 
      iprot.readFieldEnd()
8541 
    iprot.readStructEnd()
8542 
 
8543 
  def write(self, oprot):
8544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8546 
      return
1996 vikas 8547 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
8548 
    if self.affiliateId != None:
8549 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
8550 
      oprot.writeI64(self.affiliateId)
1845 vikas 8551 
      oprot.writeFieldEnd()
8552 
    oprot.writeFieldStop()
8553 
    oprot.writeStructEnd()
8554 
 
8555 
  def __repr__(self):
8556 
    L = ['%s=%r' % (key, value)
8557 
      for key, value in self.__dict__.iteritems()]
8558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8559 
 
8560 
  def __eq__(self, other):
8561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8562 
 
8563 
  def __ne__(self, other):
8564 
    return not (self == other)
8565 
 
1996 vikas 8566 
class getTrackLogsByAffiliate_result:
1845 vikas 8567 
  """
8568 
  Attributes:
8569 
   - success
8570 
   - utx
8571 
  """
8572 
 
8573 
  thrift_spec = (
8574 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 8575 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8576 
  )
8577 
 
8578 
  def __init__(self, success=None, utx=None,):
8579 
    self.success = success
8580 
    self.utx = utx
8581 
 
8582 
  def read(self, iprot):
8583 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8584 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8585 
      return
8586 
    iprot.readStructBegin()
8587 
    while True:
8588 
      (fname, ftype, fid) = iprot.readFieldBegin()
8589 
      if ftype == TType.STOP:
8590 
        break
8591 
      if fid == 0:
8592 
        if ftype == TType.LIST:
8593 
          self.success = []
1996 vikas 8594 
          (_etype73, _size70) = iprot.readListBegin()
8595 
          for _i74 in xrange(_size70):
8596 
            _elem75 = TrackLog()
8597 
            _elem75.read(iprot)
8598 
            self.success.append(_elem75)
1845 vikas 8599 
          iprot.readListEnd()
8600 
        else:
8601 
          iprot.skip(ftype)
8602 
      elif fid == 1:
8603 
        if ftype == TType.STRUCT:
1996 vikas 8604 
          self.utx = UserAffiliateException()
1845 vikas 8605 
          self.utx.read(iprot)
8606 
        else:
8607 
          iprot.skip(ftype)
8608 
      else:
8609 
        iprot.skip(ftype)
8610 
      iprot.readFieldEnd()
8611 
    iprot.readStructEnd()
8612 
 
8613 
  def write(self, oprot):
8614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8616 
      return
1996 vikas 8617 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
1845 vikas 8618 
    if self.success != None:
8619 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8620 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 8621 
      for iter76 in self.success:
8622 
        iter76.write(oprot)
1845 vikas 8623 
      oprot.writeListEnd()
8624 
      oprot.writeFieldEnd()
8625 
    if self.utx != None:
8626 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8627 
      self.utx.write(oprot)
8628 
      oprot.writeFieldEnd()
8629 
    oprot.writeFieldStop()
8630 
    oprot.writeStructEnd()
8631 
 
8632 
  def __repr__(self):
8633 
    L = ['%s=%r' % (key, value)
8634 
      for key, value in self.__dict__.iteritems()]
8635 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8636 
 
8637 
  def __eq__(self, other):
8638 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8639 
 
8640 
  def __ne__(self, other):
8641 
    return not (self == other)
8642 
 
8643 
class getTrackLogsByUser_args:
8644 
  """
8645 
  Attributes:
8646 
   - userId
8647 
  """
8648 
 
8649 
  thrift_spec = (
8650 
    None, # 0
8651 
    (1, TType.I64, 'userId', None, None, ), # 1
8652 
  )
8653 
 
8654 
  def __init__(self, userId=None,):
8655 
    self.userId = userId
8656 
 
8657 
  def read(self, iprot):
8658 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8659 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8660 
      return
8661 
    iprot.readStructBegin()
8662 
    while True:
8663 
      (fname, ftype, fid) = iprot.readFieldBegin()
8664 
      if ftype == TType.STOP:
8665 
        break
8666 
      if fid == 1:
8667 
        if ftype == TType.I64:
8668 
          self.userId = iprot.readI64();
8669 
        else:
8670 
          iprot.skip(ftype)
8671 
      else:
8672 
        iprot.skip(ftype)
8673 
      iprot.readFieldEnd()
8674 
    iprot.readStructEnd()
8675 
 
8676 
  def write(self, oprot):
8677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8679 
      return
8680 
    oprot.writeStructBegin('getTrackLogsByUser_args')
8681 
    if self.userId != None:
8682 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8683 
      oprot.writeI64(self.userId)
8684 
      oprot.writeFieldEnd()
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 getTrackLogsByUser_result:
8700 
  """
8701 
  Attributes:
8702 
   - success
8703 
   - utx
8704 
  """
8705 
 
8706 
  thrift_spec = (
8707 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 8708 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 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.LIST:
8726 
          self.success = []
1996 vikas 8727 
          (_etype80, _size77) = iprot.readListBegin()
8728 
          for _i81 in xrange(_size77):
8729 
            _elem82 = TrackLog()
8730 
            _elem82.read(iprot)
8731 
            self.success.append(_elem82)
1845 vikas 8732 
          iprot.readListEnd()
8733 
        else:
8734 
          iprot.skip(ftype)
8735 
      elif fid == 1:
8736 
        if ftype == TType.STRUCT:
1996 vikas 8737 
          self.utx = UserAffiliateException()
1845 vikas 8738 
          self.utx.read(iprot)
8739 
        else:
8740 
          iprot.skip(ftype)
8741 
      else:
8742 
        iprot.skip(ftype)
8743 
      iprot.readFieldEnd()
8744 
    iprot.readStructEnd()
8745 
 
8746 
  def write(self, oprot):
8747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8749 
      return
8750 
    oprot.writeStructBegin('getTrackLogsByUser_result')
8751 
    if self.success != None:
8752 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8753 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 8754 
      for iter83 in self.success:
8755 
        iter83.write(oprot)
1845 vikas 8756 
      oprot.writeListEnd()
8757 
      oprot.writeFieldEnd()
8758 
    if self.utx != None:
8759 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8760 
      self.utx.write(oprot)
8761 
      oprot.writeFieldEnd()
8762 
    oprot.writeFieldStop()
8763 
    oprot.writeStructEnd()
8764 
 
8765 
  def __repr__(self):
8766 
    L = ['%s=%r' % (key, value)
8767 
      for key, value in self.__dict__.iteritems()]
8768 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8769 
 
8770 
  def __eq__(self, other):
8771 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8772 
 
8773 
  def __ne__(self, other):
8774 
    return not (self == other)
8775 
 
8776 
class getTrackLogs_args:
8777 
  """
8778 
  Attributes:
8779 
   - userId
8780 
   - event
8781 
   - url
8782 
  """
8783 
 
8784 
  thrift_spec = (
8785 
    None, # 0
1996 vikas 8786 
    (1, TType.I64, 'userId', None, None, ), # 1
8787 
    (2, TType.STRING, 'event', None, None, ), # 2
8788 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 8789 
  )
8790 
 
1996 vikas 8791 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 8792 
    self.userId = userId
8793 
    self.event = event
8794 
    self.url = url
8795 
 
8796 
  def read(self, iprot):
8797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8799 
      return
8800 
    iprot.readStructBegin()
8801 
    while True:
8802 
      (fname, ftype, fid) = iprot.readFieldBegin()
8803 
      if ftype == TType.STOP:
8804 
        break
8805 
      if fid == 1:
8806 
        if ftype == TType.I64:
1996 vikas 8807 
          self.userId = iprot.readI64();
1845 vikas 8808 
        else:
8809 
          iprot.skip(ftype)
8810 
      elif fid == 2:
8811 
        if ftype == TType.STRING:
8812 
          self.event = iprot.readString();
8813 
        else:
8814 
          iprot.skip(ftype)
1996 vikas 8815 
      elif fid == 3:
1845 vikas 8816 
        if ftype == TType.STRING:
8817 
          self.url = iprot.readString();
8818 
        else:
8819 
          iprot.skip(ftype)
8820 
      else:
8821 
        iprot.skip(ftype)
8822 
      iprot.readFieldEnd()
8823 
    iprot.readStructEnd()
8824 
 
8825 
  def write(self, oprot):
8826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8828 
      return
8829 
    oprot.writeStructBegin('getTrackLogs_args')
8830 
    if self.userId != None:
1996 vikas 8831 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 8832 
      oprot.writeI64(self.userId)
8833 
      oprot.writeFieldEnd()
8834 
    if self.event != None:
1996 vikas 8835 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 8836 
      oprot.writeString(self.event)
8837 
      oprot.writeFieldEnd()
8838 
    if self.url != None:
1996 vikas 8839 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 8840 
      oprot.writeString(self.url)
8841 
      oprot.writeFieldEnd()
8842 
    oprot.writeFieldStop()
8843 
    oprot.writeStructEnd()
8844 
 
8845 
  def __repr__(self):
8846 
    L = ['%s=%r' % (key, value)
8847 
      for key, value in self.__dict__.iteritems()]
8848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8849 
 
8850 
  def __eq__(self, other):
8851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8852 
 
8853 
  def __ne__(self, other):
8854 
    return not (self == other)
8855 
 
8856 
class getTrackLogs_result:
8857 
  """
8858 
  Attributes:
8859 
   - success
8860 
   - utx
8861 
  """
8862 
 
8863 
  thrift_spec = (
8864 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 8865 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8866 
  )
8867 
 
8868 
  def __init__(self, success=None, utx=None,):
8869 
    self.success = success
8870 
    self.utx = utx
8871 
 
8872 
  def read(self, iprot):
8873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8875 
      return
8876 
    iprot.readStructBegin()
8877 
    while True:
8878 
      (fname, ftype, fid) = iprot.readFieldBegin()
8879 
      if ftype == TType.STOP:
8880 
        break
8881 
      if fid == 0:
8882 
        if ftype == TType.LIST:
8883 
          self.success = []
1996 vikas 8884 
          (_etype87, _size84) = iprot.readListBegin()
8885 
          for _i88 in xrange(_size84):
8886 
            _elem89 = TrackLog()
8887 
            _elem89.read(iprot)
8888 
            self.success.append(_elem89)
1845 vikas 8889 
          iprot.readListEnd()
8890 
        else:
8891 
          iprot.skip(ftype)
8892 
      elif fid == 1:
8893 
        if ftype == TType.STRUCT:
1996 vikas 8894 
          self.utx = UserAffiliateException()
1845 vikas 8895 
          self.utx.read(iprot)
8896 
        else:
8897 
          iprot.skip(ftype)
8898 
      else:
8899 
        iprot.skip(ftype)
8900 
      iprot.readFieldEnd()
8901 
    iprot.readStructEnd()
8902 
 
8903 
  def write(self, oprot):
8904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8906 
      return
8907 
    oprot.writeStructBegin('getTrackLogs_result')
8908 
    if self.success != None:
8909 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8910 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 8911 
      for iter90 in self.success:
8912 
        iter90.write(oprot)
1845 vikas 8913 
      oprot.writeListEnd()
8914 
      oprot.writeFieldEnd()
8915 
    if self.utx != None:
8916 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8917 
      self.utx.write(oprot)
8918 
      oprot.writeFieldEnd()
8919 
    oprot.writeFieldStop()
8920 
    oprot.writeStructEnd()
8921 
 
8922 
  def __repr__(self):
8923 
    L = ['%s=%r' % (key, value)
8924 
      for key, value in self.__dict__.iteritems()]
8925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8926 
 
8927 
  def __eq__(self, other):
8928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8929 
 
8930 
  def __ne__(self, other):
8931 
    return not (self == other)
8932 
 
559 chandransh 8933 
class createCart_args:
94 ashish 8934 
  """
8935 
  Attributes:
559 chandransh 8936 
   - userId
94 ashish 8937 
  """
8938 
 
8939 
  thrift_spec = (
8940 
    None, # 0
559 chandransh 8941 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 8942 
  )
8943 
 
559 chandransh 8944 
  def __init__(self, userId=None,):
8945 
    self.userId = userId
94 ashish 8946 
 
8947 
  def read(self, iprot):
8948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8950 
      return
8951 
    iprot.readStructBegin()
8952 
    while True:
8953 
      (fname, ftype, fid) = iprot.readFieldBegin()
8954 
      if ftype == TType.STOP:
8955 
        break
8956 
      if fid == 1:
8957 
        if ftype == TType.I64:
559 chandransh 8958 
          self.userId = iprot.readI64();
94 ashish 8959 
        else:
8960 
          iprot.skip(ftype)
559 chandransh 8961 
      else:
8962 
        iprot.skip(ftype)
8963 
      iprot.readFieldEnd()
8964 
    iprot.readStructEnd()
8965 
 
8966 
  def write(self, oprot):
8967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8969 
      return
8970 
    oprot.writeStructBegin('createCart_args')
8971 
    if self.userId != None:
8972 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8973 
      oprot.writeI64(self.userId)
8974 
      oprot.writeFieldEnd()
8975 
    oprot.writeFieldStop()
8976 
    oprot.writeStructEnd()
8977 
 
8978 
  def __repr__(self):
8979 
    L = ['%s=%r' % (key, value)
8980 
      for key, value in self.__dict__.iteritems()]
8981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8982 
 
8983 
  def __eq__(self, other):
8984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8985 
 
8986 
  def __ne__(self, other):
8987 
    return not (self == other)
8988 
 
8989 
class createCart_result:
8990 
  """
8991 
  Attributes:
8992 
   - success
8993 
   - scx
8994 
  """
8995 
 
8996 
  thrift_spec = (
8997 
    (0, TType.I64, 'success', None, None, ), # 0
8998 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
8999 
  )
9000 
 
9001 
  def __init__(self, success=None, scx=None,):
9002 
    self.success = success
9003 
    self.scx = scx
9004 
 
9005 
  def read(self, iprot):
9006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9008 
      return
9009 
    iprot.readStructBegin()
9010 
    while True:
9011 
      (fname, ftype, fid) = iprot.readFieldBegin()
9012 
      if ftype == TType.STOP:
9013 
        break
9014 
      if fid == 0:
94 ashish 9015 
        if ftype == TType.I64:
559 chandransh 9016 
          self.success = iprot.readI64();
94 ashish 9017 
        else:
9018 
          iprot.skip(ftype)
559 chandransh 9019 
      elif fid == 1:
9020 
        if ftype == TType.STRUCT:
9021 
          self.scx = ShoppingCartException()
9022 
          self.scx.read(iprot)
9023 
        else:
9024 
          iprot.skip(ftype)
94 ashish 9025 
      else:
9026 
        iprot.skip(ftype)
9027 
      iprot.readFieldEnd()
9028 
    iprot.readStructEnd()
9029 
 
9030 
  def write(self, oprot):
9031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9033 
      return
559 chandransh 9034 
    oprot.writeStructBegin('createCart_result')
9035 
    if self.success != None:
9036 
      oprot.writeFieldBegin('success', TType.I64, 0)
9037 
      oprot.writeI64(self.success)
94 ashish 9038 
      oprot.writeFieldEnd()
559 chandransh 9039 
    if self.scx != None:
9040 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9041 
      self.scx.write(oprot)
94 ashish 9042 
      oprot.writeFieldEnd()
9043 
    oprot.writeFieldStop()
9044 
    oprot.writeStructEnd()
9045 
 
9046 
  def __repr__(self):
9047 
    L = ['%s=%r' % (key, value)
9048 
      for key, value in self.__dict__.iteritems()]
9049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9050 
 
9051 
  def __eq__(self, other):
9052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9053 
 
9054 
  def __ne__(self, other):
9055 
    return not (self == other)
9056 
 
559 chandransh 9057 
class getCurrentCart_args:
94 ashish 9058 
  """
9059 
  Attributes:
559 chandransh 9060 
   - userId
9061 
  """
9062 
 
9063 
  thrift_spec = (
9064 
    None, # 0
9065 
    (1, TType.I64, 'userId', None, None, ), # 1
9066 
  )
9067 
 
9068 
  def __init__(self, userId=None,):
9069 
    self.userId = userId
9070 
 
9071 
  def read(self, iprot):
9072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9074 
      return
9075 
    iprot.readStructBegin()
9076 
    while True:
9077 
      (fname, ftype, fid) = iprot.readFieldBegin()
9078 
      if ftype == TType.STOP:
9079 
        break
9080 
      if fid == 1:
9081 
        if ftype == TType.I64:
9082 
          self.userId = iprot.readI64();
9083 
        else:
9084 
          iprot.skip(ftype)
9085 
      else:
9086 
        iprot.skip(ftype)
9087 
      iprot.readFieldEnd()
9088 
    iprot.readStructEnd()
9089 
 
9090 
  def write(self, oprot):
9091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9093 
      return
9094 
    oprot.writeStructBegin('getCurrentCart_args')
9095 
    if self.userId != None:
9096 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9097 
      oprot.writeI64(self.userId)
9098 
      oprot.writeFieldEnd()
9099 
    oprot.writeFieldStop()
9100 
    oprot.writeStructEnd()
9101 
 
9102 
  def __repr__(self):
9103 
    L = ['%s=%r' % (key, value)
9104 
      for key, value in self.__dict__.iteritems()]
9105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9106 
 
9107 
  def __eq__(self, other):
9108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9109 
 
9110 
  def __ne__(self, other):
9111 
    return not (self == other)
9112 
 
9113 
class getCurrentCart_result:
9114 
  """
9115 
  Attributes:
94 ashish 9116 
   - success
559 chandransh 9117 
   - scx
94 ashish 9118 
  """
9119 
 
9120 
  thrift_spec = (
559 chandransh 9121 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9122 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9123 
  )
9124 
 
559 chandransh 9125 
  def __init__(self, success=None, scx=None,):
94 ashish 9126 
    self.success = success
559 chandransh 9127 
    self.scx = scx
94 ashish 9128 
 
9129 
  def read(self, iprot):
9130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9132 
      return
9133 
    iprot.readStructBegin()
9134 
    while True:
9135 
      (fname, ftype, fid) = iprot.readFieldBegin()
9136 
      if ftype == TType.STOP:
9137 
        break
9138 
      if fid == 0:
559 chandransh 9139 
        if ftype == TType.STRUCT:
9140 
          self.success = Cart()
9141 
          self.success.read(iprot)
94 ashish 9142 
        else:
9143 
          iprot.skip(ftype)
9144 
      elif fid == 1:
9145 
        if ftype == TType.STRUCT:
559 chandransh 9146 
          self.scx = ShoppingCartException()
9147 
          self.scx.read(iprot)
94 ashish 9148 
        else:
9149 
          iprot.skip(ftype)
9150 
      else:
9151 
        iprot.skip(ftype)
9152 
      iprot.readFieldEnd()
9153 
    iprot.readStructEnd()
9154 
 
9155 
  def write(self, oprot):
9156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9158 
      return
559 chandransh 9159 
    oprot.writeStructBegin('getCurrentCart_result')
94 ashish 9160 
    if self.success != None:
559 chandransh 9161 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9162 
      self.success.write(oprot)
94 ashish 9163 
      oprot.writeFieldEnd()
559 chandransh 9164 
    if self.scx != None:
9165 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9166 
      self.scx.write(oprot)
94 ashish 9167 
      oprot.writeFieldEnd()
9168 
    oprot.writeFieldStop()
9169 
    oprot.writeStructEnd()
9170 
 
9171 
  def __repr__(self):
9172 
    L = ['%s=%r' % (key, value)
9173 
      for key, value in self.__dict__.iteritems()]
9174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9175 
 
9176 
  def __eq__(self, other):
9177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9178 
 
9179 
  def __ne__(self, other):
9180 
    return not (self == other)
9181 
 
559 chandransh 9182 
class getCart_args:
504 rajveer 9183 
  """
9184 
  Attributes:
559 chandransh 9185 
   - cartId
504 rajveer 9186 
  """
9187 
 
9188 
  thrift_spec = (
9189 
    None, # 0
559 chandransh 9190 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 9191 
  )
9192 
 
559 chandransh 9193 
  def __init__(self, cartId=None,):
9194 
    self.cartId = cartId
504 rajveer 9195 
 
9196 
  def read(self, iprot):
9197 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9198 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9199 
      return
9200 
    iprot.readStructBegin()
9201 
    while True:
9202 
      (fname, ftype, fid) = iprot.readFieldBegin()
9203 
      if ftype == TType.STOP:
9204 
        break
9205 
      if fid == 1:
9206 
        if ftype == TType.I64:
559 chandransh 9207 
          self.cartId = iprot.readI64();
504 rajveer 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
559 chandransh 9219 
    oprot.writeStructBegin('getCart_args')
9220 
    if self.cartId != None:
9221 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9222 
      oprot.writeI64(self.cartId)
504 rajveer 9223 
      oprot.writeFieldEnd()
9224 
    oprot.writeFieldStop()
9225 
    oprot.writeStructEnd()
9226 
 
9227 
  def __repr__(self):
9228 
    L = ['%s=%r' % (key, value)
9229 
      for key, value in self.__dict__.iteritems()]
9230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9231 
 
9232 
  def __eq__(self, other):
9233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9234 
 
9235 
  def __ne__(self, other):
9236 
    return not (self == other)
9237 
 
559 chandransh 9238 
class getCart_result:
504 rajveer 9239 
  """
9240 
  Attributes:
9241 
   - success
559 chandransh 9242 
   - scx
504 rajveer 9243 
  """
9244 
 
9245 
  thrift_spec = (
559 chandransh 9246 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9247 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 9248 
  )
9249 
 
559 chandransh 9250 
  def __init__(self, success=None, scx=None,):
504 rajveer 9251 
    self.success = success
559 chandransh 9252 
    self.scx = scx
504 rajveer 9253 
 
9254 
  def read(self, iprot):
9255 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9256 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9257 
      return
9258 
    iprot.readStructBegin()
9259 
    while True:
9260 
      (fname, ftype, fid) = iprot.readFieldBegin()
9261 
      if ftype == TType.STOP:
9262 
        break
9263 
      if fid == 0:
559 chandransh 9264 
        if ftype == TType.STRUCT:
9265 
          self.success = Cart()
9266 
          self.success.read(iprot)
504 rajveer 9267 
        else:
9268 
          iprot.skip(ftype)
9269 
      elif fid == 1:
9270 
        if ftype == TType.STRUCT:
559 chandransh 9271 
          self.scx = ShoppingCartException()
9272 
          self.scx.read(iprot)
504 rajveer 9273 
        else:
9274 
          iprot.skip(ftype)
9275 
      else:
9276 
        iprot.skip(ftype)
9277 
      iprot.readFieldEnd()
9278 
    iprot.readStructEnd()
9279 
 
9280 
  def write(self, oprot):
9281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9283 
      return
559 chandransh 9284 
    oprot.writeStructBegin('getCart_result')
504 rajveer 9285 
    if self.success != None:
559 chandransh 9286 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9287 
      self.success.write(oprot)
504 rajveer 9288 
      oprot.writeFieldEnd()
559 chandransh 9289 
    if self.scx != None:
9290 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9291 
      self.scx.write(oprot)
504 rajveer 9292 
      oprot.writeFieldEnd()
9293 
    oprot.writeFieldStop()
9294 
    oprot.writeStructEnd()
9295 
 
9296 
  def __repr__(self):
9297 
    L = ['%s=%r' % (key, value)
9298 
      for key, value in self.__dict__.iteritems()]
9299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9300 
 
9301 
  def __eq__(self, other):
9302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9303 
 
9304 
  def __ne__(self, other):
9305 
    return not (self == other)
9306 
 
559 chandransh 9307 
class getCartsForUser_args:
94 ashish 9308 
  """
9309 
  Attributes:
559 chandransh 9310 
   - userId
9311 
   - status
94 ashish 9312 
  """
9313 
 
9314 
  thrift_spec = (
9315 
    None, # 0
559 chandransh 9316 
    (1, TType.I64, 'userId', None, None, ), # 1
9317 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 9318 
  )
9319 
 
559 chandransh 9320 
  def __init__(self, userId=None, status=None,):
9321 
    self.userId = userId
9322 
    self.status = status
94 ashish 9323 
 
9324 
  def read(self, iprot):
9325 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9326 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9327 
      return
9328 
    iprot.readStructBegin()
9329 
    while True:
9330 
      (fname, ftype, fid) = iprot.readFieldBegin()
9331 
      if ftype == TType.STOP:
9332 
        break
9333 
      if fid == 1:
9334 
        if ftype == TType.I64:
559 chandransh 9335 
          self.userId = iprot.readI64();
94 ashish 9336 
        else:
9337 
          iprot.skip(ftype)
9338 
      elif fid == 2:
559 chandransh 9339 
        if ftype == TType.I32:
9340 
          self.status = iprot.readI32();
94 ashish 9341 
        else:
9342 
          iprot.skip(ftype)
9343 
      else:
9344 
        iprot.skip(ftype)
9345 
      iprot.readFieldEnd()
9346 
    iprot.readStructEnd()
9347 
 
9348 
  def write(self, oprot):
9349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9351 
      return
559 chandransh 9352 
    oprot.writeStructBegin('getCartsForUser_args')
9353 
    if self.userId != None:
9354 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9355 
      oprot.writeI64(self.userId)
94 ashish 9356 
      oprot.writeFieldEnd()
559 chandransh 9357 
    if self.status != None:
9358 
      oprot.writeFieldBegin('status', TType.I32, 2)
9359 
      oprot.writeI32(self.status)
94 ashish 9360 
      oprot.writeFieldEnd()
9361 
    oprot.writeFieldStop()
9362 
    oprot.writeStructEnd()
9363 
 
9364 
  def __repr__(self):
9365 
    L = ['%s=%r' % (key, value)
9366 
      for key, value in self.__dict__.iteritems()]
9367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9368 
 
9369 
  def __eq__(self, other):
9370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9371 
 
9372 
  def __ne__(self, other):
9373 
    return not (self == other)
9374 
 
559 chandransh 9375 
class getCartsForUser_result:
94 ashish 9376 
  """
9377 
  Attributes:
9378 
   - success
559 chandransh 9379 
   - scx
94 ashish 9380 
  """
9381 
 
9382 
  thrift_spec = (
559 chandransh 9383 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9384 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9385 
  )
9386 
 
559 chandransh 9387 
  def __init__(self, success=None, scx=None,):
94 ashish 9388 
    self.success = success
559 chandransh 9389 
    self.scx = scx
94 ashish 9390 
 
9391 
  def read(self, iprot):
9392 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9393 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9394 
      return
9395 
    iprot.readStructBegin()
9396 
    while True:
9397 
      (fname, ftype, fid) = iprot.readFieldBegin()
9398 
      if ftype == TType.STOP:
9399 
        break
9400 
      if fid == 0:
559 chandransh 9401 
        if ftype == TType.LIST:
9402 
          self.success = []
1996 vikas 9403 
          (_etype94, _size91) = iprot.readListBegin()
9404 
          for _i95 in xrange(_size91):
9405 
            _elem96 = Cart()
9406 
            _elem96.read(iprot)
9407 
            self.success.append(_elem96)
559 chandransh 9408 
          iprot.readListEnd()
94 ashish 9409 
        else:
9410 
          iprot.skip(ftype)
9411 
      elif fid == 1:
9412 
        if ftype == TType.STRUCT:
559 chandransh 9413 
          self.scx = ShoppingCartException()
9414 
          self.scx.read(iprot)
94 ashish 9415 
        else:
9416 
          iprot.skip(ftype)
9417 
      else:
9418 
        iprot.skip(ftype)
9419 
      iprot.readFieldEnd()
9420 
    iprot.readStructEnd()
9421 
 
9422 
  def write(self, oprot):
9423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9425 
      return
559 chandransh 9426 
    oprot.writeStructBegin('getCartsForUser_result')
94 ashish 9427 
    if self.success != None:
559 chandransh 9428 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9429 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 9430 
      for iter97 in self.success:
9431 
        iter97.write(oprot)
559 chandransh 9432 
      oprot.writeListEnd()
94 ashish 9433 
      oprot.writeFieldEnd()
559 chandransh 9434 
    if self.scx != None:
9435 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9436 
      self.scx.write(oprot)
94 ashish 9437 
      oprot.writeFieldEnd()
9438 
    oprot.writeFieldStop()
9439 
    oprot.writeStructEnd()
9440 
 
9441 
  def __repr__(self):
9442 
    L = ['%s=%r' % (key, value)
9443 
      for key, value in self.__dict__.iteritems()]
9444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9445 
 
9446 
  def __eq__(self, other):
9447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9448 
 
9449 
  def __ne__(self, other):
9450 
    return not (self == other)
9451 
 
559 chandransh 9452 
class getCartsByStatus_args:
94 ashish 9453 
  """
9454 
  Attributes:
559 chandransh 9455 
   - status
94 ashish 9456 
  """
9457 
 
9458 
  thrift_spec = (
9459 
    None, # 0
559 chandransh 9460 
    (1, TType.I32, 'status', None, None, ), # 1
94 ashish 9461 
  )
9462 
 
559 chandransh 9463 
  def __init__(self, status=None,):
9464 
    self.status = status
94 ashish 9465 
 
9466 
  def read(self, iprot):
9467 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9468 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9469 
      return
9470 
    iprot.readStructBegin()
9471 
    while True:
9472 
      (fname, ftype, fid) = iprot.readFieldBegin()
9473 
      if ftype == TType.STOP:
9474 
        break
9475 
      if fid == 1:
559 chandransh 9476 
        if ftype == TType.I32:
9477 
          self.status = iprot.readI32();
9478 
        else:
9479 
          iprot.skip(ftype)
9480 
      else:
9481 
        iprot.skip(ftype)
9482 
      iprot.readFieldEnd()
9483 
    iprot.readStructEnd()
9484 
 
9485 
  def write(self, oprot):
9486 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9487 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9488 
      return
9489 
    oprot.writeStructBegin('getCartsByStatus_args')
9490 
    if self.status != None:
9491 
      oprot.writeFieldBegin('status', TType.I32, 1)
9492 
      oprot.writeI32(self.status)
9493 
      oprot.writeFieldEnd()
9494 
    oprot.writeFieldStop()
9495 
    oprot.writeStructEnd()
9496 
 
9497 
  def __repr__(self):
9498 
    L = ['%s=%r' % (key, value)
9499 
      for key, value in self.__dict__.iteritems()]
9500 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9501 
 
9502 
  def __eq__(self, other):
9503 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9504 
 
9505 
  def __ne__(self, other):
9506 
    return not (self == other)
9507 
 
9508 
class getCartsByStatus_result:
9509 
  """
9510 
  Attributes:
9511 
   - success
9512 
   - scx
9513 
  """
9514 
 
9515 
  thrift_spec = (
9516 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9517 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9518 
  )
9519 
 
9520 
  def __init__(self, success=None, scx=None,):
9521 
    self.success = success
9522 
    self.scx = scx
9523 
 
9524 
  def read(self, iprot):
9525 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9526 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9527 
      return
9528 
    iprot.readStructBegin()
9529 
    while True:
9530 
      (fname, ftype, fid) = iprot.readFieldBegin()
9531 
      if ftype == TType.STOP:
9532 
        break
9533 
      if fid == 0:
9534 
        if ftype == TType.LIST:
9535 
          self.success = []
1996 vikas 9536 
          (_etype101, _size98) = iprot.readListBegin()
9537 
          for _i102 in xrange(_size98):
9538 
            _elem103 = Cart()
9539 
            _elem103.read(iprot)
9540 
            self.success.append(_elem103)
559 chandransh 9541 
          iprot.readListEnd()
9542 
        else:
9543 
          iprot.skip(ftype)
9544 
      elif fid == 1:
9545 
        if ftype == TType.STRUCT:
9546 
          self.scx = ShoppingCartException()
9547 
          self.scx.read(iprot)
9548 
        else:
9549 
          iprot.skip(ftype)
9550 
      else:
9551 
        iprot.skip(ftype)
9552 
      iprot.readFieldEnd()
9553 
    iprot.readStructEnd()
9554 
 
9555 
  def write(self, oprot):
9556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9558 
      return
9559 
    oprot.writeStructBegin('getCartsByStatus_result')
9560 
    if self.success != None:
9561 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9562 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 9563 
      for iter104 in self.success:
9564 
        iter104.write(oprot)
559 chandransh 9565 
      oprot.writeListEnd()
9566 
      oprot.writeFieldEnd()
9567 
    if self.scx != None:
9568 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9569 
      self.scx.write(oprot)
9570 
      oprot.writeFieldEnd()
9571 
    oprot.writeFieldStop()
9572 
    oprot.writeStructEnd()
9573 
 
9574 
  def __repr__(self):
9575 
    L = ['%s=%r' % (key, value)
9576 
      for key, value in self.__dict__.iteritems()]
9577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9578 
 
9579 
  def __eq__(self, other):
9580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9581 
 
9582 
  def __ne__(self, other):
9583 
    return not (self == other)
9584 
 
9585 
class getCartsByTime_args:
9586 
  """
9587 
  Attributes:
9588 
   - from_time
9589 
   - to_time
9590 
   - status
9591 
  """
9592 
 
9593 
  thrift_spec = (
9594 
    None, # 0
9595 
    (1, TType.I64, 'from_time', None, None, ), # 1
9596 
    (2, TType.I64, 'to_time', None, None, ), # 2
9597 
    (3, TType.I32, 'status', None, None, ), # 3
9598 
  )
9599 
 
9600 
  def __init__(self, from_time=None, to_time=None, status=None,):
9601 
    self.from_time = from_time
9602 
    self.to_time = to_time
9603 
    self.status = status
9604 
 
9605 
  def read(self, iprot):
9606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9608 
      return
9609 
    iprot.readStructBegin()
9610 
    while True:
9611 
      (fname, ftype, fid) = iprot.readFieldBegin()
9612 
      if ftype == TType.STOP:
9613 
        break
9614 
      if fid == 1:
94 ashish 9615 
        if ftype == TType.I64:
559 chandransh 9616 
          self.from_time = iprot.readI64();
94 ashish 9617 
        else:
9618 
          iprot.skip(ftype)
122 ashish 9619 
      elif fid == 2:
559 chandransh 9620 
        if ftype == TType.I64:
9621 
          self.to_time = iprot.readI64();
122 ashish 9622 
        else:
9623 
          iprot.skip(ftype)
559 chandransh 9624 
      elif fid == 3:
9625 
        if ftype == TType.I32:
9626 
          self.status = iprot.readI32();
9627 
        else:
9628 
          iprot.skip(ftype)
94 ashish 9629 
      else:
9630 
        iprot.skip(ftype)
9631 
      iprot.readFieldEnd()
9632 
    iprot.readStructEnd()
9633 
 
9634 
  def write(self, oprot):
9635 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9636 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9637 
      return
559 chandransh 9638 
    oprot.writeStructBegin('getCartsByTime_args')
9639 
    if self.from_time != None:
9640 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
9641 
      oprot.writeI64(self.from_time)
94 ashish 9642 
      oprot.writeFieldEnd()
559 chandransh 9643 
    if self.to_time != None:
9644 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
9645 
      oprot.writeI64(self.to_time)
122 ashish 9646 
      oprot.writeFieldEnd()
559 chandransh 9647 
    if self.status != None:
9648 
      oprot.writeFieldBegin('status', TType.I32, 3)
9649 
      oprot.writeI32(self.status)
9650 
      oprot.writeFieldEnd()
94 ashish 9651 
    oprot.writeFieldStop()
9652 
    oprot.writeStructEnd()
9653 
 
9654 
  def __repr__(self):
9655 
    L = ['%s=%r' % (key, value)
9656 
      for key, value in self.__dict__.iteritems()]
9657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9658 
 
9659 
  def __eq__(self, other):
9660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9661 
 
9662 
  def __ne__(self, other):
9663 
    return not (self == other)
9664 
 
559 chandransh 9665 
class getCartsByTime_result:
94 ashish 9666 
  """
9667 
  Attributes:
9668 
   - success
559 chandransh 9669 
   - scx
94 ashish 9670 
  """
9671 
 
9672 
  thrift_spec = (
559 chandransh 9673 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9674 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9675 
  )
9676 
 
559 chandransh 9677 
  def __init__(self, success=None, scx=None,):
94 ashish 9678 
    self.success = success
559 chandransh 9679 
    self.scx = scx
94 ashish 9680 
 
9681 
  def read(self, iprot):
9682 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9683 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9684 
      return
9685 
    iprot.readStructBegin()
9686 
    while True:
9687 
      (fname, ftype, fid) = iprot.readFieldBegin()
9688 
      if ftype == TType.STOP:
9689 
        break
9690 
      if fid == 0:
559 chandransh 9691 
        if ftype == TType.LIST:
9692 
          self.success = []
1996 vikas 9693 
          (_etype108, _size105) = iprot.readListBegin()
9694 
          for _i109 in xrange(_size105):
9695 
            _elem110 = Cart()
9696 
            _elem110.read(iprot)
9697 
            self.success.append(_elem110)
559 chandransh 9698 
          iprot.readListEnd()
94 ashish 9699 
        else:
9700 
          iprot.skip(ftype)
9701 
      elif fid == 1:
9702 
        if ftype == TType.STRUCT:
559 chandransh 9703 
          self.scx = ShoppingCartException()
9704 
          self.scx.read(iprot)
94 ashish 9705 
        else:
9706 
          iprot.skip(ftype)
9707 
      else:
9708 
        iprot.skip(ftype)
9709 
      iprot.readFieldEnd()
9710 
    iprot.readStructEnd()
9711 
 
9712 
  def write(self, oprot):
9713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9715 
      return
559 chandransh 9716 
    oprot.writeStructBegin('getCartsByTime_result')
94 ashish 9717 
    if self.success != None:
559 chandransh 9718 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9719 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 9720 
      for iter111 in self.success:
9721 
        iter111.write(oprot)
559 chandransh 9722 
      oprot.writeListEnd()
94 ashish 9723 
      oprot.writeFieldEnd()
559 chandransh 9724 
    if self.scx != None:
9725 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9726 
      self.scx.write(oprot)
94 ashish 9727 
      oprot.writeFieldEnd()
9728 
    oprot.writeFieldStop()
9729 
    oprot.writeStructEnd()
9730 
 
9731 
  def __repr__(self):
9732 
    L = ['%s=%r' % (key, value)
9733 
      for key, value in self.__dict__.iteritems()]
9734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9735 
 
9736 
  def __eq__(self, other):
9737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9738 
 
9739 
  def __ne__(self, other):
9740 
    return not (self == other)
9741 
 
559 chandransh 9742 
class changeCartStatus_args:
94 ashish 9743 
  """
9744 
  Attributes:
559 chandransh 9745 
   - cartId
9746 
   - status
94 ashish 9747 
  """
9748 
 
9749 
  thrift_spec = (
9750 
    None, # 0
559 chandransh 9751 
    (1, TType.I64, 'cartId', None, None, ), # 1
9752 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 9753 
  )
9754 
 
559 chandransh 9755 
  def __init__(self, cartId=None, status=None,):
9756 
    self.cartId = cartId
9757 
    self.status = status
94 ashish 9758 
 
9759 
  def read(self, iprot):
9760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9762 
      return
9763 
    iprot.readStructBegin()
9764 
    while True:
9765 
      (fname, ftype, fid) = iprot.readFieldBegin()
9766 
      if ftype == TType.STOP:
9767 
        break
9768 
      if fid == 1:
9769 
        if ftype == TType.I64:
559 chandransh 9770 
          self.cartId = iprot.readI64();
94 ashish 9771 
        else:
9772 
          iprot.skip(ftype)
559 chandransh 9773 
      elif fid == 2:
9774 
        if ftype == TType.I32:
9775 
          self.status = iprot.readI32();
9776 
        else:
9777 
          iprot.skip(ftype)
94 ashish 9778 
      else:
9779 
        iprot.skip(ftype)
9780 
      iprot.readFieldEnd()
9781 
    iprot.readStructEnd()
9782 
 
9783 
  def write(self, oprot):
9784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9786 
      return
559 chandransh 9787 
    oprot.writeStructBegin('changeCartStatus_args')
9788 
    if self.cartId != None:
9789 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9790 
      oprot.writeI64(self.cartId)
94 ashish 9791 
      oprot.writeFieldEnd()
559 chandransh 9792 
    if self.status != None:
9793 
      oprot.writeFieldBegin('status', TType.I32, 2)
9794 
      oprot.writeI32(self.status)
9795 
      oprot.writeFieldEnd()
94 ashish 9796 
    oprot.writeFieldStop()
9797 
    oprot.writeStructEnd()
9798 
 
9799 
  def __repr__(self):
9800 
    L = ['%s=%r' % (key, value)
9801 
      for key, value in self.__dict__.iteritems()]
9802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9803 
 
9804 
  def __eq__(self, other):
9805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9806 
 
9807 
  def __ne__(self, other):
9808 
    return not (self == other)
9809 
 
559 chandransh 9810 
class changeCartStatus_result:
94 ashish 9811 
  """
9812 
  Attributes:
559 chandransh 9813 
   - scx
9814 
  """
9815 
 
9816 
  thrift_spec = (
9817 
    None, # 0
9818 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9819 
  )
9820 
 
9821 
  def __init__(self, scx=None,):
9822 
    self.scx = scx
9823 
 
9824 
  def read(self, iprot):
9825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9827 
      return
9828 
    iprot.readStructBegin()
9829 
    while True:
9830 
      (fname, ftype, fid) = iprot.readFieldBegin()
9831 
      if ftype == TType.STOP:
9832 
        break
9833 
      if fid == 1:
9834 
        if ftype == TType.STRUCT:
9835 
          self.scx = ShoppingCartException()
9836 
          self.scx.read(iprot)
9837 
        else:
9838 
          iprot.skip(ftype)
9839 
      else:
9840 
        iprot.skip(ftype)
9841 
      iprot.readFieldEnd()
9842 
    iprot.readStructEnd()
9843 
 
9844 
  def write(self, oprot):
9845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9847 
      return
9848 
    oprot.writeStructBegin('changeCartStatus_result')
9849 
    if self.scx != None:
9850 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9851 
      self.scx.write(oprot)
9852 
      oprot.writeFieldEnd()
9853 
    oprot.writeFieldStop()
9854 
    oprot.writeStructEnd()
9855 
 
9856 
  def __repr__(self):
9857 
    L = ['%s=%r' % (key, value)
9858 
      for key, value in self.__dict__.iteritems()]
9859 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9860 
 
9861 
  def __eq__(self, other):
9862 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9863 
 
9864 
  def __ne__(self, other):
9865 
    return not (self == other)
9866 
 
9867 
class addItemToCart_args:
9868 
  """
9869 
  Attributes:
9870 
   - cartId
9871 
   - itemId
9872 
   - quantity
9873 
  """
9874 
 
9875 
  thrift_spec = (
9876 
    None, # 0
9877 
    (1, TType.I64, 'cartId', None, None, ), # 1
9878 
    (2, TType.I64, 'itemId', None, None, ), # 2
9879 
    (3, TType.I64, 'quantity', None, None, ), # 3
9880 
  )
9881 
 
9882 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
9883 
    self.cartId = cartId
9884 
    self.itemId = itemId
9885 
    self.quantity = quantity
9886 
 
9887 
  def read(self, iprot):
9888 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9889 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9890 
      return
9891 
    iprot.readStructBegin()
9892 
    while True:
9893 
      (fname, ftype, fid) = iprot.readFieldBegin()
9894 
      if ftype == TType.STOP:
9895 
        break
9896 
      if fid == 1:
9897 
        if ftype == TType.I64:
9898 
          self.cartId = iprot.readI64();
9899 
        else:
9900 
          iprot.skip(ftype)
9901 
      elif fid == 2:
9902 
        if ftype == TType.I64:
9903 
          self.itemId = iprot.readI64();
9904 
        else:
9905 
          iprot.skip(ftype)
9906 
      elif fid == 3:
9907 
        if ftype == TType.I64:
9908 
          self.quantity = iprot.readI64();
9909 
        else:
9910 
          iprot.skip(ftype)
9911 
      else:
9912 
        iprot.skip(ftype)
9913 
      iprot.readFieldEnd()
9914 
    iprot.readStructEnd()
9915 
 
9916 
  def write(self, oprot):
9917 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9918 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9919 
      return
9920 
    oprot.writeStructBegin('addItemToCart_args')
9921 
    if self.cartId != None:
9922 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9923 
      oprot.writeI64(self.cartId)
9924 
      oprot.writeFieldEnd()
9925 
    if self.itemId != None:
9926 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
9927 
      oprot.writeI64(self.itemId)
9928 
      oprot.writeFieldEnd()
9929 
    if self.quantity != None:
9930 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
9931 
      oprot.writeI64(self.quantity)
9932 
      oprot.writeFieldEnd()
9933 
    oprot.writeFieldStop()
9934 
    oprot.writeStructEnd()
9935 
 
9936 
  def __repr__(self):
9937 
    L = ['%s=%r' % (key, value)
9938 
      for key, value in self.__dict__.iteritems()]
9939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9940 
 
9941 
  def __eq__(self, other):
9942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9943 
 
9944 
  def __ne__(self, other):
9945 
    return not (self == other)
9946 
 
9947 
class addItemToCart_result:
9948 
  """
9949 
  Attributes:
2035 rajveer 9950 
   - success
559 chandransh 9951 
   - scx
9952 
  """
9953 
 
9954 
  thrift_spec = (
2035 rajveer 9955 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 9956 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9957 
  )
9958 
 
2035 rajveer 9959 
  def __init__(self, success=None, scx=None,):
9960 
    self.success = success
559 chandransh 9961 
    self.scx = scx
9962 
 
9963 
  def read(self, iprot):
9964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9966 
      return
9967 
    iprot.readStructBegin()
9968 
    while True:
9969 
      (fname, ftype, fid) = iprot.readFieldBegin()
9970 
      if ftype == TType.STOP:
9971 
        break
2035 rajveer 9972 
      if fid == 0:
9973 
        if ftype == TType.STRING:
9974 
          self.success = iprot.readString();
9975 
        else:
9976 
          iprot.skip(ftype)
9977 
      elif fid == 1:
559 chandransh 9978 
        if ftype == TType.STRUCT:
9979 
          self.scx = ShoppingCartException()
9980 
          self.scx.read(iprot)
9981 
        else:
9982 
          iprot.skip(ftype)
9983 
      else:
9984 
        iprot.skip(ftype)
9985 
      iprot.readFieldEnd()
9986 
    iprot.readStructEnd()
9987 
 
9988 
  def write(self, oprot):
9989 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9990 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9991 
      return
9992 
    oprot.writeStructBegin('addItemToCart_result')
2035 rajveer 9993 
    if self.success != None:
9994 
      oprot.writeFieldBegin('success', TType.STRING, 0)
9995 
      oprot.writeString(self.success)
9996 
      oprot.writeFieldEnd()
559 chandransh 9997 
    if self.scx != None:
9998 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9999 
      self.scx.write(oprot)
10000 
      oprot.writeFieldEnd()
10001 
    oprot.writeFieldStop()
10002 
    oprot.writeStructEnd()
10003 
 
10004 
  def __repr__(self):
10005 
    L = ['%s=%r' % (key, value)
10006 
      for key, value in self.__dict__.iteritems()]
10007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10008 
 
10009 
  def __eq__(self, other):
10010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10011 
 
10012 
  def __ne__(self, other):
10013 
    return not (self == other)
10014 
 
10015 
class deleteItemFromCart_args:
10016 
  """
10017 
  Attributes:
10018 
   - cartId
10019 
   - itemId
10020 
  """
10021 
 
10022 
  thrift_spec = (
10023 
    None, # 0
10024 
    (1, TType.I64, 'cartId', None, None, ), # 1
10025 
    (2, TType.I64, 'itemId', None, None, ), # 2
10026 
  )
10027 
 
10028 
  def __init__(self, cartId=None, itemId=None,):
10029 
    self.cartId = cartId
10030 
    self.itemId = itemId
10031 
 
10032 
  def read(self, iprot):
10033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10035 
      return
10036 
    iprot.readStructBegin()
10037 
    while True:
10038 
      (fname, ftype, fid) = iprot.readFieldBegin()
10039 
      if ftype == TType.STOP:
10040 
        break
10041 
      if fid == 1:
10042 
        if ftype == TType.I64:
10043 
          self.cartId = iprot.readI64();
10044 
        else:
10045 
          iprot.skip(ftype)
10046 
      elif fid == 2:
10047 
        if ftype == TType.I64:
10048 
          self.itemId = iprot.readI64();
10049 
        else:
10050 
          iprot.skip(ftype)
10051 
      else:
10052 
        iprot.skip(ftype)
10053 
      iprot.readFieldEnd()
10054 
    iprot.readStructEnd()
10055 
 
10056 
  def write(self, oprot):
10057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10059 
      return
10060 
    oprot.writeStructBegin('deleteItemFromCart_args')
10061 
    if self.cartId != None:
10062 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10063 
      oprot.writeI64(self.cartId)
10064 
      oprot.writeFieldEnd()
10065 
    if self.itemId != None:
10066 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10067 
      oprot.writeI64(self.itemId)
10068 
      oprot.writeFieldEnd()
10069 
    oprot.writeFieldStop()
10070 
    oprot.writeStructEnd()
10071 
 
10072 
  def __repr__(self):
10073 
    L = ['%s=%r' % (key, value)
10074 
      for key, value in self.__dict__.iteritems()]
10075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10076 
 
10077 
  def __eq__(self, other):
10078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10079 
 
10080 
  def __ne__(self, other):
10081 
    return not (self == other)
10082 
 
10083 
class deleteItemFromCart_result:
10084 
  """
10085 
  Attributes:
10086 
   - scx
10087 
  """
10088 
 
10089 
  thrift_spec = (
10090 
    None, # 0
10091 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10092 
  )
10093 
 
10094 
  def __init__(self, scx=None,):
10095 
    self.scx = scx
10096 
 
10097 
  def read(self, iprot):
10098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10100 
      return
10101 
    iprot.readStructBegin()
10102 
    while True:
10103 
      (fname, ftype, fid) = iprot.readFieldBegin()
10104 
      if ftype == TType.STOP:
10105 
        break
10106 
      if fid == 1:
10107 
        if ftype == TType.STRUCT:
10108 
          self.scx = ShoppingCartException()
10109 
          self.scx.read(iprot)
10110 
        else:
10111 
          iprot.skip(ftype)
10112 
      else:
10113 
        iprot.skip(ftype)
10114 
      iprot.readFieldEnd()
10115 
    iprot.readStructEnd()
10116 
 
10117 
  def write(self, oprot):
10118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10120 
      return
10121 
    oprot.writeStructBegin('deleteItemFromCart_result')
10122 
    if self.scx != None:
10123 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10124 
      self.scx.write(oprot)
10125 
      oprot.writeFieldEnd()
10126 
    oprot.writeFieldStop()
10127 
    oprot.writeStructEnd()
10128 
 
10129 
  def __repr__(self):
10130 
    L = ['%s=%r' % (key, value)
10131 
      for key, value in self.__dict__.iteritems()]
10132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10133 
 
10134 
  def __eq__(self, other):
10135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10136 
 
10137 
  def __ne__(self, other):
10138 
    return not (self == other)
10139 
 
10140 
class changeQuantity_args:
10141 
  """
10142 
  Attributes:
10143 
   - cartId
10144 
   - itemId
10145 
   - quantity
10146 
  """
10147 
 
10148 
  thrift_spec = (
10149 
    None, # 0
10150 
    (1, TType.I64, 'cartId', None, None, ), # 1
10151 
    (2, TType.I64, 'itemId', None, None, ), # 2
10152 
    (3, TType.I64, 'quantity', None, None, ), # 3
10153 
  )
10154 
 
10155 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
10156 
    self.cartId = cartId
10157 
    self.itemId = itemId
10158 
    self.quantity = quantity
10159 
 
10160 
  def read(self, iprot):
10161 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10162 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10163 
      return
10164 
    iprot.readStructBegin()
10165 
    while True:
10166 
      (fname, ftype, fid) = iprot.readFieldBegin()
10167 
      if ftype == TType.STOP:
10168 
        break
10169 
      if fid == 1:
10170 
        if ftype == TType.I64:
10171 
          self.cartId = iprot.readI64();
10172 
        else:
10173 
          iprot.skip(ftype)
10174 
      elif fid == 2:
10175 
        if ftype == TType.I64:
10176 
          self.itemId = iprot.readI64();
10177 
        else:
10178 
          iprot.skip(ftype)
10179 
      elif fid == 3:
10180 
        if ftype == TType.I64:
10181 
          self.quantity = iprot.readI64();
10182 
        else:
10183 
          iprot.skip(ftype)
10184 
      else:
10185 
        iprot.skip(ftype)
10186 
      iprot.readFieldEnd()
10187 
    iprot.readStructEnd()
10188 
 
10189 
  def write(self, oprot):
10190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10192 
      return
10193 
    oprot.writeStructBegin('changeQuantity_args')
10194 
    if self.cartId != None:
10195 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10196 
      oprot.writeI64(self.cartId)
10197 
      oprot.writeFieldEnd()
10198 
    if self.itemId != None:
10199 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10200 
      oprot.writeI64(self.itemId)
10201 
      oprot.writeFieldEnd()
10202 
    if self.quantity != None:
10203 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10204 
      oprot.writeI64(self.quantity)
10205 
      oprot.writeFieldEnd()
10206 
    oprot.writeFieldStop()
10207 
    oprot.writeStructEnd()
10208 
 
10209 
  def __repr__(self):
10210 
    L = ['%s=%r' % (key, value)
10211 
      for key, value in self.__dict__.iteritems()]
10212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10213 
 
10214 
  def __eq__(self, other):
10215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10216 
 
10217 
  def __ne__(self, other):
10218 
    return not (self == other)
10219 
 
10220 
class changeQuantity_result:
10221 
  """
10222 
  Attributes:
10223 
   - scx
10224 
  """
10225 
 
10226 
  thrift_spec = (
10227 
    None, # 0
10228 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10229 
  )
10230 
 
10231 
  def __init__(self, scx=None,):
10232 
    self.scx = scx
10233 
 
10234 
  def read(self, iprot):
10235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10237 
      return
10238 
    iprot.readStructBegin()
10239 
    while True:
10240 
      (fname, ftype, fid) = iprot.readFieldBegin()
10241 
      if ftype == TType.STOP:
10242 
        break
10243 
      if fid == 1:
10244 
        if ftype == TType.STRUCT:
10245 
          self.scx = ShoppingCartException()
10246 
          self.scx.read(iprot)
10247 
        else:
10248 
          iprot.skip(ftype)
10249 
      else:
10250 
        iprot.skip(ftype)
10251 
      iprot.readFieldEnd()
10252 
    iprot.readStructEnd()
10253 
 
10254 
  def write(self, oprot):
10255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10257 
      return
10258 
    oprot.writeStructBegin('changeQuantity_result')
10259 
    if self.scx != None:
10260 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10261 
      self.scx.write(oprot)
10262 
      oprot.writeFieldEnd()
10263 
    oprot.writeFieldStop()
10264 
    oprot.writeStructEnd()
10265 
 
10266 
  def __repr__(self):
10267 
    L = ['%s=%r' % (key, value)
10268 
      for key, value in self.__dict__.iteritems()]
10269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10270 
 
10271 
  def __eq__(self, other):
10272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10273 
 
10274 
  def __ne__(self, other):
10275 
    return not (self == other)
10276 
 
10277 
class changeItemStatus_args:
10278 
  """
10279 
  Attributes:
10280 
   - cartId
10281 
   - itemId
10282 
   - status
10283 
  """
10284 
 
10285 
  thrift_spec = (
10286 
    None, # 0
10287 
    (1, TType.I64, 'cartId', None, None, ), # 1
10288 
    (2, TType.I64, 'itemId', None, None, ), # 2
10289 
    (3, TType.I32, 'status', None, None, ), # 3
10290 
  )
10291 
 
10292 
  def __init__(self, cartId=None, itemId=None, status=None,):
10293 
    self.cartId = cartId
10294 
    self.itemId = itemId
10295 
    self.status = status
10296 
 
10297 
  def read(self, iprot):
10298 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10299 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10300 
      return
10301 
    iprot.readStructBegin()
10302 
    while True:
10303 
      (fname, ftype, fid) = iprot.readFieldBegin()
10304 
      if ftype == TType.STOP:
10305 
        break
10306 
      if fid == 1:
10307 
        if ftype == TType.I64:
10308 
          self.cartId = iprot.readI64();
10309 
        else:
10310 
          iprot.skip(ftype)
10311 
      elif fid == 2:
10312 
        if ftype == TType.I64:
10313 
          self.itemId = iprot.readI64();
10314 
        else:
10315 
          iprot.skip(ftype)
10316 
      elif fid == 3:
10317 
        if ftype == TType.I32:
10318 
          self.status = iprot.readI32();
10319 
        else:
10320 
          iprot.skip(ftype)
10321 
      else:
10322 
        iprot.skip(ftype)
10323 
      iprot.readFieldEnd()
10324 
    iprot.readStructEnd()
10325 
 
10326 
  def write(self, oprot):
10327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10329 
      return
10330 
    oprot.writeStructBegin('changeItemStatus_args')
10331 
    if self.cartId != None:
10332 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10333 
      oprot.writeI64(self.cartId)
10334 
      oprot.writeFieldEnd()
10335 
    if self.itemId != None:
10336 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10337 
      oprot.writeI64(self.itemId)
10338 
      oprot.writeFieldEnd()
10339 
    if self.status != None:
10340 
      oprot.writeFieldBegin('status', TType.I32, 3)
10341 
      oprot.writeI32(self.status)
10342 
      oprot.writeFieldEnd()
10343 
    oprot.writeFieldStop()
10344 
    oprot.writeStructEnd()
10345 
 
10346 
  def __repr__(self):
10347 
    L = ['%s=%r' % (key, value)
10348 
      for key, value in self.__dict__.iteritems()]
10349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10350 
 
10351 
  def __eq__(self, other):
10352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10353 
 
10354 
  def __ne__(self, other):
10355 
    return not (self == other)
10356 
 
10357 
class changeItemStatus_result:
10358 
  """
10359 
  Attributes:
10360 
   - scx
10361 
  """
10362 
 
10363 
  thrift_spec = (
10364 
    None, # 0
10365 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10366 
  )
10367 
 
10368 
  def __init__(self, scx=None,):
10369 
    self.scx = scx
10370 
 
10371 
  def read(self, iprot):
10372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10374 
      return
10375 
    iprot.readStructBegin()
10376 
    while True:
10377 
      (fname, ftype, fid) = iprot.readFieldBegin()
10378 
      if ftype == TType.STOP:
10379 
        break
10380 
      if fid == 1:
10381 
        if ftype == TType.STRUCT:
10382 
          self.scx = ShoppingCartException()
10383 
          self.scx.read(iprot)
10384 
        else:
10385 
          iprot.skip(ftype)
10386 
      else:
10387 
        iprot.skip(ftype)
10388 
      iprot.readFieldEnd()
10389 
    iprot.readStructEnd()
10390 
 
10391 
  def write(self, oprot):
10392 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10393 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10394 
      return
10395 
    oprot.writeStructBegin('changeItemStatus_result')
10396 
    if self.scx != None:
10397 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10398 
      self.scx.write(oprot)
10399 
      oprot.writeFieldEnd()
10400 
    oprot.writeFieldStop()
10401 
    oprot.writeStructEnd()
10402 
 
10403 
  def __repr__(self):
10404 
    L = ['%s=%r' % (key, value)
10405 
      for key, value in self.__dict__.iteritems()]
10406 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10407 
 
10408 
  def __eq__(self, other):
10409 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10410 
 
10411 
  def __ne__(self, other):
10412 
    return not (self == other)
10413 
 
10414 
class addAddressToCart_args:
10415 
  """
10416 
  Attributes:
10417 
   - cartId
10418 
   - addressId
10419 
  """
10420 
 
10421 
  thrift_spec = (
10422 
    None, # 0
10423 
    (1, TType.I64, 'cartId', None, None, ), # 1
10424 
    (2, TType.I64, 'addressId', None, None, ), # 2
10425 
  )
10426 
 
10427 
  def __init__(self, cartId=None, addressId=None,):
10428 
    self.cartId = cartId
10429 
    self.addressId = addressId
10430 
 
10431 
  def read(self, iprot):
10432 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10433 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10434 
      return
10435 
    iprot.readStructBegin()
10436 
    while True:
10437 
      (fname, ftype, fid) = iprot.readFieldBegin()
10438 
      if ftype == TType.STOP:
10439 
        break
10440 
      if fid == 1:
10441 
        if ftype == TType.I64:
10442 
          self.cartId = iprot.readI64();
10443 
        else:
10444 
          iprot.skip(ftype)
10445 
      elif fid == 2:
10446 
        if ftype == TType.I64:
10447 
          self.addressId = iprot.readI64();
10448 
        else:
10449 
          iprot.skip(ftype)
10450 
      else:
10451 
        iprot.skip(ftype)
10452 
      iprot.readFieldEnd()
10453 
    iprot.readStructEnd()
10454 
 
10455 
  def write(self, oprot):
10456 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10457 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10458 
      return
10459 
    oprot.writeStructBegin('addAddressToCart_args')
10460 
    if self.cartId != None:
10461 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10462 
      oprot.writeI64(self.cartId)
10463 
      oprot.writeFieldEnd()
10464 
    if self.addressId != None:
10465 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
10466 
      oprot.writeI64(self.addressId)
10467 
      oprot.writeFieldEnd()
10468 
    oprot.writeFieldStop()
10469 
    oprot.writeStructEnd()
10470 
 
10471 
  def __repr__(self):
10472 
    L = ['%s=%r' % (key, value)
10473 
      for key, value in self.__dict__.iteritems()]
10474 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10475 
 
10476 
  def __eq__(self, other):
10477 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10478 
 
10479 
  def __ne__(self, other):
10480 
    return not (self == other)
10481 
 
10482 
class addAddressToCart_result:
575 chandransh 10483 
  """
10484 
  Attributes:
10485 
   - scx
10486 
  """
559 chandransh 10487 
 
10488 
  thrift_spec = (
575 chandransh 10489 
    None, # 0
10490 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 10491 
  )
10492 
 
575 chandransh 10493 
  def __init__(self, scx=None,):
10494 
    self.scx = scx
10495 
 
559 chandransh 10496 
  def read(self, iprot):
10497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10499 
      return
10500 
    iprot.readStructBegin()
10501 
    while True:
10502 
      (fname, ftype, fid) = iprot.readFieldBegin()
10503 
      if ftype == TType.STOP:
10504 
        break
575 chandransh 10505 
      if fid == 1:
10506 
        if ftype == TType.STRUCT:
10507 
          self.scx = ShoppingCartException()
10508 
          self.scx.read(iprot)
10509 
        else:
10510 
          iprot.skip(ftype)
559 chandransh 10511 
      else:
10512 
        iprot.skip(ftype)
10513 
      iprot.readFieldEnd()
10514 
    iprot.readStructEnd()
10515 
 
10516 
  def write(self, oprot):
10517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10519 
      return
10520 
    oprot.writeStructBegin('addAddressToCart_result')
575 chandransh 10521 
    if self.scx != None:
10522 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10523 
      self.scx.write(oprot)
10524 
      oprot.writeFieldEnd()
559 chandransh 10525 
    oprot.writeFieldStop()
10526 
    oprot.writeStructEnd()
10527 
 
10528 
  def __repr__(self):
10529 
    L = ['%s=%r' % (key, value)
10530 
      for key, value in self.__dict__.iteritems()]
10531 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10532 
 
10533 
  def __eq__(self, other):
10534 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10535 
 
10536 
  def __ne__(self, other):
10537 
    return not (self == other)
10538 
 
1976 varun.gupt 10539 
class applyCouponToCart_args:
10540 
  """
10541 
  Attributes:
10542 
   - cartId
10543 
   - couponCode
10544 
   - totalPrice
10545 
   - discountedPrice
10546 
  """
10547 
 
10548 
  thrift_spec = (
10549 
    None, # 0
10550 
    (1, TType.I64, 'cartId', None, None, ), # 1
10551 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
10552 
    (3, TType.DOUBLE, 'totalPrice', None, None, ), # 3
10553 
    (4, TType.DOUBLE, 'discountedPrice', None, None, ), # 4
10554 
  )
10555 
 
10556 
  def __init__(self, cartId=None, couponCode=None, totalPrice=None, discountedPrice=None,):
10557 
    self.cartId = cartId
10558 
    self.couponCode = couponCode
10559 
    self.totalPrice = totalPrice
10560 
    self.discountedPrice = discountedPrice
10561 
 
10562 
  def read(self, iprot):
10563 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10564 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10565 
      return
10566 
    iprot.readStructBegin()
10567 
    while True:
10568 
      (fname, ftype, fid) = iprot.readFieldBegin()
10569 
      if ftype == TType.STOP:
10570 
        break
10571 
      if fid == 1:
10572 
        if ftype == TType.I64:
10573 
          self.cartId = iprot.readI64();
10574 
        else:
10575 
          iprot.skip(ftype)
10576 
      elif fid == 2:
10577 
        if ftype == TType.STRING:
10578 
          self.couponCode = iprot.readString();
10579 
        else:
10580 
          iprot.skip(ftype)
10581 
      elif fid == 3:
10582 
        if ftype == TType.DOUBLE:
10583 
          self.totalPrice = iprot.readDouble();
10584 
        else:
10585 
          iprot.skip(ftype)
10586 
      elif fid == 4:
10587 
        if ftype == TType.DOUBLE:
10588 
          self.discountedPrice = iprot.readDouble();
10589 
        else:
10590 
          iprot.skip(ftype)
10591 
      else:
10592 
        iprot.skip(ftype)
10593 
      iprot.readFieldEnd()
10594 
    iprot.readStructEnd()
10595 
 
10596 
  def write(self, oprot):
10597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10599 
      return
10600 
    oprot.writeStructBegin('applyCouponToCart_args')
10601 
    if self.cartId != None:
10602 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10603 
      oprot.writeI64(self.cartId)
10604 
      oprot.writeFieldEnd()
10605 
    if self.couponCode != None:
10606 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
10607 
      oprot.writeString(self.couponCode)
10608 
      oprot.writeFieldEnd()
10609 
    if self.totalPrice != None:
10610 
      oprot.writeFieldBegin('totalPrice', TType.DOUBLE, 3)
10611 
      oprot.writeDouble(self.totalPrice)
10612 
      oprot.writeFieldEnd()
10613 
    if self.discountedPrice != None:
10614 
      oprot.writeFieldBegin('discountedPrice', TType.DOUBLE, 4)
10615 
      oprot.writeDouble(self.discountedPrice)
10616 
      oprot.writeFieldEnd()
10617 
    oprot.writeFieldStop()
10618 
    oprot.writeStructEnd()
10619 
 
10620 
  def __repr__(self):
10621 
    L = ['%s=%r' % (key, value)
10622 
      for key, value in self.__dict__.iteritems()]
10623 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10624 
 
10625 
  def __eq__(self, other):
10626 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10627 
 
10628 
  def __ne__(self, other):
10629 
    return not (self == other)
10630 
 
10631 
class applyCouponToCart_result:
10632 
  """
10633 
  Attributes:
10634 
   - scx
10635 
  """
10636 
 
10637 
  thrift_spec = (
10638 
    None, # 0
10639 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10640 
  )
10641 
 
10642 
  def __init__(self, scx=None,):
10643 
    self.scx = scx
10644 
 
10645 
  def read(self, iprot):
10646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10648 
      return
10649 
    iprot.readStructBegin()
10650 
    while True:
10651 
      (fname, ftype, fid) = iprot.readFieldBegin()
10652 
      if ftype == TType.STOP:
10653 
        break
10654 
      if fid == 1:
10655 
        if ftype == TType.STRUCT:
10656 
          self.scx = ShoppingCartException()
10657 
          self.scx.read(iprot)
10658 
        else:
10659 
          iprot.skip(ftype)
10660 
      else:
10661 
        iprot.skip(ftype)
10662 
      iprot.readFieldEnd()
10663 
    iprot.readStructEnd()
10664 
 
10665 
  def write(self, oprot):
10666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10668 
      return
10669 
    oprot.writeStructBegin('applyCouponToCart_result')
10670 
    if self.scx != None:
10671 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10672 
      self.scx.write(oprot)
10673 
      oprot.writeFieldEnd()
10674 
    oprot.writeFieldStop()
10675 
    oprot.writeStructEnd()
10676 
 
10677 
  def __repr__(self):
10678 
    L = ['%s=%r' % (key, value)
10679 
      for key, value in self.__dict__.iteritems()]
10680 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10681 
 
10682 
  def __eq__(self, other):
10683 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10684 
 
10685 
  def __ne__(self, other):
10686 
    return not (self == other)
10687 
 
10688 
class removeCoupon_args:
10689 
  """
10690 
  Attributes:
10691 
   - cartId
10692 
  """
10693 
 
10694 
  thrift_spec = (
10695 
    None, # 0
10696 
    (1, TType.I64, 'cartId', None, None, ), # 1
10697 
  )
10698 
 
10699 
  def __init__(self, cartId=None,):
10700 
    self.cartId = cartId
10701 
 
10702 
  def read(self, iprot):
10703 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10704 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10705 
      return
10706 
    iprot.readStructBegin()
10707 
    while True:
10708 
      (fname, ftype, fid) = iprot.readFieldBegin()
10709 
      if ftype == TType.STOP:
10710 
        break
10711 
      if fid == 1:
10712 
        if ftype == TType.I64:
10713 
          self.cartId = iprot.readI64();
10714 
        else:
10715 
          iprot.skip(ftype)
10716 
      else:
10717 
        iprot.skip(ftype)
10718 
      iprot.readFieldEnd()
10719 
    iprot.readStructEnd()
10720 
 
10721 
  def write(self, oprot):
10722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10724 
      return
10725 
    oprot.writeStructBegin('removeCoupon_args')
10726 
    if self.cartId != None:
10727 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10728 
      oprot.writeI64(self.cartId)
10729 
      oprot.writeFieldEnd()
10730 
    oprot.writeFieldStop()
10731 
    oprot.writeStructEnd()
10732 
 
10733 
  def __repr__(self):
10734 
    L = ['%s=%r' % (key, value)
10735 
      for key, value in self.__dict__.iteritems()]
10736 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10737 
 
10738 
  def __eq__(self, other):
10739 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10740 
 
10741 
  def __ne__(self, other):
10742 
    return not (self == other)
10743 
 
10744 
class removeCoupon_result:
10745 
  """
10746 
  Attributes:
10747 
   - scx
10748 
  """
10749 
 
10750 
  thrift_spec = (
10751 
    None, # 0
10752 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10753 
  )
10754 
 
10755 
  def __init__(self, scx=None,):
10756 
    self.scx = scx
10757 
 
10758 
  def read(self, iprot):
10759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10761 
      return
10762 
    iprot.readStructBegin()
10763 
    while True:
10764 
      (fname, ftype, fid) = iprot.readFieldBegin()
10765 
      if ftype == TType.STOP:
10766 
        break
10767 
      if fid == 1:
10768 
        if ftype == TType.STRUCT:
10769 
          self.scx = ShoppingCartException()
10770 
          self.scx.read(iprot)
10771 
        else:
10772 
          iprot.skip(ftype)
10773 
      else:
10774 
        iprot.skip(ftype)
10775 
      iprot.readFieldEnd()
10776 
    iprot.readStructEnd()
10777 
 
10778 
  def write(self, oprot):
10779 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10780 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10781 
      return
10782 
    oprot.writeStructBegin('removeCoupon_result')
10783 
    if self.scx != None:
10784 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10785 
      self.scx.write(oprot)
10786 
      oprot.writeFieldEnd()
10787 
    oprot.writeFieldStop()
10788 
    oprot.writeStructEnd()
10789 
 
10790 
  def __repr__(self):
10791 
    L = ['%s=%r' % (key, value)
10792 
      for key, value in self.__dict__.iteritems()]
10793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10794 
 
10795 
  def __eq__(self, other):
10796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10797 
 
10798 
  def __ne__(self, other):
10799 
    return not (self == other)
10800 
 
690 chandransh 10801 
class createOrders_args:
559 chandransh 10802 
  """
10803 
  Attributes:
10804 
   - cartId
10805 
  """
10806 
 
10807 
  thrift_spec = (
10808 
    None, # 0
10809 
    (1, TType.I64, 'cartId', None, None, ), # 1
10810 
  )
10811 
 
10812 
  def __init__(self, cartId=None,):
10813 
    self.cartId = cartId
10814 
 
10815 
  def read(self, iprot):
10816 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10817 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10818 
      return
10819 
    iprot.readStructBegin()
10820 
    while True:
10821 
      (fname, ftype, fid) = iprot.readFieldBegin()
10822 
      if ftype == TType.STOP:
10823 
        break
10824 
      if fid == 1:
10825 
        if ftype == TType.I64:
10826 
          self.cartId = iprot.readI64();
10827 
        else:
10828 
          iprot.skip(ftype)
10829 
      else:
10830 
        iprot.skip(ftype)
10831 
      iprot.readFieldEnd()
10832 
    iprot.readStructEnd()
10833 
 
10834 
  def write(self, oprot):
10835 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10836 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10837 
      return
690 chandransh 10838 
    oprot.writeStructBegin('createOrders_args')
559 chandransh 10839 
    if self.cartId != None:
10840 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10841 
      oprot.writeI64(self.cartId)
10842 
      oprot.writeFieldEnd()
10843 
    oprot.writeFieldStop()
10844 
    oprot.writeStructEnd()
10845 
 
10846 
  def __repr__(self):
10847 
    L = ['%s=%r' % (key, value)
10848 
      for key, value in self.__dict__.iteritems()]
10849 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10850 
 
10851 
  def __eq__(self, other):
10852 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10853 
 
10854 
  def __ne__(self, other):
10855 
    return not (self == other)
10856 
 
690 chandransh 10857 
class createOrders_result:
559 chandransh 10858 
  """
10859 
  Attributes:
94 ashish 10860 
   - success
559 chandransh 10861 
   - scx
94 ashish 10862 
  """
10863 
 
10864 
  thrift_spec = (
575 chandransh 10865 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 10866 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10867 
  )
10868 
 
559 chandransh 10869 
  def __init__(self, success=None, scx=None,):
94 ashish 10870 
    self.success = success
559 chandransh 10871 
    self.scx = scx
94 ashish 10872 
 
10873 
  def read(self, iprot):
10874 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10875 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10876 
      return
10877 
    iprot.readStructBegin()
10878 
    while True:
10879 
      (fname, ftype, fid) = iprot.readFieldBegin()
10880 
      if ftype == TType.STOP:
10881 
        break
10882 
      if fid == 0:
575 chandransh 10883 
        if ftype == TType.I64:
10884 
          self.success = iprot.readI64();
94 ashish 10885 
        else:
10886 
          iprot.skip(ftype)
10887 
      elif fid == 1:
10888 
        if ftype == TType.STRUCT:
559 chandransh 10889 
          self.scx = ShoppingCartException()
10890 
          self.scx.read(iprot)
94 ashish 10891 
        else:
10892 
          iprot.skip(ftype)
10893 
      else:
10894 
        iprot.skip(ftype)
10895 
      iprot.readFieldEnd()
10896 
    iprot.readStructEnd()
10897 
 
10898 
  def write(self, oprot):
10899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10901 
      return
690 chandransh 10902 
    oprot.writeStructBegin('createOrders_result')
94 ashish 10903 
    if self.success != None:
575 chandransh 10904 
      oprot.writeFieldBegin('success', TType.I64, 0)
10905 
      oprot.writeI64(self.success)
94 ashish 10906 
      oprot.writeFieldEnd()
559 chandransh 10907 
    if self.scx != None:
10908 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10909 
      self.scx.write(oprot)
94 ashish 10910 
      oprot.writeFieldEnd()
10911 
    oprot.writeFieldStop()
10912 
    oprot.writeStructEnd()
10913 
 
10914 
  def __repr__(self):
10915 
    L = ['%s=%r' % (key, value)
10916 
      for key, value in self.__dict__.iteritems()]
10917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10918 
 
10919 
  def __eq__(self, other):
10920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10921 
 
10922 
  def __ne__(self, other):
10923 
    return not (self == other)
10924 
 
559 chandransh 10925 
class validateCart_args:
94 ashish 10926 
  """
10927 
  Attributes:
559 chandransh 10928 
   - cartId
94 ashish 10929 
  """
10930 
 
10931 
  thrift_spec = (
10932 
    None, # 0
559 chandransh 10933 
    (1, TType.I64, 'cartId', None, None, ), # 1
94 ashish 10934 
  )
10935 
 
559 chandransh 10936 
  def __init__(self, cartId=None,):
10937 
    self.cartId = cartId
94 ashish 10938 
 
10939 
  def read(self, iprot):
10940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10942 
      return
10943 
    iprot.readStructBegin()
10944 
    while True:
10945 
      (fname, ftype, fid) = iprot.readFieldBegin()
10946 
      if ftype == TType.STOP:
10947 
        break
10948 
      if fid == 1:
10949 
        if ftype == TType.I64:
559 chandransh 10950 
          self.cartId = iprot.readI64();
94 ashish 10951 
        else:
10952 
          iprot.skip(ftype)
10953 
      else:
10954 
        iprot.skip(ftype)
10955 
      iprot.readFieldEnd()
10956 
    iprot.readStructEnd()
10957 
 
10958 
  def write(self, oprot):
10959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10961 
      return
559 chandransh 10962 
    oprot.writeStructBegin('validateCart_args')
10963 
    if self.cartId != None:
10964 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10965 
      oprot.writeI64(self.cartId)
94 ashish 10966 
      oprot.writeFieldEnd()
10967 
    oprot.writeFieldStop()
10968 
    oprot.writeStructEnd()
10969 
 
10970 
  def __repr__(self):
10971 
    L = ['%s=%r' % (key, value)
10972 
      for key, value in self.__dict__.iteritems()]
10973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10974 
 
10975 
  def __eq__(self, other):
10976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10977 
 
10978 
  def __ne__(self, other):
10979 
    return not (self == other)
10980 
 
559 chandransh 10981 
class validateCart_result:
94 ashish 10982 
  """
10983 
  Attributes:
10984 
   - success
575 chandransh 10985 
   - scex
94 ashish 10986 
  """
10987 
 
10988 
  thrift_spec = (
1466 ankur.sing 10989 
    (0, TType.STRING, 'success', None, None, ), # 0
575 chandransh 10990 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10991 
  )
10992 
 
575 chandransh 10993 
  def __init__(self, success=None, scex=None,):
94 ashish 10994 
    self.success = success
575 chandransh 10995 
    self.scex = scex
94 ashish 10996 
 
10997 
  def read(self, iprot):
10998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11000 
      return
11001 
    iprot.readStructBegin()
11002 
    while True:
11003 
      (fname, ftype, fid) = iprot.readFieldBegin()
11004 
      if ftype == TType.STOP:
11005 
        break
11006 
      if fid == 0:
1466 ankur.sing 11007 
        if ftype == TType.STRING:
11008 
          self.success = iprot.readString();
94 ashish 11009 
        else:
11010 
          iprot.skip(ftype)
575 chandransh 11011 
      elif fid == 1:
11012 
        if ftype == TType.STRUCT:
11013 
          self.scex = ShoppingCartException()
11014 
          self.scex.read(iprot)
11015 
        else:
11016 
          iprot.skip(ftype)
94 ashish 11017 
      else:
11018 
        iprot.skip(ftype)
11019 
      iprot.readFieldEnd()
11020 
    iprot.readStructEnd()
11021 
 
11022 
  def write(self, oprot):
11023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11025 
      return
559 chandransh 11026 
    oprot.writeStructBegin('validateCart_result')
94 ashish 11027 
    if self.success != None:
1466 ankur.sing 11028 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11029 
      oprot.writeString(self.success)
94 ashish 11030 
      oprot.writeFieldEnd()
575 chandransh 11031 
    if self.scex != None:
11032 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11033 
      self.scex.write(oprot)
11034 
      oprot.writeFieldEnd()
559 chandransh 11035 
    oprot.writeFieldStop()
11036 
    oprot.writeStructEnd()
11037 
 
11038 
  def __repr__(self):
11039 
    L = ['%s=%r' % (key, value)
11040 
      for key, value in self.__dict__.iteritems()]
11041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11042 
 
11043 
  def __eq__(self, other):
11044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11045 
 
11046 
  def __ne__(self, other):
11047 
    return not (self == other)
11048 
 
690 chandransh 11049 
class mergeCart_args:
575 chandransh 11050 
  """
11051 
  Attributes:
690 chandransh 11052 
   - fromCartId
11053 
   - toCartId
11054 
  """
11055 
 
11056 
  thrift_spec = (
11057 
    None, # 0
11058 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
11059 
    (2, TType.I64, 'toCartId', None, None, ), # 2
11060 
  )
11061 
 
11062 
  def __init__(self, fromCartId=None, toCartId=None,):
11063 
    self.fromCartId = fromCartId
11064 
    self.toCartId = toCartId
11065 
 
11066 
  def read(self, iprot):
11067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11069 
      return
11070 
    iprot.readStructBegin()
11071 
    while True:
11072 
      (fname, ftype, fid) = iprot.readFieldBegin()
11073 
      if ftype == TType.STOP:
11074 
        break
11075 
      if fid == 1:
11076 
        if ftype == TType.I64:
11077 
          self.fromCartId = iprot.readI64();
11078 
        else:
11079 
          iprot.skip(ftype)
11080 
      elif fid == 2:
11081 
        if ftype == TType.I64:
11082 
          self.toCartId = iprot.readI64();
11083 
        else:
11084 
          iprot.skip(ftype)
11085 
      else:
11086 
        iprot.skip(ftype)
11087 
      iprot.readFieldEnd()
11088 
    iprot.readStructEnd()
11089 
 
11090 
  def write(self, oprot):
11091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11093 
      return
11094 
    oprot.writeStructBegin('mergeCart_args')
11095 
    if self.fromCartId != None:
11096 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
11097 
      oprot.writeI64(self.fromCartId)
11098 
      oprot.writeFieldEnd()
11099 
    if self.toCartId != None:
11100 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
11101 
      oprot.writeI64(self.toCartId)
11102 
      oprot.writeFieldEnd()
11103 
    oprot.writeFieldStop()
11104 
    oprot.writeStructEnd()
11105 
 
11106 
  def __repr__(self):
11107 
    L = ['%s=%r' % (key, value)
11108 
      for key, value in self.__dict__.iteritems()]
11109 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11110 
 
11111 
  def __eq__(self, other):
11112 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11113 
 
11114 
  def __ne__(self, other):
11115 
    return not (self == other)
11116 
 
11117 
class mergeCart_result:
11118 
 
11119 
  thrift_spec = (
11120 
  )
11121 
 
11122 
  def read(self, iprot):
11123 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11124 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11125 
      return
11126 
    iprot.readStructBegin()
11127 
    while True:
11128 
      (fname, ftype, fid) = iprot.readFieldBegin()
11129 
      if ftype == TType.STOP:
11130 
        break
11131 
      else:
11132 
        iprot.skip(ftype)
11133 
      iprot.readFieldEnd()
11134 
    iprot.readStructEnd()
11135 
 
11136 
  def write(self, oprot):
11137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11139 
      return
11140 
    oprot.writeStructBegin('mergeCart_result')
11141 
    oprot.writeFieldStop()
11142 
    oprot.writeStructEnd()
11143 
 
11144 
  def __repr__(self):
11145 
    L = ['%s=%r' % (key, value)
11146 
      for key, value in self.__dict__.iteritems()]
11147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11148 
 
11149 
  def __eq__(self, other):
11150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11151 
 
11152 
  def __ne__(self, other):
11153 
    return not (self == other)
11154 
 
11155 
class checkOut_args:
11156 
  """
11157 
  Attributes:
575 chandransh 11158 
   - cartId
11159 
  """
11160 
 
11161 
  thrift_spec = (
11162 
    None, # 0
11163 
    (1, TType.I64, 'cartId', None, None, ), # 1
11164 
  )
11165 
 
11166 
  def __init__(self, cartId=None,):
11167 
    self.cartId = cartId
11168 
 
11169 
  def read(self, iprot):
11170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11172 
      return
11173 
    iprot.readStructBegin()
11174 
    while True:
11175 
      (fname, ftype, fid) = iprot.readFieldBegin()
11176 
      if ftype == TType.STOP:
11177 
        break
11178 
      if fid == 1:
11179 
        if ftype == TType.I64:
11180 
          self.cartId = iprot.readI64();
11181 
        else:
11182 
          iprot.skip(ftype)
11183 
      else:
11184 
        iprot.skip(ftype)
11185 
      iprot.readFieldEnd()
11186 
    iprot.readStructEnd()
11187 
 
11188 
  def write(self, oprot):
11189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11191 
      return
690 chandransh 11192 
    oprot.writeStructBegin('checkOut_args')
575 chandransh 11193 
    if self.cartId != None:
11194 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11195 
      oprot.writeI64(self.cartId)
11196 
      oprot.writeFieldEnd()
11197 
    oprot.writeFieldStop()
11198 
    oprot.writeStructEnd()
11199 
 
11200 
  def __repr__(self):
11201 
    L = ['%s=%r' % (key, value)
11202 
      for key, value in self.__dict__.iteritems()]
11203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11204 
 
11205 
  def __eq__(self, other):
11206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11207 
 
11208 
  def __ne__(self, other):
11209 
    return not (self == other)
11210 
 
690 chandransh 11211 
class checkOut_result:
575 chandransh 11212 
  """
11213 
  Attributes:
11214 
   - success
11215 
   - scex
11216 
  """
11217 
 
11218 
  thrift_spec = (
11219 
    (0, TType.BOOL, 'success', None, None, ), # 0
11220 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11221 
  )
11222 
 
11223 
  def __init__(self, success=None, scex=None,):
11224 
    self.success = success
11225 
    self.scex = scex
11226 
 
11227 
  def read(self, iprot):
11228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11230 
      return
11231 
    iprot.readStructBegin()
11232 
    while True:
11233 
      (fname, ftype, fid) = iprot.readFieldBegin()
11234 
      if ftype == TType.STOP:
11235 
        break
11236 
      if fid == 0:
11237 
        if ftype == TType.BOOL:
11238 
          self.success = iprot.readBool();
11239 
        else:
11240 
          iprot.skip(ftype)
11241 
      elif fid == 1:
11242 
        if ftype == TType.STRUCT:
11243 
          self.scex = ShoppingCartException()
11244 
          self.scex.read(iprot)
11245 
        else:
11246 
          iprot.skip(ftype)
11247 
      else:
11248 
        iprot.skip(ftype)
11249 
      iprot.readFieldEnd()
11250 
    iprot.readStructEnd()
11251 
 
11252 
  def write(self, oprot):
11253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11255 
      return
690 chandransh 11256 
    oprot.writeStructBegin('checkOut_result')
575 chandransh 11257 
    if self.success != None:
11258 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11259 
      oprot.writeBool(self.success)
11260 
      oprot.writeFieldEnd()
11261 
    if self.scex != None:
11262 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11263 
      self.scex.write(oprot)
11264 
      oprot.writeFieldEnd()
11265 
    oprot.writeFieldStop()
11266 
    oprot.writeStructEnd()
11267 
 
11268 
  def __repr__(self):
11269 
    L = ['%s=%r' % (key, value)
11270 
      for key, value in self.__dict__.iteritems()]
11271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11272 
 
11273 
  def __eq__(self, other):
11274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11275 
 
11276 
  def __ne__(self, other):
11277 
    return not (self == other)
11278 
 
690 chandransh 11279 
class resetCart_args:
559 chandransh 11280 
  """
11281 
  Attributes:
690 chandransh 11282 
   - cartId
11283 
   - items
559 chandransh 11284 
  """
11285 
 
11286 
  thrift_spec = (
11287 
    None, # 0
690 chandransh 11288 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 11289 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 11290 
  )
11291 
 
690 chandransh 11292 
  def __init__(self, cartId=None, items=None,):
11293 
    self.cartId = cartId
11294 
    self.items = items
559 chandransh 11295 
 
11296 
  def read(self, iprot):
11297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11299 
      return
11300 
    iprot.readStructBegin()
11301 
    while True:
11302 
      (fname, ftype, fid) = iprot.readFieldBegin()
11303 
      if ftype == TType.STOP:
11304 
        break
11305 
      if fid == 1:
11306 
        if ftype == TType.I64:
690 chandransh 11307 
          self.cartId = iprot.readI64();
559 chandransh 11308 
        else:
11309 
          iprot.skip(ftype)
11310 
      elif fid == 2:
690 chandransh 11311 
        if ftype == TType.MAP:
11312 
          self.items = {}
1996 vikas 11313 
          (_ktype113, _vtype114, _size112 ) = iprot.readMapBegin()
11314 
          for _i116 in xrange(_size112):
11315 
            _key117 = iprot.readI64();
11316 
            _val118 = iprot.readDouble();
11317 
            self.items[_key117] = _val118
690 chandransh 11318 
          iprot.readMapEnd()
559 chandransh 11319 
        else:
11320 
          iprot.skip(ftype)
11321 
      else:
11322 
        iprot.skip(ftype)
11323 
      iprot.readFieldEnd()
11324 
    iprot.readStructEnd()
11325 
 
11326 
  def write(self, oprot):
11327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11329 
      return
690 chandransh 11330 
    oprot.writeStructBegin('resetCart_args')
11331 
    if self.cartId != None:
11332 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11333 
      oprot.writeI64(self.cartId)
94 ashish 11334 
      oprot.writeFieldEnd()
690 chandransh 11335 
    if self.items != None:
11336 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 11337 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
1996 vikas 11338 
      for kiter119,viter120 in self.items.items():
11339 
        oprot.writeI64(kiter119)
11340 
        oprot.writeDouble(viter120)
690 chandransh 11341 
      oprot.writeMapEnd()
559 chandransh 11342 
      oprot.writeFieldEnd()
94 ashish 11343 
    oprot.writeFieldStop()
11344 
    oprot.writeStructEnd()
11345 
 
11346 
  def __repr__(self):
11347 
    L = ['%s=%r' % (key, value)
11348 
      for key, value in self.__dict__.iteritems()]
11349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11350 
 
11351 
  def __eq__(self, other):
11352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11353 
 
11354 
  def __ne__(self, other):
11355 
    return not (self == other)
11356 
 
690 chandransh 11357 
class resetCart_result:
11358 
  """
11359 
  Attributes:
11360 
   - success
11361 
   - scex
11362 
  """
559 chandransh 11363 
 
11364 
  thrift_spec = (
690 chandransh 11365 
    (0, TType.BOOL, 'success', None, None, ), # 0
11366 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11367 
  )
11368 
 
690 chandransh 11369 
  def __init__(self, success=None, scex=None,):
11370 
    self.success = success
11371 
    self.scex = scex
11372 
 
559 chandransh 11373 
  def read(self, iprot):
11374 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11375 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11376 
      return
11377 
    iprot.readStructBegin()
11378 
    while True:
11379 
      (fname, ftype, fid) = iprot.readFieldBegin()
11380 
      if ftype == TType.STOP:
11381 
        break
690 chandransh 11382 
      if fid == 0:
11383 
        if ftype == TType.BOOL:
11384 
          self.success = iprot.readBool();
11385 
        else:
11386 
          iprot.skip(ftype)
11387 
      elif fid == 1:
11388 
        if ftype == TType.STRUCT:
11389 
          self.scex = ShoppingCartException()
11390 
          self.scex.read(iprot)
11391 
        else:
11392 
          iprot.skip(ftype)
559 chandransh 11393 
      else:
11394 
        iprot.skip(ftype)
11395 
      iprot.readFieldEnd()
11396 
    iprot.readStructEnd()
11397 
 
11398 
  def write(self, oprot):
11399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11401 
      return
690 chandransh 11402 
    oprot.writeStructBegin('resetCart_result')
11403 
    if self.success != None:
11404 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11405 
      oprot.writeBool(self.success)
11406 
      oprot.writeFieldEnd()
11407 
    if self.scex != None:
11408 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11409 
      self.scex.write(oprot)
11410 
      oprot.writeFieldEnd()
559 chandransh 11411 
    oprot.writeFieldStop()
11412 
    oprot.writeStructEnd()
11413 
 
11414 
  def __repr__(self):
11415 
    L = ['%s=%r' % (key, value)
11416 
      for key, value in self.__dict__.iteritems()]
11417 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11418 
 
11419 
  def __eq__(self, other):
11420 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11421 
 
11422 
  def __ne__(self, other):
11423 
    return not (self == other)
11424 
 
772 rajveer 11425 
class getMyResearch_args:
94 ashish 11426 
  """
11427 
  Attributes:
559 chandransh 11428 
   - userId
11429 
  """
11430 
 
11431 
  thrift_spec = (
11432 
    None, # 0
772 rajveer 11433 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 11434 
  )
11435 
 
772 rajveer 11436 
  def __init__(self, userId=None,):
559 chandransh 11437 
    self.userId = userId
11438 
 
11439 
  def read(self, iprot):
11440 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11441 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11442 
      return
11443 
    iprot.readStructBegin()
11444 
    while True:
11445 
      (fname, ftype, fid) = iprot.readFieldBegin()
11446 
      if ftype == TType.STOP:
11447 
        break
11448 
      if fid == 1:
11449 
        if ftype == TType.I64:
11450 
          self.userId = iprot.readI64();
11451 
        else:
11452 
          iprot.skip(ftype)
11453 
      else:
11454 
        iprot.skip(ftype)
11455 
      iprot.readFieldEnd()
11456 
    iprot.readStructEnd()
11457 
 
11458 
  def write(self, oprot):
11459 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11460 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11461 
      return
772 rajveer 11462 
    oprot.writeStructBegin('getMyResearch_args')
559 chandransh 11463 
    if self.userId != None:
772 rajveer 11464 
      oprot.writeFieldBegin('userId', TType.I64, 1)
559 chandransh 11465 
      oprot.writeI64(self.userId)
11466 
      oprot.writeFieldEnd()
11467 
    oprot.writeFieldStop()
11468 
    oprot.writeStructEnd()
11469 
 
11470 
  def __repr__(self):
11471 
    L = ['%s=%r' % (key, value)
11472 
      for key, value in self.__dict__.iteritems()]
11473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11474 
 
11475 
  def __eq__(self, other):
11476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11477 
 
11478 
  def __ne__(self, other):
11479 
    return not (self == other)
11480 
 
11481 
class getMyResearch_result:
94 ashish 11482 
  """
11483 
  Attributes:
11484 
   - success
559 chandransh 11485 
   - scx
94 ashish 11486 
  """
11487 
 
11488 
  thrift_spec = (
559 chandransh 11489 
    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
11490 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
94 ashish 11491 
  )
11492 
 
559 chandransh 11493 
  def __init__(self, success=None, scx=None,):
94 ashish 11494 
    self.success = success
559 chandransh 11495 
    self.scx = scx
94 ashish 11496 
 
11497 
  def read(self, iprot):
11498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11500 
      return
11501 
    iprot.readStructBegin()
11502 
    while True:
11503 
      (fname, ftype, fid) = iprot.readFieldBegin()
11504 
      if ftype == TType.STOP:
11505 
        break
11506 
      if fid == 0:
559 chandransh 11507 
        if ftype == TType.STRUCT:
11508 
          self.success = Widget()
11509 
          self.success.read(iprot)
94 ashish 11510 
        else:
11511 
          iprot.skip(ftype)
11512 
      elif fid == 1:
11513 
        if ftype == TType.STRUCT:
559 chandransh 11514 
          self.scx = WidgetException()
11515 
          self.scx.read(iprot)
94 ashish 11516 
        else:
11517 
          iprot.skip(ftype)
11518 
      else:
11519 
        iprot.skip(ftype)
11520 
      iprot.readFieldEnd()
11521 
    iprot.readStructEnd()
11522 
 
11523 
  def write(self, oprot):
11524 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11525 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11526 
      return
559 chandransh 11527 
    oprot.writeStructBegin('getMyResearch_result')
94 ashish 11528 
    if self.success != None:
559 chandransh 11529 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11530 
      self.success.write(oprot)
94 ashish 11531 
      oprot.writeFieldEnd()
559 chandransh 11532 
    if self.scx != None:
11533 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11534 
      self.scx.write(oprot)
94 ashish 11535 
      oprot.writeFieldEnd()
11536 
    oprot.writeFieldStop()
11537 
    oprot.writeStructEnd()
11538 
 
11539 
  def __repr__(self):
11540 
    L = ['%s=%r' % (key, value)
11541 
      for key, value in self.__dict__.iteritems()]
11542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11543 
 
11544 
  def __eq__(self, other):
11545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11546 
 
11547 
  def __ne__(self, other):
11548 
    return not (self == other)
11549 
 
559 chandransh 11550 
class updateMyResearch_args:
94 ashish 11551 
  """
11552 
  Attributes:
772 rajveer 11553 
   - userId
11554 
   - itemId
94 ashish 11555 
  """
11556 
 
11557 
  thrift_spec = (
11558 
    None, # 0
772 rajveer 11559 
    (1, TType.I64, 'userId', None, None, ), # 1
11560 
    (2, TType.I64, 'itemId', None, None, ), # 2
94 ashish 11561 
  )
11562 
 
772 rajveer 11563 
  def __init__(self, userId=None, itemId=None,):
11564 
    self.userId = userId
11565 
    self.itemId = itemId
94 ashish 11566 
 
11567 
  def read(self, iprot):
11568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11570 
      return
11571 
    iprot.readStructBegin()
11572 
    while True:
11573 
      (fname, ftype, fid) = iprot.readFieldBegin()
11574 
      if ftype == TType.STOP:
11575 
        break
11576 
      if fid == 1:
11577 
        if ftype == TType.I64:
772 rajveer 11578 
          self.userId = iprot.readI64();
94 ashish 11579 
        else:
11580 
          iprot.skip(ftype)
11581 
      elif fid == 2:
559 chandransh 11582 
        if ftype == TType.I64:
772 rajveer 11583 
          self.itemId = iprot.readI64();
94 ashish 11584 
        else:
11585 
          iprot.skip(ftype)
11586 
      else:
11587 
        iprot.skip(ftype)
11588 
      iprot.readFieldEnd()
11589 
    iprot.readStructEnd()
11590 
 
11591 
  def write(self, oprot):
11592 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11593 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11594 
      return
559 chandransh 11595 
    oprot.writeStructBegin('updateMyResearch_args')
772 rajveer 11596 
    if self.userId != None:
11597 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11598 
      oprot.writeI64(self.userId)
94 ashish 11599 
      oprot.writeFieldEnd()
772 rajveer 11600 
    if self.itemId != None:
11601 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11602 
      oprot.writeI64(self.itemId)
94 ashish 11603 
      oprot.writeFieldEnd()
11604 
    oprot.writeFieldStop()
11605 
    oprot.writeStructEnd()
11606 
 
11607 
  def __repr__(self):
11608 
    L = ['%s=%r' % (key, value)
11609 
      for key, value in self.__dict__.iteritems()]
11610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11611 
 
11612 
  def __eq__(self, other):
11613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11614 
 
11615 
  def __ne__(self, other):
11616 
    return not (self == other)
11617 
 
559 chandransh 11618 
class updateMyResearch_result:
94 ashish 11619 
  """
11620 
  Attributes:
11621 
   - success
559 chandransh 11622 
   - scx
94 ashish 11623 
  """
11624 
 
11625 
  thrift_spec = (
11626 
    (0, TType.BOOL, 'success', None, None, ), # 0
559 chandransh 11627 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
94 ashish 11628 
  )
11629 
 
559 chandransh 11630 
  def __init__(self, success=None, scx=None,):
94 ashish 11631 
    self.success = success
559 chandransh 11632 
    self.scx = scx
94 ashish 11633 
 
11634 
  def read(self, iprot):
11635 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11636 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11637 
      return
11638 
    iprot.readStructBegin()
11639 
    while True:
11640 
      (fname, ftype, fid) = iprot.readFieldBegin()
11641 
      if ftype == TType.STOP:
11642 
        break
11643 
      if fid == 0:
11644 
        if ftype == TType.BOOL:
11645 
          self.success = iprot.readBool();
11646 
        else:
11647 
          iprot.skip(ftype)
11648 
      elif fid == 1:
11649 
        if ftype == TType.STRUCT:
559 chandransh 11650 
          self.scx = WidgetException()
11651 
          self.scx.read(iprot)
94 ashish 11652 
        else:
11653 
          iprot.skip(ftype)
11654 
      else:
11655 
        iprot.skip(ftype)
11656 
      iprot.readFieldEnd()
11657 
    iprot.readStructEnd()
11658 
 
11659 
  def write(self, oprot):
11660 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11661 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11662 
      return
559 chandransh 11663 
    oprot.writeStructBegin('updateMyResearch_result')
94 ashish 11664 
    if self.success != None:
11665 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11666 
      oprot.writeBool(self.success)
11667 
      oprot.writeFieldEnd()
559 chandransh 11668 
    if self.scx != None:
11669 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11670 
      self.scx.write(oprot)
94 ashish 11671 
      oprot.writeFieldEnd()
11672 
    oprot.writeFieldStop()
11673 
    oprot.writeStructEnd()
11674 
 
11675 
  def __repr__(self):
11676 
    L = ['%s=%r' % (key, value)
11677 
      for key, value in self.__dict__.iteritems()]
11678 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11679 
 
11680 
  def __eq__(self, other):
11681 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11682 
 
11683 
  def __ne__(self, other):
11684 
    return not (self == other)
11685 
 
559 chandransh 11686 
class deleteItemFromMyResearch_args:
130 ashish 11687 
  """
11688 
  Attributes:
772 rajveer 11689 
   - userId
11690 
   - itemId
130 ashish 11691 
  """
94 ashish 11692 
 
130 ashish 11693 
  thrift_spec = (
11694 
    None, # 0
772 rajveer 11695 
    (1, TType.I64, 'userId', None, None, ), # 1
11696 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 11697 
  )
11698 
 
772 rajveer 11699 
  def __init__(self, userId=None, itemId=None,):
11700 
    self.userId = userId
11701 
    self.itemId = itemId
130 ashish 11702 
 
11703 
  def read(self, iprot):
11704 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11705 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11706 
      return
11707 
    iprot.readStructBegin()
11708 
    while True:
11709 
      (fname, ftype, fid) = iprot.readFieldBegin()
11710 
      if ftype == TType.STOP:
11711 
        break
11712 
      if fid == 1:
11713 
        if ftype == TType.I64:
772 rajveer 11714 
          self.userId = iprot.readI64();
130 ashish 11715 
        else:
11716 
          iprot.skip(ftype)
559 chandransh 11717 
      elif fid == 2:
11718 
        if ftype == TType.I64:
772 rajveer 11719 
          self.itemId = iprot.readI64();
559 chandransh 11720 
        else:
11721 
          iprot.skip(ftype)
130 ashish 11722 
      else:
11723 
        iprot.skip(ftype)
11724 
      iprot.readFieldEnd()
11725 
    iprot.readStructEnd()
11726 
 
11727 
  def write(self, oprot):
11728 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11729 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11730 
      return
559 chandransh 11731 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
772 rajveer 11732 
    if self.userId != None:
11733 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11734 
      oprot.writeI64(self.userId)
130 ashish 11735 
      oprot.writeFieldEnd()
772 rajveer 11736 
    if self.itemId != None:
11737 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11738 
      oprot.writeI64(self.itemId)
559 chandransh 11739 
      oprot.writeFieldEnd()
130 ashish 11740 
    oprot.writeFieldStop()
11741 
    oprot.writeStructEnd()
11742 
 
11743 
  def __repr__(self):
11744 
    L = ['%s=%r' % (key, value)
11745 
      for key, value in self.__dict__.iteritems()]
11746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11747 
 
11748 
  def __eq__(self, other):
11749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11750 
 
11751 
  def __ne__(self, other):
11752 
    return not (self == other)
11753 
 
559 chandransh 11754 
class deleteItemFromMyResearch_result:
130 ashish 11755 
  """
11756 
  Attributes:
559 chandransh 11757 
   - scx
11758 
  """
11759 
 
11760 
  thrift_spec = (
11761 
    None, # 0
11762 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
11763 
  )
11764 
 
11765 
  def __init__(self, scx=None,):
11766 
    self.scx = scx
11767 
 
11768 
  def read(self, iprot):
11769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11771 
      return
11772 
    iprot.readStructBegin()
11773 
    while True:
11774 
      (fname, ftype, fid) = iprot.readFieldBegin()
11775 
      if ftype == TType.STOP:
11776 
        break
11777 
      if fid == 1:
11778 
        if ftype == TType.STRUCT:
11779 
          self.scx = WidgetException()
11780 
          self.scx.read(iprot)
11781 
        else:
11782 
          iprot.skip(ftype)
11783 
      else:
11784 
        iprot.skip(ftype)
11785 
      iprot.readFieldEnd()
11786 
    iprot.readStructEnd()
11787 
 
11788 
  def write(self, oprot):
11789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11791 
      return
11792 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
11793 
    if self.scx != None:
11794 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11795 
      self.scx.write(oprot)
11796 
      oprot.writeFieldEnd()
11797 
    oprot.writeFieldStop()
11798 
    oprot.writeStructEnd()
11799 
 
11800 
  def __repr__(self):
11801 
    L = ['%s=%r' % (key, value)
11802 
      for key, value in self.__dict__.iteritems()]
11803 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11804 
 
11805 
  def __eq__(self, other):
11806 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11807 
 
11808 
  def __ne__(self, other):
11809 
    return not (self == other)
11810 
 
772 rajveer 11811 
class updateBrowseHistory_args:
559 chandransh 11812 
  """
11813 
  Attributes:
772 rajveer 11814 
   - userId
11815 
   - itemId
559 chandransh 11816 
  """
11817 
 
11818 
  thrift_spec = (
11819 
    None, # 0
772 rajveer 11820 
    (1, TType.I64, 'userId', None, None, ), # 1
11821 
    (2, TType.I64, 'itemId', None, None, ), # 2
559 chandransh 11822 
  )
11823 
 
772 rajveer 11824 
  def __init__(self, userId=None, itemId=None,):
11825 
    self.userId = userId
11826 
    self.itemId = itemId
559 chandransh 11827 
 
11828 
  def read(self, iprot):
11829 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11830 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11831 
      return
11832 
    iprot.readStructBegin()
11833 
    while True:
11834 
      (fname, ftype, fid) = iprot.readFieldBegin()
11835 
      if ftype == TType.STOP:
11836 
        break
11837 
      if fid == 1:
11838 
        if ftype == TType.I64:
772 rajveer 11839 
          self.userId = iprot.readI64();
559 chandransh 11840 
        else:
11841 
          iprot.skip(ftype)
11842 
      elif fid == 2:
11843 
        if ftype == TType.I64:
772 rajveer 11844 
          self.itemId = iprot.readI64();
559 chandransh 11845 
        else:
11846 
          iprot.skip(ftype)
11847 
      else:
11848 
        iprot.skip(ftype)
11849 
      iprot.readFieldEnd()
11850 
    iprot.readStructEnd()
11851 
 
11852 
  def write(self, oprot):
11853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11855 
      return
772 rajveer 11856 
    oprot.writeStructBegin('updateBrowseHistory_args')
11857 
    if self.userId != None:
11858 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11859 
      oprot.writeI64(self.userId)
559 chandransh 11860 
      oprot.writeFieldEnd()
772 rajveer 11861 
    if self.itemId != None:
11862 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11863 
      oprot.writeI64(self.itemId)
559 chandransh 11864 
      oprot.writeFieldEnd()
11865 
    oprot.writeFieldStop()
11866 
    oprot.writeStructEnd()
11867 
 
11868 
  def __repr__(self):
11869 
    L = ['%s=%r' % (key, value)
11870 
      for key, value in self.__dict__.iteritems()]
11871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11872 
 
11873 
  def __eq__(self, other):
11874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11875 
 
11876 
  def __ne__(self, other):
11877 
    return not (self == other)
11878 
 
772 rajveer 11879 
class updateBrowseHistory_result:
559 chandransh 11880 
 
11881 
  thrift_spec = (
11882 
  )
11883 
 
11884 
  def read(self, iprot):
11885 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11886 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11887 
      return
11888 
    iprot.readStructBegin()
11889 
    while True:
11890 
      (fname, ftype, fid) = iprot.readFieldBegin()
11891 
      if ftype == TType.STOP:
11892 
        break
11893 
      else:
11894 
        iprot.skip(ftype)
11895 
      iprot.readFieldEnd()
11896 
    iprot.readStructEnd()
11897 
 
11898 
  def write(self, oprot):
11899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11901 
      return
772 rajveer 11902 
    oprot.writeStructBegin('updateBrowseHistory_result')
559 chandransh 11903 
    oprot.writeFieldStop()
11904 
    oprot.writeStructEnd()
11905 
 
11906 
  def __repr__(self):
11907 
    L = ['%s=%r' % (key, value)
11908 
      for key, value in self.__dict__.iteritems()]
11909 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11910 
 
11911 
  def __eq__(self, other):
11912 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11913 
 
11914 
  def __ne__(self, other):
11915 
    return not (self == other)
11916 
 
772 rajveer 11917 
class getBrowseHistory_args:
559 chandransh 11918 
  """
11919 
  Attributes:
772 rajveer 11920 
   - userId
559 chandransh 11921 
  """
11922 
 
11923 
  thrift_spec = (
11924 
    None, # 0
772 rajveer 11925 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 11926 
  )
11927 
 
772 rajveer 11928 
  def __init__(self, userId=None,):
11929 
    self.userId = userId
559 chandransh 11930 
 
11931 
  def read(self, iprot):
11932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11934 
      return
11935 
    iprot.readStructBegin()
11936 
    while True:
11937 
      (fname, ftype, fid) = iprot.readFieldBegin()
11938 
      if ftype == TType.STOP:
11939 
        break
11940 
      if fid == 1:
11941 
        if ftype == TType.I64:
772 rajveer 11942 
          self.userId = iprot.readI64();
559 chandransh 11943 
        else:
11944 
          iprot.skip(ftype)
11945 
      else:
11946 
        iprot.skip(ftype)
11947 
      iprot.readFieldEnd()
11948 
    iprot.readStructEnd()
11949 
 
11950 
  def write(self, oprot):
11951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11953 
      return
772 rajveer 11954 
    oprot.writeStructBegin('getBrowseHistory_args')
11955 
    if self.userId != None:
11956 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11957 
      oprot.writeI64(self.userId)
559 chandransh 11958 
      oprot.writeFieldEnd()
11959 
    oprot.writeFieldStop()
11960 
    oprot.writeStructEnd()
11961 
 
11962 
  def __repr__(self):
11963 
    L = ['%s=%r' % (key, value)
11964 
      for key, value in self.__dict__.iteritems()]
11965 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11966 
 
11967 
  def __eq__(self, other):
11968 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11969 
 
11970 
  def __ne__(self, other):
11971 
    return not (self == other)
11972 
 
772 rajveer 11973 
class getBrowseHistory_result:
559 chandransh 11974 
  """
11975 
  Attributes:
130 ashish 11976 
   - success
559 chandransh 11977 
   - scx
130 ashish 11978 
  """
11979 
 
11980 
  thrift_spec = (
772 rajveer 11981 
    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
559 chandransh 11982 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 11983 
  )
11984 
 
559 chandransh 11985 
  def __init__(self, success=None, scx=None,):
130 ashish 11986 
    self.success = success
559 chandransh 11987 
    self.scx = scx
130 ashish 11988 
 
11989 
  def read(self, iprot):
11990 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11991 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11992 
      return
11993 
    iprot.readStructBegin()
11994 
    while True:
11995 
      (fname, ftype, fid) = iprot.readFieldBegin()
11996 
      if ftype == TType.STOP:
11997 
        break
11998 
      if fid == 0:
559 chandransh 11999 
        if ftype == TType.STRUCT:
772 rajveer 12000 
          self.success = Widget()
559 chandransh 12001 
          self.success.read(iprot)
130 ashish 12002 
        else:
12003 
          iprot.skip(ftype)
12004 
      elif fid == 1:
12005 
        if ftype == TType.STRUCT:
559 chandransh 12006 
          self.scx = WidgetException()
12007 
          self.scx.read(iprot)
130 ashish 12008 
        else:
12009 
          iprot.skip(ftype)
12010 
      else:
12011 
        iprot.skip(ftype)
12012 
      iprot.readFieldEnd()
12013 
    iprot.readStructEnd()
12014 
 
12015 
  def write(self, oprot):
12016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12018 
      return
772 rajveer 12019 
    oprot.writeStructBegin('getBrowseHistory_result')
130 ashish 12020 
    if self.success != None:
559 chandransh 12021 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12022 
      self.success.write(oprot)
130 ashish 12023 
      oprot.writeFieldEnd()
559 chandransh 12024 
    if self.scx != None:
12025 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12026 
      self.scx.write(oprot)
130 ashish 12027 
      oprot.writeFieldEnd()
12028 
    oprot.writeFieldStop()
12029 
    oprot.writeStructEnd()
12030 
 
12031 
  def __repr__(self):
12032 
    L = ['%s=%r' % (key, value)
12033 
      for key, value in self.__dict__.iteritems()]
12034 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12035 
 
12036 
  def __eq__(self, other):
12037 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12038 
 
12039 
  def __ne__(self, other):
12040 
    return not (self == other)
12041 
 
772 rajveer 12042 
class mergeBrowseHistory_args:
130 ashish 12043 
  """
12044 
  Attributes:
772 rajveer 12045 
   - fromUserId
12046 
   - toUserId
130 ashish 12047 
  """
12048 
 
12049 
  thrift_spec = (
12050 
    None, # 0
772 rajveer 12051 
    (1, TType.I64, 'fromUserId', None, None, ), # 1
12052 
    (2, TType.I64, 'toUserId', None, None, ), # 2
130 ashish 12053 
  )
12054 
 
772 rajveer 12055 
  def __init__(self, fromUserId=None, toUserId=None,):
12056 
    self.fromUserId = fromUserId
12057 
    self.toUserId = toUserId
130 ashish 12058 
 
12059 
  def read(self, iprot):
12060 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12061 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12062 
      return
12063 
    iprot.readStructBegin()
12064 
    while True:
12065 
      (fname, ftype, fid) = iprot.readFieldBegin()
12066 
      if ftype == TType.STOP:
12067 
        break
12068 
      if fid == 1:
559 chandransh 12069 
        if ftype == TType.I64:
772 rajveer 12070 
          self.fromUserId = iprot.readI64();
130 ashish 12071 
        else:
12072 
          iprot.skip(ftype)
12073 
      elif fid == 2:
559 chandransh 12074 
        if ftype == TType.I64:
772 rajveer 12075 
          self.toUserId = iprot.readI64();
559 chandransh 12076 
        else:
12077 
          iprot.skip(ftype)
130 ashish 12078 
      else:
12079 
        iprot.skip(ftype)
12080 
      iprot.readFieldEnd()
12081 
    iprot.readStructEnd()
12082 
 
12083 
  def write(self, oprot):
12084 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12085 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12086 
      return
772 rajveer 12087 
    oprot.writeStructBegin('mergeBrowseHistory_args')
12088 
    if self.fromUserId != None:
12089 
      oprot.writeFieldBegin('fromUserId', TType.I64, 1)
12090 
      oprot.writeI64(self.fromUserId)
130 ashish 12091 
      oprot.writeFieldEnd()
772 rajveer 12092 
    if self.toUserId != None:
12093 
      oprot.writeFieldBegin('toUserId', TType.I64, 2)
12094 
      oprot.writeI64(self.toUserId)
130 ashish 12095 
      oprot.writeFieldEnd()
12096 
    oprot.writeFieldStop()
12097 
    oprot.writeStructEnd()
12098 
 
12099 
  def __repr__(self):
12100 
    L = ['%s=%r' % (key, value)
12101 
      for key, value in self.__dict__.iteritems()]
12102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12103 
 
12104 
  def __eq__(self, other):
12105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12106 
 
12107 
  def __ne__(self, other):
12108 
    return not (self == other)
12109 
 
772 rajveer 12110 
class mergeBrowseHistory_result:
559 chandransh 12111 
 
12112 
  thrift_spec = (
12113 
  )
12114 
 
12115 
  def read(self, iprot):
12116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12118 
      return
12119 
    iprot.readStructBegin()
12120 
    while True:
12121 
      (fname, ftype, fid) = iprot.readFieldBegin()
12122 
      if ftype == TType.STOP:
12123 
        break
12124 
      else:
12125 
        iprot.skip(ftype)
12126 
      iprot.readFieldEnd()
12127 
    iprot.readStructEnd()
12128 
 
12129 
  def write(self, oprot):
12130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12132 
      return
772 rajveer 12133 
    oprot.writeStructBegin('mergeBrowseHistory_result')
559 chandransh 12134 
    oprot.writeFieldStop()
12135 
    oprot.writeStructEnd()
12136 
 
12137 
  def __repr__(self):
12138 
    L = ['%s=%r' % (key, value)
12139 
      for key, value in self.__dict__.iteritems()]
12140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12141 
 
12142 
  def __eq__(self, other):
12143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12144 
 
12145 
  def __ne__(self, other):
12146 
    return not (self == other)
12147 
 
1596 ankur.sing 12148 
class getUserCount_args:
12149 
  """
12150 
  Attributes:
12151 
   - userType
12152 
  """
559 chandransh 12153 
 
1596 ankur.sing 12154 
  thrift_spec = (
12155 
    None, # 0
12156 
    (1, TType.I32, 'userType', None, None, ), # 1
12157 
  )
12158 
 
12159 
  def __init__(self, userType=None,):
12160 
    self.userType = userType
12161 
 
12162 
  def read(self, iprot):
12163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12165 
      return
12166 
    iprot.readStructBegin()
12167 
    while True:
12168 
      (fname, ftype, fid) = iprot.readFieldBegin()
12169 
      if ftype == TType.STOP:
12170 
        break
12171 
      if fid == 1:
12172 
        if ftype == TType.I32:
12173 
          self.userType = iprot.readI32();
12174 
        else:
12175 
          iprot.skip(ftype)
12176 
      else:
12177 
        iprot.skip(ftype)
12178 
      iprot.readFieldEnd()
12179 
    iprot.readStructEnd()
12180 
 
12181 
  def write(self, oprot):
12182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12184 
      return
12185 
    oprot.writeStructBegin('getUserCount_args')
12186 
    if self.userType != None:
12187 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12188 
      oprot.writeI32(self.userType)
12189 
      oprot.writeFieldEnd()
12190 
    oprot.writeFieldStop()
12191 
    oprot.writeStructEnd()
12192 
 
12193 
  def __repr__(self):
12194 
    L = ['%s=%r' % (key, value)
12195 
      for key, value in self.__dict__.iteritems()]
12196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12197 
 
12198 
  def __eq__(self, other):
12199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12200 
 
12201 
  def __ne__(self, other):
12202 
    return not (self == other)
12203 
 
12204 
class getUserCount_result:
12205 
  """
12206 
  Attributes:
12207 
   - success
12208 
  """
12209 
 
12210 
  thrift_spec = (
12211 
    (0, TType.I64, 'success', None, None, ), # 0
12212 
  )
12213 
 
12214 
  def __init__(self, success=None,):
12215 
    self.success = success
12216 
 
12217 
  def read(self, iprot):
12218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12220 
      return
12221 
    iprot.readStructBegin()
12222 
    while True:
12223 
      (fname, ftype, fid) = iprot.readFieldBegin()
12224 
      if ftype == TType.STOP:
12225 
        break
12226 
      if fid == 0:
12227 
        if ftype == TType.I64:
12228 
          self.success = iprot.readI64();
12229 
        else:
12230 
          iprot.skip(ftype)
12231 
      else:
12232 
        iprot.skip(ftype)
12233 
      iprot.readFieldEnd()
12234 
    iprot.readStructEnd()
12235 
 
12236 
  def write(self, oprot):
12237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12239 
      return
12240 
    oprot.writeStructBegin('getUserCount_result')
12241 
    if self.success != None:
12242 
      oprot.writeFieldBegin('success', TType.I64, 0)
12243 
      oprot.writeI64(self.success)
12244 
      oprot.writeFieldEnd()
12245 
    oprot.writeFieldStop()
12246 
    oprot.writeStructEnd()
12247 
 
12248 
  def __repr__(self):
12249 
    L = ['%s=%r' % (key, value)
12250 
      for key, value in self.__dict__.iteritems()]
12251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12252 
 
12253 
  def __eq__(self, other):
12254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12255 
 
12256 
  def __ne__(self, other):
12257 
    return not (self == other)
12258 
 
1673 ankur.sing 12259 
class getAllUsers_args:
12260 
  """
12261 
  Attributes:
12262 
   - userType
1891 ankur.sing 12263 
   - startDate
12264 
   - endDate
1673 ankur.sing 12265 
  """
1596 ankur.sing 12266 
 
1673 ankur.sing 12267 
  thrift_spec = (
12268 
    None, # 0
12269 
    (1, TType.I32, 'userType', None, None, ), # 1
1891 ankur.sing 12270 
    (2, TType.I64, 'startDate', None, None, ), # 2
12271 
    (3, TType.I64, 'endDate', None, None, ), # 3
1673 ankur.sing 12272 
  )
12273 
 
1891 ankur.sing 12274 
  def __init__(self, userType=None, startDate=None, endDate=None,):
1673 ankur.sing 12275 
    self.userType = userType
1891 ankur.sing 12276 
    self.startDate = startDate
12277 
    self.endDate = endDate
1673 ankur.sing 12278 
 
12279 
  def read(self, iprot):
12280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12282 
      return
12283 
    iprot.readStructBegin()
12284 
    while True:
12285 
      (fname, ftype, fid) = iprot.readFieldBegin()
12286 
      if ftype == TType.STOP:
12287 
        break
12288 
      if fid == 1:
12289 
        if ftype == TType.I32:
12290 
          self.userType = iprot.readI32();
12291 
        else:
12292 
          iprot.skip(ftype)
1891 ankur.sing 12293 
      elif fid == 2:
12294 
        if ftype == TType.I64:
12295 
          self.startDate = iprot.readI64();
12296 
        else:
12297 
          iprot.skip(ftype)
12298 
      elif fid == 3:
12299 
        if ftype == TType.I64:
12300 
          self.endDate = iprot.readI64();
12301 
        else:
12302 
          iprot.skip(ftype)
1673 ankur.sing 12303 
      else:
12304 
        iprot.skip(ftype)
12305 
      iprot.readFieldEnd()
12306 
    iprot.readStructEnd()
12307 
 
12308 
  def write(self, oprot):
12309 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12310 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12311 
      return
12312 
    oprot.writeStructBegin('getAllUsers_args')
12313 
    if self.userType != None:
12314 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12315 
      oprot.writeI32(self.userType)
12316 
      oprot.writeFieldEnd()
1891 ankur.sing 12317 
    if self.startDate != None:
12318 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
12319 
      oprot.writeI64(self.startDate)
12320 
      oprot.writeFieldEnd()
12321 
    if self.endDate != None:
12322 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
12323 
      oprot.writeI64(self.endDate)
12324 
      oprot.writeFieldEnd()
1673 ankur.sing 12325 
    oprot.writeFieldStop()
12326 
    oprot.writeStructEnd()
12327 
 
12328 
  def __repr__(self):
12329 
    L = ['%s=%r' % (key, value)
12330 
      for key, value in self.__dict__.iteritems()]
12331 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12332 
 
12333 
  def __eq__(self, other):
12334 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12335 
 
12336 
  def __ne__(self, other):
12337 
    return not (self == other)
12338 
 
12339 
class getAllUsers_result:
12340 
  """
12341 
  Attributes:
12342 
   - success
12343 
  """
12344 
 
12345 
  thrift_spec = (
12346 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
12347 
  )
12348 
 
12349 
  def __init__(self, success=None,):
12350 
    self.success = success
12351 
 
12352 
  def read(self, iprot):
12353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12355 
      return
12356 
    iprot.readStructBegin()
12357 
    while True:
12358 
      (fname, ftype, fid) = iprot.readFieldBegin()
12359 
      if ftype == TType.STOP:
12360 
        break
12361 
      if fid == 0:
12362 
        if ftype == TType.LIST:
12363 
          self.success = []
1996 vikas 12364 
          (_etype124, _size121) = iprot.readListBegin()
12365 
          for _i125 in xrange(_size121):
12366 
            _elem126 = User()
12367 
            _elem126.read(iprot)
12368 
            self.success.append(_elem126)
1673 ankur.sing 12369 
          iprot.readListEnd()
12370 
        else:
12371 
          iprot.skip(ftype)
12372 
      else:
12373 
        iprot.skip(ftype)
12374 
      iprot.readFieldEnd()
12375 
    iprot.readStructEnd()
12376 
 
12377 
  def write(self, oprot):
12378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12380 
      return
12381 
    oprot.writeStructBegin('getAllUsers_result')
12382 
    if self.success != None:
12383 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12384 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 12385 
      for iter127 in self.success:
12386 
        iter127.write(oprot)
1673 ankur.sing 12387 
      oprot.writeListEnd()
12388 
      oprot.writeFieldEnd()
12389 
    oprot.writeFieldStop()
12390 
    oprot.writeStructEnd()
12391 
 
12392 
  def __repr__(self):
12393 
    L = ['%s=%r' % (key, value)
12394 
      for key, value in self.__dict__.iteritems()]
12395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12396 
 
12397 
  def __eq__(self, other):
12398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12399 
 
12400 
  def __ne__(self, other):
12401 
    return not (self == other)
12402 
 
12403