Subversion Repositories SmartDukaan

Rev

Rev 1891 | Rev 1899 | 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 
 
217 
  def getMasterAffiliateById(self, id):
218 
    """
219 
    Parameters:
220 
     - id
221 
    """
222 
    pass
223 
 
224 
  def getMasterAffiliateByName(self, name):
225 
    """
226 
    Parameters:
227 
     - name
228 
    """
229 
    pass
230 
 
1859 vikas 231 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 232 
    """
233 
    Parameters:
234 
     - name
235 
     - url
236 
     - masterAffiliateId
1859 vikas 237 
     - addedOn
1845 vikas 238 
    """
239 
    pass
240 
 
241 
  def getAffiliateById(self, id):
242 
    """
243 
    Parameters:
244 
     - id
245 
    """
246 
    pass
247 
 
248 
  def getAffiliateByName(self, name):
249 
    """
250 
    Parameters:
251 
     - name
252 
    """
253 
    pass
254 
 
255 
  def getAffiliatesByMasterAffiliate(self, id):
256 
    """
257 
    Parameters:
258 
     - id
259 
    """
260 
    pass
261 
 
1859 vikas 262 
  def createTracker(self, affiliateId, addedOn):
1845 vikas 263 
    """
264 
    Parameters:
265 
     - affiliateId
1859 vikas 266 
     - addedOn
1845 vikas 267 
    """
268 
    pass
269 
 
270 
  def getTrackerById(self, trackerId):
271 
    """
272 
    Parameters:
273 
     - trackerId
274 
    """
275 
    pass
276 
 
277 
  def getTrackersByAffiliate(self, affiliateId):
278 
    """
279 
    Parameters:
280 
     - affiliateId
281 
    """
282 
    pass
283 
 
1859 vikas 284 
  def addTrackLog(self, trackerId, userId, event, url, data, addedOn):
1845 vikas 285 
    """
286 
    Parameters:
287 
     - trackerId
288 
     - userId
289 
     - event
290 
     - url
291 
     - data
1859 vikas 292 
     - addedOn
1845 vikas 293 
    """
294 
    pass
295 
 
296 
  def getTrackLogById(self, id):
297 
    """
298 
    Parameters:
299 
     - id
300 
    """
301 
    pass
302 
 
303 
  def getTrackLogsByTracker(self, trackerId):
304 
    """
305 
    Parameters:
306 
     - trackerId
307 
    """
308 
    pass
309 
 
310 
  def getTrackLogsByUser(self, userId):
311 
    """
312 
    Parameters:
313 
     - userId
314 
    """
315 
    pass
316 
 
317 
  def getTrackLogs(self, trackerId, userId, event, url):
318 
    """
319 
    Parameters:
320 
     - trackerId
321 
     - userId
322 
     - event
323 
     - url
324 
    """
325 
    pass
326 
 
559 chandransh 327 
  def createCart(self, userId):
94 ashish 328 
    """
329 
    Parameters:
559 chandransh 330 
     - userId
94 ashish 331 
    """
332 
    pass
333 
 
559 chandransh 334 
  def getCurrentCart(self, userId):
94 ashish 335 
    """
336 
    Parameters:
559 chandransh 337 
     - userId
94 ashish 338 
    """
339 
    pass
340 
 
559 chandransh 341 
  def getCart(self, cartId):
94 ashish 342 
    """
343 
    Parameters:
559 chandransh 344 
     - cartId
94 ashish 345 
    """
346 
    pass
347 
 
559 chandransh 348 
  def getCartsForUser(self, userId, status):
94 ashish 349 
    """
350 
    Parameters:
559 chandransh 351 
     - userId
352 
     - status
94 ashish 353 
    """
354 
    pass
355 
 
559 chandransh 356 
  def getCartsByStatus(self, status):
94 ashish 357 
    """
358 
    Parameters:
559 chandransh 359 
     - status
94 ashish 360 
    """
361 
    pass
362 
 
559 chandransh 363 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 364 
    """
365 
    Parameters:
559 chandransh 366 
     - from_time
367 
     - to_time
368 
     - status
94 ashish 369 
    """
370 
    pass
371 
 
559 chandransh 372 
  def changeCartStatus(self, cartId, status):
130 ashish 373 
    """
374 
    Parameters:
559 chandransh 375 
     - cartId
376 
     - status
130 ashish 377 
    """
378 
    pass
94 ashish 379 
 
559 chandransh 380 
  def addItemToCart(self, cartId, itemId, quantity):
130 ashish 381 
    """
382 
    Parameters:
559 chandransh 383 
     - cartId
384 
     - itemId
385 
     - quantity
130 ashish 386 
    """
387 
    pass
388 
 
559 chandransh 389 
  def deleteItemFromCart(self, cartId, itemId):
390 
    """
391 
    Parameters:
392 
     - cartId
393 
     - itemId
394 
    """
395 
    pass
130 ashish 396 
 
559 chandransh 397 
  def changeQuantity(self, cartId, itemId, quantity):
398 
    """
399 
    Parameters:
400 
     - cartId
401 
     - itemId
402 
     - quantity
403 
    """
404 
    pass
405 
 
406 
  def changeItemStatus(self, cartId, itemId, status):
407 
    """
408 
    Parameters:
409 
     - cartId
410 
     - itemId
411 
     - status
412 
    """
413 
    pass
414 
 
415 
  def addAddressToCart(self, cartId, addressId):
416 
    """
417 
    Parameters:
418 
     - cartId
419 
     - addressId
420 
    """
421 
    pass
422 
 
690 chandransh 423 
  def createOrders(self, cartId):
559 chandransh 424 
    """
690 chandransh 425 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
426 
 
559 chandransh 427 
    Parameters:
428 
     - cartId
429 
    """
430 
    pass
431 
 
432 
  def validateCart(self, cartId):
433 
    """
690 chandransh 434 
    Validates that:
435 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 436 
    2. All of the lines in the cart are active items.
690 chandransh 437 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 438 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 439 
 
559 chandransh 440 
    Parameters:
441 
     - cartId
442 
    """
443 
    pass
444 
 
690 chandransh 445 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 446 
    """
690 chandransh 447 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
448 
 
575 chandransh 449 
    Parameters:
690 chandransh 450 
     - fromCartId
451 
     - toCartId
452 
    """
453 
    pass
454 
 
455 
  def checkOut(self, cartId):
456 
    """
457 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
458 
 
459 
    Parameters:
575 chandransh 460 
     - cartId
461 
    """
462 
    pass
463 
 
690 chandransh 464 
  def resetCart(self, cartId, items):
559 chandransh 465 
    """
690 chandransh 466 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
467 
    This methods removes the specified quantiry of the specified item from the cart.
468 
 
559 chandransh 469 
    Parameters:
690 chandransh 470 
     - cartId
471 
     - items
559 chandransh 472 
    """
473 
    pass
474 
 
772 rajveer 475 
  def getMyResearch(self, userId):
559 chandransh 476 
    """
772 rajveer 477 
    Widgets
478 
 
559 chandransh 479 
    Parameters:
772 rajveer 480 
     - userId
559 chandransh 481 
    """
482 
    pass
483 
 
772 rajveer 484 
  def updateMyResearch(self, userId, itemId):
559 chandransh 485 
    """
486 
    Parameters:
772 rajveer 487 
     - userId
488 
     - itemId
559 chandransh 489 
    """
490 
    pass
491 
 
772 rajveer 492 
  def deleteItemFromMyResearch(self, userId, itemId):
559 chandransh 493 
    """
494 
    Parameters:
772 rajveer 495 
     - userId
496 
     - itemId
559 chandransh 497 
    """
498 
    pass
499 
 
772 rajveer 500 
  def updateBrowseHistory(self, userId, itemId):
559 chandransh 501 
    """
502 
    Parameters:
772 rajveer 503 
     - userId
504 
     - itemId
559 chandransh 505 
    """
506 
    pass
507 
 
772 rajveer 508 
  def getBrowseHistory(self, userId):
559 chandransh 509 
    """
510 
    Parameters:
511 
     - userId
512 
    """
513 
    pass
514 
 
772 rajveer 515 
  def mergeBrowseHistory(self, fromUserId, toUserId):
559 chandransh 516 
    """
517 
    Parameters:
772 rajveer 518 
     - fromUserId
519 
     - toUserId
559 chandransh 520 
    """
521 
    pass
522 
 
1596 ankur.sing 523 
  def getUserCount(self, userType):
524 
    """
525 
    Returns number of registered users.
526 
    If userType = null, then it returns count of all users, including anonymous
527 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
528 
    If userType = UserType.USER, then it returns count of non-anonymous users only
529 
 
530 
    Parameters:
531 
     - userType
532 
    """
533 
    pass
559 chandransh 534 
 
1891 ankur.sing 535 
  def getAllUsers(self, userType, startDate, endDate):
1673 ankur.sing 536 
    """
1891 ankur.sing 537 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
538 
    If any of startDate or endDate is -1, then that filter is ignored.
539 
    If userType is null, then returns all the users, irrespective of anonymous flag
1673 ankur.sing 540 
 
1891 ankur.sing 541 
 
1673 ankur.sing 542 
    Parameters:
543 
     - userType
1891 ankur.sing 544 
     - startDate
545 
     - endDate
1673 ankur.sing 546 
    """
547 
    pass
1596 ankur.sing 548 
 
1673 ankur.sing 549 
 
94 ashish 550 
class Client(Iface):
551 
  """
552 
  service
553 
  """
554 
  def __init__(self, iprot, oprot=None):
555 
    self._iprot = self._oprot = iprot
556 
    if oprot != None:
557 
      self._oprot = oprot
558 
    self._seqid = 0
559 
 
765 rajveer 560 
  def closeSession(self, ):
561 
    """
562 
    For closing the open session in sqlalchemy
563 
    """
564 
    self.send_closeSession()
565 
    self.recv_closeSession()
566 
 
567 
  def send_closeSession(self, ):
568 
    self._oprot.writeMessageBegin('closeSession', TMessageType.CALL, self._seqid)
569 
    args = closeSession_args()
570 
    args.write(self._oprot)
571 
    self._oprot.writeMessageEnd()
572 
    self._oprot.trans.flush()
573 
 
574 
  def recv_closeSession(self, ):
575 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
576 
    if mtype == TMessageType.EXCEPTION:
577 
      x = TApplicationException()
578 
      x.read(self._iprot)
579 
      self._iprot.readMessageEnd()
580 
      raise x
581 
    result = closeSession_result()
582 
    result.read(self._iprot)
583 
    self._iprot.readMessageEnd()
584 
    return
585 
 
559 chandransh 586 
  def createAnonymousUser(self, jsessionId):
94 ashish 587 
    """
588 
    Parameters:
559 chandransh 589 
     - jsessionId
94 ashish 590 
    """
559 chandransh 591 
    self.send_createAnonymousUser(jsessionId)
592 
    return self.recv_createAnonymousUser()
94 ashish 593 
 
559 chandransh 594 
  def send_createAnonymousUser(self, jsessionId):
595 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
596 
    args = createAnonymousUser_args()
597 
    args.jsessionId = jsessionId
94 ashish 598 
    args.write(self._oprot)
599 
    self._oprot.writeMessageEnd()
600 
    self._oprot.trans.flush()
601 
 
559 chandransh 602 
  def recv_createAnonymousUser(self, ):
94 ashish 603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
604 
    if mtype == TMessageType.EXCEPTION:
605 
      x = TApplicationException()
606 
      x.read(self._iprot)
607 
      self._iprot.readMessageEnd()
608 
      raise x
559 chandransh 609 
    result = createAnonymousUser_result()
94 ashish 610 
    result.read(self._iprot)
611 
    self._iprot.readMessageEnd()
612 
    if result.success != None:
613 
      return result.success
559 chandransh 614 
    if result.ucex != None:
615 
      raise result.ucex
616 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 617 
 
559 chandransh 618 
  def getUserById(self, userId):
94 ashish 619 
    """
620 
    Parameters:
621 
     - userId
622 
    """
559 chandransh 623 
    self.send_getUserById(userId)
624 
    return self.recv_getUserById()
94 ashish 625 
 
559 chandransh 626 
  def send_getUserById(self, userId):
627 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
628 
    args = getUserById_args()
94 ashish 629 
    args.userId = userId
630 
    args.write(self._oprot)
631 
    self._oprot.writeMessageEnd()
632 
    self._oprot.trans.flush()
633 
 
559 chandransh 634 
  def recv_getUserById(self, ):
94 ashish 635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
636 
    if mtype == TMessageType.EXCEPTION:
637 
      x = TApplicationException()
638 
      x.read(self._iprot)
639 
      self._iprot.readMessageEnd()
640 
      raise x
559 chandransh 641 
    result = getUserById_result()
94 ashish 642 
    result.read(self._iprot)
643 
    self._iprot.readMessageEnd()
644 
    if result.success != None:
645 
      return result.success
559 chandransh 646 
    if result.ucex != None:
647 
      raise result.ucex
648 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 649 
 
1491 vikas 650 
  def getUserByEmail(self, email):
651 
    """
652 
    Parameters:
653 
     - email
654 
    """
655 
    self.send_getUserByEmail(email)
656 
    return self.recv_getUserByEmail()
657 
 
658 
  def send_getUserByEmail(self, email):
659 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
660 
    args = getUserByEmail_args()
661 
    args.email = email
662 
    args.write(self._oprot)
663 
    self._oprot.writeMessageEnd()
664 
    self._oprot.trans.flush()
665 
 
666 
  def recv_getUserByEmail(self, ):
667 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
668 
    if mtype == TMessageType.EXCEPTION:
669 
      x = TApplicationException()
670 
      x.read(self._iprot)
671 
      self._iprot.readMessageEnd()
672 
      raise x
673 
    result = getUserByEmail_result()
674 
    result.read(self._iprot)
675 
    self._iprot.readMessageEnd()
676 
    if result.success != None:
677 
      return result.success
678 
    if result.ucex != None:
679 
      raise result.ucex
680 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
681 
 
559 chandransh 682 
  def createUser(self, user):
94 ashish 683 
    """
684 
    Parameters:
559 chandransh 685 
     - user
94 ashish 686 
    """
559 chandransh 687 
    self.send_createUser(user)
688 
    return self.recv_createUser()
94 ashish 689 
 
559 chandransh 690 
  def send_createUser(self, user):
691 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
692 
    args = createUser_args()
693 
    args.user = user
94 ashish 694 
    args.write(self._oprot)
695 
    self._oprot.writeMessageEnd()
696 
    self._oprot.trans.flush()
697 
 
559 chandransh 698 
  def recv_createUser(self, ):
94 ashish 699 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
700 
    if mtype == TMessageType.EXCEPTION:
701 
      x = TApplicationException()
702 
      x.read(self._iprot)
703 
      self._iprot.readMessageEnd()
704 
      raise x
559 chandransh 705 
    result = createUser_result()
94 ashish 706 
    result.read(self._iprot)
707 
    self._iprot.readMessageEnd()
708 
    if result.success != None:
709 
      return result.success
559 chandransh 710 
    if result.ucex != None:
711 
      raise result.ucex
712 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 713 
 
559 chandransh 714 
  def updateUser(self, user):
94 ashish 715 
    """
716 
    Parameters:
559 chandransh 717 
     - user
94 ashish 718 
    """
559 chandransh 719 
    self.send_updateUser(user)
720 
    return self.recv_updateUser()
94 ashish 721 
 
559 chandransh 722 
  def send_updateUser(self, user):
723 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
724 
    args = updateUser_args()
725 
    args.user = user
94 ashish 726 
    args.write(self._oprot)
727 
    self._oprot.writeMessageEnd()
728 
    self._oprot.trans.flush()
729 
 
559 chandransh 730 
  def recv_updateUser(self, ):
94 ashish 731 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
732 
    if mtype == TMessageType.EXCEPTION:
733 
      x = TApplicationException()
734 
      x.read(self._iprot)
735 
      self._iprot.readMessageEnd()
736 
      raise x
559 chandransh 737 
    result = updateUser_result()
94 ashish 738 
    result.read(self._iprot)
739 
    self._iprot.readMessageEnd()
740 
    if result.success != None:
741 
      return result.success
559 chandransh 742 
    if result.ucex != None:
743 
      raise result.ucex
744 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 745 
 
559 chandransh 746 
  def deleteUser(self, userId):
94 ashish 747 
    """
748 
    Parameters:
749 
     - userId
750 
    """
559 chandransh 751 
    self.send_deleteUser(userId)
752 
    return self.recv_deleteUser()
94 ashish 753 
 
559 chandransh 754 
  def send_deleteUser(self, userId):
755 
    self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
756 
    args = deleteUser_args()
94 ashish 757 
    args.userId = userId
758 
    args.write(self._oprot)
759 
    self._oprot.writeMessageEnd()
760 
    self._oprot.trans.flush()
761 
 
559 chandransh 762 
  def recv_deleteUser(self, ):
94 ashish 763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
764 
    if mtype == TMessageType.EXCEPTION:
765 
      x = TApplicationException()
766 
      x.read(self._iprot)
767 
      self._iprot.readMessageEnd()
768 
      raise x
559 chandransh 769 
    result = deleteUser_result()
94 ashish 770 
    result.read(self._iprot)
771 
    self._iprot.readMessageEnd()
772 
    if result.success != None:
773 
      return result.success
559 chandransh 774 
    if result.ucex != None:
775 
      raise result.ucex
776 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
94 ashish 777 
 
559 chandransh 778 
  def getUserState(self, userId):
94 ashish 779 
    """
780 
    Parameters:
781 
     - userId
782 
    """
559 chandransh 783 
    self.send_getUserState(userId)
784 
    return self.recv_getUserState()
94 ashish 785 
 
559 chandransh 786 
  def send_getUserState(self, userId):
787 
    self._oprot.writeMessageBegin('getUserState', TMessageType.CALL, self._seqid)
788 
    args = getUserState_args()
94 ashish 789 
    args.userId = userId
790 
    args.write(self._oprot)
791 
    self._oprot.writeMessageEnd()
792 
    self._oprot.trans.flush()
793 
 
559 chandransh 794 
  def recv_getUserState(self, ):
94 ashish 795 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
796 
    if mtype == TMessageType.EXCEPTION:
797 
      x = TApplicationException()
798 
      x.read(self._iprot)
799 
      self._iprot.readMessageEnd()
800 
      raise x
559 chandransh 801 
    result = getUserState_result()
94 ashish 802 
    result.read(self._iprot)
803 
    self._iprot.readMessageEnd()
804 
    if result.success != None:
805 
      return result.success
559 chandransh 806 
    if result.ucex != None:
807 
      raise result.ucex
808 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserState failed: unknown result");
94 ashish 809 
 
559 chandransh 810 
  def authenticateUser(self, email, password):
94 ashish 811 
    """
812 
    Parameters:
813 
     - email
814 
     - password
815 
    """
559 chandransh 816 
    self.send_authenticateUser(email, password)
122 ashish 817 
    return self.recv_authenticateUser()
818 
 
559 chandransh 819 
  def send_authenticateUser(self, email, password):
122 ashish 820 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
821 
    args = authenticateUser_args()
559 chandransh 822 
    args.email = email
122 ashish 823 
    args.password = password
824 
    args.write(self._oprot)
825 
    self._oprot.writeMessageEnd()
826 
    self._oprot.trans.flush()
827 
 
828 
  def recv_authenticateUser(self, ):
829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
830 
    if mtype == TMessageType.EXCEPTION:
831 
      x = TApplicationException()
832 
      x.read(self._iprot)
833 
      self._iprot.readMessageEnd()
834 
      raise x
835 
    result = authenticateUser_result()
836 
    result.read(self._iprot)
837 
    self._iprot.readMessageEnd()
838 
    if result.success != None:
839 
      return result.success
559 chandransh 840 
    if result.auex != None:
841 
      raise result.auex
122 ashish 842 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
843 
 
94 ashish 844 
  def userExists(self, email):
845 
    """
846 
    Parameters:
847 
     - email
848 
    """
849 
    self.send_userExists(email)
850 
    return self.recv_userExists()
851 
 
852 
  def send_userExists(self, email):
853 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
854 
    args = userExists_args()
855 
    args.email = email
856 
    args.write(self._oprot)
857 
    self._oprot.writeMessageEnd()
858 
    self._oprot.trans.flush()
859 
 
860 
  def recv_userExists(self, ):
861 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
862 
    if mtype == TMessageType.EXCEPTION:
863 
      x = TApplicationException()
864 
      x.read(self._iprot)
865 
      self._iprot.readMessageEnd()
866 
      raise x
867 
    result = userExists_result()
868 
    result.read(self._iprot)
869 
    self._iprot.readMessageEnd()
870 
    if result.success != None:
871 
      return result.success
872 
    if result.ucx != None:
873 
      raise result.ucx
874 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
875 
 
567 rajveer 876 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 877 
    """
878 
    Parameters:
879 
     - userId
880 
     - address
513 rajveer 881 
     - setDefault
94 ashish 882 
    """
567 rajveer 883 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 884 
    return self.recv_addAddressForUser()
885 
 
567 rajveer 886 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 887 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
888 
    args = addAddressForUser_args()
559 chandransh 889 
    args.userId = userId
94 ashish 890 
    args.address = address
513 rajveer 891 
    args.setDefault = setDefault
94 ashish 892 
    args.write(self._oprot)
893 
    self._oprot.writeMessageEnd()
894 
    self._oprot.trans.flush()
895 
 
896 
  def recv_addAddressForUser(self, ):
897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
898 
    if mtype == TMessageType.EXCEPTION:
899 
      x = TApplicationException()
900 
      x.read(self._iprot)
901 
      self._iprot.readMessageEnd()
902 
      raise x
903 
    result = addAddressForUser_result()
904 
    result.read(self._iprot)
905 
    self._iprot.readMessageEnd()
906 
    if result.success != None:
907 
      return result.success
908 
    if result.ucx != None:
909 
      raise result.ucx
910 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
911 
 
912 
  def removeAddressForUser(self, userid, addressId):
913 
    """
914 
    Parameters:
915 
     - userid
916 
     - addressId
917 
    """
918 
    self.send_removeAddressForUser(userid, addressId)
919 
    return self.recv_removeAddressForUser()
920 
 
921 
  def send_removeAddressForUser(self, userid, addressId):
922 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
923 
    args = removeAddressForUser_args()
924 
    args.userid = userid
925 
    args.addressId = addressId
926 
    args.write(self._oprot)
927 
    self._oprot.writeMessageEnd()
928 
    self._oprot.trans.flush()
929 
 
930 
  def recv_removeAddressForUser(self, ):
931 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
932 
    if mtype == TMessageType.EXCEPTION:
933 
      x = TApplicationException()
934 
      x.read(self._iprot)
935 
      self._iprot.readMessageEnd()
936 
      raise x
937 
    result = removeAddressForUser_result()
938 
    result.read(self._iprot)
939 
    self._iprot.readMessageEnd()
940 
    if result.success != None:
941 
      return result.success
942 
    if result.ucx != None:
943 
      raise result.ucx
944 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
945 
 
946 
  def setUserAsLoggedIn(self, userId, timestamp):
947 
    """
948 
    Parameters:
949 
     - userId
950 
     - timestamp
951 
    """
952 
    self.send_setUserAsLoggedIn(userId, timestamp)
953 
    return self.recv_setUserAsLoggedIn()
954 
 
955 
  def send_setUserAsLoggedIn(self, userId, timestamp):
956 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
957 
    args = setUserAsLoggedIn_args()
958 
    args.userId = userId
959 
    args.timestamp = timestamp
960 
    args.write(self._oprot)
961 
    self._oprot.writeMessageEnd()
962 
    self._oprot.trans.flush()
963 
 
964 
  def recv_setUserAsLoggedIn(self, ):
965 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
966 
    if mtype == TMessageType.EXCEPTION:
967 
      x = TApplicationException()
968 
      x.read(self._iprot)
969 
      self._iprot.readMessageEnd()
970 
      raise x
971 
    result = setUserAsLoggedIn_result()
972 
    result.read(self._iprot)
973 
    self._iprot.readMessageEnd()
974 
    if result.success != None:
975 
      return result.success
976 
    if result.ucx != None:
977 
      raise result.ucx
978 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
979 
 
980 
  def setUserAsLoggedOut(self, userid, timestamp):
981 
    """
982 
    Parameters:
983 
     - userid
984 
     - timestamp
985 
    """
986 
    self.send_setUserAsLoggedOut(userid, timestamp)
987 
    return self.recv_setUserAsLoggedOut()
988 
 
989 
  def send_setUserAsLoggedOut(self, userid, timestamp):
990 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
991 
    args = setUserAsLoggedOut_args()
992 
    args.userid = userid
993 
    args.timestamp = timestamp
994 
    args.write(self._oprot)
995 
    self._oprot.writeMessageEnd()
996 
    self._oprot.trans.flush()
997 
 
998 
  def recv_setUserAsLoggedOut(self, ):
999 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1000 
    if mtype == TMessageType.EXCEPTION:
1001 
      x = TApplicationException()
1002 
      x.read(self._iprot)
1003 
      self._iprot.readMessageEnd()
1004 
      raise x
1005 
    result = setUserAsLoggedOut_result()
1006 
    result.read(self._iprot)
1007 
    self._iprot.readMessageEnd()
1008 
    if result.success != None:
1009 
      return result.success
1010 
    if result.ucx != None:
1011 
      raise result.ucx
1012 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1013 
 
504 rajveer 1014 
  def setDefaultAddress(self, userid, addressId):
1015 
    """
1016 
    Parameters:
1017 
     - userid
1018 
     - addressId
1019 
    """
1020 
    self.send_setDefaultAddress(userid, addressId)
1021 
    return self.recv_setDefaultAddress()
1022 
 
1023 
  def send_setDefaultAddress(self, userid, addressId):
1024 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1025 
    args = setDefaultAddress_args()
1026 
    args.userid = userid
1027 
    args.addressId = addressId
1028 
    args.write(self._oprot)
1029 
    self._oprot.writeMessageEnd()
1030 
    self._oprot.trans.flush()
1031 
 
1032 
  def recv_setDefaultAddress(self, ):
1033 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1034 
    if mtype == TMessageType.EXCEPTION:
1035 
      x = TApplicationException()
1036 
      x.read(self._iprot)
1037 
      self._iprot.readMessageEnd()
1038 
      raise x
1039 
    result = setDefaultAddress_result()
1040 
    result.read(self._iprot)
1041 
    self._iprot.readMessageEnd()
1042 
    if result.success != None:
1043 
      return result.success
1044 
    if result.ucx != None:
1045 
      raise result.ucx
1046 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1047 
 
594 rajveer 1048 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1049 
    """
1050 
    Parameters:
1051 
     - userid
594 rajveer 1052 
     - oldPassword
1053 
     - newPassword
94 ashish 1054 
    """
594 rajveer 1055 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1056 
    return self.recv_updatePassword()
1057 
 
594 rajveer 1058 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1059 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1060 
    args = updatePassword_args()
1061 
    args.userid = userid
594 rajveer 1062 
    args.oldPassword = oldPassword
1063 
    args.newPassword = newPassword
94 ashish 1064 
    args.write(self._oprot)
1065 
    self._oprot.writeMessageEnd()
1066 
    self._oprot.trans.flush()
1067 
 
1068 
  def recv_updatePassword(self, ):
1069 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1070 
    if mtype == TMessageType.EXCEPTION:
1071 
      x = TApplicationException()
1072 
      x.read(self._iprot)
1073 
      self._iprot.readMessageEnd()
1074 
      raise x
1075 
    result = updatePassword_result()
1076 
    result.read(self._iprot)
1077 
    self._iprot.readMessageEnd()
1078 
    if result.success != None:
1079 
      return result.success
1080 
    if result.ucx != None:
1081 
      raise result.ucx
1082 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1083 
 
884 rajveer 1084 
  def forgotPassword(self, email, newPassword):
581 rajveer 1085 
    """
1086 
    Parameters:
1087 
     - email
884 rajveer 1088 
     - newPassword
581 rajveer 1089 
    """
884 rajveer 1090 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1091 
    return self.recv_forgotPassword()
1092 
 
884 rajveer 1093 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1094 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1095 
    args = forgotPassword_args()
1096 
    args.email = email
884 rajveer 1097 
    args.newPassword = newPassword
581 rajveer 1098 
    args.write(self._oprot)
1099 
    self._oprot.writeMessageEnd()
1100 
    self._oprot.trans.flush()
1101 
 
1102 
  def recv_forgotPassword(self, ):
1103 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1104 
    if mtype == TMessageType.EXCEPTION:
1105 
      x = TApplicationException()
1106 
      x.read(self._iprot)
1107 
      self._iprot.readMessageEnd()
1108 
      raise x
1109 
    result = forgotPassword_result()
1110 
    result.read(self._iprot)
1111 
    self._iprot.readMessageEnd()
1112 
    if result.success != None:
1113 
      return result.success
1114 
    if result.ucx != None:
1115 
      raise result.ucx
1116 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1117 
 
594 rajveer 1118 
  def getAllAddressesForUser(self, userId):
1119 
    """
1120 
    Parameters:
1121 
     - userId
1122 
    """
1123 
    self.send_getAllAddressesForUser(userId)
1124 
    return self.recv_getAllAddressesForUser()
1125 
 
1126 
  def send_getAllAddressesForUser(self, userId):
1127 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1128 
    args = getAllAddressesForUser_args()
1129 
    args.userId = userId
1130 
    args.write(self._oprot)
1131 
    self._oprot.writeMessageEnd()
1132 
    self._oprot.trans.flush()
1133 
 
1134 
  def recv_getAllAddressesForUser(self, ):
1135 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1136 
    if mtype == TMessageType.EXCEPTION:
1137 
      x = TApplicationException()
1138 
      x.read(self._iprot)
1139 
      self._iprot.readMessageEnd()
1140 
      raise x
1141 
    result = getAllAddressesForUser_result()
1142 
    result.read(self._iprot)
1143 
    self._iprot.readMessageEnd()
1144 
    if result.success != None:
1145 
      return result.success
1146 
    if result.ucx != None:
1147 
      raise result.ucx
1148 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1149 
 
1894 vikas 1150 
  def getAddressById(self, addressId):
1151 
    """
1152 
    Parameters:
1153 
     - addressId
1154 
    """
1155 
    self.send_getAddressById(addressId)
1156 
    return self.recv_getAddressById()
1157 
 
1158 
  def send_getAddressById(self, addressId):
1159 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1160 
    args = getAddressById_args()
1161 
    args.addressId = addressId
1162 
    args.write(self._oprot)
1163 
    self._oprot.writeMessageEnd()
1164 
    self._oprot.trans.flush()
1165 
 
1166 
  def recv_getAddressById(self, ):
1167 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1168 
    if mtype == TMessageType.EXCEPTION:
1169 
      x = TApplicationException()
1170 
      x.read(self._iprot)
1171 
      self._iprot.readMessageEnd()
1172 
      raise x
1173 
    result = getAddressById_result()
1174 
    result.read(self._iprot)
1175 
    self._iprot.readMessageEnd()
1176 
    if result.success != None:
1177 
      return result.success
1178 
    if result.ucx != None:
1179 
      raise result.ucx
1180 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1181 
 
594 rajveer 1182 
  def getDefaultAddressId(self, userId):
1183 
    """
1184 
    Parameters:
1185 
     - userId
1186 
    """
1187 
    self.send_getDefaultAddressId(userId)
1188 
    return self.recv_getDefaultAddressId()
1189 
 
1190 
  def send_getDefaultAddressId(self, userId):
1191 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1192 
    args = getDefaultAddressId_args()
1193 
    args.userId = userId
1194 
    args.write(self._oprot)
1195 
    self._oprot.writeMessageEnd()
1196 
    self._oprot.trans.flush()
1197 
 
1198 
  def recv_getDefaultAddressId(self, ):
1199 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1200 
    if mtype == TMessageType.EXCEPTION:
1201 
      x = TApplicationException()
1202 
      x.read(self._iprot)
1203 
      self._iprot.readMessageEnd()
1204 
      raise x
1205 
    result = getDefaultAddressId_result()
1206 
    result.read(self._iprot)
1207 
    self._iprot.readMessageEnd()
1208 
    if result.success != None:
1209 
      return result.success
1210 
    if result.ucx != None:
1211 
      raise result.ucx
1212 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1213 
 
785 rajveer 1214 
  def getDefaultPincode(self, userId):
1215 
    """
1216 
    Parameters:
1217 
     - userId
1218 
    """
1219 
    self.send_getDefaultPincode(userId)
1220 
    return self.recv_getDefaultPincode()
1221 
 
1222 
  def send_getDefaultPincode(self, userId):
1223 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1224 
    args = getDefaultPincode_args()
1225 
    args.userId = userId
1226 
    args.write(self._oprot)
1227 
    self._oprot.writeMessageEnd()
1228 
    self._oprot.trans.flush()
1229 
 
1230 
  def recv_getDefaultPincode(self, ):
1231 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1232 
    if mtype == TMessageType.EXCEPTION:
1233 
      x = TApplicationException()
1234 
      x.read(self._iprot)
1235 
      self._iprot.readMessageEnd()
1236 
      raise x
1237 
    result = getDefaultPincode_result()
1238 
    result.read(self._iprot)
1239 
    self._iprot.readMessageEnd()
1240 
    if result.success != None:
1241 
      return result.success
1242 
    if result.ucx != None:
1243 
      raise result.ucx
1244 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1245 
 
1274 varun.gupt 1246 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1247 
    """
1248 
    Parameters:
1249 
     - userId
1250 
     - replyTo
1251 
     - communicationType
1252 
     - orderId
1253 
     - airwaybillNo
1254 
     - productName
1255 
     - subject
1256 
     - message
1257 
    """
1258 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1259 
    return self.recv_saveUserCommunication()
1260 
 
1261 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1262 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1263 
    args = saveUserCommunication_args()
1264 
    args.userId = userId
1265 
    args.replyTo = replyTo
1266 
    args.communicationType = communicationType
1267 
    args.orderId = orderId
1268 
    args.airwaybillNo = airwaybillNo
1269 
    args.productName = productName
1270 
    args.subject = subject
1271 
    args.message = message
1272 
    args.write(self._oprot)
1273 
    self._oprot.writeMessageEnd()
1274 
    self._oprot.trans.flush()
1275 
 
1276 
  def recv_saveUserCommunication(self, ):
1277 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1278 
    if mtype == TMessageType.EXCEPTION:
1279 
      x = TApplicationException()
1280 
      x.read(self._iprot)
1281 
      self._iprot.readMessageEnd()
1282 
      raise x
1283 
    result = saveUserCommunication_result()
1284 
    result.read(self._iprot)
1285 
    self._iprot.readMessageEnd()
1286 
    if result.success != None:
1287 
      return result.success
1288 
    if result.ucx != None:
1289 
      raise result.ucx
1290 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1291 
 
1590 varun.gupt 1292 
  def getUserCommunicationById(self, id):
1293 
    """
1294 
    Parameters:
1295 
     - id
1296 
    """
1297 
    self.send_getUserCommunicationById(id)
1298 
    return self.recv_getUserCommunicationById()
1299 
 
1300 
  def send_getUserCommunicationById(self, id):
1301 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1302 
    args = getUserCommunicationById_args()
1303 
    args.id = id
1304 
    args.write(self._oprot)
1305 
    self._oprot.writeMessageEnd()
1306 
    self._oprot.trans.flush()
1307 
 
1308 
  def recv_getUserCommunicationById(self, ):
1309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1310 
    if mtype == TMessageType.EXCEPTION:
1311 
      x = TApplicationException()
1312 
      x.read(self._iprot)
1313 
      self._iprot.readMessageEnd()
1314 
      raise x
1315 
    result = getUserCommunicationById_result()
1316 
    result.read(self._iprot)
1317 
    self._iprot.readMessageEnd()
1318 
    if result.success != None:
1319 
      return result.success
1320 
    if result.ucx != None:
1321 
      raise result.ucx
1322 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1323 
 
1324 
  def getUserCommunicationByUser(self, userId):
1325 
    """
1326 
    Parameters:
1327 
     - userId
1328 
    """
1329 
    self.send_getUserCommunicationByUser(userId)
1330 
    return self.recv_getUserCommunicationByUser()
1331 
 
1332 
  def send_getUserCommunicationByUser(self, userId):
1333 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1334 
    args = getUserCommunicationByUser_args()
1335 
    args.userId = userId
1336 
    args.write(self._oprot)
1337 
    self._oprot.writeMessageEnd()
1338 
    self._oprot.trans.flush()
1339 
 
1340 
  def recv_getUserCommunicationByUser(self, ):
1341 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1342 
    if mtype == TMessageType.EXCEPTION:
1343 
      x = TApplicationException()
1344 
      x.read(self._iprot)
1345 
      self._iprot.readMessageEnd()
1346 
      raise x
1347 
    result = getUserCommunicationByUser_result()
1348 
    result.read(self._iprot)
1349 
    self._iprot.readMessageEnd()
1350 
    if result.success != None:
1351 
      return result.success
1352 
    if result.ucx != None:
1353 
      raise result.ucx
1354 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1355 
 
1356 
  def getAllUserCommunications(self, ):
1357 
    self.send_getAllUserCommunications()
1358 
    return self.recv_getAllUserCommunications()
1359 
 
1360 
  def send_getAllUserCommunications(self, ):
1361 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1362 
    args = getAllUserCommunications_args()
1363 
    args.write(self._oprot)
1364 
    self._oprot.writeMessageEnd()
1365 
    self._oprot.trans.flush()
1366 
 
1367 
  def recv_getAllUserCommunications(self, ):
1368 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1369 
    if mtype == TMessageType.EXCEPTION:
1370 
      x = TApplicationException()
1371 
      x.read(self._iprot)
1372 
      self._iprot.readMessageEnd()
1373 
      raise x
1374 
    result = getAllUserCommunications_result()
1375 
    result.read(self._iprot)
1376 
    self._iprot.readMessageEnd()
1377 
    if result.success != None:
1378 
      return result.success
1379 
    if result.ucx != None:
1380 
      raise result.ucx
1381 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1382 
 
1859 vikas 1383 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1384 
    """
1385 
    Parameters:
1386 
     - name
1859 vikas 1387 
     - addedOn
1845 vikas 1388 
    """
1859 vikas 1389 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1390 
    return self.recv_createMasterAffiliate()
1391 
 
1859 vikas 1392 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1393 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1394 
    args = createMasterAffiliate_args()
1395 
    args.name = name
1859 vikas 1396 
    args.addedOn = addedOn
1845 vikas 1397 
    args.write(self._oprot)
1398 
    self._oprot.writeMessageEnd()
1399 
    self._oprot.trans.flush()
1400 
 
1401 
  def recv_createMasterAffiliate(self, ):
1402 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1403 
    if mtype == TMessageType.EXCEPTION:
1404 
      x = TApplicationException()
1405 
      x.read(self._iprot)
1406 
      self._iprot.readMessageEnd()
1407 
      raise x
1408 
    result = createMasterAffiliate_result()
1409 
    result.read(self._iprot)
1410 
    self._iprot.readMessageEnd()
1411 
    if result.success != None:
1412 
      return result.success
1413 
    if result.utx != None:
1414 
      raise result.utx
1415 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1416 
 
1417 
  def getMasterAffiliateById(self, id):
1418 
    """
1419 
    Parameters:
1420 
     - id
1421 
    """
1422 
    self.send_getMasterAffiliateById(id)
1423 
    return self.recv_getMasterAffiliateById()
1424 
 
1425 
  def send_getMasterAffiliateById(self, id):
1426 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1427 
    args = getMasterAffiliateById_args()
1428 
    args.id = id
1429 
    args.write(self._oprot)
1430 
    self._oprot.writeMessageEnd()
1431 
    self._oprot.trans.flush()
1432 
 
1433 
  def recv_getMasterAffiliateById(self, ):
1434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1435 
    if mtype == TMessageType.EXCEPTION:
1436 
      x = TApplicationException()
1437 
      x.read(self._iprot)
1438 
      self._iprot.readMessageEnd()
1439 
      raise x
1440 
    result = getMasterAffiliateById_result()
1441 
    result.read(self._iprot)
1442 
    self._iprot.readMessageEnd()
1443 
    if result.success != None:
1444 
      return result.success
1445 
    if result.utx != None:
1446 
      raise result.utx
1447 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1448 
 
1449 
  def getMasterAffiliateByName(self, name):
1450 
    """
1451 
    Parameters:
1452 
     - name
1453 
    """
1454 
    self.send_getMasterAffiliateByName(name)
1455 
    return self.recv_getMasterAffiliateByName()
1456 
 
1457 
  def send_getMasterAffiliateByName(self, name):
1458 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1459 
    args = getMasterAffiliateByName_args()
1460 
    args.name = name
1461 
    args.write(self._oprot)
1462 
    self._oprot.writeMessageEnd()
1463 
    self._oprot.trans.flush()
1464 
 
1465 
  def recv_getMasterAffiliateByName(self, ):
1466 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1467 
    if mtype == TMessageType.EXCEPTION:
1468 
      x = TApplicationException()
1469 
      x.read(self._iprot)
1470 
      self._iprot.readMessageEnd()
1471 
      raise x
1472 
    result = getMasterAffiliateByName_result()
1473 
    result.read(self._iprot)
1474 
    self._iprot.readMessageEnd()
1475 
    if result.success != None:
1476 
      return result.success
1477 
    if result.utx != None:
1478 
      raise result.utx
1479 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1480 
 
1859 vikas 1481 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1482 
    """
1483 
    Parameters:
1484 
     - name
1485 
     - url
1486 
     - masterAffiliateId
1859 vikas 1487 
     - addedOn
1845 vikas 1488 
    """
1859 vikas 1489 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1490 
    return self.recv_createAffiliate()
1491 
 
1859 vikas 1492 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1493 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1494 
    args = createAffiliate_args()
1495 
    args.name = name
1496 
    args.url = url
1497 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1498 
    args.addedOn = addedOn
1845 vikas 1499 
    args.write(self._oprot)
1500 
    self._oprot.writeMessageEnd()
1501 
    self._oprot.trans.flush()
1502 
 
1503 
  def recv_createAffiliate(self, ):
1504 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1505 
    if mtype == TMessageType.EXCEPTION:
1506 
      x = TApplicationException()
1507 
      x.read(self._iprot)
1508 
      self._iprot.readMessageEnd()
1509 
      raise x
1510 
    result = createAffiliate_result()
1511 
    result.read(self._iprot)
1512 
    self._iprot.readMessageEnd()
1513 
    if result.success != None:
1514 
      return result.success
1515 
    if result.utx != None:
1516 
      raise result.utx
1517 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1518 
 
1519 
  def getAffiliateById(self, id):
1520 
    """
1521 
    Parameters:
1522 
     - id
1523 
    """
1524 
    self.send_getAffiliateById(id)
1525 
    return self.recv_getAffiliateById()
1526 
 
1527 
  def send_getAffiliateById(self, id):
1528 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1529 
    args = getAffiliateById_args()
1530 
    args.id = id
1531 
    args.write(self._oprot)
1532 
    self._oprot.writeMessageEnd()
1533 
    self._oprot.trans.flush()
1534 
 
1535 
  def recv_getAffiliateById(self, ):
1536 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1537 
    if mtype == TMessageType.EXCEPTION:
1538 
      x = TApplicationException()
1539 
      x.read(self._iprot)
1540 
      self._iprot.readMessageEnd()
1541 
      raise x
1542 
    result = getAffiliateById_result()
1543 
    result.read(self._iprot)
1544 
    self._iprot.readMessageEnd()
1545 
    if result.success != None:
1546 
      return result.success
1547 
    if result.utx != None:
1548 
      raise result.utx
1549 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1550 
 
1551 
  def getAffiliateByName(self, name):
1552 
    """
1553 
    Parameters:
1554 
     - name
1555 
    """
1556 
    self.send_getAffiliateByName(name)
1557 
    return self.recv_getAffiliateByName()
1558 
 
1559 
  def send_getAffiliateByName(self, name):
1560 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1561 
    args = getAffiliateByName_args()
1562 
    args.name = name
1563 
    args.write(self._oprot)
1564 
    self._oprot.writeMessageEnd()
1565 
    self._oprot.trans.flush()
1566 
 
1567 
  def recv_getAffiliateByName(self, ):
1568 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1569 
    if mtype == TMessageType.EXCEPTION:
1570 
      x = TApplicationException()
1571 
      x.read(self._iprot)
1572 
      self._iprot.readMessageEnd()
1573 
      raise x
1574 
    result = getAffiliateByName_result()
1575 
    result.read(self._iprot)
1576 
    self._iprot.readMessageEnd()
1577 
    if result.success != None:
1578 
      return result.success
1579 
    if result.utx != None:
1580 
      raise result.utx
1581 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1582 
 
1583 
  def getAffiliatesByMasterAffiliate(self, id):
1584 
    """
1585 
    Parameters:
1586 
     - id
1587 
    """
1588 
    self.send_getAffiliatesByMasterAffiliate(id)
1589 
    return self.recv_getAffiliatesByMasterAffiliate()
1590 
 
1591 
  def send_getAffiliatesByMasterAffiliate(self, id):
1592 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1593 
    args = getAffiliatesByMasterAffiliate_args()
1594 
    args.id = id
1595 
    args.write(self._oprot)
1596 
    self._oprot.writeMessageEnd()
1597 
    self._oprot.trans.flush()
1598 
 
1599 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1600 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1601 
    if mtype == TMessageType.EXCEPTION:
1602 
      x = TApplicationException()
1603 
      x.read(self._iprot)
1604 
      self._iprot.readMessageEnd()
1605 
      raise x
1606 
    result = getAffiliatesByMasterAffiliate_result()
1607 
    result.read(self._iprot)
1608 
    self._iprot.readMessageEnd()
1609 
    if result.success != None:
1610 
      return result.success
1611 
    if result.utx != None:
1612 
      raise result.utx
1613 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1614 
 
1859 vikas 1615 
  def createTracker(self, affiliateId, addedOn):
1845 vikas 1616 
    """
1617 
    Parameters:
1618 
     - affiliateId
1859 vikas 1619 
     - addedOn
1845 vikas 1620 
    """
1859 vikas 1621 
    self.send_createTracker(affiliateId, addedOn)
1845 vikas 1622 
    return self.recv_createTracker()
1623 
 
1859 vikas 1624 
  def send_createTracker(self, affiliateId, addedOn):
1845 vikas 1625 
    self._oprot.writeMessageBegin('createTracker', TMessageType.CALL, self._seqid)
1626 
    args = createTracker_args()
1627 
    args.affiliateId = affiliateId
1859 vikas 1628 
    args.addedOn = addedOn
1845 vikas 1629 
    args.write(self._oprot)
1630 
    self._oprot.writeMessageEnd()
1631 
    self._oprot.trans.flush()
1632 
 
1633 
  def recv_createTracker(self, ):
1634 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1635 
    if mtype == TMessageType.EXCEPTION:
1636 
      x = TApplicationException()
1637 
      x.read(self._iprot)
1638 
      self._iprot.readMessageEnd()
1639 
      raise x
1640 
    result = createTracker_result()
1641 
    result.read(self._iprot)
1642 
    self._iprot.readMessageEnd()
1643 
    if result.success != None:
1644 
      return result.success
1645 
    if result.utx != None:
1646 
      raise result.utx
1647 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTracker failed: unknown result");
1648 
 
1649 
  def getTrackerById(self, trackerId):
1650 
    """
1651 
    Parameters:
1652 
     - trackerId
1653 
    """
1654 
    self.send_getTrackerById(trackerId)
1655 
    return self.recv_getTrackerById()
1656 
 
1657 
  def send_getTrackerById(self, trackerId):
1658 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1659 
    args = getTrackerById_args()
1660 
    args.trackerId = trackerId
1661 
    args.write(self._oprot)
1662 
    self._oprot.writeMessageEnd()
1663 
    self._oprot.trans.flush()
1664 
 
1665 
  def recv_getTrackerById(self, ):
1666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1667 
    if mtype == TMessageType.EXCEPTION:
1668 
      x = TApplicationException()
1669 
      x.read(self._iprot)
1670 
      self._iprot.readMessageEnd()
1671 
      raise x
1672 
    result = getTrackerById_result()
1673 
    result.read(self._iprot)
1674 
    self._iprot.readMessageEnd()
1675 
    if result.success != None:
1676 
      return result.success
1677 
    if result.utx != None:
1678 
      raise result.utx
1679 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1680 
 
1681 
  def getTrackersByAffiliate(self, affiliateId):
1682 
    """
1683 
    Parameters:
1684 
     - affiliateId
1685 
    """
1686 
    self.send_getTrackersByAffiliate(affiliateId)
1687 
    return self.recv_getTrackersByAffiliate()
1688 
 
1689 
  def send_getTrackersByAffiliate(self, affiliateId):
1690 
    self._oprot.writeMessageBegin('getTrackersByAffiliate', TMessageType.CALL, self._seqid)
1691 
    args = getTrackersByAffiliate_args()
1692 
    args.affiliateId = affiliateId
1693 
    args.write(self._oprot)
1694 
    self._oprot.writeMessageEnd()
1695 
    self._oprot.trans.flush()
1696 
 
1697 
  def recv_getTrackersByAffiliate(self, ):
1698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1699 
    if mtype == TMessageType.EXCEPTION:
1700 
      x = TApplicationException()
1701 
      x.read(self._iprot)
1702 
      self._iprot.readMessageEnd()
1703 
      raise x
1704 
    result = getTrackersByAffiliate_result()
1705 
    result.read(self._iprot)
1706 
    self._iprot.readMessageEnd()
1707 
    if result.success != None:
1708 
      return result.success
1709 
    if result.utx != None:
1710 
      raise result.utx
1711 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackersByAffiliate failed: unknown result");
1712 
 
1859 vikas 1713 
  def addTrackLog(self, trackerId, userId, event, url, data, addedOn):
1845 vikas 1714 
    """
1715 
    Parameters:
1716 
     - trackerId
1717 
     - userId
1718 
     - event
1719 
     - url
1720 
     - data
1859 vikas 1721 
     - addedOn
1845 vikas 1722 
    """
1859 vikas 1723 
    self.send_addTrackLog(trackerId, userId, event, url, data, addedOn)
1845 vikas 1724 
    return self.recv_addTrackLog()
1725 
 
1859 vikas 1726 
  def send_addTrackLog(self, trackerId, userId, event, url, data, addedOn):
1845 vikas 1727 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1728 
    args = addTrackLog_args()
1729 
    args.trackerId = trackerId
1730 
    args.userId = userId
1731 
    args.event = event
1732 
    args.url = url
1733 
    args.data = data
1859 vikas 1734 
    args.addedOn = addedOn
1845 vikas 1735 
    args.write(self._oprot)
1736 
    self._oprot.writeMessageEnd()
1737 
    self._oprot.trans.flush()
1738 
 
1739 
  def recv_addTrackLog(self, ):
1740 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1741 
    if mtype == TMessageType.EXCEPTION:
1742 
      x = TApplicationException()
1743 
      x.read(self._iprot)
1744 
      self._iprot.readMessageEnd()
1745 
      raise x
1746 
    result = addTrackLog_result()
1747 
    result.read(self._iprot)
1748 
    self._iprot.readMessageEnd()
1749 
    if result.success != None:
1750 
      return result.success
1751 
    if result.utx != None:
1752 
      raise result.utx
1753 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1754 
 
1755 
  def getTrackLogById(self, id):
1756 
    """
1757 
    Parameters:
1758 
     - id
1759 
    """
1760 
    self.send_getTrackLogById(id)
1761 
    return self.recv_getTrackLogById()
1762 
 
1763 
  def send_getTrackLogById(self, id):
1764 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1765 
    args = getTrackLogById_args()
1766 
    args.id = id
1767 
    args.write(self._oprot)
1768 
    self._oprot.writeMessageEnd()
1769 
    self._oprot.trans.flush()
1770 
 
1771 
  def recv_getTrackLogById(self, ):
1772 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1773 
    if mtype == TMessageType.EXCEPTION:
1774 
      x = TApplicationException()
1775 
      x.read(self._iprot)
1776 
      self._iprot.readMessageEnd()
1777 
      raise x
1778 
    result = getTrackLogById_result()
1779 
    result.read(self._iprot)
1780 
    self._iprot.readMessageEnd()
1781 
    if result.success != None:
1782 
      return result.success
1783 
    if result.utx != None:
1784 
      raise result.utx
1785 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1786 
 
1787 
  def getTrackLogsByTracker(self, trackerId):
1788 
    """
1789 
    Parameters:
1790 
     - trackerId
1791 
    """
1792 
    self.send_getTrackLogsByTracker(trackerId)
1793 
    return self.recv_getTrackLogsByTracker()
1794 
 
1795 
  def send_getTrackLogsByTracker(self, trackerId):
1796 
    self._oprot.writeMessageBegin('getTrackLogsByTracker', TMessageType.CALL, self._seqid)
1797 
    args = getTrackLogsByTracker_args()
1798 
    args.trackerId = trackerId
1799 
    args.write(self._oprot)
1800 
    self._oprot.writeMessageEnd()
1801 
    self._oprot.trans.flush()
1802 
 
1803 
  def recv_getTrackLogsByTracker(self, ):
1804 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1805 
    if mtype == TMessageType.EXCEPTION:
1806 
      x = TApplicationException()
1807 
      x.read(self._iprot)
1808 
      self._iprot.readMessageEnd()
1809 
      raise x
1810 
    result = getTrackLogsByTracker_result()
1811 
    result.read(self._iprot)
1812 
    self._iprot.readMessageEnd()
1813 
    if result.success != None:
1814 
      return result.success
1815 
    if result.utx != None:
1816 
      raise result.utx
1817 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByTracker failed: unknown result");
1818 
 
1819 
  def getTrackLogsByUser(self, userId):
1820 
    """
1821 
    Parameters:
1822 
     - userId
1823 
    """
1824 
    self.send_getTrackLogsByUser(userId)
1825 
    return self.recv_getTrackLogsByUser()
1826 
 
1827 
  def send_getTrackLogsByUser(self, userId):
1828 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
1829 
    args = getTrackLogsByUser_args()
1830 
    args.userId = userId
1831 
    args.write(self._oprot)
1832 
    self._oprot.writeMessageEnd()
1833 
    self._oprot.trans.flush()
1834 
 
1835 
  def recv_getTrackLogsByUser(self, ):
1836 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1837 
    if mtype == TMessageType.EXCEPTION:
1838 
      x = TApplicationException()
1839 
      x.read(self._iprot)
1840 
      self._iprot.readMessageEnd()
1841 
      raise x
1842 
    result = getTrackLogsByUser_result()
1843 
    result.read(self._iprot)
1844 
    self._iprot.readMessageEnd()
1845 
    if result.success != None:
1846 
      return result.success
1847 
    if result.utx != None:
1848 
      raise result.utx
1849 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
1850 
 
1851 
  def getTrackLogs(self, trackerId, userId, event, url):
1852 
    """
1853 
    Parameters:
1854 
     - trackerId
1855 
     - userId
1856 
     - event
1857 
     - url
1858 
    """
1859 
    self.send_getTrackLogs(trackerId, userId, event, url)
1860 
    return self.recv_getTrackLogs()
1861 
 
1862 
  def send_getTrackLogs(self, trackerId, userId, event, url):
1863 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
1864 
    args = getTrackLogs_args()
1865 
    args.trackerId = trackerId
1866 
    args.userId = userId
1867 
    args.event = event
1868 
    args.url = url
1869 
    args.write(self._oprot)
1870 
    self._oprot.writeMessageEnd()
1871 
    self._oprot.trans.flush()
1872 
 
1873 
  def recv_getTrackLogs(self, ):
1874 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1875 
    if mtype == TMessageType.EXCEPTION:
1876 
      x = TApplicationException()
1877 
      x.read(self._iprot)
1878 
      self._iprot.readMessageEnd()
1879 
      raise x
1880 
    result = getTrackLogs_result()
1881 
    result.read(self._iprot)
1882 
    self._iprot.readMessageEnd()
1883 
    if result.success != None:
1884 
      return result.success
1885 
    if result.utx != None:
1886 
      raise result.utx
1887 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
1888 
 
559 chandransh 1889 
  def createCart(self, userId):
94 ashish 1890 
    """
1891 
    Parameters:
559 chandransh 1892 
     - userId
94 ashish 1893 
    """
559 chandransh 1894 
    self.send_createCart(userId)
1895 
    return self.recv_createCart()
94 ashish 1896 
 
559 chandransh 1897 
  def send_createCart(self, userId):
1898 
    self._oprot.writeMessageBegin('createCart', TMessageType.CALL, self._seqid)
1899 
    args = createCart_args()
1900 
    args.userId = userId
94 ashish 1901 
    args.write(self._oprot)
1902 
    self._oprot.writeMessageEnd()
1903 
    self._oprot.trans.flush()
1904 
 
559 chandransh 1905 
  def recv_createCart(self, ):
94 ashish 1906 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1907 
    if mtype == TMessageType.EXCEPTION:
1908 
      x = TApplicationException()
1909 
      x.read(self._iprot)
1910 
      self._iprot.readMessageEnd()
1911 
      raise x
559 chandransh 1912 
    result = createCart_result()
94 ashish 1913 
    result.read(self._iprot)
1914 
    self._iprot.readMessageEnd()
1915 
    if result.success != None:
1916 
      return result.success
559 chandransh 1917 
    if result.scx != None:
1918 
      raise result.scx
1919 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createCart failed: unknown result");
94 ashish 1920 
 
559 chandransh 1921 
  def getCurrentCart(self, userId):
94 ashish 1922 
    """
1923 
    Parameters:
559 chandransh 1924 
     - userId
94 ashish 1925 
    """
559 chandransh 1926 
    self.send_getCurrentCart(userId)
1927 
    return self.recv_getCurrentCart()
94 ashish 1928 
 
559 chandransh 1929 
  def send_getCurrentCart(self, userId):
1930 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
1931 
    args = getCurrentCart_args()
1932 
    args.userId = userId
94 ashish 1933 
    args.write(self._oprot)
1934 
    self._oprot.writeMessageEnd()
1935 
    self._oprot.trans.flush()
1936 
 
559 chandransh 1937 
  def recv_getCurrentCart(self, ):
94 ashish 1938 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1939 
    if mtype == TMessageType.EXCEPTION:
1940 
      x = TApplicationException()
1941 
      x.read(self._iprot)
1942 
      self._iprot.readMessageEnd()
1943 
      raise x
559 chandransh 1944 
    result = getCurrentCart_result()
94 ashish 1945 
    result.read(self._iprot)
1946 
    self._iprot.readMessageEnd()
1947 
    if result.success != None:
1948 
      return result.success
559 chandransh 1949 
    if result.scx != None:
1950 
      raise result.scx
1951 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 1952 
 
559 chandransh 1953 
  def getCart(self, cartId):
94 ashish 1954 
    """
1955 
    Parameters:
559 chandransh 1956 
     - cartId
94 ashish 1957 
    """
559 chandransh 1958 
    self.send_getCart(cartId)
1959 
    return self.recv_getCart()
94 ashish 1960 
 
559 chandransh 1961 
  def send_getCart(self, cartId):
1962 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
1963 
    args = getCart_args()
1964 
    args.cartId = cartId
94 ashish 1965 
    args.write(self._oprot)
1966 
    self._oprot.writeMessageEnd()
1967 
    self._oprot.trans.flush()
1968 
 
559 chandransh 1969 
  def recv_getCart(self, ):
94 ashish 1970 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1971 
    if mtype == TMessageType.EXCEPTION:
1972 
      x = TApplicationException()
1973 
      x.read(self._iprot)
1974 
      self._iprot.readMessageEnd()
1975 
      raise x
559 chandransh 1976 
    result = getCart_result()
94 ashish 1977 
    result.read(self._iprot)
1978 
    self._iprot.readMessageEnd()
1979 
    if result.success != None:
1980 
      return result.success
559 chandransh 1981 
    if result.scx != None:
1982 
      raise result.scx
1983 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 1984 
 
559 chandransh 1985 
  def getCartsForUser(self, userId, status):
94 ashish 1986 
    """
1987 
    Parameters:
559 chandransh 1988 
     - userId
1989 
     - status
94 ashish 1990 
    """
559 chandransh 1991 
    self.send_getCartsForUser(userId, status)
1992 
    return self.recv_getCartsForUser()
94 ashish 1993 
 
559 chandransh 1994 
  def send_getCartsForUser(self, userId, status):
1995 
    self._oprot.writeMessageBegin('getCartsForUser', TMessageType.CALL, self._seqid)
1996 
    args = getCartsForUser_args()
1997 
    args.userId = userId
1998 
    args.status = status
94 ashish 1999 
    args.write(self._oprot)
2000 
    self._oprot.writeMessageEnd()
2001 
    self._oprot.trans.flush()
2002 
 
559 chandransh 2003 
  def recv_getCartsForUser(self, ):
94 ashish 2004 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2005 
    if mtype == TMessageType.EXCEPTION:
2006 
      x = TApplicationException()
2007 
      x.read(self._iprot)
2008 
      self._iprot.readMessageEnd()
2009 
      raise x
559 chandransh 2010 
    result = getCartsForUser_result()
94 ashish 2011 
    result.read(self._iprot)
2012 
    self._iprot.readMessageEnd()
2013 
    if result.success != None:
2014 
      return result.success
559 chandransh 2015 
    if result.scx != None:
2016 
      raise result.scx
2017 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsForUser failed: unknown result");
94 ashish 2018 
 
559 chandransh 2019 
  def getCartsByStatus(self, status):
94 ashish 2020 
    """
2021 
    Parameters:
559 chandransh 2022 
     - status
94 ashish 2023 
    """
559 chandransh 2024 
    self.send_getCartsByStatus(status)
2025 
    return self.recv_getCartsByStatus()
94 ashish 2026 
 
559 chandransh 2027 
  def send_getCartsByStatus(self, status):
2028 
    self._oprot.writeMessageBegin('getCartsByStatus', TMessageType.CALL, self._seqid)
2029 
    args = getCartsByStatus_args()
2030 
    args.status = status
94 ashish 2031 
    args.write(self._oprot)
2032 
    self._oprot.writeMessageEnd()
2033 
    self._oprot.trans.flush()
2034 
 
559 chandransh 2035 
  def recv_getCartsByStatus(self, ):
94 ashish 2036 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2037 
    if mtype == TMessageType.EXCEPTION:
2038 
      x = TApplicationException()
2039 
      x.read(self._iprot)
2040 
      self._iprot.readMessageEnd()
2041 
      raise x
559 chandransh 2042 
    result = getCartsByStatus_result()
94 ashish 2043 
    result.read(self._iprot)
2044 
    self._iprot.readMessageEnd()
2045 
    if result.success != None:
2046 
      return result.success
559 chandransh 2047 
    if result.scx != None:
2048 
      raise result.scx
2049 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByStatus failed: unknown result");
94 ashish 2050 
 
559 chandransh 2051 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2052 
    """
2053 
    Parameters:
559 chandransh 2054 
     - from_time
2055 
     - to_time
2056 
     - status
94 ashish 2057 
    """
559 chandransh 2058 
    self.send_getCartsByTime(from_time, to_time, status)
2059 
    return self.recv_getCartsByTime()
94 ashish 2060 
 
559 chandransh 2061 
  def send_getCartsByTime(self, from_time, to_time, status):
2062 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2063 
    args = getCartsByTime_args()
2064 
    args.from_time = from_time
2065 
    args.to_time = to_time
2066 
    args.status = status
94 ashish 2067 
    args.write(self._oprot)
2068 
    self._oprot.writeMessageEnd()
2069 
    self._oprot.trans.flush()
2070 
 
559 chandransh 2071 
  def recv_getCartsByTime(self, ):
94 ashish 2072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2073 
    if mtype == TMessageType.EXCEPTION:
2074 
      x = TApplicationException()
2075 
      x.read(self._iprot)
2076 
      self._iprot.readMessageEnd()
2077 
      raise x
559 chandransh 2078 
    result = getCartsByTime_result()
94 ashish 2079 
    result.read(self._iprot)
2080 
    self._iprot.readMessageEnd()
2081 
    if result.success != None:
2082 
      return result.success
559 chandransh 2083 
    if result.scx != None:
2084 
      raise result.scx
2085 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2086 
 
559 chandransh 2087 
  def changeCartStatus(self, cartId, status):
130 ashish 2088 
    """
2089 
    Parameters:
559 chandransh 2090 
     - cartId
2091 
     - status
130 ashish 2092 
    """
559 chandransh 2093 
    self.send_changeCartStatus(cartId, status)
2094 
    self.recv_changeCartStatus()
94 ashish 2095 
 
559 chandransh 2096 
  def send_changeCartStatus(self, cartId, status):
2097 
    self._oprot.writeMessageBegin('changeCartStatus', TMessageType.CALL, self._seqid)
2098 
    args = changeCartStatus_args()
2099 
    args.cartId = cartId
2100 
    args.status = status
130 ashish 2101 
    args.write(self._oprot)
2102 
    self._oprot.writeMessageEnd()
2103 
    self._oprot.trans.flush()
2104 
 
559 chandransh 2105 
  def recv_changeCartStatus(self, ):
130 ashish 2106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2107 
    if mtype == TMessageType.EXCEPTION:
2108 
      x = TApplicationException()
2109 
      x.read(self._iprot)
2110 
      self._iprot.readMessageEnd()
2111 
      raise x
559 chandransh 2112 
    result = changeCartStatus_result()
130 ashish 2113 
    result.read(self._iprot)
2114 
    self._iprot.readMessageEnd()
559 chandransh 2115 
    if result.scx != None:
2116 
      raise result.scx
2117 
    return
2118 
 
2119 
  def addItemToCart(self, cartId, itemId, quantity):
2120 
    """
2121 
    Parameters:
2122 
     - cartId
2123 
     - itemId
2124 
     - quantity
2125 
    """
2126 
    self.send_addItemToCart(cartId, itemId, quantity)
2127 
    self.recv_addItemToCart()
2128 
 
2129 
  def send_addItemToCart(self, cartId, itemId, quantity):
2130 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2131 
    args = addItemToCart_args()
2132 
    args.cartId = cartId
2133 
    args.itemId = itemId
2134 
    args.quantity = quantity
2135 
    args.write(self._oprot)
2136 
    self._oprot.writeMessageEnd()
2137 
    self._oprot.trans.flush()
2138 
 
2139 
  def recv_addItemToCart(self, ):
2140 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2141 
    if mtype == TMessageType.EXCEPTION:
2142 
      x = TApplicationException()
2143 
      x.read(self._iprot)
2144 
      self._iprot.readMessageEnd()
2145 
      raise x
2146 
    result = addItemToCart_result()
2147 
    result.read(self._iprot)
2148 
    self._iprot.readMessageEnd()
2149 
    if result.scx != None:
2150 
      raise result.scx
2151 
    return
2152 
 
2153 
  def deleteItemFromCart(self, cartId, itemId):
2154 
    """
2155 
    Parameters:
2156 
     - cartId
2157 
     - itemId
2158 
    """
2159 
    self.send_deleteItemFromCart(cartId, itemId)
2160 
    self.recv_deleteItemFromCart()
2161 
 
2162 
  def send_deleteItemFromCart(self, cartId, itemId):
2163 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2164 
    args = deleteItemFromCart_args()
2165 
    args.cartId = cartId
2166 
    args.itemId = itemId
2167 
    args.write(self._oprot)
2168 
    self._oprot.writeMessageEnd()
2169 
    self._oprot.trans.flush()
2170 
 
2171 
  def recv_deleteItemFromCart(self, ):
2172 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2173 
    if mtype == TMessageType.EXCEPTION:
2174 
      x = TApplicationException()
2175 
      x.read(self._iprot)
2176 
      self._iprot.readMessageEnd()
2177 
      raise x
2178 
    result = deleteItemFromCart_result()
2179 
    result.read(self._iprot)
2180 
    self._iprot.readMessageEnd()
2181 
    if result.scx != None:
2182 
      raise result.scx
2183 
    return
2184 
 
2185 
  def changeQuantity(self, cartId, itemId, quantity):
2186 
    """
2187 
    Parameters:
2188 
     - cartId
2189 
     - itemId
2190 
     - quantity
2191 
    """
2192 
    self.send_changeQuantity(cartId, itemId, quantity)
2193 
    self.recv_changeQuantity()
2194 
 
2195 
  def send_changeQuantity(self, cartId, itemId, quantity):
2196 
    self._oprot.writeMessageBegin('changeQuantity', TMessageType.CALL, self._seqid)
2197 
    args = changeQuantity_args()
2198 
    args.cartId = cartId
2199 
    args.itemId = itemId
2200 
    args.quantity = quantity
2201 
    args.write(self._oprot)
2202 
    self._oprot.writeMessageEnd()
2203 
    self._oprot.trans.flush()
2204 
 
2205 
  def recv_changeQuantity(self, ):
2206 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2207 
    if mtype == TMessageType.EXCEPTION:
2208 
      x = TApplicationException()
2209 
      x.read(self._iprot)
2210 
      self._iprot.readMessageEnd()
2211 
      raise x
2212 
    result = changeQuantity_result()
2213 
    result.read(self._iprot)
2214 
    self._iprot.readMessageEnd()
2215 
    if result.scx != None:
2216 
      raise result.scx
2217 
    return
2218 
 
2219 
  def changeItemStatus(self, cartId, itemId, status):
2220 
    """
2221 
    Parameters:
2222 
     - cartId
2223 
     - itemId
2224 
     - status
2225 
    """
2226 
    self.send_changeItemStatus(cartId, itemId, status)
2227 
    self.recv_changeItemStatus()
2228 
 
2229 
  def send_changeItemStatus(self, cartId, itemId, status):
2230 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
2231 
    args = changeItemStatus_args()
2232 
    args.cartId = cartId
2233 
    args.itemId = itemId
2234 
    args.status = status
2235 
    args.write(self._oprot)
2236 
    self._oprot.writeMessageEnd()
2237 
    self._oprot.trans.flush()
2238 
 
2239 
  def recv_changeItemStatus(self, ):
2240 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2241 
    if mtype == TMessageType.EXCEPTION:
2242 
      x = TApplicationException()
2243 
      x.read(self._iprot)
2244 
      self._iprot.readMessageEnd()
2245 
      raise x
2246 
    result = changeItemStatus_result()
2247 
    result.read(self._iprot)
2248 
    self._iprot.readMessageEnd()
2249 
    if result.scx != None:
2250 
      raise result.scx
2251 
    return
2252 
 
2253 
  def addAddressToCart(self, cartId, addressId):
2254 
    """
2255 
    Parameters:
2256 
     - cartId
2257 
     - addressId
2258 
    """
2259 
    self.send_addAddressToCart(cartId, addressId)
2260 
    self.recv_addAddressToCart()
2261 
 
2262 
  def send_addAddressToCart(self, cartId, addressId):
2263 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2264 
    args = addAddressToCart_args()
2265 
    args.cartId = cartId
2266 
    args.addressId = addressId
2267 
    args.write(self._oprot)
2268 
    self._oprot.writeMessageEnd()
2269 
    self._oprot.trans.flush()
2270 
 
2271 
  def recv_addAddressToCart(self, ):
2272 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2273 
    if mtype == TMessageType.EXCEPTION:
2274 
      x = TApplicationException()
2275 
      x.read(self._iprot)
2276 
      self._iprot.readMessageEnd()
2277 
      raise x
2278 
    result = addAddressToCart_result()
2279 
    result.read(self._iprot)
2280 
    self._iprot.readMessageEnd()
575 chandransh 2281 
    if result.scx != None:
2282 
      raise result.scx
559 chandransh 2283 
    return
2284 
 
690 chandransh 2285 
  def createOrders(self, cartId):
559 chandransh 2286 
    """
690 chandransh 2287 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
2288 
 
559 chandransh 2289 
    Parameters:
2290 
     - cartId
2291 
    """
690 chandransh 2292 
    self.send_createOrders(cartId)
2293 
    return self.recv_createOrders()
559 chandransh 2294 
 
690 chandransh 2295 
  def send_createOrders(self, cartId):
2296 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2297 
    args = createOrders_args()
559 chandransh 2298 
    args.cartId = cartId
2299 
    args.write(self._oprot)
2300 
    self._oprot.writeMessageEnd()
2301 
    self._oprot.trans.flush()
2302 
 
690 chandransh 2303 
  def recv_createOrders(self, ):
559 chandransh 2304 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2305 
    if mtype == TMessageType.EXCEPTION:
2306 
      x = TApplicationException()
2307 
      x.read(self._iprot)
2308 
      self._iprot.readMessageEnd()
2309 
      raise x
690 chandransh 2310 
    result = createOrders_result()
559 chandransh 2311 
    result.read(self._iprot)
2312 
    self._iprot.readMessageEnd()
130 ashish 2313 
    if result.success != None:
2314 
      return result.success
559 chandransh 2315 
    if result.scx != None:
2316 
      raise result.scx
690 chandransh 2317 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2318 
 
559 chandransh 2319 
  def validateCart(self, cartId):
130 ashish 2320 
    """
690 chandransh 2321 
    Validates that:
2322 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2323 
    2. All of the lines in the cart are active items.
690 chandransh 2324 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2325 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 2326 
 
130 ashish 2327 
    Parameters:
559 chandransh 2328 
     - cartId
130 ashish 2329 
    """
559 chandransh 2330 
    self.send_validateCart(cartId)
2331 
    return self.recv_validateCart()
130 ashish 2332 
 
559 chandransh 2333 
  def send_validateCart(self, cartId):
2334 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2335 
    args = validateCart_args()
2336 
    args.cartId = cartId
130 ashish 2337 
    args.write(self._oprot)
2338 
    self._oprot.writeMessageEnd()
2339 
    self._oprot.trans.flush()
2340 
 
559 chandransh 2341 
  def recv_validateCart(self, ):
130 ashish 2342 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2343 
    if mtype == TMessageType.EXCEPTION:
2344 
      x = TApplicationException()
2345 
      x.read(self._iprot)
2346 
      self._iprot.readMessageEnd()
2347 
      raise x
559 chandransh 2348 
    result = validateCart_result()
130 ashish 2349 
    result.read(self._iprot)
2350 
    self._iprot.readMessageEnd()
2351 
    if result.success != None:
2352 
      return result.success
575 chandransh 2353 
    if result.scex != None:
2354 
      raise result.scex
559 chandransh 2355 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2356 
 
690 chandransh 2357 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2358 
    """
690 chandransh 2359 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
2360 
 
575 chandransh 2361 
    Parameters:
690 chandransh 2362 
     - fromCartId
2363 
     - toCartId
2364 
    """
2365 
    self.send_mergeCart(fromCartId, toCartId)
2366 
    self.recv_mergeCart()
2367 
 
2368 
  def send_mergeCart(self, fromCartId, toCartId):
2369 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2370 
    args = mergeCart_args()
2371 
    args.fromCartId = fromCartId
2372 
    args.toCartId = toCartId
2373 
    args.write(self._oprot)
2374 
    self._oprot.writeMessageEnd()
2375 
    self._oprot.trans.flush()
2376 
 
2377 
  def recv_mergeCart(self, ):
2378 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2379 
    if mtype == TMessageType.EXCEPTION:
2380 
      x = TApplicationException()
2381 
      x.read(self._iprot)
2382 
      self._iprot.readMessageEnd()
2383 
      raise x
2384 
    result = mergeCart_result()
2385 
    result.read(self._iprot)
2386 
    self._iprot.readMessageEnd()
2387 
    return
2388 
 
2389 
  def checkOut(self, cartId):
2390 
    """
2391 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
2392 
 
2393 
    Parameters:
575 chandransh 2394 
     - cartId
2395 
    """
690 chandransh 2396 
    self.send_checkOut(cartId)
2397 
    return self.recv_checkOut()
575 chandransh 2398 
 
690 chandransh 2399 
  def send_checkOut(self, cartId):
2400 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2401 
    args = checkOut_args()
575 chandransh 2402 
    args.cartId = cartId
2403 
    args.write(self._oprot)
2404 
    self._oprot.writeMessageEnd()
2405 
    self._oprot.trans.flush()
2406 
 
690 chandransh 2407 
  def recv_checkOut(self, ):
575 chandransh 2408 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2409 
    if mtype == TMessageType.EXCEPTION:
2410 
      x = TApplicationException()
2411 
      x.read(self._iprot)
2412 
      self._iprot.readMessageEnd()
2413 
      raise x
690 chandransh 2414 
    result = checkOut_result()
575 chandransh 2415 
    result.read(self._iprot)
2416 
    self._iprot.readMessageEnd()
2417 
    if result.success != None:
2418 
      return result.success
2419 
    if result.scex != None:
2420 
      raise result.scex
690 chandransh 2421 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2422 
 
690 chandransh 2423 
  def resetCart(self, cartId, items):
559 chandransh 2424 
    """
690 chandransh 2425 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2426 
    This methods removes the specified quantiry of the specified item from the cart.
2427 
 
559 chandransh 2428 
    Parameters:
690 chandransh 2429 
     - cartId
2430 
     - items
559 chandransh 2431 
    """
690 chandransh 2432 
    self.send_resetCart(cartId, items)
2433 
    return self.recv_resetCart()
130 ashish 2434 
 
690 chandransh 2435 
  def send_resetCart(self, cartId, items):
2436 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2437 
    args = resetCart_args()
2438 
    args.cartId = cartId
2439 
    args.items = items
559 chandransh 2440 
    args.write(self._oprot)
2441 
    self._oprot.writeMessageEnd()
2442 
    self._oprot.trans.flush()
2443 
 
690 chandransh 2444 
  def recv_resetCart(self, ):
559 chandransh 2445 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2446 
    if mtype == TMessageType.EXCEPTION:
2447 
      x = TApplicationException()
2448 
      x.read(self._iprot)
2449 
      self._iprot.readMessageEnd()
2450 
      raise x
690 chandransh 2451 
    result = resetCart_result()
559 chandransh 2452 
    result.read(self._iprot)
2453 
    self._iprot.readMessageEnd()
690 chandransh 2454 
    if result.success != None:
2455 
      return result.success
2456 
    if result.scex != None:
2457 
      raise result.scex
2458 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2459 
 
772 rajveer 2460 
  def getMyResearch(self, userId):
559 chandransh 2461 
    """
772 rajveer 2462 
    Widgets
2463 
 
559 chandransh 2464 
    Parameters:
2465 
     - userId
2466 
    """
772 rajveer 2467 
    self.send_getMyResearch(userId)
559 chandransh 2468 
    return self.recv_getMyResearch()
2469 
 
772 rajveer 2470 
  def send_getMyResearch(self, userId):
559 chandransh 2471 
    self._oprot.writeMessageBegin('getMyResearch', TMessageType.CALL, self._seqid)
2472 
    args = getMyResearch_args()
772 rajveer 2473 
    args.userId = userId
559 chandransh 2474 
    args.write(self._oprot)
2475 
    self._oprot.writeMessageEnd()
2476 
    self._oprot.trans.flush()
2477 
 
2478 
  def recv_getMyResearch(self, ):
2479 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2480 
    if mtype == TMessageType.EXCEPTION:
2481 
      x = TApplicationException()
2482 
      x.read(self._iprot)
2483 
      self._iprot.readMessageEnd()
2484 
      raise x
2485 
    result = getMyResearch_result()
2486 
    result.read(self._iprot)
2487 
    self._iprot.readMessageEnd()
2488 
    if result.success != None:
2489 
      return result.success
2490 
    if result.scx != None:
2491 
      raise result.scx
2492 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearch failed: unknown result");
2493 
 
772 rajveer 2494 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2495 
    """
2496 
    Parameters:
772 rajveer 2497 
     - userId
2498 
     - itemId
559 chandransh 2499 
    """
772 rajveer 2500 
    self.send_updateMyResearch(userId, itemId)
559 chandransh 2501 
    return self.recv_updateMyResearch()
2502 
 
772 rajveer 2503 
  def send_updateMyResearch(self, userId, itemId):
559 chandransh 2504 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2505 
    args = updateMyResearch_args()
772 rajveer 2506 
    args.userId = userId
2507 
    args.itemId = itemId
559 chandransh 2508 
    args.write(self._oprot)
2509 
    self._oprot.writeMessageEnd()
2510 
    self._oprot.trans.flush()
2511 
 
2512 
  def recv_updateMyResearch(self, ):
2513 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2514 
    if mtype == TMessageType.EXCEPTION:
2515 
      x = TApplicationException()
2516 
      x.read(self._iprot)
2517 
      self._iprot.readMessageEnd()
2518 
      raise x
2519 
    result = updateMyResearch_result()
2520 
    result.read(self._iprot)
2521 
    self._iprot.readMessageEnd()
2522 
    if result.success != None:
2523 
      return result.success
2524 
    if result.scx != None:
2525 
      raise result.scx
2526 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
2527 
 
772 rajveer 2528 
  def deleteItemFromMyResearch(self, userId, itemId):
559 chandransh 2529 
    """
2530 
    Parameters:
772 rajveer 2531 
     - userId
2532 
     - itemId
559 chandransh 2533 
    """
772 rajveer 2534 
    self.send_deleteItemFromMyResearch(userId, itemId)
559 chandransh 2535 
    self.recv_deleteItemFromMyResearch()
2536 
 
772 rajveer 2537 
  def send_deleteItemFromMyResearch(self, userId, itemId):
559 chandransh 2538 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2539 
    args = deleteItemFromMyResearch_args()
772 rajveer 2540 
    args.userId = userId
2541 
    args.itemId = itemId
559 chandransh 2542 
    args.write(self._oprot)
2543 
    self._oprot.writeMessageEnd()
2544 
    self._oprot.trans.flush()
2545 
 
2546 
  def recv_deleteItemFromMyResearch(self, ):
2547 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2548 
    if mtype == TMessageType.EXCEPTION:
2549 
      x = TApplicationException()
2550 
      x.read(self._iprot)
2551 
      self._iprot.readMessageEnd()
2552 
      raise x
2553 
    result = deleteItemFromMyResearch_result()
2554 
    result.read(self._iprot)
2555 
    self._iprot.readMessageEnd()
2556 
    if result.scx != None:
2557 
      raise result.scx
2558 
    return
2559 
 
772 rajveer 2560 
  def updateBrowseHistory(self, userId, itemId):
559 chandransh 2561 
    """
2562 
    Parameters:
772 rajveer 2563 
     - userId
2564 
     - itemId
559 chandransh 2565 
    """
772 rajveer 2566 
    self.send_updateBrowseHistory(userId, itemId)
2567 
    self.recv_updateBrowseHistory()
559 chandransh 2568 
 
772 rajveer 2569 
  def send_updateBrowseHistory(self, userId, itemId):
2570 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2571 
    args = updateBrowseHistory_args()
2572 
    args.userId = userId
2573 
    args.itemId = itemId
559 chandransh 2574 
    args.write(self._oprot)
2575 
    self._oprot.writeMessageEnd()
2576 
    self._oprot.trans.flush()
2577 
 
772 rajveer 2578 
  def recv_updateBrowseHistory(self, ):
559 chandransh 2579 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2580 
    if mtype == TMessageType.EXCEPTION:
2581 
      x = TApplicationException()
2582 
      x.read(self._iprot)
2583 
      self._iprot.readMessageEnd()
2584 
      raise x
772 rajveer 2585 
    result = updateBrowseHistory_result()
559 chandransh 2586 
    result.read(self._iprot)
2587 
    self._iprot.readMessageEnd()
2588 
    return
2589 
 
772 rajveer 2590 
  def getBrowseHistory(self, userId):
559 chandransh 2591 
    """
2592 
    Parameters:
772 rajveer 2593 
     - userId
559 chandransh 2594 
    """
772 rajveer 2595 
    self.send_getBrowseHistory(userId)
2596 
    return self.recv_getBrowseHistory()
559 chandransh 2597 
 
772 rajveer 2598 
  def send_getBrowseHistory(self, userId):
2599 
    self._oprot.writeMessageBegin('getBrowseHistory', TMessageType.CALL, self._seqid)
2600 
    args = getBrowseHistory_args()
2601 
    args.userId = userId
559 chandransh 2602 
    args.write(self._oprot)
2603 
    self._oprot.writeMessageEnd()
2604 
    self._oprot.trans.flush()
2605 
 
772 rajveer 2606 
  def recv_getBrowseHistory(self, ):
559 chandransh 2607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2608 
    if mtype == TMessageType.EXCEPTION:
2609 
      x = TApplicationException()
2610 
      x.read(self._iprot)
2611 
      self._iprot.readMessageEnd()
2612 
      raise x
772 rajveer 2613 
    result = getBrowseHistory_result()
559 chandransh 2614 
    result.read(self._iprot)
2615 
    self._iprot.readMessageEnd()
2616 
    if result.success != None:
2617 
      return result.success
2618 
    if result.scx != None:
2619 
      raise result.scx
772 rajveer 2620 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistory failed: unknown result");
559 chandransh 2621 
 
772 rajveer 2622 
  def mergeBrowseHistory(self, fromUserId, toUserId):
559 chandransh 2623 
    """
2624 
    Parameters:
772 rajveer 2625 
     - fromUserId
2626 
     - toUserId
559 chandransh 2627 
    """
772 rajveer 2628 
    self.send_mergeBrowseHistory(fromUserId, toUserId)
2629 
    self.recv_mergeBrowseHistory()
559 chandransh 2630 
 
772 rajveer 2631 
  def send_mergeBrowseHistory(self, fromUserId, toUserId):
2632 
    self._oprot.writeMessageBegin('mergeBrowseHistory', TMessageType.CALL, self._seqid)
2633 
    args = mergeBrowseHistory_args()
2634 
    args.fromUserId = fromUserId
2635 
    args.toUserId = toUserId
559 chandransh 2636 
    args.write(self._oprot)
2637 
    self._oprot.writeMessageEnd()
2638 
    self._oprot.trans.flush()
2639 
 
772 rajveer 2640 
  def recv_mergeBrowseHistory(self, ):
559 chandransh 2641 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2642 
    if mtype == TMessageType.EXCEPTION:
2643 
      x = TApplicationException()
2644 
      x.read(self._iprot)
2645 
      self._iprot.readMessageEnd()
2646 
      raise x
772 rajveer 2647 
    result = mergeBrowseHistory_result()
559 chandransh 2648 
    result.read(self._iprot)
2649 
    self._iprot.readMessageEnd()
2650 
    return
2651 
 
1596 ankur.sing 2652 
  def getUserCount(self, userType):
2653 
    """
2654 
    Returns number of registered users.
2655 
    If userType = null, then it returns count of all users, including anonymous
2656 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2657 
    If userType = UserType.USER, then it returns count of non-anonymous users only
2658 
 
2659 
    Parameters:
2660 
     - userType
2661 
    """
2662 
    self.send_getUserCount(userType)
2663 
    return self.recv_getUserCount()
559 chandransh 2664 
 
1596 ankur.sing 2665 
  def send_getUserCount(self, userType):
2666 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2667 
    args = getUserCount_args()
2668 
    args.userType = userType
2669 
    args.write(self._oprot)
2670 
    self._oprot.writeMessageEnd()
2671 
    self._oprot.trans.flush()
2672 
 
2673 
  def recv_getUserCount(self, ):
2674 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2675 
    if mtype == TMessageType.EXCEPTION:
2676 
      x = TApplicationException()
2677 
      x.read(self._iprot)
2678 
      self._iprot.readMessageEnd()
2679 
      raise x
2680 
    result = getUserCount_result()
2681 
    result.read(self._iprot)
2682 
    self._iprot.readMessageEnd()
2683 
    if result.success != None:
2684 
      return result.success
2685 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
2686 
 
1891 ankur.sing 2687 
  def getAllUsers(self, userType, startDate, endDate):
1673 ankur.sing 2688 
    """
1891 ankur.sing 2689 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2690 
    If any of startDate or endDate is -1, then that filter is ignored.
2691 
    If userType is null, then returns all the users, irrespective of anonymous flag
1673 ankur.sing 2692 
 
1891 ankur.sing 2693 
 
1673 ankur.sing 2694 
    Parameters:
2695 
     - userType
1891 ankur.sing 2696 
     - startDate
2697 
     - endDate
1673 ankur.sing 2698 
    """
1891 ankur.sing 2699 
    self.send_getAllUsers(userType, startDate, endDate)
1673 ankur.sing 2700 
    return self.recv_getAllUsers()
1596 ankur.sing 2701 
 
1891 ankur.sing 2702 
  def send_getAllUsers(self, userType, startDate, endDate):
1673 ankur.sing 2703 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2704 
    args = getAllUsers_args()
2705 
    args.userType = userType
1891 ankur.sing 2706 
    args.startDate = startDate
2707 
    args.endDate = endDate
1673 ankur.sing 2708 
    args.write(self._oprot)
2709 
    self._oprot.writeMessageEnd()
2710 
    self._oprot.trans.flush()
2711 
 
2712 
  def recv_getAllUsers(self, ):
2713 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2714 
    if mtype == TMessageType.EXCEPTION:
2715 
      x = TApplicationException()
2716 
      x.read(self._iprot)
2717 
      self._iprot.readMessageEnd()
2718 
      raise x
2719 
    result = getAllUsers_result()
2720 
    result.read(self._iprot)
2721 
    self._iprot.readMessageEnd()
2722 
    if result.success != None:
2723 
      return result.success
2724 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
2725 
 
2726 
 
94 ashish 2727 
class Processor(Iface, TProcessor):
2728 
  def __init__(self, handler):
2729 
    self._handler = handler
2730 
    self._processMap = {}
765 rajveer 2731 
    self._processMap["closeSession"] = Processor.process_closeSession
559 chandransh 2732 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
2733 
    self._processMap["getUserById"] = Processor.process_getUserById
1491 vikas 2734 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
559 chandransh 2735 
    self._processMap["createUser"] = Processor.process_createUser
2736 
    self._processMap["updateUser"] = Processor.process_updateUser
2737 
    self._processMap["deleteUser"] = Processor.process_deleteUser
2738 
    self._processMap["getUserState"] = Processor.process_getUserState
122 ashish 2739 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 2740 
    self._processMap["userExists"] = Processor.process_userExists
2741 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
2742 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
2743 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
2744 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 2745 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 2746 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 2747 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 2748 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 2749 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 2750 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 2751 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 2752 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 2753 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
2754 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
2755 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
1845 vikas 2756 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
2757 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
2758 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
2759 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
2760 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
2761 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
2762 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
2763 
    self._processMap["createTracker"] = Processor.process_createTracker
2764 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
2765 
    self._processMap["getTrackersByAffiliate"] = Processor.process_getTrackersByAffiliate
2766 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
2767 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
2768 
    self._processMap["getTrackLogsByTracker"] = Processor.process_getTrackLogsByTracker
2769 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
2770 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 2771 
    self._processMap["createCart"] = Processor.process_createCart
2772 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
2773 
    self._processMap["getCart"] = Processor.process_getCart
2774 
    self._processMap["getCartsForUser"] = Processor.process_getCartsForUser
2775 
    self._processMap["getCartsByStatus"] = Processor.process_getCartsByStatus
2776 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
2777 
    self._processMap["changeCartStatus"] = Processor.process_changeCartStatus
2778 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
2779 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
2780 
    self._processMap["changeQuantity"] = Processor.process_changeQuantity
2781 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
2782 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
690 chandransh 2783 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 2784 
    self._processMap["validateCart"] = Processor.process_validateCart
2785 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 2786 
    self._processMap["checkOut"] = Processor.process_checkOut
2787 
    self._processMap["resetCart"] = Processor.process_resetCart
559 chandransh 2788 
    self._processMap["getMyResearch"] = Processor.process_getMyResearch
2789 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
2790 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
2791 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
2792 
    self._processMap["getBrowseHistory"] = Processor.process_getBrowseHistory
772 rajveer 2793 
    self._processMap["mergeBrowseHistory"] = Processor.process_mergeBrowseHistory
1596 ankur.sing 2794 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 2795 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
94 ashish 2796 
 
2797 
  def process(self, iprot, oprot):
2798 
    (name, type, seqid) = iprot.readMessageBegin()
2799 
    if name not in self._processMap:
2800 
      iprot.skip(TType.STRUCT)
2801 
      iprot.readMessageEnd()
2802 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
2803 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
2804 
      x.write(oprot)
2805 
      oprot.writeMessageEnd()
2806 
      oprot.trans.flush()
2807 
      return
2808 
    else:
2809 
      self._processMap[name](self, seqid, iprot, oprot)
2810 
    return True
2811 
 
765 rajveer 2812 
  def process_closeSession(self, seqid, iprot, oprot):
2813 
    args = closeSession_args()
2814 
    args.read(iprot)
2815 
    iprot.readMessageEnd()
2816 
    result = closeSession_result()
2817 
    self._handler.closeSession()
2818 
    oprot.writeMessageBegin("closeSession", TMessageType.REPLY, seqid)
2819 
    result.write(oprot)
2820 
    oprot.writeMessageEnd()
2821 
    oprot.trans.flush()
2822 
 
559 chandransh 2823 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
2824 
    args = createAnonymousUser_args()
94 ashish 2825 
    args.read(iprot)
2826 
    iprot.readMessageEnd()
559 chandransh 2827 
    result = createAnonymousUser_result()
94 ashish 2828 
    try:
559 chandransh 2829 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
2830 
    except UserContextException, ucex:
2831 
      result.ucex = ucex
2832 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 2833 
    result.write(oprot)
2834 
    oprot.writeMessageEnd()
2835 
    oprot.trans.flush()
2836 
 
559 chandransh 2837 
  def process_getUserById(self, seqid, iprot, oprot):
2838 
    args = getUserById_args()
94 ashish 2839 
    args.read(iprot)
2840 
    iprot.readMessageEnd()
559 chandransh 2841 
    result = getUserById_result()
94 ashish 2842 
    try:
559 chandransh 2843 
      result.success = self._handler.getUserById(args.userId)
2844 
    except UserContextException, ucex:
2845 
      result.ucex = ucex
2846 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 2847 
    result.write(oprot)
2848 
    oprot.writeMessageEnd()
2849 
    oprot.trans.flush()
2850 
 
1491 vikas 2851 
  def process_getUserByEmail(self, seqid, iprot, oprot):
2852 
    args = getUserByEmail_args()
2853 
    args.read(iprot)
2854 
    iprot.readMessageEnd()
2855 
    result = getUserByEmail_result()
2856 
    try:
2857 
      result.success = self._handler.getUserByEmail(args.email)
2858 
    except UserContextException, ucex:
2859 
      result.ucex = ucex
2860 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
2861 
    result.write(oprot)
2862 
    oprot.writeMessageEnd()
2863 
    oprot.trans.flush()
2864 
 
559 chandransh 2865 
  def process_createUser(self, seqid, iprot, oprot):
2866 
    args = createUser_args()
94 ashish 2867 
    args.read(iprot)
2868 
    iprot.readMessageEnd()
559 chandransh 2869 
    result = createUser_result()
94 ashish 2870 
    try:
559 chandransh 2871 
      result.success = self._handler.createUser(args.user)
2872 
    except UserContextException, ucex:
2873 
      result.ucex = ucex
2874 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 2875 
    result.write(oprot)
2876 
    oprot.writeMessageEnd()
2877 
    oprot.trans.flush()
2878 
 
559 chandransh 2879 
  def process_updateUser(self, seqid, iprot, oprot):
2880 
    args = updateUser_args()
94 ashish 2881 
    args.read(iprot)
2882 
    iprot.readMessageEnd()
559 chandransh 2883 
    result = updateUser_result()
94 ashish 2884 
    try:
559 chandransh 2885 
      result.success = self._handler.updateUser(args.user)
2886 
    except UserContextException, ucex:
2887 
      result.ucex = ucex
2888 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 2889 
    result.write(oprot)
2890 
    oprot.writeMessageEnd()
2891 
    oprot.trans.flush()
2892 
 
559 chandransh 2893 
  def process_deleteUser(self, seqid, iprot, oprot):
2894 
    args = deleteUser_args()
94 ashish 2895 
    args.read(iprot)
2896 
    iprot.readMessageEnd()
559 chandransh 2897 
    result = deleteUser_result()
94 ashish 2898 
    try:
559 chandransh 2899 
      result.success = self._handler.deleteUser(args.userId)
2900 
    except UserContextException, ucex:
2901 
      result.ucex = ucex
2902 
    oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
94 ashish 2903 
    result.write(oprot)
2904 
    oprot.writeMessageEnd()
2905 
    oprot.trans.flush()
2906 
 
559 chandransh 2907 
  def process_getUserState(self, seqid, iprot, oprot):
2908 
    args = getUserState_args()
94 ashish 2909 
    args.read(iprot)
2910 
    iprot.readMessageEnd()
559 chandransh 2911 
    result = getUserState_result()
94 ashish 2912 
    try:
559 chandransh 2913 
      result.success = self._handler.getUserState(args.userId)
2914 
    except UserContextException, ucex:
2915 
      result.ucex = ucex
2916 
    oprot.writeMessageBegin("getUserState", TMessageType.REPLY, seqid)
94 ashish 2917 
    result.write(oprot)
2918 
    oprot.writeMessageEnd()
2919 
    oprot.trans.flush()
2920 
 
122 ashish 2921 
  def process_authenticateUser(self, seqid, iprot, oprot):
2922 
    args = authenticateUser_args()
2923 
    args.read(iprot)
2924 
    iprot.readMessageEnd()
2925 
    result = authenticateUser_result()
2926 
    try:
559 chandransh 2927 
      result.success = self._handler.authenticateUser(args.email, args.password)
2928 
    except AuthenticationException, auex:
2929 
      result.auex = auex
122 ashish 2930 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
2931 
    result.write(oprot)
2932 
    oprot.writeMessageEnd()
2933 
    oprot.trans.flush()
2934 
 
94 ashish 2935 
  def process_userExists(self, seqid, iprot, oprot):
2936 
    args = userExists_args()
2937 
    args.read(iprot)
2938 
    iprot.readMessageEnd()
2939 
    result = userExists_result()
2940 
    try:
2941 
      result.success = self._handler.userExists(args.email)
2942 
    except UserContextException, ucx:
2943 
      result.ucx = ucx
2944 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
2945 
    result.write(oprot)
2946 
    oprot.writeMessageEnd()
2947 
    oprot.trans.flush()
2948 
 
2949 
  def process_addAddressForUser(self, seqid, iprot, oprot):
2950 
    args = addAddressForUser_args()
2951 
    args.read(iprot)
2952 
    iprot.readMessageEnd()
2953 
    result = addAddressForUser_result()
2954 
    try:
567 rajveer 2955 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 2956 
    except UserContextException, ucx:
2957 
      result.ucx = ucx
2958 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
2959 
    result.write(oprot)
2960 
    oprot.writeMessageEnd()
2961 
    oprot.trans.flush()
2962 
 
2963 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
2964 
    args = removeAddressForUser_args()
2965 
    args.read(iprot)
2966 
    iprot.readMessageEnd()
2967 
    result = removeAddressForUser_result()
2968 
    try:
2969 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
2970 
    except UserContextException, ucx:
2971 
      result.ucx = ucx
2972 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
2973 
    result.write(oprot)
2974 
    oprot.writeMessageEnd()
2975 
    oprot.trans.flush()
2976 
 
2977 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
2978 
    args = setUserAsLoggedIn_args()
2979 
    args.read(iprot)
2980 
    iprot.readMessageEnd()
2981 
    result = setUserAsLoggedIn_result()
2982 
    try:
2983 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
2984 
    except UserContextException, ucx:
2985 
      result.ucx = ucx
2986 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
2987 
    result.write(oprot)
2988 
    oprot.writeMessageEnd()
2989 
    oprot.trans.flush()
2990 
 
2991 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
2992 
    args = setUserAsLoggedOut_args()
2993 
    args.read(iprot)
2994 
    iprot.readMessageEnd()
2995 
    result = setUserAsLoggedOut_result()
2996 
    try:
2997 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
2998 
    except UserContextException, ucx:
2999 
      result.ucx = ucx
3000 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
3001 
    result.write(oprot)
3002 
    oprot.writeMessageEnd()
3003 
    oprot.trans.flush()
3004 
 
504 rajveer 3005 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
3006 
    args = setDefaultAddress_args()
3007 
    args.read(iprot)
3008 
    iprot.readMessageEnd()
3009 
    result = setDefaultAddress_result()
3010 
    try:
3011 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
3012 
    except UserContextException, ucx:
3013 
      result.ucx = ucx
3014 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
3015 
    result.write(oprot)
3016 
    oprot.writeMessageEnd()
3017 
    oprot.trans.flush()
3018 
 
94 ashish 3019 
  def process_updatePassword(self, seqid, iprot, oprot):
3020 
    args = updatePassword_args()
3021 
    args.read(iprot)
3022 
    iprot.readMessageEnd()
3023 
    result = updatePassword_result()
3024 
    try:
594 rajveer 3025 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 3026 
    except UserContextException, ucx:
3027 
      result.ucx = ucx
3028 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
3029 
    result.write(oprot)
3030 
    oprot.writeMessageEnd()
3031 
    oprot.trans.flush()
3032 
 
581 rajveer 3033 
  def process_forgotPassword(self, seqid, iprot, oprot):
3034 
    args = forgotPassword_args()
3035 
    args.read(iprot)
3036 
    iprot.readMessageEnd()
3037 
    result = forgotPassword_result()
3038 
    try:
884 rajveer 3039 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 3040 
    except UserContextException, ucx:
3041 
      result.ucx = ucx
3042 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
3043 
    result.write(oprot)
3044 
    oprot.writeMessageEnd()
3045 
    oprot.trans.flush()
3046 
 
594 rajveer 3047 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
3048 
    args = getAllAddressesForUser_args()
3049 
    args.read(iprot)
3050 
    iprot.readMessageEnd()
3051 
    result = getAllAddressesForUser_result()
3052 
    try:
3053 
      result.success = self._handler.getAllAddressesForUser(args.userId)
3054 
    except UserContextException, ucx:
3055 
      result.ucx = ucx
3056 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
3057 
    result.write(oprot)
3058 
    oprot.writeMessageEnd()
3059 
    oprot.trans.flush()
3060 
 
1894 vikas 3061 
  def process_getAddressById(self, seqid, iprot, oprot):
3062 
    args = getAddressById_args()
3063 
    args.read(iprot)
3064 
    iprot.readMessageEnd()
3065 
    result = getAddressById_result()
3066 
    try:
3067 
      result.success = self._handler.getAddressById(args.addressId)
3068 
    except UserContextException, ucx:
3069 
      result.ucx = ucx
3070 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
3071 
    result.write(oprot)
3072 
    oprot.writeMessageEnd()
3073 
    oprot.trans.flush()
3074 
 
594 rajveer 3075 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
3076 
    args = getDefaultAddressId_args()
3077 
    args.read(iprot)
3078 
    iprot.readMessageEnd()
3079 
    result = getDefaultAddressId_result()
3080 
    try:
3081 
      result.success = self._handler.getDefaultAddressId(args.userId)
3082 
    except UserContextException, ucx:
3083 
      result.ucx = ucx
3084 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
3085 
    result.write(oprot)
3086 
    oprot.writeMessageEnd()
3087 
    oprot.trans.flush()
3088 
 
785 rajveer 3089 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
3090 
    args = getDefaultPincode_args()
3091 
    args.read(iprot)
3092 
    iprot.readMessageEnd()
3093 
    result = getDefaultPincode_result()
3094 
    try:
3095 
      result.success = self._handler.getDefaultPincode(args.userId)
3096 
    except UserContextException, ucx:
3097 
      result.ucx = ucx
3098 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
3099 
    result.write(oprot)
3100 
    oprot.writeMessageEnd()
3101 
    oprot.trans.flush()
3102 
 
1274 varun.gupt 3103 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
3104 
    args = saveUserCommunication_args()
3105 
    args.read(iprot)
3106 
    iprot.readMessageEnd()
3107 
    result = saveUserCommunication_result()
3108 
    try:
3109 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
3110 
    except UserCommunicationException, ucx:
3111 
      result.ucx = ucx
3112 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
3113 
    result.write(oprot)
3114 
    oprot.writeMessageEnd()
3115 
    oprot.trans.flush()
3116 
 
1590 varun.gupt 3117 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
3118 
    args = getUserCommunicationById_args()
3119 
    args.read(iprot)
3120 
    iprot.readMessageEnd()
3121 
    result = getUserCommunicationById_result()
3122 
    try:
3123 
      result.success = self._handler.getUserCommunicationById(args.id)
3124 
    except UserCommunicationException, ucx:
3125 
      result.ucx = ucx
3126 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
3127 
    result.write(oprot)
3128 
    oprot.writeMessageEnd()
3129 
    oprot.trans.flush()
3130 
 
3131 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
3132 
    args = getUserCommunicationByUser_args()
3133 
    args.read(iprot)
3134 
    iprot.readMessageEnd()
3135 
    result = getUserCommunicationByUser_result()
3136 
    try:
3137 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
3138 
    except UserCommunicationException, ucx:
3139 
      result.ucx = ucx
3140 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
3141 
    result.write(oprot)
3142 
    oprot.writeMessageEnd()
3143 
    oprot.trans.flush()
3144 
 
3145 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
3146 
    args = getAllUserCommunications_args()
3147 
    args.read(iprot)
3148 
    iprot.readMessageEnd()
3149 
    result = getAllUserCommunications_result()
3150 
    try:
3151 
      result.success = self._handler.getAllUserCommunications()
3152 
    except UserCommunicationException, ucx:
3153 
      result.ucx = ucx
3154 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
3155 
    result.write(oprot)
3156 
    oprot.writeMessageEnd()
3157 
    oprot.trans.flush()
3158 
 
1845 vikas 3159 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
3160 
    args = createMasterAffiliate_args()
3161 
    args.read(iprot)
3162 
    iprot.readMessageEnd()
3163 
    result = createMasterAffiliate_result()
3164 
    try:
1859 vikas 3165 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1845 vikas 3166 
    except UserTrackerException, utx:
3167 
      result.utx = utx
3168 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
3169 
    result.write(oprot)
3170 
    oprot.writeMessageEnd()
3171 
    oprot.trans.flush()
3172 
 
3173 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
3174 
    args = getMasterAffiliateById_args()
3175 
    args.read(iprot)
3176 
    iprot.readMessageEnd()
3177 
    result = getMasterAffiliateById_result()
3178 
    try:
3179 
      result.success = self._handler.getMasterAffiliateById(args.id)
3180 
    except UserTrackerException, utx:
3181 
      result.utx = utx
3182 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
3183 
    result.write(oprot)
3184 
    oprot.writeMessageEnd()
3185 
    oprot.trans.flush()
3186 
 
3187 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
3188 
    args = getMasterAffiliateByName_args()
3189 
    args.read(iprot)
3190 
    iprot.readMessageEnd()
3191 
    result = getMasterAffiliateByName_result()
3192 
    try:
3193 
      result.success = self._handler.getMasterAffiliateByName(args.name)
3194 
    except UserTrackerException, utx:
3195 
      result.utx = utx
3196 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
3197 
    result.write(oprot)
3198 
    oprot.writeMessageEnd()
3199 
    oprot.trans.flush()
3200 
 
3201 
  def process_createAffiliate(self, seqid, iprot, oprot):
3202 
    args = createAffiliate_args()
3203 
    args.read(iprot)
3204 
    iprot.readMessageEnd()
3205 
    result = createAffiliate_result()
3206 
    try:
1859 vikas 3207 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1845 vikas 3208 
    except UserTrackerException, utx:
3209 
      result.utx = utx
3210 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
3211 
    result.write(oprot)
3212 
    oprot.writeMessageEnd()
3213 
    oprot.trans.flush()
3214 
 
3215 
  def process_getAffiliateById(self, seqid, iprot, oprot):
3216 
    args = getAffiliateById_args()
3217 
    args.read(iprot)
3218 
    iprot.readMessageEnd()
3219 
    result = getAffiliateById_result()
3220 
    try:
3221 
      result.success = self._handler.getAffiliateById(args.id)
3222 
    except UserTrackerException, utx:
3223 
      result.utx = utx
3224 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
3225 
    result.write(oprot)
3226 
    oprot.writeMessageEnd()
3227 
    oprot.trans.flush()
3228 
 
3229 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
3230 
    args = getAffiliateByName_args()
3231 
    args.read(iprot)
3232 
    iprot.readMessageEnd()
3233 
    result = getAffiliateByName_result()
3234 
    try:
3235 
      result.success = self._handler.getAffiliateByName(args.name)
3236 
    except UserTrackerException, utx:
3237 
      result.utx = utx
3238 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
3239 
    result.write(oprot)
3240 
    oprot.writeMessageEnd()
3241 
    oprot.trans.flush()
3242 
 
3243 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
3244 
    args = getAffiliatesByMasterAffiliate_args()
3245 
    args.read(iprot)
3246 
    iprot.readMessageEnd()
3247 
    result = getAffiliatesByMasterAffiliate_result()
3248 
    try:
3249 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
3250 
    except UserTrackerException, utx:
3251 
      result.utx = utx
3252 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
3253 
    result.write(oprot)
3254 
    oprot.writeMessageEnd()
3255 
    oprot.trans.flush()
3256 
 
3257 
  def process_createTracker(self, seqid, iprot, oprot):
3258 
    args = createTracker_args()
3259 
    args.read(iprot)
3260 
    iprot.readMessageEnd()
3261 
    result = createTracker_result()
3262 
    try:
1859 vikas 3263 
      result.success = self._handler.createTracker(args.affiliateId, args.addedOn)
1845 vikas 3264 
    except UserTrackerException, utx:
3265 
      result.utx = utx
3266 
    oprot.writeMessageBegin("createTracker", TMessageType.REPLY, seqid)
3267 
    result.write(oprot)
3268 
    oprot.writeMessageEnd()
3269 
    oprot.trans.flush()
3270 
 
3271 
  def process_getTrackerById(self, seqid, iprot, oprot):
3272 
    args = getTrackerById_args()
3273 
    args.read(iprot)
3274 
    iprot.readMessageEnd()
3275 
    result = getTrackerById_result()
3276 
    try:
3277 
      result.success = self._handler.getTrackerById(args.trackerId)
3278 
    except UserTrackerException, utx:
3279 
      result.utx = utx
3280 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
3281 
    result.write(oprot)
3282 
    oprot.writeMessageEnd()
3283 
    oprot.trans.flush()
3284 
 
3285 
  def process_getTrackersByAffiliate(self, seqid, iprot, oprot):
3286 
    args = getTrackersByAffiliate_args()
3287 
    args.read(iprot)
3288 
    iprot.readMessageEnd()
3289 
    result = getTrackersByAffiliate_result()
3290 
    try:
3291 
      result.success = self._handler.getTrackersByAffiliate(args.affiliateId)
3292 
    except UserTrackerException, utx:
3293 
      result.utx = utx
3294 
    oprot.writeMessageBegin("getTrackersByAffiliate", TMessageType.REPLY, seqid)
3295 
    result.write(oprot)
3296 
    oprot.writeMessageEnd()
3297 
    oprot.trans.flush()
3298 
 
3299 
  def process_addTrackLog(self, seqid, iprot, oprot):
3300 
    args = addTrackLog_args()
3301 
    args.read(iprot)
3302 
    iprot.readMessageEnd()
3303 
    result = addTrackLog_result()
3304 
    try:
1859 vikas 3305 
      result.success = self._handler.addTrackLog(args.trackerId, args.userId, args.event, args.url, args.data, args.addedOn)
1845 vikas 3306 
    except UserTrackerException, utx:
3307 
      result.utx = utx
3308 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
3309 
    result.write(oprot)
3310 
    oprot.writeMessageEnd()
3311 
    oprot.trans.flush()
3312 
 
3313 
  def process_getTrackLogById(self, seqid, iprot, oprot):
3314 
    args = getTrackLogById_args()
3315 
    args.read(iprot)
3316 
    iprot.readMessageEnd()
3317 
    result = getTrackLogById_result()
3318 
    try:
3319 
      result.success = self._handler.getTrackLogById(args.id)
3320 
    except UserTrackerException, utx:
3321 
      result.utx = utx
3322 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
3323 
    result.write(oprot)
3324 
    oprot.writeMessageEnd()
3325 
    oprot.trans.flush()
3326 
 
3327 
  def process_getTrackLogsByTracker(self, seqid, iprot, oprot):
3328 
    args = getTrackLogsByTracker_args()
3329 
    args.read(iprot)
3330 
    iprot.readMessageEnd()
3331 
    result = getTrackLogsByTracker_result()
3332 
    try:
3333 
      result.success = self._handler.getTrackLogsByTracker(args.trackerId)
3334 
    except UserTrackerException, utx:
3335 
      result.utx = utx
3336 
    oprot.writeMessageBegin("getTrackLogsByTracker", TMessageType.REPLY, seqid)
3337 
    result.write(oprot)
3338 
    oprot.writeMessageEnd()
3339 
    oprot.trans.flush()
3340 
 
3341 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
3342 
    args = getTrackLogsByUser_args()
3343 
    args.read(iprot)
3344 
    iprot.readMessageEnd()
3345 
    result = getTrackLogsByUser_result()
3346 
    try:
3347 
      result.success = self._handler.getTrackLogsByUser(args.userId)
3348 
    except UserTrackerException, utx:
3349 
      result.utx = utx
3350 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
3351 
    result.write(oprot)
3352 
    oprot.writeMessageEnd()
3353 
    oprot.trans.flush()
3354 
 
3355 
  def process_getTrackLogs(self, seqid, iprot, oprot):
3356 
    args = getTrackLogs_args()
3357 
    args.read(iprot)
3358 
    iprot.readMessageEnd()
3359 
    result = getTrackLogs_result()
3360 
    try:
3361 
      result.success = self._handler.getTrackLogs(args.trackerId, args.userId, args.event, args.url)
3362 
    except UserTrackerException, utx:
3363 
      result.utx = utx
3364 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
3365 
    result.write(oprot)
3366 
    oprot.writeMessageEnd()
3367 
    oprot.trans.flush()
3368 
 
559 chandransh 3369 
  def process_createCart(self, seqid, iprot, oprot):
3370 
    args = createCart_args()
94 ashish 3371 
    args.read(iprot)
3372 
    iprot.readMessageEnd()
559 chandransh 3373 
    result = createCart_result()
94 ashish 3374 
    try:
559 chandransh 3375 
      result.success = self._handler.createCart(args.userId)
3376 
    except ShoppingCartException, scx:
3377 
      result.scx = scx
3378 
    oprot.writeMessageBegin("createCart", TMessageType.REPLY, seqid)
94 ashish 3379 
    result.write(oprot)
3380 
    oprot.writeMessageEnd()
3381 
    oprot.trans.flush()
3382 
 
559 chandransh 3383 
  def process_getCurrentCart(self, seqid, iprot, oprot):
3384 
    args = getCurrentCart_args()
94 ashish 3385 
    args.read(iprot)
3386 
    iprot.readMessageEnd()
559 chandransh 3387 
    result = getCurrentCart_result()
94 ashish 3388 
    try:
559 chandransh 3389 
      result.success = self._handler.getCurrentCart(args.userId)
3390 
    except ShoppingCartException, scx:
3391 
      result.scx = scx
3392 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 3393 
    result.write(oprot)
3394 
    oprot.writeMessageEnd()
3395 
    oprot.trans.flush()
3396 
 
559 chandransh 3397 
  def process_getCart(self, seqid, iprot, oprot):
3398 
    args = getCart_args()
94 ashish 3399 
    args.read(iprot)
3400 
    iprot.readMessageEnd()
559 chandransh 3401 
    result = getCart_result()
94 ashish 3402 
    try:
559 chandransh 3403 
      result.success = self._handler.getCart(args.cartId)
3404 
    except ShoppingCartException, scx:
3405 
      result.scx = scx
3406 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 3407 
    result.write(oprot)
3408 
    oprot.writeMessageEnd()
3409 
    oprot.trans.flush()
3410 
 
559 chandransh 3411 
  def process_getCartsForUser(self, seqid, iprot, oprot):
3412 
    args = getCartsForUser_args()
94 ashish 3413 
    args.read(iprot)
3414 
    iprot.readMessageEnd()
559 chandransh 3415 
    result = getCartsForUser_result()
94 ashish 3416 
    try:
559 chandransh 3417 
      result.success = self._handler.getCartsForUser(args.userId, args.status)
3418 
    except ShoppingCartException, scx:
3419 
      result.scx = scx
3420 
    oprot.writeMessageBegin("getCartsForUser", TMessageType.REPLY, seqid)
94 ashish 3421 
    result.write(oprot)
3422 
    oprot.writeMessageEnd()
3423 
    oprot.trans.flush()
3424 
 
559 chandransh 3425 
  def process_getCartsByStatus(self, seqid, iprot, oprot):
3426 
    args = getCartsByStatus_args()
94 ashish 3427 
    args.read(iprot)
3428 
    iprot.readMessageEnd()
559 chandransh 3429 
    result = getCartsByStatus_result()
94 ashish 3430 
    try:
559 chandransh 3431 
      result.success = self._handler.getCartsByStatus(args.status)
3432 
    except ShoppingCartException, scx:
3433 
      result.scx = scx
3434 
    oprot.writeMessageBegin("getCartsByStatus", TMessageType.REPLY, seqid)
94 ashish 3435 
    result.write(oprot)
3436 
    oprot.writeMessageEnd()
3437 
    oprot.trans.flush()
3438 
 
559 chandransh 3439 
  def process_getCartsByTime(self, seqid, iprot, oprot):
3440 
    args = getCartsByTime_args()
94 ashish 3441 
    args.read(iprot)
3442 
    iprot.readMessageEnd()
559 chandransh 3443 
    result = getCartsByTime_result()
94 ashish 3444 
    try:
559 chandransh 3445 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
3446 
    except ShoppingCartException, scx:
3447 
      result.scx = scx
3448 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 3449 
    result.write(oprot)
3450 
    oprot.writeMessageEnd()
3451 
    oprot.trans.flush()
3452 
 
559 chandransh 3453 
  def process_changeCartStatus(self, seqid, iprot, oprot):
3454 
    args = changeCartStatus_args()
130 ashish 3455 
    args.read(iprot)
3456 
    iprot.readMessageEnd()
559 chandransh 3457 
    result = changeCartStatus_result()
130 ashish 3458 
    try:
559 chandransh 3459 
      self._handler.changeCartStatus(args.cartId, args.status)
3460 
    except ShoppingCartException, scx:
3461 
      result.scx = scx
3462 
    oprot.writeMessageBegin("changeCartStatus", TMessageType.REPLY, seqid)
130 ashish 3463 
    result.write(oprot)
3464 
    oprot.writeMessageEnd()
3465 
    oprot.trans.flush()
94 ashish 3466 
 
559 chandransh 3467 
  def process_addItemToCart(self, seqid, iprot, oprot):
3468 
    args = addItemToCart_args()
130 ashish 3469 
    args.read(iprot)
3470 
    iprot.readMessageEnd()
559 chandransh 3471 
    result = addItemToCart_result()
130 ashish 3472 
    try:
559 chandransh 3473 
      self._handler.addItemToCart(args.cartId, args.itemId, args.quantity)
3474 
    except ShoppingCartException, scx:
3475 
      result.scx = scx
3476 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 3477 
    result.write(oprot)
3478 
    oprot.writeMessageEnd()
3479 
    oprot.trans.flush()
3480 
 
559 chandransh 3481 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
3482 
    args = deleteItemFromCart_args()
3483 
    args.read(iprot)
3484 
    iprot.readMessageEnd()
3485 
    result = deleteItemFromCart_result()
3486 
    try:
3487 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
3488 
    except ShoppingCartException, scx:
3489 
      result.scx = scx
3490 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
3491 
    result.write(oprot)
3492 
    oprot.writeMessageEnd()
3493 
    oprot.trans.flush()
130 ashish 3494 
 
559 chandransh 3495 
  def process_changeQuantity(self, seqid, iprot, oprot):
3496 
    args = changeQuantity_args()
3497 
    args.read(iprot)
3498 
    iprot.readMessageEnd()
3499 
    result = changeQuantity_result()
3500 
    try:
3501 
      self._handler.changeQuantity(args.cartId, args.itemId, args.quantity)
3502 
    except ShoppingCartException, scx:
3503 
      result.scx = scx
3504 
    oprot.writeMessageBegin("changeQuantity", TMessageType.REPLY, seqid)
3505 
    result.write(oprot)
3506 
    oprot.writeMessageEnd()
3507 
    oprot.trans.flush()
3508 
 
3509 
  def process_changeItemStatus(self, seqid, iprot, oprot):
3510 
    args = changeItemStatus_args()
3511 
    args.read(iprot)
3512 
    iprot.readMessageEnd()
3513 
    result = changeItemStatus_result()
3514 
    try:
3515 
      self._handler.changeItemStatus(args.cartId, args.itemId, args.status)
3516 
    except ShoppingCartException, scx:
3517 
      result.scx = scx
3518 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
3519 
    result.write(oprot)
3520 
    oprot.writeMessageEnd()
3521 
    oprot.trans.flush()
3522 
 
3523 
  def process_addAddressToCart(self, seqid, iprot, oprot):
3524 
    args = addAddressToCart_args()
3525 
    args.read(iprot)
3526 
    iprot.readMessageEnd()
3527 
    result = addAddressToCart_result()
575 chandransh 3528 
    try:
3529 
      self._handler.addAddressToCart(args.cartId, args.addressId)
3530 
    except ShoppingCartException, scx:
3531 
      result.scx = scx
559 chandransh 3532 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
3533 
    result.write(oprot)
3534 
    oprot.writeMessageEnd()
3535 
    oprot.trans.flush()
3536 
 
690 chandransh 3537 
  def process_createOrders(self, seqid, iprot, oprot):
3538 
    args = createOrders_args()
559 chandransh 3539 
    args.read(iprot)
3540 
    iprot.readMessageEnd()
690 chandransh 3541 
    result = createOrders_result()
559 chandransh 3542 
    try:
690 chandransh 3543 
      result.success = self._handler.createOrders(args.cartId)
559 chandransh 3544 
    except ShoppingCartException, scx:
3545 
      result.scx = scx
690 chandransh 3546 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 3547 
    result.write(oprot)
3548 
    oprot.writeMessageEnd()
3549 
    oprot.trans.flush()
3550 
 
3551 
  def process_validateCart(self, seqid, iprot, oprot):
3552 
    args = validateCart_args()
3553 
    args.read(iprot)
3554 
    iprot.readMessageEnd()
3555 
    result = validateCart_result()
575 chandransh 3556 
    try:
3557 
      result.success = self._handler.validateCart(args.cartId)
3558 
    except ShoppingCartException, scex:
3559 
      result.scex = scex
559 chandransh 3560 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
3561 
    result.write(oprot)
3562 
    oprot.writeMessageEnd()
3563 
    oprot.trans.flush()
3564 
 
690 chandransh 3565 
  def process_mergeCart(self, seqid, iprot, oprot):
3566 
    args = mergeCart_args()
575 chandransh 3567 
    args.read(iprot)
3568 
    iprot.readMessageEnd()
690 chandransh 3569 
    result = mergeCart_result()
3570 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
3571 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
3572 
    result.write(oprot)
3573 
    oprot.writeMessageEnd()
3574 
    oprot.trans.flush()
3575 
 
3576 
  def process_checkOut(self, seqid, iprot, oprot):
3577 
    args = checkOut_args()
3578 
    args.read(iprot)
3579 
    iprot.readMessageEnd()
3580 
    result = checkOut_result()
575 chandransh 3581 
    try:
690 chandransh 3582 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 3583 
    except ShoppingCartException, scex:
3584 
      result.scex = scex
690 chandransh 3585 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 3586 
    result.write(oprot)
3587 
    oprot.writeMessageEnd()
3588 
    oprot.trans.flush()
3589 
 
690 chandransh 3590 
  def process_resetCart(self, seqid, iprot, oprot):
3591 
    args = resetCart_args()
559 chandransh 3592 
    args.read(iprot)
3593 
    iprot.readMessageEnd()
690 chandransh 3594 
    result = resetCart_result()
3595 
    try:
3596 
      result.success = self._handler.resetCart(args.cartId, args.items)
3597 
    except ShoppingCartException, scex:
3598 
      result.scex = scex
3599 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 3600 
    result.write(oprot)
3601 
    oprot.writeMessageEnd()
3602 
    oprot.trans.flush()
3603 
 
3604 
  def process_getMyResearch(self, seqid, iprot, oprot):
3605 
    args = getMyResearch_args()
3606 
    args.read(iprot)
3607 
    iprot.readMessageEnd()
3608 
    result = getMyResearch_result()
3609 
    try:
772 rajveer 3610 
      result.success = self._handler.getMyResearch(args.userId)
559 chandransh 3611 
    except WidgetException, scx:
3612 
      result.scx = scx
3613 
    oprot.writeMessageBegin("getMyResearch", TMessageType.REPLY, seqid)
3614 
    result.write(oprot)
3615 
    oprot.writeMessageEnd()
3616 
    oprot.trans.flush()
3617 
 
3618 
  def process_updateMyResearch(self, seqid, iprot, oprot):
3619 
    args = updateMyResearch_args()
3620 
    args.read(iprot)
3621 
    iprot.readMessageEnd()
3622 
    result = updateMyResearch_result()
3623 
    try:
772 rajveer 3624 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
559 chandransh 3625 
    except WidgetException, scx:
3626 
      result.scx = scx
3627 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
3628 
    result.write(oprot)
3629 
    oprot.writeMessageEnd()
3630 
    oprot.trans.flush()
3631 
 
3632 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
3633 
    args = deleteItemFromMyResearch_args()
3634 
    args.read(iprot)
3635 
    iprot.readMessageEnd()
3636 
    result = deleteItemFromMyResearch_result()
3637 
    try:
772 rajveer 3638 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
559 chandransh 3639 
    except WidgetException, scx:
3640 
      result.scx = scx
3641 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
3642 
    result.write(oprot)
3643 
    oprot.writeMessageEnd()
3644 
    oprot.trans.flush()
3645 
 
3646 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
3647 
    args = updateBrowseHistory_args()
3648 
    args.read(iprot)
3649 
    iprot.readMessageEnd()
3650 
    result = updateBrowseHistory_result()
772 rajveer 3651 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
559 chandransh 3652 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
3653 
    result.write(oprot)
3654 
    oprot.writeMessageEnd()
3655 
    oprot.trans.flush()
3656 
 
3657 
  def process_getBrowseHistory(self, seqid, iprot, oprot):
3658 
    args = getBrowseHistory_args()
3659 
    args.read(iprot)
3660 
    iprot.readMessageEnd()
3661 
    result = getBrowseHistory_result()
3662 
    try:
772 rajveer 3663 
      result.success = self._handler.getBrowseHistory(args.userId)
559 chandransh 3664 
    except WidgetException, scx:
3665 
      result.scx = scx
3666 
    oprot.writeMessageBegin("getBrowseHistory", TMessageType.REPLY, seqid)
3667 
    result.write(oprot)
3668 
    oprot.writeMessageEnd()
3669 
    oprot.trans.flush()
3670 
 
772 rajveer 3671 
  def process_mergeBrowseHistory(self, seqid, iprot, oprot):
3672 
    args = mergeBrowseHistory_args()
3673 
    args.read(iprot)
3674 
    iprot.readMessageEnd()
3675 
    result = mergeBrowseHistory_result()
3676 
    self._handler.mergeBrowseHistory(args.fromUserId, args.toUserId)
3677 
    oprot.writeMessageBegin("mergeBrowseHistory", TMessageType.REPLY, seqid)
3678 
    result.write(oprot)
3679 
    oprot.writeMessageEnd()
3680 
    oprot.trans.flush()
559 chandransh 3681 
 
1596 ankur.sing 3682 
  def process_getUserCount(self, seqid, iprot, oprot):
3683 
    args = getUserCount_args()
3684 
    args.read(iprot)
3685 
    iprot.readMessageEnd()
3686 
    result = getUserCount_result()
3687 
    result.success = self._handler.getUserCount(args.userType)
3688 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
3689 
    result.write(oprot)
3690 
    oprot.writeMessageEnd()
3691 
    oprot.trans.flush()
772 rajveer 3692 
 
1673 ankur.sing 3693 
  def process_getAllUsers(self, seqid, iprot, oprot):
3694 
    args = getAllUsers_args()
3695 
    args.read(iprot)
3696 
    iprot.readMessageEnd()
3697 
    result = getAllUsers_result()
1891 ankur.sing 3698 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
1673 ankur.sing 3699 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
3700 
    result.write(oprot)
3701 
    oprot.writeMessageEnd()
3702 
    oprot.trans.flush()
1596 ankur.sing 3703 
 
1673 ankur.sing 3704 
 
94 ashish 3705 
# HELPER FUNCTIONS AND STRUCTURES
3706 
 
765 rajveer 3707 
class closeSession_args:
3708 
 
3709 
  thrift_spec = (
3710 
  )
3711 
 
3712 
  def read(self, iprot):
3713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3715 
      return
3716 
    iprot.readStructBegin()
3717 
    while True:
3718 
      (fname, ftype, fid) = iprot.readFieldBegin()
3719 
      if ftype == TType.STOP:
3720 
        break
3721 
      else:
3722 
        iprot.skip(ftype)
3723 
      iprot.readFieldEnd()
3724 
    iprot.readStructEnd()
3725 
 
3726 
  def write(self, oprot):
3727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3729 
      return
3730 
    oprot.writeStructBegin('closeSession_args')
3731 
    oprot.writeFieldStop()
3732 
    oprot.writeStructEnd()
3733 
 
3734 
  def __repr__(self):
3735 
    L = ['%s=%r' % (key, value)
3736 
      for key, value in self.__dict__.iteritems()]
3737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3738 
 
3739 
  def __eq__(self, other):
3740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3741 
 
3742 
  def __ne__(self, other):
3743 
    return not (self == other)
3744 
 
3745 
class closeSession_result:
3746 
 
3747 
  thrift_spec = (
3748 
  )
3749 
 
3750 
  def read(self, iprot):
3751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3753 
      return
3754 
    iprot.readStructBegin()
3755 
    while True:
3756 
      (fname, ftype, fid) = iprot.readFieldBegin()
3757 
      if ftype == TType.STOP:
3758 
        break
3759 
      else:
3760 
        iprot.skip(ftype)
3761 
      iprot.readFieldEnd()
3762 
    iprot.readStructEnd()
3763 
 
3764 
  def write(self, oprot):
3765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3767 
      return
3768 
    oprot.writeStructBegin('closeSession_result')
3769 
    oprot.writeFieldStop()
3770 
    oprot.writeStructEnd()
3771 
 
3772 
  def __repr__(self):
3773 
    L = ['%s=%r' % (key, value)
3774 
      for key, value in self.__dict__.iteritems()]
3775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3776 
 
3777 
  def __eq__(self, other):
3778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3779 
 
3780 
  def __ne__(self, other):
3781 
    return not (self == other)
3782 
 
559 chandransh 3783 
class createAnonymousUser_args:
94 ashish 3784 
  """
3785 
  Attributes:
559 chandransh 3786 
   - jsessionId
94 ashish 3787 
  """
3788 
 
3789 
  thrift_spec = (
3790 
    None, # 0
559 chandransh 3791 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 3792 
  )
3793 
 
559 chandransh 3794 
  def __init__(self, jsessionId=None,):
3795 
    self.jsessionId = jsessionId
94 ashish 3796 
 
3797 
  def read(self, iprot):
3798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3800 
      return
3801 
    iprot.readStructBegin()
3802 
    while True:
3803 
      (fname, ftype, fid) = iprot.readFieldBegin()
3804 
      if ftype == TType.STOP:
3805 
        break
3806 
      if fid == 1:
559 chandransh 3807 
        if ftype == TType.STRING:
3808 
          self.jsessionId = iprot.readString();
94 ashish 3809 
        else:
3810 
          iprot.skip(ftype)
3811 
      else:
3812 
        iprot.skip(ftype)
3813 
      iprot.readFieldEnd()
3814 
    iprot.readStructEnd()
3815 
 
3816 
  def write(self, oprot):
3817 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3818 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3819 
      return
559 chandransh 3820 
    oprot.writeStructBegin('createAnonymousUser_args')
3821 
    if self.jsessionId != None:
3822 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
3823 
      oprot.writeString(self.jsessionId)
94 ashish 3824 
      oprot.writeFieldEnd()
3825 
    oprot.writeFieldStop()
3826 
    oprot.writeStructEnd()
3827 
 
3828 
  def __repr__(self):
3829 
    L = ['%s=%r' % (key, value)
3830 
      for key, value in self.__dict__.iteritems()]
3831 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3832 
 
3833 
  def __eq__(self, other):
3834 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3835 
 
3836 
  def __ne__(self, other):
3837 
    return not (self == other)
3838 
 
559 chandransh 3839 
class createAnonymousUser_result:
94 ashish 3840 
  """
3841 
  Attributes:
3842 
   - success
559 chandransh 3843 
   - ucex
94 ashish 3844 
  """
3845 
 
3846 
  thrift_spec = (
559 chandransh 3847 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
3848 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 3849 
  )
3850 
 
559 chandransh 3851 
  def __init__(self, success=None, ucex=None,):
94 ashish 3852 
    self.success = success
559 chandransh 3853 
    self.ucex = ucex
94 ashish 3854 
 
3855 
  def read(self, iprot):
3856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3858 
      return
3859 
    iprot.readStructBegin()
3860 
    while True:
3861 
      (fname, ftype, fid) = iprot.readFieldBegin()
3862 
      if ftype == TType.STOP:
3863 
        break
3864 
      if fid == 0:
3865 
        if ftype == TType.STRUCT:
559 chandransh 3866 
          self.success = User()
94 ashish 3867 
          self.success.read(iprot)
3868 
        else:
3869 
          iprot.skip(ftype)
3870 
      elif fid == 1:
3871 
        if ftype == TType.STRUCT:
559 chandransh 3872 
          self.ucex = UserContextException()
3873 
          self.ucex.read(iprot)
94 ashish 3874 
        else:
3875 
          iprot.skip(ftype)
3876 
      else:
3877 
        iprot.skip(ftype)
3878 
      iprot.readFieldEnd()
3879 
    iprot.readStructEnd()
3880 
 
3881 
  def write(self, oprot):
3882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3884 
      return
559 chandransh 3885 
    oprot.writeStructBegin('createAnonymousUser_result')
94 ashish 3886 
    if self.success != None:
3887 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3888 
      self.success.write(oprot)
3889 
      oprot.writeFieldEnd()
559 chandransh 3890 
    if self.ucex != None:
3891 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
3892 
      self.ucex.write(oprot)
94 ashish 3893 
      oprot.writeFieldEnd()
3894 
    oprot.writeFieldStop()
3895 
    oprot.writeStructEnd()
3896 
 
3897 
  def __repr__(self):
3898 
    L = ['%s=%r' % (key, value)
3899 
      for key, value in self.__dict__.iteritems()]
3900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3901 
 
3902 
  def __eq__(self, other):
3903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3904 
 
3905 
  def __ne__(self, other):
3906 
    return not (self == other)
3907 
 
559 chandransh 3908 
class getUserById_args:
94 ashish 3909 
  """
3910 
  Attributes:
3911 
   - userId
3912 
  """
3913 
 
3914 
  thrift_spec = (
3915 
    None, # 0
3916 
    (1, TType.I64, 'userId', None, None, ), # 1
3917 
  )
3918 
 
559 chandransh 3919 
  def __init__(self, userId=None,):
94 ashish 3920 
    self.userId = userId
3921 
 
3922 
  def read(self, iprot):
3923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3925 
      return
3926 
    iprot.readStructBegin()
3927 
    while True:
3928 
      (fname, ftype, fid) = iprot.readFieldBegin()
3929 
      if ftype == TType.STOP:
3930 
        break
3931 
      if fid == 1:
3932 
        if ftype == TType.I64:
3933 
          self.userId = iprot.readI64();
3934 
        else:
3935 
          iprot.skip(ftype)
3936 
      else:
3937 
        iprot.skip(ftype)
3938 
      iprot.readFieldEnd()
3939 
    iprot.readStructEnd()
3940 
 
3941 
  def write(self, oprot):
3942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3944 
      return
559 chandransh 3945 
    oprot.writeStructBegin('getUserById_args')
94 ashish 3946 
    if self.userId != None:
3947 
      oprot.writeFieldBegin('userId', TType.I64, 1)
3948 
      oprot.writeI64(self.userId)
3949 
      oprot.writeFieldEnd()
3950 
    oprot.writeFieldStop()
3951 
    oprot.writeStructEnd()
3952 
 
3953 
  def __repr__(self):
3954 
    L = ['%s=%r' % (key, value)
3955 
      for key, value in self.__dict__.iteritems()]
3956 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3957 
 
3958 
  def __eq__(self, other):
3959 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3960 
 
3961 
  def __ne__(self, other):
3962 
    return not (self == other)
3963 
 
559 chandransh 3964 
class getUserById_result:
94 ashish 3965 
  """
3966 
  Attributes:
3967 
   - success
559 chandransh 3968 
   - ucex
94 ashish 3969 
  """
3970 
 
3971 
  thrift_spec = (
559 chandransh 3972 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
3973 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 3974 
  )
3975 
 
559 chandransh 3976 
  def __init__(self, success=None, ucex=None,):
94 ashish 3977 
    self.success = success
559 chandransh 3978 
    self.ucex = ucex
94 ashish 3979 
 
3980 
  def read(self, iprot):
3981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3983 
      return
3984 
    iprot.readStructBegin()
3985 
    while True:
3986 
      (fname, ftype, fid) = iprot.readFieldBegin()
3987 
      if ftype == TType.STOP:
3988 
        break
3989 
      if fid == 0:
3990 
        if ftype == TType.STRUCT:
559 chandransh 3991 
          self.success = User()
94 ashish 3992 
          self.success.read(iprot)
3993 
        else:
3994 
          iprot.skip(ftype)
3995 
      elif fid == 1:
3996 
        if ftype == TType.STRUCT:
559 chandransh 3997 
          self.ucex = UserContextException()
3998 
          self.ucex.read(iprot)
94 ashish 3999 
        else:
4000 
          iprot.skip(ftype)
4001 
      else:
4002 
        iprot.skip(ftype)
4003 
      iprot.readFieldEnd()
4004 
    iprot.readStructEnd()
4005 
 
4006 
  def write(self, oprot):
4007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4009 
      return
559 chandransh 4010 
    oprot.writeStructBegin('getUserById_result')
94 ashish 4011 
    if self.success != None:
4012 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4013 
      self.success.write(oprot)
4014 
      oprot.writeFieldEnd()
559 chandransh 4015 
    if self.ucex != None:
4016 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4017 
      self.ucex.write(oprot)
94 ashish 4018 
      oprot.writeFieldEnd()
4019 
    oprot.writeFieldStop()
4020 
    oprot.writeStructEnd()
4021 
 
4022 
  def __repr__(self):
4023 
    L = ['%s=%r' % (key, value)
4024 
      for key, value in self.__dict__.iteritems()]
4025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4026 
 
4027 
  def __eq__(self, other):
4028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4029 
 
4030 
  def __ne__(self, other):
4031 
    return not (self == other)
4032 
 
1491 vikas 4033 
class getUserByEmail_args:
4034 
  """
4035 
  Attributes:
4036 
   - email
4037 
  """
4038 
 
4039 
  thrift_spec = (
4040 
    None, # 0
4041 
    (1, TType.STRING, 'email', None, None, ), # 1
4042 
  )
4043 
 
4044 
  def __init__(self, email=None,):
4045 
    self.email = email
4046 
 
4047 
  def read(self, iprot):
4048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4050 
      return
4051 
    iprot.readStructBegin()
4052 
    while True:
4053 
      (fname, ftype, fid) = iprot.readFieldBegin()
4054 
      if ftype == TType.STOP:
4055 
        break
4056 
      if fid == 1:
4057 
        if ftype == TType.STRING:
4058 
          self.email = iprot.readString();
4059 
        else:
4060 
          iprot.skip(ftype)
4061 
      else:
4062 
        iprot.skip(ftype)
4063 
      iprot.readFieldEnd()
4064 
    iprot.readStructEnd()
4065 
 
4066 
  def write(self, oprot):
4067 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4068 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4069 
      return
4070 
    oprot.writeStructBegin('getUserByEmail_args')
4071 
    if self.email != None:
4072 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4073 
      oprot.writeString(self.email)
4074 
      oprot.writeFieldEnd()
4075 
    oprot.writeFieldStop()
4076 
    oprot.writeStructEnd()
4077 
 
4078 
  def __repr__(self):
4079 
    L = ['%s=%r' % (key, value)
4080 
      for key, value in self.__dict__.iteritems()]
4081 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4082 
 
4083 
  def __eq__(self, other):
4084 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4085 
 
4086 
  def __ne__(self, other):
4087 
    return not (self == other)
4088 
 
4089 
class getUserByEmail_result:
4090 
  """
4091 
  Attributes:
4092 
   - success
4093 
   - ucex
4094 
  """
4095 
 
4096 
  thrift_spec = (
4097 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4098 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4099 
  )
4100 
 
4101 
  def __init__(self, success=None, ucex=None,):
4102 
    self.success = success
4103 
    self.ucex = ucex
4104 
 
4105 
  def read(self, iprot):
4106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4108 
      return
4109 
    iprot.readStructBegin()
4110 
    while True:
4111 
      (fname, ftype, fid) = iprot.readFieldBegin()
4112 
      if ftype == TType.STOP:
4113 
        break
4114 
      if fid == 0:
4115 
        if ftype == TType.STRUCT:
4116 
          self.success = User()
4117 
          self.success.read(iprot)
4118 
        else:
4119 
          iprot.skip(ftype)
4120 
      elif fid == 1:
4121 
        if ftype == TType.STRUCT:
4122 
          self.ucex = UserContextException()
4123 
          self.ucex.read(iprot)
4124 
        else:
4125 
          iprot.skip(ftype)
4126 
      else:
4127 
        iprot.skip(ftype)
4128 
      iprot.readFieldEnd()
4129 
    iprot.readStructEnd()
4130 
 
4131 
  def write(self, oprot):
4132 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4133 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4134 
      return
4135 
    oprot.writeStructBegin('getUserByEmail_result')
4136 
    if self.success != None:
4137 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4138 
      self.success.write(oprot)
4139 
      oprot.writeFieldEnd()
4140 
    if self.ucex != None:
4141 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4142 
      self.ucex.write(oprot)
4143 
      oprot.writeFieldEnd()
4144 
    oprot.writeFieldStop()
4145 
    oprot.writeStructEnd()
4146 
 
4147 
  def __repr__(self):
4148 
    L = ['%s=%r' % (key, value)
4149 
      for key, value in self.__dict__.iteritems()]
4150 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4151 
 
4152 
  def __eq__(self, other):
4153 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4154 
 
4155 
  def __ne__(self, other):
4156 
    return not (self == other)
4157 
 
559 chandransh 4158 
class createUser_args:
94 ashish 4159 
  """
4160 
  Attributes:
559 chandransh 4161 
   - user
94 ashish 4162 
  """
4163 
 
4164 
  thrift_spec = (
4165 
    None, # 0
559 chandransh 4166 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4167 
  )
4168 
 
559 chandransh 4169 
  def __init__(self, user=None,):
4170 
    self.user = user
94 ashish 4171 
 
4172 
  def read(self, iprot):
4173 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4174 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4175 
      return
4176 
    iprot.readStructBegin()
4177 
    while True:
4178 
      (fname, ftype, fid) = iprot.readFieldBegin()
4179 
      if ftype == TType.STOP:
4180 
        break
4181 
      if fid == 1:
559 chandransh 4182 
        if ftype == TType.STRUCT:
4183 
          self.user = User()
4184 
          self.user.read(iprot)
94 ashish 4185 
        else:
4186 
          iprot.skip(ftype)
4187 
      else:
4188 
        iprot.skip(ftype)
4189 
      iprot.readFieldEnd()
4190 
    iprot.readStructEnd()
4191 
 
4192 
  def write(self, oprot):
4193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4195 
      return
559 chandransh 4196 
    oprot.writeStructBegin('createUser_args')
4197 
    if self.user != None:
4198 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4199 
      self.user.write(oprot)
94 ashish 4200 
      oprot.writeFieldEnd()
4201 
    oprot.writeFieldStop()
4202 
    oprot.writeStructEnd()
4203 
 
4204 
  def __repr__(self):
4205 
    L = ['%s=%r' % (key, value)
4206 
      for key, value in self.__dict__.iteritems()]
4207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4208 
 
4209 
  def __eq__(self, other):
4210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4211 
 
4212 
  def __ne__(self, other):
4213 
    return not (self == other)
4214 
 
559 chandransh 4215 
class createUser_result:
94 ashish 4216 
  """
4217 
  Attributes:
4218 
   - success
559 chandransh 4219 
   - ucex
94 ashish 4220 
  """
4221 
 
4222 
  thrift_spec = (
559 chandransh 4223 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4224 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4225 
  )
4226 
 
559 chandransh 4227 
  def __init__(self, success=None, ucex=None,):
94 ashish 4228 
    self.success = success
559 chandransh 4229 
    self.ucex = ucex
94 ashish 4230 
 
4231 
  def read(self, iprot):
4232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4234 
      return
4235 
    iprot.readStructBegin()
4236 
    while True:
4237 
      (fname, ftype, fid) = iprot.readFieldBegin()
4238 
      if ftype == TType.STOP:
4239 
        break
4240 
      if fid == 0:
4241 
        if ftype == TType.STRUCT:
559 chandransh 4242 
          self.success = User()
94 ashish 4243 
          self.success.read(iprot)
4244 
        else:
4245 
          iprot.skip(ftype)
4246 
      elif fid == 1:
4247 
        if ftype == TType.STRUCT:
559 chandransh 4248 
          self.ucex = UserContextException()
4249 
          self.ucex.read(iprot)
94 ashish 4250 
        else:
4251 
          iprot.skip(ftype)
4252 
      else:
4253 
        iprot.skip(ftype)
4254 
      iprot.readFieldEnd()
4255 
    iprot.readStructEnd()
4256 
 
4257 
  def write(self, oprot):
4258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4260 
      return
559 chandransh 4261 
    oprot.writeStructBegin('createUser_result')
94 ashish 4262 
    if self.success != None:
4263 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4264 
      self.success.write(oprot)
4265 
      oprot.writeFieldEnd()
559 chandransh 4266 
    if self.ucex != None:
4267 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4268 
      self.ucex.write(oprot)
94 ashish 4269 
      oprot.writeFieldEnd()
4270 
    oprot.writeFieldStop()
4271 
    oprot.writeStructEnd()
4272 
 
4273 
  def __repr__(self):
4274 
    L = ['%s=%r' % (key, value)
4275 
      for key, value in self.__dict__.iteritems()]
4276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4277 
 
4278 
  def __eq__(self, other):
4279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4280 
 
4281 
  def __ne__(self, other):
4282 
    return not (self == other)
4283 
 
559 chandransh 4284 
class updateUser_args:
94 ashish 4285 
  """
4286 
  Attributes:
559 chandransh 4287 
   - user
94 ashish 4288 
  """
4289 
 
4290 
  thrift_spec = (
4291 
    None, # 0
559 chandransh 4292 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4293 
  )
4294 
 
559 chandransh 4295 
  def __init__(self, user=None,):
4296 
    self.user = user
94 ashish 4297 
 
4298 
  def read(self, iprot):
4299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4301 
      return
4302 
    iprot.readStructBegin()
4303 
    while True:
4304 
      (fname, ftype, fid) = iprot.readFieldBegin()
4305 
      if ftype == TType.STOP:
4306 
        break
4307 
      if fid == 1:
559 chandransh 4308 
        if ftype == TType.STRUCT:
4309 
          self.user = User()
4310 
          self.user.read(iprot)
94 ashish 4311 
        else:
4312 
          iprot.skip(ftype)
4313 
      else:
4314 
        iprot.skip(ftype)
4315 
      iprot.readFieldEnd()
4316 
    iprot.readStructEnd()
4317 
 
4318 
  def write(self, oprot):
4319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4321 
      return
559 chandransh 4322 
    oprot.writeStructBegin('updateUser_args')
4323 
    if self.user != None:
4324 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4325 
      self.user.write(oprot)
94 ashish 4326 
      oprot.writeFieldEnd()
4327 
    oprot.writeFieldStop()
4328 
    oprot.writeStructEnd()
4329 
 
4330 
  def __repr__(self):
4331 
    L = ['%s=%r' % (key, value)
4332 
      for key, value in self.__dict__.iteritems()]
4333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4334 
 
4335 
  def __eq__(self, other):
4336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4337 
 
4338 
  def __ne__(self, other):
4339 
    return not (self == other)
4340 
 
559 chandransh 4341 
class updateUser_result:
94 ashish 4342 
  """
4343 
  Attributes:
4344 
   - success
559 chandransh 4345 
   - ucex
94 ashish 4346 
  """
4347 
 
4348 
  thrift_spec = (
559 chandransh 4349 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4350 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4351 
  )
4352 
 
559 chandransh 4353 
  def __init__(self, success=None, ucex=None,):
94 ashish 4354 
    self.success = success
559 chandransh 4355 
    self.ucex = ucex
94 ashish 4356 
 
4357 
  def read(self, iprot):
4358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4360 
      return
4361 
    iprot.readStructBegin()
4362 
    while True:
4363 
      (fname, ftype, fid) = iprot.readFieldBegin()
4364 
      if ftype == TType.STOP:
4365 
        break
4366 
      if fid == 0:
4367 
        if ftype == TType.STRUCT:
559 chandransh 4368 
          self.success = User()
94 ashish 4369 
          self.success.read(iprot)
4370 
        else:
4371 
          iprot.skip(ftype)
4372 
      elif fid == 1:
4373 
        if ftype == TType.STRUCT:
559 chandransh 4374 
          self.ucex = UserContextException()
4375 
          self.ucex.read(iprot)
94 ashish 4376 
        else:
4377 
          iprot.skip(ftype)
4378 
      else:
4379 
        iprot.skip(ftype)
4380 
      iprot.readFieldEnd()
4381 
    iprot.readStructEnd()
4382 
 
4383 
  def write(self, oprot):
4384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4386 
      return
559 chandransh 4387 
    oprot.writeStructBegin('updateUser_result')
94 ashish 4388 
    if self.success != None:
4389 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4390 
      self.success.write(oprot)
4391 
      oprot.writeFieldEnd()
559 chandransh 4392 
    if self.ucex != None:
4393 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4394 
      self.ucex.write(oprot)
94 ashish 4395 
      oprot.writeFieldEnd()
4396 
    oprot.writeFieldStop()
4397 
    oprot.writeStructEnd()
4398 
 
4399 
  def __repr__(self):
4400 
    L = ['%s=%r' % (key, value)
4401 
      for key, value in self.__dict__.iteritems()]
4402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4403 
 
4404 
  def __eq__(self, other):
4405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4406 
 
4407 
  def __ne__(self, other):
4408 
    return not (self == other)
4409 
 
559 chandransh 4410 
class deleteUser_args:
94 ashish 4411 
  """
4412 
  Attributes:
4413 
   - userId
4414 
  """
4415 
 
4416 
  thrift_spec = (
4417 
    None, # 0
4418 
    (1, TType.I64, 'userId', None, None, ), # 1
4419 
  )
4420 
 
559 chandransh 4421 
  def __init__(self, userId=None,):
94 ashish 4422 
    self.userId = userId
4423 
 
4424 
  def read(self, iprot):
4425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4427 
      return
4428 
    iprot.readStructBegin()
4429 
    while True:
4430 
      (fname, ftype, fid) = iprot.readFieldBegin()
4431 
      if ftype == TType.STOP:
4432 
        break
4433 
      if fid == 1:
4434 
        if ftype == TType.I64:
4435 
          self.userId = iprot.readI64();
4436 
        else:
4437 
          iprot.skip(ftype)
4438 
      else:
4439 
        iprot.skip(ftype)
4440 
      iprot.readFieldEnd()
4441 
    iprot.readStructEnd()
4442 
 
4443 
  def write(self, oprot):
4444 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4445 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4446 
      return
559 chandransh 4447 
    oprot.writeStructBegin('deleteUser_args')
94 ashish 4448 
    if self.userId != None:
4449 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4450 
      oprot.writeI64(self.userId)
4451 
      oprot.writeFieldEnd()
4452 
    oprot.writeFieldStop()
4453 
    oprot.writeStructEnd()
4454 
 
4455 
  def __repr__(self):
4456 
    L = ['%s=%r' % (key, value)
4457 
      for key, value in self.__dict__.iteritems()]
4458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4459 
 
4460 
  def __eq__(self, other):
4461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4462 
 
4463 
  def __ne__(self, other):
4464 
    return not (self == other)
4465 
 
559 chandransh 4466 
class deleteUser_result:
94 ashish 4467 
  """
4468 
  Attributes:
4469 
   - success
559 chandransh 4470 
   - ucex
94 ashish 4471 
  """
4472 
 
4473 
  thrift_spec = (
559 chandransh 4474 
    (0, TType.BOOL, 'success', None, None, ), # 0
4475 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4476 
  )
4477 
 
559 chandransh 4478 
  def __init__(self, success=None, ucex=None,):
94 ashish 4479 
    self.success = success
559 chandransh 4480 
    self.ucex = ucex
94 ashish 4481 
 
4482 
  def read(self, iprot):
4483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4485 
      return
4486 
    iprot.readStructBegin()
4487 
    while True:
4488 
      (fname, ftype, fid) = iprot.readFieldBegin()
4489 
      if ftype == TType.STOP:
4490 
        break
4491 
      if fid == 0:
559 chandransh 4492 
        if ftype == TType.BOOL:
4493 
          self.success = iprot.readBool();
94 ashish 4494 
        else:
4495 
          iprot.skip(ftype)
4496 
      elif fid == 1:
4497 
        if ftype == TType.STRUCT:
559 chandransh 4498 
          self.ucex = UserContextException()
4499 
          self.ucex.read(iprot)
94 ashish 4500 
        else:
4501 
          iprot.skip(ftype)
4502 
      else:
4503 
        iprot.skip(ftype)
4504 
      iprot.readFieldEnd()
4505 
    iprot.readStructEnd()
4506 
 
4507 
  def write(self, oprot):
4508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4510 
      return
559 chandransh 4511 
    oprot.writeStructBegin('deleteUser_result')
94 ashish 4512 
    if self.success != None:
559 chandransh 4513 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4514 
      oprot.writeBool(self.success)
94 ashish 4515 
      oprot.writeFieldEnd()
559 chandransh 4516 
    if self.ucex != None:
4517 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4518 
      self.ucex.write(oprot)
94 ashish 4519 
      oprot.writeFieldEnd()
4520 
    oprot.writeFieldStop()
4521 
    oprot.writeStructEnd()
4522 
 
4523 
  def __repr__(self):
4524 
    L = ['%s=%r' % (key, value)
4525 
      for key, value in self.__dict__.iteritems()]
4526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4527 
 
4528 
  def __eq__(self, other):
4529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4530 
 
4531 
  def __ne__(self, other):
4532 
    return not (self == other)
4533 
 
559 chandransh 4534 
class getUserState_args:
94 ashish 4535 
  """
4536 
  Attributes:
4537 
   - userId
4538 
  """
4539 
 
4540 
  thrift_spec = (
4541 
    None, # 0
4542 
    (1, TType.I64, 'userId', None, None, ), # 1
4543 
  )
4544 
 
559 chandransh 4545 
  def __init__(self, userId=None,):
94 ashish 4546 
    self.userId = userId
4547 
 
4548 
  def read(self, iprot):
4549 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4550 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4551 
      return
4552 
    iprot.readStructBegin()
4553 
    while True:
4554 
      (fname, ftype, fid) = iprot.readFieldBegin()
4555 
      if ftype == TType.STOP:
4556 
        break
4557 
      if fid == 1:
4558 
        if ftype == TType.I64:
4559 
          self.userId = iprot.readI64();
4560 
        else:
4561 
          iprot.skip(ftype)
4562 
      else:
4563 
        iprot.skip(ftype)
4564 
      iprot.readFieldEnd()
4565 
    iprot.readStructEnd()
4566 
 
4567 
  def write(self, oprot):
4568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4570 
      return
559 chandransh 4571 
    oprot.writeStructBegin('getUserState_args')
94 ashish 4572 
    if self.userId != None:
4573 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4574 
      oprot.writeI64(self.userId)
4575 
      oprot.writeFieldEnd()
4576 
    oprot.writeFieldStop()
4577 
    oprot.writeStructEnd()
4578 
 
4579 
  def __repr__(self):
4580 
    L = ['%s=%r' % (key, value)
4581 
      for key, value in self.__dict__.iteritems()]
4582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4583 
 
4584 
  def __eq__(self, other):
4585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4586 
 
4587 
  def __ne__(self, other):
4588 
    return not (self == other)
4589 
 
559 chandransh 4590 
class getUserState_result:
94 ashish 4591 
  """
4592 
  Attributes:
4593 
   - success
559 chandransh 4594 
   - ucex
94 ashish 4595 
  """
4596 
 
4597 
  thrift_spec = (
559 chandransh 4598 
    (0, TType.STRUCT, 'success', (UserState, UserState.thrift_spec), None, ), # 0
4599 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4600 
  )
4601 
 
559 chandransh 4602 
  def __init__(self, success=None, ucex=None,):
94 ashish 4603 
    self.success = success
559 chandransh 4604 
    self.ucex = ucex
94 ashish 4605 
 
4606 
  def read(self, iprot):
4607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4609 
      return
4610 
    iprot.readStructBegin()
4611 
    while True:
4612 
      (fname, ftype, fid) = iprot.readFieldBegin()
4613 
      if ftype == TType.STOP:
4614 
        break
4615 
      if fid == 0:
4616 
        if ftype == TType.STRUCT:
559 chandransh 4617 
          self.success = UserState()
94 ashish 4618 
          self.success.read(iprot)
4619 
        else:
4620 
          iprot.skip(ftype)
4621 
      elif fid == 1:
4622 
        if ftype == TType.STRUCT:
559 chandransh 4623 
          self.ucex = UserContextException()
4624 
          self.ucex.read(iprot)
94 ashish 4625 
        else:
4626 
          iprot.skip(ftype)
4627 
      else:
4628 
        iprot.skip(ftype)
4629 
      iprot.readFieldEnd()
4630 
    iprot.readStructEnd()
4631 
 
4632 
  def write(self, oprot):
4633 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4634 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4635 
      return
559 chandransh 4636 
    oprot.writeStructBegin('getUserState_result')
94 ashish 4637 
    if self.success != None:
4638 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4639 
      self.success.write(oprot)
4640 
      oprot.writeFieldEnd()
559 chandransh 4641 
    if self.ucex != None:
4642 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4643 
      self.ucex.write(oprot)
94 ashish 4644 
      oprot.writeFieldEnd()
4645 
    oprot.writeFieldStop()
4646 
    oprot.writeStructEnd()
4647 
 
4648 
  def __repr__(self):
4649 
    L = ['%s=%r' % (key, value)
4650 
      for key, value in self.__dict__.iteritems()]
4651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4652 
 
4653 
  def __eq__(self, other):
4654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4655 
 
4656 
  def __ne__(self, other):
4657 
    return not (self == other)
4658 
 
559 chandransh 4659 
class authenticateUser_args:
94 ashish 4660 
  """
4661 
  Attributes:
4662 
   - email
4663 
   - password
4664 
  """
4665 
 
4666 
  thrift_spec = (
4667 
    None, # 0
4668 
    (1, TType.STRING, 'email', None, None, ), # 1
4669 
    (2, TType.STRING, 'password', None, None, ), # 2
4670 
  )
4671 
 
4672 
  def __init__(self, email=None, password=None,):
4673 
    self.email = email
4674 
    self.password = password
4675 
 
4676 
  def read(self, iprot):
4677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4679 
      return
4680 
    iprot.readStructBegin()
4681 
    while True:
4682 
      (fname, ftype, fid) = iprot.readFieldBegin()
4683 
      if ftype == TType.STOP:
4684 
        break
4685 
      if fid == 1:
4686 
        if ftype == TType.STRING:
4687 
          self.email = iprot.readString();
4688 
        else:
4689 
          iprot.skip(ftype)
4690 
      elif fid == 2:
4691 
        if ftype == TType.STRING:
4692 
          self.password = iprot.readString();
4693 
        else:
4694 
          iprot.skip(ftype)
4695 
      else:
4696 
        iprot.skip(ftype)
4697 
      iprot.readFieldEnd()
4698 
    iprot.readStructEnd()
4699 
 
4700 
  def write(self, oprot):
4701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4703 
      return
559 chandransh 4704 
    oprot.writeStructBegin('authenticateUser_args')
94 ashish 4705 
    if self.email != None:
4706 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4707 
      oprot.writeString(self.email)
4708 
      oprot.writeFieldEnd()
4709 
    if self.password != None:
4710 
      oprot.writeFieldBegin('password', TType.STRING, 2)
4711 
      oprot.writeString(self.password)
4712 
      oprot.writeFieldEnd()
4713 
    oprot.writeFieldStop()
4714 
    oprot.writeStructEnd()
4715 
 
4716 
  def __repr__(self):
4717 
    L = ['%s=%r' % (key, value)
4718 
      for key, value in self.__dict__.iteritems()]
4719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4720 
 
4721 
  def __eq__(self, other):
4722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4723 
 
4724 
  def __ne__(self, other):
4725 
    return not (self == other)
4726 
 
559 chandransh 4727 
class authenticateUser_result:
94 ashish 4728 
  """
4729 
  Attributes:
4730 
   - success
559 chandransh 4731 
   - auex
94 ashish 4732 
  """
4733 
 
4734 
  thrift_spec = (
559 chandransh 4735 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4736 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 4737 
  )
4738 
 
559 chandransh 4739 
  def __init__(self, success=None, auex=None,):
94 ashish 4740 
    self.success = success
559 chandransh 4741 
    self.auex = auex
94 ashish 4742 
 
4743 
  def read(self, iprot):
4744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4746 
      return
4747 
    iprot.readStructBegin()
4748 
    while True:
4749 
      (fname, ftype, fid) = iprot.readFieldBegin()
4750 
      if ftype == TType.STOP:
4751 
        break
4752 
      if fid == 0:
4753 
        if ftype == TType.STRUCT:
559 chandransh 4754 
          self.success = User()
94 ashish 4755 
          self.success.read(iprot)
4756 
        else:
4757 
          iprot.skip(ftype)
4758 
      elif fid == 1:
4759 
        if ftype == TType.STRUCT:
559 chandransh 4760 
          self.auex = AuthenticationException()
4761 
          self.auex.read(iprot)
94 ashish 4762 
        else:
4763 
          iprot.skip(ftype)
4764 
      else:
4765 
        iprot.skip(ftype)
4766 
      iprot.readFieldEnd()
4767 
    iprot.readStructEnd()
4768 
 
4769 
  def write(self, oprot):
4770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4772 
      return
559 chandransh 4773 
    oprot.writeStructBegin('authenticateUser_result')
94 ashish 4774 
    if self.success != None:
4775 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4776 
      self.success.write(oprot)
4777 
      oprot.writeFieldEnd()
559 chandransh 4778 
    if self.auex != None:
4779 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
4780 
      self.auex.write(oprot)
94 ashish 4781 
      oprot.writeFieldEnd()
4782 
    oprot.writeFieldStop()
4783 
    oprot.writeStructEnd()
4784 
 
4785 
  def __repr__(self):
4786 
    L = ['%s=%r' % (key, value)
4787 
      for key, value in self.__dict__.iteritems()]
4788 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4789 
 
4790 
  def __eq__(self, other):
4791 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4792 
 
4793 
  def __ne__(self, other):
4794 
    return not (self == other)
4795 
 
559 chandransh 4796 
class userExists_args:
122 ashish 4797 
  """
4798 
  Attributes:
559 chandransh 4799 
   - email
122 ashish 4800 
  """
4801 
 
4802 
  thrift_spec = (
4803 
    None, # 0
559 chandransh 4804 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 4805 
  )
4806 
 
559 chandransh 4807 
  def __init__(self, email=None,):
4808 
    self.email = email
122 ashish 4809 
 
4810 
  def read(self, iprot):
4811 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4812 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4813 
      return
4814 
    iprot.readStructBegin()
4815 
    while True:
4816 
      (fname, ftype, fid) = iprot.readFieldBegin()
4817 
      if ftype == TType.STOP:
4818 
        break
4819 
      if fid == 1:
4820 
        if ftype == TType.STRING:
559 chandransh 4821 
          self.email = iprot.readString();
122 ashish 4822 
        else:
4823 
          iprot.skip(ftype)
559 chandransh 4824 
      else:
4825 
        iprot.skip(ftype)
4826 
      iprot.readFieldEnd()
4827 
    iprot.readStructEnd()
4828 
 
4829 
  def write(self, oprot):
4830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4832 
      return
4833 
    oprot.writeStructBegin('userExists_args')
4834 
    if self.email != None:
4835 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4836 
      oprot.writeString(self.email)
4837 
      oprot.writeFieldEnd()
4838 
    oprot.writeFieldStop()
4839 
    oprot.writeStructEnd()
4840 
 
4841 
  def __repr__(self):
4842 
    L = ['%s=%r' % (key, value)
4843 
      for key, value in self.__dict__.iteritems()]
4844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4845 
 
4846 
  def __eq__(self, other):
4847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4848 
 
4849 
  def __ne__(self, other):
4850 
    return not (self == other)
4851 
 
4852 
class userExists_result:
4853 
  """
4854 
  Attributes:
4855 
   - success
4856 
   - ucx
4857 
  """
4858 
 
4859 
  thrift_spec = (
4860 
    (0, TType.BOOL, 'success', None, None, ), # 0
4861 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4862 
  )
4863 
 
4864 
  def __init__(self, success=None, ucx=None,):
4865 
    self.success = success
4866 
    self.ucx = ucx
4867 
 
4868 
  def read(self, iprot):
4869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4871 
      return
4872 
    iprot.readStructBegin()
4873 
    while True:
4874 
      (fname, ftype, fid) = iprot.readFieldBegin()
4875 
      if ftype == TType.STOP:
4876 
        break
4877 
      if fid == 0:
4878 
        if ftype == TType.BOOL:
4879 
          self.success = iprot.readBool();
4880 
        else:
4881 
          iprot.skip(ftype)
4882 
      elif fid == 1:
4883 
        if ftype == TType.STRUCT:
4884 
          self.ucx = UserContextException()
4885 
          self.ucx.read(iprot)
4886 
        else:
4887 
          iprot.skip(ftype)
4888 
      else:
4889 
        iprot.skip(ftype)
4890 
      iprot.readFieldEnd()
4891 
    iprot.readStructEnd()
4892 
 
4893 
  def write(self, oprot):
4894 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4895 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4896 
      return
4897 
    oprot.writeStructBegin('userExists_result')
4898 
    if self.success != None:
4899 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4900 
      oprot.writeBool(self.success)
4901 
      oprot.writeFieldEnd()
4902 
    if self.ucx != None:
4903 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4904 
      self.ucx.write(oprot)
4905 
      oprot.writeFieldEnd()
4906 
    oprot.writeFieldStop()
4907 
    oprot.writeStructEnd()
4908 
 
4909 
  def __repr__(self):
4910 
    L = ['%s=%r' % (key, value)
4911 
      for key, value in self.__dict__.iteritems()]
4912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4913 
 
4914 
  def __eq__(self, other):
4915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4916 
 
4917 
  def __ne__(self, other):
4918 
    return not (self == other)
4919 
 
4920 
class addAddressForUser_args:
4921 
  """
4922 
  Attributes:
4923 
   - userId
4924 
   - address
4925 
   - setDefault
4926 
  """
4927 
 
4928 
  thrift_spec = (
4929 
    None, # 0
4930 
    (1, TType.I64, 'userId', None, None, ), # 1
4931 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 4932 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 4933 
  )
4934 
 
567 rajveer 4935 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 4936 
    self.userId = userId
4937 
    self.address = address
4938 
    self.setDefault = setDefault
4939 
 
4940 
  def read(self, iprot):
4941 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4942 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4943 
      return
4944 
    iprot.readStructBegin()
4945 
    while True:
4946 
      (fname, ftype, fid) = iprot.readFieldBegin()
4947 
      if ftype == TType.STOP:
4948 
        break
4949 
      if fid == 1:
4950 
        if ftype == TType.I64:
4951 
          self.userId = iprot.readI64();
4952 
        else:
4953 
          iprot.skip(ftype)
122 ashish 4954 
      elif fid == 2:
559 chandransh 4955 
        if ftype == TType.STRUCT:
4956 
          self.address = Address()
4957 
          self.address.read(iprot)
122 ashish 4958 
        else:
4959 
          iprot.skip(ftype)
4960 
      elif fid == 3:
4961 
        if ftype == TType.BOOL:
559 chandransh 4962 
          self.setDefault = iprot.readBool();
122 ashish 4963 
        else:
4964 
          iprot.skip(ftype)
4965 
      else:
4966 
        iprot.skip(ftype)
4967 
      iprot.readFieldEnd()
4968 
    iprot.readStructEnd()
4969 
 
4970 
  def write(self, oprot):
4971 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4972 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4973 
      return
559 chandransh 4974 
    oprot.writeStructBegin('addAddressForUser_args')
4975 
    if self.userId != None:
4976 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4977 
      oprot.writeI64(self.userId)
122 ashish 4978 
      oprot.writeFieldEnd()
559 chandransh 4979 
    if self.address != None:
4980 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
4981 
      self.address.write(oprot)
122 ashish 4982 
      oprot.writeFieldEnd()
559 chandransh 4983 
    if self.setDefault != None:
567 rajveer 4984 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 4985 
      oprot.writeBool(self.setDefault)
4986 
      oprot.writeFieldEnd()
122 ashish 4987 
    oprot.writeFieldStop()
4988 
    oprot.writeStructEnd()
4989 
 
4990 
  def __repr__(self):
4991 
    L = ['%s=%r' % (key, value)
4992 
      for key, value in self.__dict__.iteritems()]
4993 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4994 
 
4995 
  def __eq__(self, other):
4996 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4997 
 
4998 
  def __ne__(self, other):
4999 
    return not (self == other)
5000 
 
559 chandransh 5001 
class addAddressForUser_result:
122 ashish 5002 
  """
5003 
  Attributes:
5004 
   - success
559 chandransh 5005 
   - ucx
122 ashish 5006 
  """
5007 
 
5008 
  thrift_spec = (
567 rajveer 5009 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 5010 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 5011 
  )
5012 
 
559 chandransh 5013 
  def __init__(self, success=None, ucx=None,):
122 ashish 5014 
    self.success = success
559 chandransh 5015 
    self.ucx = ucx
122 ashish 5016 
 
5017 
  def read(self, iprot):
5018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5020 
      return
5021 
    iprot.readStructBegin()
5022 
    while True:
5023 
      (fname, ftype, fid) = iprot.readFieldBegin()
5024 
      if ftype == TType.STOP:
5025 
        break
5026 
      if fid == 0:
567 rajveer 5027 
        if ftype == TType.I64:
5028 
          self.success = iprot.readI64();
122 ashish 5029 
        else:
5030 
          iprot.skip(ftype)
5031 
      elif fid == 1:
5032 
        if ftype == TType.STRUCT:
559 chandransh 5033 
          self.ucx = UserContextException()
5034 
          self.ucx.read(iprot)
122 ashish 5035 
        else:
5036 
          iprot.skip(ftype)
5037 
      else:
5038 
        iprot.skip(ftype)
5039 
      iprot.readFieldEnd()
5040 
    iprot.readStructEnd()
5041 
 
5042 
  def write(self, oprot):
5043 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5044 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5045 
      return
559 chandransh 5046 
    oprot.writeStructBegin('addAddressForUser_result')
122 ashish 5047 
    if self.success != None:
567 rajveer 5048 
      oprot.writeFieldBegin('success', TType.I64, 0)
5049 
      oprot.writeI64(self.success)
122 ashish 5050 
      oprot.writeFieldEnd()
559 chandransh 5051 
    if self.ucx != None:
5052 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5053 
      self.ucx.write(oprot)
122 ashish 5054 
      oprot.writeFieldEnd()
5055 
    oprot.writeFieldStop()
5056 
    oprot.writeStructEnd()
5057 
 
5058 
  def __repr__(self):
5059 
    L = ['%s=%r' % (key, value)
5060 
      for key, value in self.__dict__.iteritems()]
5061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5062 
 
5063 
  def __eq__(self, other):
5064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5065 
 
5066 
  def __ne__(self, other):
5067 
    return not (self == other)
5068 
 
559 chandransh 5069 
class removeAddressForUser_args:
94 ashish 5070 
  """
5071 
  Attributes:
559 chandransh 5072 
   - userid
5073 
   - addressId
94 ashish 5074 
  """
5075 
 
5076 
  thrift_spec = (
5077 
    None, # 0
559 chandransh 5078 
    (1, TType.I64, 'userid', None, None, ), # 1
5079 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 5080 
  )
5081 
 
559 chandransh 5082 
  def __init__(self, userid=None, addressId=None,):
5083 
    self.userid = userid
5084 
    self.addressId = addressId
94 ashish 5085 
 
5086 
  def read(self, iprot):
5087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5089 
      return
5090 
    iprot.readStructBegin()
5091 
    while True:
5092 
      (fname, ftype, fid) = iprot.readFieldBegin()
5093 
      if ftype == TType.STOP:
5094 
        break
5095 
      if fid == 1:
559 chandransh 5096 
        if ftype == TType.I64:
5097 
          self.userid = iprot.readI64();
94 ashish 5098 
        else:
5099 
          iprot.skip(ftype)
559 chandransh 5100 
      elif fid == 2:
5101 
        if ftype == TType.I64:
5102 
          self.addressId = iprot.readI64();
5103 
        else:
5104 
          iprot.skip(ftype)
94 ashish 5105 
      else:
5106 
        iprot.skip(ftype)
5107 
      iprot.readFieldEnd()
5108 
    iprot.readStructEnd()
5109 
 
5110 
  def write(self, oprot):
5111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5113 
      return
559 chandransh 5114 
    oprot.writeStructBegin('removeAddressForUser_args')
5115 
    if self.userid != None:
5116 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5117 
      oprot.writeI64(self.userid)
94 ashish 5118 
      oprot.writeFieldEnd()
559 chandransh 5119 
    if self.addressId != None:
5120 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5121 
      oprot.writeI64(self.addressId)
5122 
      oprot.writeFieldEnd()
94 ashish 5123 
    oprot.writeFieldStop()
5124 
    oprot.writeStructEnd()
5125 
 
5126 
  def __repr__(self):
5127 
    L = ['%s=%r' % (key, value)
5128 
      for key, value in self.__dict__.iteritems()]
5129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5130 
 
5131 
  def __eq__(self, other):
5132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5133 
 
5134 
  def __ne__(self, other):
5135 
    return not (self == other)
5136 
 
559 chandransh 5137 
class removeAddressForUser_result:
94 ashish 5138 
  """
5139 
  Attributes:
5140 
   - success
5141 
   - ucx
5142 
  """
5143 
 
5144 
  thrift_spec = (
5145 
    (0, TType.BOOL, 'success', None, None, ), # 0
5146 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5147 
  )
5148 
 
5149 
  def __init__(self, success=None, ucx=None,):
5150 
    self.success = success
5151 
    self.ucx = ucx
5152 
 
5153 
  def read(self, iprot):
5154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5156 
      return
5157 
    iprot.readStructBegin()
5158 
    while True:
5159 
      (fname, ftype, fid) = iprot.readFieldBegin()
5160 
      if ftype == TType.STOP:
5161 
        break
5162 
      if fid == 0:
5163 
        if ftype == TType.BOOL:
5164 
          self.success = iprot.readBool();
5165 
        else:
5166 
          iprot.skip(ftype)
5167 
      elif fid == 1:
5168 
        if ftype == TType.STRUCT:
5169 
          self.ucx = UserContextException()
5170 
          self.ucx.read(iprot)
5171 
        else:
5172 
          iprot.skip(ftype)
5173 
      else:
5174 
        iprot.skip(ftype)
5175 
      iprot.readFieldEnd()
5176 
    iprot.readStructEnd()
5177 
 
5178 
  def write(self, oprot):
5179 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5180 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5181 
      return
559 chandransh 5182 
    oprot.writeStructBegin('removeAddressForUser_result')
94 ashish 5183 
    if self.success != None:
5184 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5185 
      oprot.writeBool(self.success)
5186 
      oprot.writeFieldEnd()
5187 
    if self.ucx != None:
5188 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5189 
      self.ucx.write(oprot)
5190 
      oprot.writeFieldEnd()
5191 
    oprot.writeFieldStop()
5192 
    oprot.writeStructEnd()
5193 
 
5194 
  def __repr__(self):
5195 
    L = ['%s=%r' % (key, value)
5196 
      for key, value in self.__dict__.iteritems()]
5197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5198 
 
5199 
  def __eq__(self, other):
5200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5201 
 
5202 
  def __ne__(self, other):
5203 
    return not (self == other)
5204 
 
559 chandransh 5205 
class setUserAsLoggedIn_args:
94 ashish 5206 
  """
5207 
  Attributes:
559 chandransh 5208 
   - userId
94 ashish 5209 
   - timestamp
5210 
  """
5211 
 
5212 
  thrift_spec = (
5213 
    None, # 0
559 chandransh 5214 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 5215 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5216 
  )
5217 
 
559 chandransh 5218 
  def __init__(self, userId=None, timestamp=None,):
5219 
    self.userId = userId
94 ashish 5220 
    self.timestamp = timestamp
5221 
 
5222 
  def read(self, iprot):
5223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5225 
      return
5226 
    iprot.readStructBegin()
5227 
    while True:
5228 
      (fname, ftype, fid) = iprot.readFieldBegin()
5229 
      if ftype == TType.STOP:
5230 
        break
5231 
      if fid == 1:
559 chandransh 5232 
        if ftype == TType.I64:
5233 
          self.userId = iprot.readI64();
94 ashish 5234 
        else:
5235 
          iprot.skip(ftype)
5236 
      elif fid == 2:
5237 
        if ftype == TType.I64:
5238 
          self.timestamp = iprot.readI64();
5239 
        else:
5240 
          iprot.skip(ftype)
5241 
      else:
5242 
        iprot.skip(ftype)
5243 
      iprot.readFieldEnd()
5244 
    iprot.readStructEnd()
5245 
 
5246 
  def write(self, oprot):
5247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5249 
      return
559 chandransh 5250 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
5251 
    if self.userId != None:
5252 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5253 
      oprot.writeI64(self.userId)
94 ashish 5254 
      oprot.writeFieldEnd()
5255 
    if self.timestamp != None:
5256 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5257 
      oprot.writeI64(self.timestamp)
5258 
      oprot.writeFieldEnd()
5259 
    oprot.writeFieldStop()
5260 
    oprot.writeStructEnd()
5261 
 
5262 
  def __repr__(self):
5263 
    L = ['%s=%r' % (key, value)
5264 
      for key, value in self.__dict__.iteritems()]
5265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5266 
 
5267 
  def __eq__(self, other):
5268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5269 
 
5270 
  def __ne__(self, other):
5271 
    return not (self == other)
5272 
 
559 chandransh 5273 
class setUserAsLoggedIn_result:
94 ashish 5274 
  """
5275 
  Attributes:
5276 
   - success
5277 
   - ucx
5278 
  """
5279 
 
5280 
  thrift_spec = (
5281 
    (0, TType.BOOL, 'success', None, None, ), # 0
5282 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5283 
  )
5284 
 
5285 
  def __init__(self, success=None, ucx=None,):
5286 
    self.success = success
5287 
    self.ucx = ucx
5288 
 
5289 
  def read(self, iprot):
5290 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5291 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5292 
      return
5293 
    iprot.readStructBegin()
5294 
    while True:
5295 
      (fname, ftype, fid) = iprot.readFieldBegin()
5296 
      if ftype == TType.STOP:
5297 
        break
5298 
      if fid == 0:
5299 
        if ftype == TType.BOOL:
5300 
          self.success = iprot.readBool();
5301 
        else:
5302 
          iprot.skip(ftype)
5303 
      elif fid == 1:
5304 
        if ftype == TType.STRUCT:
5305 
          self.ucx = UserContextException()
5306 
          self.ucx.read(iprot)
5307 
        else:
5308 
          iprot.skip(ftype)
5309 
      else:
5310 
        iprot.skip(ftype)
5311 
      iprot.readFieldEnd()
5312 
    iprot.readStructEnd()
5313 
 
5314 
  def write(self, oprot):
5315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5317 
      return
559 chandransh 5318 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
94 ashish 5319 
    if self.success != None:
5320 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5321 
      oprot.writeBool(self.success)
5322 
      oprot.writeFieldEnd()
5323 
    if self.ucx != None:
5324 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5325 
      self.ucx.write(oprot)
5326 
      oprot.writeFieldEnd()
5327 
    oprot.writeFieldStop()
5328 
    oprot.writeStructEnd()
5329 
 
5330 
  def __repr__(self):
5331 
    L = ['%s=%r' % (key, value)
5332 
      for key, value in self.__dict__.iteritems()]
5333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5334 
 
5335 
  def __eq__(self, other):
5336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5337 
 
5338 
  def __ne__(self, other):
5339 
    return not (self == other)
5340 
 
559 chandransh 5341 
class setUserAsLoggedOut_args:
94 ashish 5342 
  """
5343 
  Attributes:
5344 
   - userid
5345 
   - timestamp
5346 
  """
5347 
 
5348 
  thrift_spec = (
5349 
    None, # 0
559 chandransh 5350 
    (1, TType.I64, 'userid', None, None, ), # 1
5351 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 5352 
  )
5353 
 
559 chandransh 5354 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 5355 
    self.userid = userid
5356 
    self.timestamp = timestamp
5357 
 
5358 
  def read(self, iprot):
5359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5361 
      return
5362 
    iprot.readStructBegin()
5363 
    while True:
5364 
      (fname, ftype, fid) = iprot.readFieldBegin()
5365 
      if ftype == TType.STOP:
5366 
        break
5367 
      if fid == 1:
5368 
        if ftype == TType.I64:
5369 
          self.userid = iprot.readI64();
5370 
        else:
5371 
          iprot.skip(ftype)
559 chandransh 5372 
      elif fid == 2:
94 ashish 5373 
        if ftype == TType.I64:
5374 
          self.timestamp = iprot.readI64();
5375 
        else:
5376 
          iprot.skip(ftype)
5377 
      else:
5378 
        iprot.skip(ftype)
5379 
      iprot.readFieldEnd()
5380 
    iprot.readStructEnd()
5381 
 
5382 
  def write(self, oprot):
5383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5385 
      return
559 chandransh 5386 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
94 ashish 5387 
    if self.userid != None:
559 chandransh 5388 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 5389 
      oprot.writeI64(self.userid)
5390 
      oprot.writeFieldEnd()
5391 
    if self.timestamp != None:
559 chandransh 5392 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 5393 
      oprot.writeI64(self.timestamp)
5394 
      oprot.writeFieldEnd()
5395 
    oprot.writeFieldStop()
5396 
    oprot.writeStructEnd()
5397 
 
5398 
  def __repr__(self):
5399 
    L = ['%s=%r' % (key, value)
5400 
      for key, value in self.__dict__.iteritems()]
5401 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5402 
 
5403 
  def __eq__(self, other):
5404 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5405 
 
5406 
  def __ne__(self, other):
5407 
    return not (self == other)
5408 
 
559 chandransh 5409 
class setUserAsLoggedOut_result:
94 ashish 5410 
  """
5411 
  Attributes:
5412 
   - success
5413 
   - ucx
5414 
  """
5415 
 
5416 
  thrift_spec = (
5417 
    (0, TType.BOOL, 'success', None, None, ), # 0
5418 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5419 
  )
5420 
 
5421 
  def __init__(self, success=None, ucx=None,):
5422 
    self.success = success
5423 
    self.ucx = ucx
5424 
 
5425 
  def read(self, iprot):
5426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5428 
      return
5429 
    iprot.readStructBegin()
5430 
    while True:
5431 
      (fname, ftype, fid) = iprot.readFieldBegin()
5432 
      if ftype == TType.STOP:
5433 
        break
5434 
      if fid == 0:
5435 
        if ftype == TType.BOOL:
5436 
          self.success = iprot.readBool();
5437 
        else:
5438 
          iprot.skip(ftype)
5439 
      elif fid == 1:
5440 
        if ftype == TType.STRUCT:
5441 
          self.ucx = UserContextException()
5442 
          self.ucx.read(iprot)
5443 
        else:
5444 
          iprot.skip(ftype)
5445 
      else:
5446 
        iprot.skip(ftype)
5447 
      iprot.readFieldEnd()
5448 
    iprot.readStructEnd()
5449 
 
5450 
  def write(self, oprot):
5451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5453 
      return
559 chandransh 5454 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
94 ashish 5455 
    if self.success != None:
5456 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5457 
      oprot.writeBool(self.success)
5458 
      oprot.writeFieldEnd()
5459 
    if self.ucx != None:
5460 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5461 
      self.ucx.write(oprot)
5462 
      oprot.writeFieldEnd()
5463 
    oprot.writeFieldStop()
5464 
    oprot.writeStructEnd()
5465 
 
5466 
  def __repr__(self):
5467 
    L = ['%s=%r' % (key, value)
5468 
      for key, value in self.__dict__.iteritems()]
5469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5470 
 
5471 
  def __eq__(self, other):
5472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5473 
 
5474 
  def __ne__(self, other):
5475 
    return not (self == other)
5476 
 
559 chandransh 5477 
class setDefaultAddress_args:
94 ashish 5478 
  """
5479 
  Attributes:
5480 
   - userid
5481 
   - addressId
5482 
  """
5483 
 
5484 
  thrift_spec = (
5485 
    None, # 0
5486 
    (1, TType.I64, 'userid', None, None, ), # 1
5487 
    (2, TType.I64, 'addressId', None, None, ), # 2
5488 
  )
5489 
 
5490 
  def __init__(self, userid=None, addressId=None,):
5491 
    self.userid = userid
5492 
    self.addressId = addressId
5493 
 
5494 
  def read(self, iprot):
5495 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5496 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5497 
      return
5498 
    iprot.readStructBegin()
5499 
    while True:
5500 
      (fname, ftype, fid) = iprot.readFieldBegin()
5501 
      if ftype == TType.STOP:
5502 
        break
5503 
      if fid == 1:
5504 
        if ftype == TType.I64:
5505 
          self.userid = iprot.readI64();
5506 
        else:
5507 
          iprot.skip(ftype)
5508 
      elif fid == 2:
5509 
        if ftype == TType.I64:
5510 
          self.addressId = iprot.readI64();
5511 
        else:
5512 
          iprot.skip(ftype)
5513 
      else:
5514 
        iprot.skip(ftype)
5515 
      iprot.readFieldEnd()
5516 
    iprot.readStructEnd()
5517 
 
5518 
  def write(self, oprot):
5519 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5520 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5521 
      return
559 chandransh 5522 
    oprot.writeStructBegin('setDefaultAddress_args')
94 ashish 5523 
    if self.userid != None:
5524 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5525 
      oprot.writeI64(self.userid)
5526 
      oprot.writeFieldEnd()
5527 
    if self.addressId != None:
5528 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5529 
      oprot.writeI64(self.addressId)
5530 
      oprot.writeFieldEnd()
5531 
    oprot.writeFieldStop()
5532 
    oprot.writeStructEnd()
5533 
 
5534 
  def __repr__(self):
5535 
    L = ['%s=%r' % (key, value)
5536 
      for key, value in self.__dict__.iteritems()]
5537 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5538 
 
5539 
  def __eq__(self, other):
5540 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5541 
 
5542 
  def __ne__(self, other):
5543 
    return not (self == other)
5544 
 
559 chandransh 5545 
class setDefaultAddress_result:
94 ashish 5546 
  """
5547 
  Attributes:
5548 
   - success
5549 
   - ucx
5550 
  """
5551 
 
5552 
  thrift_spec = (
5553 
    (0, TType.BOOL, 'success', None, None, ), # 0
5554 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5555 
  )
5556 
 
5557 
  def __init__(self, success=None, ucx=None,):
5558 
    self.success = success
5559 
    self.ucx = ucx
5560 
 
5561 
  def read(self, iprot):
5562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5564 
      return
5565 
    iprot.readStructBegin()
5566 
    while True:
5567 
      (fname, ftype, fid) = iprot.readFieldBegin()
5568 
      if ftype == TType.STOP:
5569 
        break
5570 
      if fid == 0:
5571 
        if ftype == TType.BOOL:
5572 
          self.success = iprot.readBool();
5573 
        else:
5574 
          iprot.skip(ftype)
5575 
      elif fid == 1:
5576 
        if ftype == TType.STRUCT:
5577 
          self.ucx = UserContextException()
5578 
          self.ucx.read(iprot)
5579 
        else:
5580 
          iprot.skip(ftype)
5581 
      else:
5582 
        iprot.skip(ftype)
5583 
      iprot.readFieldEnd()
5584 
    iprot.readStructEnd()
5585 
 
5586 
  def write(self, oprot):
5587 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5588 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5589 
      return
559 chandransh 5590 
    oprot.writeStructBegin('setDefaultAddress_result')
94 ashish 5591 
    if self.success != None:
5592 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5593 
      oprot.writeBool(self.success)
5594 
      oprot.writeFieldEnd()
5595 
    if self.ucx != None:
5596 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5597 
      self.ucx.write(oprot)
5598 
      oprot.writeFieldEnd()
5599 
    oprot.writeFieldStop()
5600 
    oprot.writeStructEnd()
5601 
 
5602 
  def __repr__(self):
5603 
    L = ['%s=%r' % (key, value)
5604 
      for key, value in self.__dict__.iteritems()]
5605 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5606 
 
5607 
  def __eq__(self, other):
5608 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5609 
 
5610 
  def __ne__(self, other):
5611 
    return not (self == other)
5612 
 
559 chandransh 5613 
class updatePassword_args:
94 ashish 5614 
  """
5615 
  Attributes:
559 chandransh 5616 
   - userid
594 rajveer 5617 
   - oldPassword
5618 
   - newPassword
94 ashish 5619 
  """
5620 
 
5621 
  thrift_spec = (
5622 
    None, # 0
559 chandransh 5623 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 5624 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
5625 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 5626 
  )
5627 
 
594 rajveer 5628 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 5629 
    self.userid = userid
594 rajveer 5630 
    self.oldPassword = oldPassword
5631 
    self.newPassword = newPassword
94 ashish 5632 
 
5633 
  def read(self, iprot):
5634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5636 
      return
5637 
    iprot.readStructBegin()
5638 
    while True:
5639 
      (fname, ftype, fid) = iprot.readFieldBegin()
5640 
      if ftype == TType.STOP:
5641 
        break
5642 
      if fid == 1:
5643 
        if ftype == TType.I64:
559 chandransh 5644 
          self.userid = iprot.readI64();
94 ashish 5645 
        else:
5646 
          iprot.skip(ftype)
5647 
      elif fid == 2:
559 chandransh 5648 
        if ftype == TType.STRING:
594 rajveer 5649 
          self.oldPassword = iprot.readString();
94 ashish 5650 
        else:
5651 
          iprot.skip(ftype)
594 rajveer 5652 
      elif fid == 3:
5653 
        if ftype == TType.STRING:
5654 
          self.newPassword = iprot.readString();
5655 
        else:
5656 
          iprot.skip(ftype)
94 ashish 5657 
      else:
5658 
        iprot.skip(ftype)
5659 
      iprot.readFieldEnd()
5660 
    iprot.readStructEnd()
5661 
 
5662 
  def write(self, oprot):
5663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5665 
      return
559 chandransh 5666 
    oprot.writeStructBegin('updatePassword_args')
5667 
    if self.userid != None:
5668 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5669 
      oprot.writeI64(self.userid)
94 ashish 5670 
      oprot.writeFieldEnd()
594 rajveer 5671 
    if self.oldPassword != None:
5672 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
5673 
      oprot.writeString(self.oldPassword)
94 ashish 5674 
      oprot.writeFieldEnd()
594 rajveer 5675 
    if self.newPassword != None:
5676 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
5677 
      oprot.writeString(self.newPassword)
5678 
      oprot.writeFieldEnd()
94 ashish 5679 
    oprot.writeFieldStop()
5680 
    oprot.writeStructEnd()
5681 
 
5682 
  def __repr__(self):
5683 
    L = ['%s=%r' % (key, value)
5684 
      for key, value in self.__dict__.iteritems()]
5685 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5686 
 
5687 
  def __eq__(self, other):
5688 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5689 
 
5690 
  def __ne__(self, other):
5691 
    return not (self == other)
5692 
 
559 chandransh 5693 
class updatePassword_result:
94 ashish 5694 
  """
5695 
  Attributes:
5696 
   - success
5697 
   - ucx
5698 
  """
5699 
 
5700 
  thrift_spec = (
5701 
    (0, TType.BOOL, 'success', None, None, ), # 0
5702 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5703 
  )
5704 
 
5705 
  def __init__(self, success=None, ucx=None,):
5706 
    self.success = success
5707 
    self.ucx = ucx
5708 
 
5709 
  def read(self, iprot):
5710 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5711 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5712 
      return
5713 
    iprot.readStructBegin()
5714 
    while True:
5715 
      (fname, ftype, fid) = iprot.readFieldBegin()
5716 
      if ftype == TType.STOP:
5717 
        break
5718 
      if fid == 0:
5719 
        if ftype == TType.BOOL:
5720 
          self.success = iprot.readBool();
5721 
        else:
5722 
          iprot.skip(ftype)
5723 
      elif fid == 1:
5724 
        if ftype == TType.STRUCT:
5725 
          self.ucx = UserContextException()
5726 
          self.ucx.read(iprot)
5727 
        else:
5728 
          iprot.skip(ftype)
5729 
      else:
5730 
        iprot.skip(ftype)
5731 
      iprot.readFieldEnd()
5732 
    iprot.readStructEnd()
5733 
 
5734 
  def write(self, oprot):
5735 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5736 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5737 
      return
559 chandransh 5738 
    oprot.writeStructBegin('updatePassword_result')
94 ashish 5739 
    if self.success != None:
5740 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5741 
      oprot.writeBool(self.success)
5742 
      oprot.writeFieldEnd()
5743 
    if self.ucx != None:
5744 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5745 
      self.ucx.write(oprot)
5746 
      oprot.writeFieldEnd()
5747 
    oprot.writeFieldStop()
5748 
    oprot.writeStructEnd()
5749 
 
5750 
  def __repr__(self):
5751 
    L = ['%s=%r' % (key, value)
5752 
      for key, value in self.__dict__.iteritems()]
5753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5754 
 
5755 
  def __eq__(self, other):
5756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5757 
 
5758 
  def __ne__(self, other):
5759 
    return not (self == other)
5760 
 
581 rajveer 5761 
class forgotPassword_args:
5762 
  """
5763 
  Attributes:
5764 
   - email
884 rajveer 5765 
   - newPassword
581 rajveer 5766 
  """
5767 
 
5768 
  thrift_spec = (
5769 
    None, # 0
5770 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 5771 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 5772 
  )
5773 
 
884 rajveer 5774 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 5775 
    self.email = email
884 rajveer 5776 
    self.newPassword = newPassword
581 rajveer 5777 
 
5778 
  def read(self, iprot):
5779 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5780 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5781 
      return
5782 
    iprot.readStructBegin()
5783 
    while True:
5784 
      (fname, ftype, fid) = iprot.readFieldBegin()
5785 
      if ftype == TType.STOP:
5786 
        break
5787 
      if fid == 1:
5788 
        if ftype == TType.STRING:
5789 
          self.email = iprot.readString();
5790 
        else:
5791 
          iprot.skip(ftype)
884 rajveer 5792 
      elif fid == 2:
5793 
        if ftype == TType.STRING:
5794 
          self.newPassword = iprot.readString();
5795 
        else:
5796 
          iprot.skip(ftype)
581 rajveer 5797 
      else:
5798 
        iprot.skip(ftype)
5799 
      iprot.readFieldEnd()
5800 
    iprot.readStructEnd()
5801 
 
5802 
  def write(self, oprot):
5803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5805 
      return
5806 
    oprot.writeStructBegin('forgotPassword_args')
5807 
    if self.email != None:
5808 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5809 
      oprot.writeString(self.email)
5810 
      oprot.writeFieldEnd()
884 rajveer 5811 
    if self.newPassword != None:
5812 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
5813 
      oprot.writeString(self.newPassword)
5814 
      oprot.writeFieldEnd()
581 rajveer 5815 
    oprot.writeFieldStop()
5816 
    oprot.writeStructEnd()
5817 
 
5818 
  def __repr__(self):
5819 
    L = ['%s=%r' % (key, value)
5820 
      for key, value in self.__dict__.iteritems()]
5821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5822 
 
5823 
  def __eq__(self, other):
5824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5825 
 
5826 
  def __ne__(self, other):
5827 
    return not (self == other)
5828 
 
5829 
class forgotPassword_result:
5830 
  """
5831 
  Attributes:
5832 
   - success
5833 
   - ucx
5834 
  """
5835 
 
5836 
  thrift_spec = (
5837 
    (0, TType.BOOL, 'success', None, None, ), # 0
5838 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5839 
  )
5840 
 
5841 
  def __init__(self, success=None, ucx=None,):
5842 
    self.success = success
5843 
    self.ucx = ucx
5844 
 
5845 
  def read(self, iprot):
5846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5848 
      return
5849 
    iprot.readStructBegin()
5850 
    while True:
5851 
      (fname, ftype, fid) = iprot.readFieldBegin()
5852 
      if ftype == TType.STOP:
5853 
        break
5854 
      if fid == 0:
5855 
        if ftype == TType.BOOL:
5856 
          self.success = iprot.readBool();
5857 
        else:
5858 
          iprot.skip(ftype)
5859 
      elif fid == 1:
5860 
        if ftype == TType.STRUCT:
5861 
          self.ucx = UserContextException()
5862 
          self.ucx.read(iprot)
5863 
        else:
5864 
          iprot.skip(ftype)
5865 
      else:
5866 
        iprot.skip(ftype)
5867 
      iprot.readFieldEnd()
5868 
    iprot.readStructEnd()
5869 
 
5870 
  def write(self, oprot):
5871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5873 
      return
5874 
    oprot.writeStructBegin('forgotPassword_result')
5875 
    if self.success != None:
5876 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5877 
      oprot.writeBool(self.success)
5878 
      oprot.writeFieldEnd()
5879 
    if self.ucx != None:
5880 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5881 
      self.ucx.write(oprot)
5882 
      oprot.writeFieldEnd()
5883 
    oprot.writeFieldStop()
5884 
    oprot.writeStructEnd()
5885 
 
5886 
  def __repr__(self):
5887 
    L = ['%s=%r' % (key, value)
5888 
      for key, value in self.__dict__.iteritems()]
5889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5890 
 
5891 
  def __eq__(self, other):
5892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5893 
 
5894 
  def __ne__(self, other):
5895 
    return not (self == other)
5896 
 
594 rajveer 5897 
class getAllAddressesForUser_args:
5898 
  """
5899 
  Attributes:
5900 
   - userId
5901 
  """
5902 
 
5903 
  thrift_spec = (
5904 
    None, # 0
5905 
    (1, TType.I64, 'userId', None, None, ), # 1
5906 
  )
5907 
 
5908 
  def __init__(self, userId=None,):
5909 
    self.userId = userId
5910 
 
5911 
  def read(self, iprot):
5912 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5913 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5914 
      return
5915 
    iprot.readStructBegin()
5916 
    while True:
5917 
      (fname, ftype, fid) = iprot.readFieldBegin()
5918 
      if ftype == TType.STOP:
5919 
        break
5920 
      if fid == 1:
5921 
        if ftype == TType.I64:
5922 
          self.userId = iprot.readI64();
5923 
        else:
5924 
          iprot.skip(ftype)
5925 
      else:
5926 
        iprot.skip(ftype)
5927 
      iprot.readFieldEnd()
5928 
    iprot.readStructEnd()
5929 
 
5930 
  def write(self, oprot):
5931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5933 
      return
5934 
    oprot.writeStructBegin('getAllAddressesForUser_args')
5935 
    if self.userId != None:
5936 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5937 
      oprot.writeI64(self.userId)
5938 
      oprot.writeFieldEnd()
5939 
    oprot.writeFieldStop()
5940 
    oprot.writeStructEnd()
5941 
 
5942 
  def __repr__(self):
5943 
    L = ['%s=%r' % (key, value)
5944 
      for key, value in self.__dict__.iteritems()]
5945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5946 
 
5947 
  def __eq__(self, other):
5948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5949 
 
5950 
  def __ne__(self, other):
5951 
    return not (self == other)
5952 
 
5953 
class getAllAddressesForUser_result:
5954 
  """
5955 
  Attributes:
5956 
   - success
5957 
   - ucx
5958 
  """
5959 
 
5960 
  thrift_spec = (
5961 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
5962 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5963 
  )
5964 
 
5965 
  def __init__(self, success=None, ucx=None,):
5966 
    self.success = success
5967 
    self.ucx = ucx
5968 
 
5969 
  def read(self, iprot):
5970 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5971 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5972 
      return
5973 
    iprot.readStructBegin()
5974 
    while True:
5975 
      (fname, ftype, fid) = iprot.readFieldBegin()
5976 
      if ftype == TType.STOP:
5977 
        break
5978 
      if fid == 0:
5979 
        if ftype == TType.LIST:
5980 
          self.success = []
772 rajveer 5981 
          (_etype31, _size28) = iprot.readListBegin()
5982 
          for _i32 in xrange(_size28):
5983 
            _elem33 = Address()
5984 
            _elem33.read(iprot)
5985 
            self.success.append(_elem33)
594 rajveer 5986 
          iprot.readListEnd()
5987 
        else:
5988 
          iprot.skip(ftype)
5989 
      elif fid == 1:
5990 
        if ftype == TType.STRUCT:
5991 
          self.ucx = UserContextException()
5992 
          self.ucx.read(iprot)
5993 
        else:
5994 
          iprot.skip(ftype)
5995 
      else:
5996 
        iprot.skip(ftype)
5997 
      iprot.readFieldEnd()
5998 
    iprot.readStructEnd()
5999 
 
6000 
  def write(self, oprot):
6001 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6002 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6003 
      return
6004 
    oprot.writeStructBegin('getAllAddressesForUser_result')
6005 
    if self.success != None:
6006 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6007 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
772 rajveer 6008 
      for iter34 in self.success:
6009 
        iter34.write(oprot)
594 rajveer 6010 
      oprot.writeListEnd()
6011 
      oprot.writeFieldEnd()
6012 
    if self.ucx != None:
6013 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6014 
      self.ucx.write(oprot)
6015 
      oprot.writeFieldEnd()
6016 
    oprot.writeFieldStop()
6017 
    oprot.writeStructEnd()
6018 
 
6019 
  def __repr__(self):
6020 
    L = ['%s=%r' % (key, value)
6021 
      for key, value in self.__dict__.iteritems()]
6022 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6023 
 
6024 
  def __eq__(self, other):
6025 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6026 
 
6027 
  def __ne__(self, other):
6028 
    return not (self == other)
6029 
 
1894 vikas 6030 
class getAddressById_args:
6031 
  """
6032 
  Attributes:
6033 
   - addressId
6034 
  """
6035 
 
6036 
  thrift_spec = (
6037 
    None, # 0
6038 
    (1, TType.I64, 'addressId', None, None, ), # 1
6039 
  )
6040 
 
6041 
  def __init__(self, addressId=None,):
6042 
    self.addressId = addressId
6043 
 
6044 
  def read(self, iprot):
6045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6047 
      return
6048 
    iprot.readStructBegin()
6049 
    while True:
6050 
      (fname, ftype, fid) = iprot.readFieldBegin()
6051 
      if ftype == TType.STOP:
6052 
        break
6053 
      if fid == 1:
6054 
        if ftype == TType.I64:
6055 
          self.addressId = iprot.readI64();
6056 
        else:
6057 
          iprot.skip(ftype)
6058 
      else:
6059 
        iprot.skip(ftype)
6060 
      iprot.readFieldEnd()
6061 
    iprot.readStructEnd()
6062 
 
6063 
  def write(self, oprot):
6064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6066 
      return
6067 
    oprot.writeStructBegin('getAddressById_args')
6068 
    if self.addressId != None:
6069 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
6070 
      oprot.writeI64(self.addressId)
6071 
      oprot.writeFieldEnd()
6072 
    oprot.writeFieldStop()
6073 
    oprot.writeStructEnd()
6074 
 
6075 
  def __repr__(self):
6076 
    L = ['%s=%r' % (key, value)
6077 
      for key, value in self.__dict__.iteritems()]
6078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6079 
 
6080 
  def __eq__(self, other):
6081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6082 
 
6083 
  def __ne__(self, other):
6084 
    return not (self == other)
6085 
 
6086 
class getAddressById_result:
6087 
  """
6088 
  Attributes:
6089 
   - success
6090 
   - ucx
6091 
  """
6092 
 
6093 
  thrift_spec = (
6094 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
6095 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6096 
  )
6097 
 
6098 
  def __init__(self, success=None, ucx=None,):
6099 
    self.success = success
6100 
    self.ucx = ucx
6101 
 
6102 
  def read(self, iprot):
6103 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6104 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6105 
      return
6106 
    iprot.readStructBegin()
6107 
    while True:
6108 
      (fname, ftype, fid) = iprot.readFieldBegin()
6109 
      if ftype == TType.STOP:
6110 
        break
6111 
      if fid == 0:
6112 
        if ftype == TType.STRUCT:
6113 
          self.success = Address()
6114 
          self.success.read(iprot)
6115 
        else:
6116 
          iprot.skip(ftype)
6117 
      elif fid == 1:
6118 
        if ftype == TType.STRUCT:
6119 
          self.ucx = UserContextException()
6120 
          self.ucx.read(iprot)
6121 
        else:
6122 
          iprot.skip(ftype)
6123 
      else:
6124 
        iprot.skip(ftype)
6125 
      iprot.readFieldEnd()
6126 
    iprot.readStructEnd()
6127 
 
6128 
  def write(self, oprot):
6129 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6130 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6131 
      return
6132 
    oprot.writeStructBegin('getAddressById_result')
6133 
    if self.success != None:
6134 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6135 
      self.success.write(oprot)
6136 
      oprot.writeFieldEnd()
6137 
    if self.ucx != None:
6138 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6139 
      self.ucx.write(oprot)
6140 
      oprot.writeFieldEnd()
6141 
    oprot.writeFieldStop()
6142 
    oprot.writeStructEnd()
6143 
 
6144 
  def __repr__(self):
6145 
    L = ['%s=%r' % (key, value)
6146 
      for key, value in self.__dict__.iteritems()]
6147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6148 
 
6149 
  def __eq__(self, other):
6150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6151 
 
6152 
  def __ne__(self, other):
6153 
    return not (self == other)
6154 
 
594 rajveer 6155 
class getDefaultAddressId_args:
6156 
  """
6157 
  Attributes:
6158 
   - userId
6159 
  """
6160 
 
6161 
  thrift_spec = (
6162 
    None, # 0
6163 
    (1, TType.I64, 'userId', None, None, ), # 1
6164 
  )
6165 
 
6166 
  def __init__(self, userId=None,):
6167 
    self.userId = userId
6168 
 
6169 
  def read(self, iprot):
6170 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6171 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6172 
      return
6173 
    iprot.readStructBegin()
6174 
    while True:
6175 
      (fname, ftype, fid) = iprot.readFieldBegin()
6176 
      if ftype == TType.STOP:
6177 
        break
6178 
      if fid == 1:
6179 
        if ftype == TType.I64:
6180 
          self.userId = iprot.readI64();
6181 
        else:
6182 
          iprot.skip(ftype)
6183 
      else:
6184 
        iprot.skip(ftype)
6185 
      iprot.readFieldEnd()
6186 
    iprot.readStructEnd()
6187 
 
6188 
  def write(self, oprot):
6189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6191 
      return
6192 
    oprot.writeStructBegin('getDefaultAddressId_args')
6193 
    if self.userId != None:
6194 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6195 
      oprot.writeI64(self.userId)
6196 
      oprot.writeFieldEnd()
6197 
    oprot.writeFieldStop()
6198 
    oprot.writeStructEnd()
6199 
 
6200 
  def __repr__(self):
6201 
    L = ['%s=%r' % (key, value)
6202 
      for key, value in self.__dict__.iteritems()]
6203 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6204 
 
6205 
  def __eq__(self, other):
6206 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6207 
 
6208 
  def __ne__(self, other):
6209 
    return not (self == other)
6210 
 
6211 
class getDefaultAddressId_result:
6212 
  """
6213 
  Attributes:
6214 
   - success
6215 
   - ucx
6216 
  """
6217 
 
6218 
  thrift_spec = (
6219 
    (0, TType.I64, 'success', None, None, ), # 0
6220 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6221 
  )
6222 
 
6223 
  def __init__(self, success=None, ucx=None,):
6224 
    self.success = success
6225 
    self.ucx = ucx
6226 
 
6227 
  def read(self, iprot):
6228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6230 
      return
6231 
    iprot.readStructBegin()
6232 
    while True:
6233 
      (fname, ftype, fid) = iprot.readFieldBegin()
6234 
      if ftype == TType.STOP:
6235 
        break
6236 
      if fid == 0:
6237 
        if ftype == TType.I64:
6238 
          self.success = iprot.readI64();
6239 
        else:
6240 
          iprot.skip(ftype)
6241 
      elif fid == 1:
6242 
        if ftype == TType.STRUCT:
6243 
          self.ucx = UserContextException()
6244 
          self.ucx.read(iprot)
6245 
        else:
6246 
          iprot.skip(ftype)
6247 
      else:
6248 
        iprot.skip(ftype)
6249 
      iprot.readFieldEnd()
6250 
    iprot.readStructEnd()
6251 
 
6252 
  def write(self, oprot):
6253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6255 
      return
6256 
    oprot.writeStructBegin('getDefaultAddressId_result')
6257 
    if self.success != None:
6258 
      oprot.writeFieldBegin('success', TType.I64, 0)
6259 
      oprot.writeI64(self.success)
6260 
      oprot.writeFieldEnd()
6261 
    if self.ucx != None:
6262 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6263 
      self.ucx.write(oprot)
6264 
      oprot.writeFieldEnd()
6265 
    oprot.writeFieldStop()
6266 
    oprot.writeStructEnd()
6267 
 
6268 
  def __repr__(self):
6269 
    L = ['%s=%r' % (key, value)
6270 
      for key, value in self.__dict__.iteritems()]
6271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6272 
 
6273 
  def __eq__(self, other):
6274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6275 
 
6276 
  def __ne__(self, other):
6277 
    return not (self == other)
6278 
 
785 rajveer 6279 
class getDefaultPincode_args:
6280 
  """
6281 
  Attributes:
6282 
   - userId
6283 
  """
6284 
 
6285 
  thrift_spec = (
6286 
    None, # 0
6287 
    (1, TType.I64, 'userId', None, None, ), # 1
6288 
  )
6289 
 
6290 
  def __init__(self, userId=None,):
6291 
    self.userId = userId
6292 
 
6293 
  def read(self, iprot):
6294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6296 
      return
6297 
    iprot.readStructBegin()
6298 
    while True:
6299 
      (fname, ftype, fid) = iprot.readFieldBegin()
6300 
      if ftype == TType.STOP:
6301 
        break
6302 
      if fid == 1:
6303 
        if ftype == TType.I64:
6304 
          self.userId = iprot.readI64();
6305 
        else:
6306 
          iprot.skip(ftype)
6307 
      else:
6308 
        iprot.skip(ftype)
6309 
      iprot.readFieldEnd()
6310 
    iprot.readStructEnd()
6311 
 
6312 
  def write(self, oprot):
6313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6315 
      return
6316 
    oprot.writeStructBegin('getDefaultPincode_args')
6317 
    if self.userId != None:
6318 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6319 
      oprot.writeI64(self.userId)
6320 
      oprot.writeFieldEnd()
6321 
    oprot.writeFieldStop()
6322 
    oprot.writeStructEnd()
6323 
 
6324 
  def __repr__(self):
6325 
    L = ['%s=%r' % (key, value)
6326 
      for key, value in self.__dict__.iteritems()]
6327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6328 
 
6329 
  def __eq__(self, other):
6330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6331 
 
6332 
  def __ne__(self, other):
6333 
    return not (self == other)
6334 
 
6335 
class getDefaultPincode_result:
6336 
  """
6337 
  Attributes:
6338 
   - success
6339 
   - ucx
6340 
  """
6341 
 
6342 
  thrift_spec = (
6343 
    (0, TType.STRING, 'success', None, None, ), # 0
6344 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6345 
  )
6346 
 
6347 
  def __init__(self, success=None, ucx=None,):
6348 
    self.success = success
6349 
    self.ucx = ucx
6350 
 
6351 
  def read(self, iprot):
6352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6354 
      return
6355 
    iprot.readStructBegin()
6356 
    while True:
6357 
      (fname, ftype, fid) = iprot.readFieldBegin()
6358 
      if ftype == TType.STOP:
6359 
        break
6360 
      if fid == 0:
6361 
        if ftype == TType.STRING:
6362 
          self.success = iprot.readString();
6363 
        else:
6364 
          iprot.skip(ftype)
6365 
      elif fid == 1:
6366 
        if ftype == TType.STRUCT:
6367 
          self.ucx = UserContextException()
6368 
          self.ucx.read(iprot)
6369 
        else:
6370 
          iprot.skip(ftype)
6371 
      else:
6372 
        iprot.skip(ftype)
6373 
      iprot.readFieldEnd()
6374 
    iprot.readStructEnd()
6375 
 
6376 
  def write(self, oprot):
6377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6379 
      return
6380 
    oprot.writeStructBegin('getDefaultPincode_result')
6381 
    if self.success != None:
6382 
      oprot.writeFieldBegin('success', TType.STRING, 0)
6383 
      oprot.writeString(self.success)
6384 
      oprot.writeFieldEnd()
6385 
    if self.ucx != None:
6386 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6387 
      self.ucx.write(oprot)
6388 
      oprot.writeFieldEnd()
6389 
    oprot.writeFieldStop()
6390 
    oprot.writeStructEnd()
6391 
 
6392 
  def __repr__(self):
6393 
    L = ['%s=%r' % (key, value)
6394 
      for key, value in self.__dict__.iteritems()]
6395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6396 
 
6397 
  def __eq__(self, other):
6398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6399 
 
6400 
  def __ne__(self, other):
6401 
    return not (self == other)
6402 
 
1274 varun.gupt 6403 
class saveUserCommunication_args:
6404 
  """
6405 
  Attributes:
6406 
   - userId
6407 
   - replyTo
6408 
   - communicationType
6409 
   - orderId
6410 
   - airwaybillNo
6411 
   - productName
6412 
   - subject
6413 
   - message
6414 
  """
6415 
 
6416 
  thrift_spec = (
6417 
    None, # 0
6418 
    (1, TType.I64, 'userId', None, None, ), # 1
6419 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
6420 
    (3, TType.I64, 'communicationType', None, None, ), # 3
6421 
    (4, TType.I64, 'orderId', None, None, ), # 4
6422 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
6423 
    (6, TType.STRING, 'productName', None, None, ), # 6
6424 
    (7, TType.STRING, 'subject', None, None, ), # 7
6425 
    (8, TType.STRING, 'message', None, None, ), # 8
6426 
  )
6427 
 
6428 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
6429 
    self.userId = userId
6430 
    self.replyTo = replyTo
6431 
    self.communicationType = communicationType
6432 
    self.orderId = orderId
6433 
    self.airwaybillNo = airwaybillNo
6434 
    self.productName = productName
6435 
    self.subject = subject
6436 
    self.message = message
6437 
 
6438 
  def read(self, iprot):
6439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6441 
      return
6442 
    iprot.readStructBegin()
6443 
    while True:
6444 
      (fname, ftype, fid) = iprot.readFieldBegin()
6445 
      if ftype == TType.STOP:
6446 
        break
6447 
      if fid == 1:
6448 
        if ftype == TType.I64:
6449 
          self.userId = iprot.readI64();
6450 
        else:
6451 
          iprot.skip(ftype)
6452 
      elif fid == 2:
6453 
        if ftype == TType.STRING:
6454 
          self.replyTo = iprot.readString();
6455 
        else:
6456 
          iprot.skip(ftype)
6457 
      elif fid == 3:
6458 
        if ftype == TType.I64:
6459 
          self.communicationType = iprot.readI64();
6460 
        else:
6461 
          iprot.skip(ftype)
6462 
      elif fid == 4:
6463 
        if ftype == TType.I64:
6464 
          self.orderId = iprot.readI64();
6465 
        else:
6466 
          iprot.skip(ftype)
6467 
      elif fid == 5:
6468 
        if ftype == TType.STRING:
6469 
          self.airwaybillNo = iprot.readString();
6470 
        else:
6471 
          iprot.skip(ftype)
6472 
      elif fid == 6:
6473 
        if ftype == TType.STRING:
6474 
          self.productName = iprot.readString();
6475 
        else:
6476 
          iprot.skip(ftype)
6477 
      elif fid == 7:
6478 
        if ftype == TType.STRING:
6479 
          self.subject = iprot.readString();
6480 
        else:
6481 
          iprot.skip(ftype)
6482 
      elif fid == 8:
6483 
        if ftype == TType.STRING:
6484 
          self.message = iprot.readString();
6485 
        else:
6486 
          iprot.skip(ftype)
6487 
      else:
6488 
        iprot.skip(ftype)
6489 
      iprot.readFieldEnd()
6490 
    iprot.readStructEnd()
6491 
 
6492 
  def write(self, oprot):
6493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6495 
      return
6496 
    oprot.writeStructBegin('saveUserCommunication_args')
6497 
    if self.userId != None:
6498 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6499 
      oprot.writeI64(self.userId)
6500 
      oprot.writeFieldEnd()
6501 
    if self.replyTo != None:
6502 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
6503 
      oprot.writeString(self.replyTo)
6504 
      oprot.writeFieldEnd()
6505 
    if self.communicationType != None:
6506 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
6507 
      oprot.writeI64(self.communicationType)
6508 
      oprot.writeFieldEnd()
6509 
    if self.orderId != None:
6510 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
6511 
      oprot.writeI64(self.orderId)
6512 
      oprot.writeFieldEnd()
6513 
    if self.airwaybillNo != None:
6514 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
6515 
      oprot.writeString(self.airwaybillNo)
6516 
      oprot.writeFieldEnd()
6517 
    if self.productName != None:
6518 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
6519 
      oprot.writeString(self.productName)
6520 
      oprot.writeFieldEnd()
6521 
    if self.subject != None:
6522 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
6523 
      oprot.writeString(self.subject)
6524 
      oprot.writeFieldEnd()
6525 
    if self.message != None:
6526 
      oprot.writeFieldBegin('message', TType.STRING, 8)
6527 
      oprot.writeString(self.message)
6528 
      oprot.writeFieldEnd()
6529 
    oprot.writeFieldStop()
6530 
    oprot.writeStructEnd()
6531 
 
6532 
  def __repr__(self):
6533 
    L = ['%s=%r' % (key, value)
6534 
      for key, value in self.__dict__.iteritems()]
6535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6536 
 
6537 
  def __eq__(self, other):
6538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6539 
 
6540 
  def __ne__(self, other):
6541 
    return not (self == other)
6542 
 
6543 
class saveUserCommunication_result:
6544 
  """
6545 
  Attributes:
6546 
   - success
6547 
   - ucx
6548 
  """
6549 
 
6550 
  thrift_spec = (
6551 
    (0, TType.BOOL, 'success', None, None, ), # 0
6552 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6553 
  )
6554 
 
6555 
  def __init__(self, success=None, ucx=None,):
6556 
    self.success = success
6557 
    self.ucx = ucx
6558 
 
6559 
  def read(self, iprot):
6560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6562 
      return
6563 
    iprot.readStructBegin()
6564 
    while True:
6565 
      (fname, ftype, fid) = iprot.readFieldBegin()
6566 
      if ftype == TType.STOP:
6567 
        break
6568 
      if fid == 0:
6569 
        if ftype == TType.BOOL:
6570 
          self.success = iprot.readBool();
6571 
        else:
6572 
          iprot.skip(ftype)
6573 
      elif fid == 1:
6574 
        if ftype == TType.STRUCT:
6575 
          self.ucx = UserCommunicationException()
6576 
          self.ucx.read(iprot)
6577 
        else:
6578 
          iprot.skip(ftype)
6579 
      else:
6580 
        iprot.skip(ftype)
6581 
      iprot.readFieldEnd()
6582 
    iprot.readStructEnd()
6583 
 
6584 
  def write(self, oprot):
6585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6587 
      return
6588 
    oprot.writeStructBegin('saveUserCommunication_result')
6589 
    if self.success != None:
6590 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6591 
      oprot.writeBool(self.success)
6592 
      oprot.writeFieldEnd()
6593 
    if self.ucx != None:
6594 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6595 
      self.ucx.write(oprot)
6596 
      oprot.writeFieldEnd()
6597 
    oprot.writeFieldStop()
6598 
    oprot.writeStructEnd()
6599 
 
6600 
  def __repr__(self):
6601 
    L = ['%s=%r' % (key, value)
6602 
      for key, value in self.__dict__.iteritems()]
6603 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6604 
 
6605 
  def __eq__(self, other):
6606 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6607 
 
6608 
  def __ne__(self, other):
6609 
    return not (self == other)
6610 
 
1590 varun.gupt 6611 
class getUserCommunicationById_args:
6612 
  """
6613 
  Attributes:
6614 
   - id
6615 
  """
6616 
 
6617 
  thrift_spec = (
6618 
    None, # 0
6619 
    (1, TType.I64, 'id', None, None, ), # 1
6620 
  )
6621 
 
6622 
  def __init__(self, id=None,):
6623 
    self.id = id
6624 
 
6625 
  def read(self, iprot):
6626 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6627 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6628 
      return
6629 
    iprot.readStructBegin()
6630 
    while True:
6631 
      (fname, ftype, fid) = iprot.readFieldBegin()
6632 
      if ftype == TType.STOP:
6633 
        break
6634 
      if fid == 1:
6635 
        if ftype == TType.I64:
6636 
          self.id = iprot.readI64();
6637 
        else:
6638 
          iprot.skip(ftype)
6639 
      else:
6640 
        iprot.skip(ftype)
6641 
      iprot.readFieldEnd()
6642 
    iprot.readStructEnd()
6643 
 
6644 
  def write(self, oprot):
6645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6647 
      return
6648 
    oprot.writeStructBegin('getUserCommunicationById_args')
6649 
    if self.id != None:
6650 
      oprot.writeFieldBegin('id', TType.I64, 1)
6651 
      oprot.writeI64(self.id)
6652 
      oprot.writeFieldEnd()
6653 
    oprot.writeFieldStop()
6654 
    oprot.writeStructEnd()
6655 
 
6656 
  def __repr__(self):
6657 
    L = ['%s=%r' % (key, value)
6658 
      for key, value in self.__dict__.iteritems()]
6659 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6660 
 
6661 
  def __eq__(self, other):
6662 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6663 
 
6664 
  def __ne__(self, other):
6665 
    return not (self == other)
6666 
 
6667 
class getUserCommunicationById_result:
6668 
  """
6669 
  Attributes:
6670 
   - success
6671 
   - ucx
6672 
  """
6673 
 
6674 
  thrift_spec = (
6675 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
6676 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6677 
  )
6678 
 
6679 
  def __init__(self, success=None, ucx=None,):
6680 
    self.success = success
6681 
    self.ucx = ucx
6682 
 
6683 
  def read(self, iprot):
6684 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6685 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6686 
      return
6687 
    iprot.readStructBegin()
6688 
    while True:
6689 
      (fname, ftype, fid) = iprot.readFieldBegin()
6690 
      if ftype == TType.STOP:
6691 
        break
6692 
      if fid == 0:
6693 
        if ftype == TType.STRUCT:
6694 
          self.success = UserCommunication()
6695 
          self.success.read(iprot)
6696 
        else:
6697 
          iprot.skip(ftype)
6698 
      elif fid == 1:
6699 
        if ftype == TType.STRUCT:
6700 
          self.ucx = UserCommunicationException()
6701 
          self.ucx.read(iprot)
6702 
        else:
6703 
          iprot.skip(ftype)
6704 
      else:
6705 
        iprot.skip(ftype)
6706 
      iprot.readFieldEnd()
6707 
    iprot.readStructEnd()
6708 
 
6709 
  def write(self, oprot):
6710 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6711 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6712 
      return
6713 
    oprot.writeStructBegin('getUserCommunicationById_result')
6714 
    if self.success != None:
6715 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6716 
      self.success.write(oprot)
6717 
      oprot.writeFieldEnd()
6718 
    if self.ucx != None:
6719 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6720 
      self.ucx.write(oprot)
6721 
      oprot.writeFieldEnd()
6722 
    oprot.writeFieldStop()
6723 
    oprot.writeStructEnd()
6724 
 
6725 
  def __repr__(self):
6726 
    L = ['%s=%r' % (key, value)
6727 
      for key, value in self.__dict__.iteritems()]
6728 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6729 
 
6730 
  def __eq__(self, other):
6731 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6732 
 
6733 
  def __ne__(self, other):
6734 
    return not (self == other)
6735 
 
6736 
class getUserCommunicationByUser_args:
6737 
  """
6738 
  Attributes:
6739 
   - userId
6740 
  """
6741 
 
6742 
  thrift_spec = (
6743 
    None, # 0
6744 
    (1, TType.I64, 'userId', None, None, ), # 1
6745 
  )
6746 
 
6747 
  def __init__(self, userId=None,):
6748 
    self.userId = userId
6749 
 
6750 
  def read(self, iprot):
6751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6753 
      return
6754 
    iprot.readStructBegin()
6755 
    while True:
6756 
      (fname, ftype, fid) = iprot.readFieldBegin()
6757 
      if ftype == TType.STOP:
6758 
        break
6759 
      if fid == 1:
6760 
        if ftype == TType.I64:
6761 
          self.userId = iprot.readI64();
6762 
        else:
6763 
          iprot.skip(ftype)
6764 
      else:
6765 
        iprot.skip(ftype)
6766 
      iprot.readFieldEnd()
6767 
    iprot.readStructEnd()
6768 
 
6769 
  def write(self, oprot):
6770 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6771 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6772 
      return
6773 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
6774 
    if self.userId != None:
6775 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6776 
      oprot.writeI64(self.userId)
6777 
      oprot.writeFieldEnd()
6778 
    oprot.writeFieldStop()
6779 
    oprot.writeStructEnd()
6780 
 
6781 
  def __repr__(self):
6782 
    L = ['%s=%r' % (key, value)
6783 
      for key, value in self.__dict__.iteritems()]
6784 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6785 
 
6786 
  def __eq__(self, other):
6787 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6788 
 
6789 
  def __ne__(self, other):
6790 
    return not (self == other)
6791 
 
6792 
class getUserCommunicationByUser_result:
6793 
  """
6794 
  Attributes:
6795 
   - success
6796 
   - ucx
6797 
  """
6798 
 
6799 
  thrift_spec = (
6800 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
6801 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6802 
  )
6803 
 
6804 
  def __init__(self, success=None, ucx=None,):
6805 
    self.success = success
6806 
    self.ucx = ucx
6807 
 
6808 
  def read(self, iprot):
6809 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6810 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6811 
      return
6812 
    iprot.readStructBegin()
6813 
    while True:
6814 
      (fname, ftype, fid) = iprot.readFieldBegin()
6815 
      if ftype == TType.STOP:
6816 
        break
6817 
      if fid == 0:
6818 
        if ftype == TType.LIST:
6819 
          self.success = []
6820 
          (_etype38, _size35) = iprot.readListBegin()
6821 
          for _i39 in xrange(_size35):
6822 
            _elem40 = UserCommunication()
6823 
            _elem40.read(iprot)
6824 
            self.success.append(_elem40)
6825 
          iprot.readListEnd()
6826 
        else:
6827 
          iprot.skip(ftype)
6828 
      elif fid == 1:
6829 
        if ftype == TType.STRUCT:
6830 
          self.ucx = UserCommunicationException()
6831 
          self.ucx.read(iprot)
6832 
        else:
6833 
          iprot.skip(ftype)
6834 
      else:
6835 
        iprot.skip(ftype)
6836 
      iprot.readFieldEnd()
6837 
    iprot.readStructEnd()
6838 
 
6839 
  def write(self, oprot):
6840 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6841 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6842 
      return
6843 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
6844 
    if self.success != None:
6845 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6846 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6847 
      for iter41 in self.success:
6848 
        iter41.write(oprot)
6849 
      oprot.writeListEnd()
6850 
      oprot.writeFieldEnd()
6851 
    if self.ucx != None:
6852 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6853 
      self.ucx.write(oprot)
6854 
      oprot.writeFieldEnd()
6855 
    oprot.writeFieldStop()
6856 
    oprot.writeStructEnd()
6857 
 
6858 
  def __repr__(self):
6859 
    L = ['%s=%r' % (key, value)
6860 
      for key, value in self.__dict__.iteritems()]
6861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6862 
 
6863 
  def __eq__(self, other):
6864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6865 
 
6866 
  def __ne__(self, other):
6867 
    return not (self == other)
6868 
 
6869 
class getAllUserCommunications_args:
6870 
 
6871 
  thrift_spec = (
6872 
  )
6873 
 
6874 
  def read(self, iprot):
6875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6877 
      return
6878 
    iprot.readStructBegin()
6879 
    while True:
6880 
      (fname, ftype, fid) = iprot.readFieldBegin()
6881 
      if ftype == TType.STOP:
6882 
        break
6883 
      else:
6884 
        iprot.skip(ftype)
6885 
      iprot.readFieldEnd()
6886 
    iprot.readStructEnd()
6887 
 
6888 
  def write(self, oprot):
6889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6891 
      return
6892 
    oprot.writeStructBegin('getAllUserCommunications_args')
6893 
    oprot.writeFieldStop()
6894 
    oprot.writeStructEnd()
6895 
 
6896 
  def __repr__(self):
6897 
    L = ['%s=%r' % (key, value)
6898 
      for key, value in self.__dict__.iteritems()]
6899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6900 
 
6901 
  def __eq__(self, other):
6902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6903 
 
6904 
  def __ne__(self, other):
6905 
    return not (self == other)
6906 
 
6907 
class getAllUserCommunications_result:
6908 
  """
6909 
  Attributes:
6910 
   - success
6911 
   - ucx
6912 
  """
6913 
 
6914 
  thrift_spec = (
6915 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
6916 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6917 
  )
6918 
 
6919 
  def __init__(self, success=None, ucx=None,):
6920 
    self.success = success
6921 
    self.ucx = ucx
6922 
 
6923 
  def read(self, iprot):
6924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6926 
      return
6927 
    iprot.readStructBegin()
6928 
    while True:
6929 
      (fname, ftype, fid) = iprot.readFieldBegin()
6930 
      if ftype == TType.STOP:
6931 
        break
6932 
      if fid == 0:
6933 
        if ftype == TType.LIST:
6934 
          self.success = []
6935 
          (_etype45, _size42) = iprot.readListBegin()
6936 
          for _i46 in xrange(_size42):
6937 
            _elem47 = UserCommunication()
6938 
            _elem47.read(iprot)
6939 
            self.success.append(_elem47)
6940 
          iprot.readListEnd()
6941 
        else:
6942 
          iprot.skip(ftype)
6943 
      elif fid == 1:
6944 
        if ftype == TType.STRUCT:
6945 
          self.ucx = UserCommunicationException()
6946 
          self.ucx.read(iprot)
6947 
        else:
6948 
          iprot.skip(ftype)
6949 
      else:
6950 
        iprot.skip(ftype)
6951 
      iprot.readFieldEnd()
6952 
    iprot.readStructEnd()
6953 
 
6954 
  def write(self, oprot):
6955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6957 
      return
6958 
    oprot.writeStructBegin('getAllUserCommunications_result')
6959 
    if self.success != None:
6960 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6961 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6962 
      for iter48 in self.success:
6963 
        iter48.write(oprot)
6964 
      oprot.writeListEnd()
6965 
      oprot.writeFieldEnd()
6966 
    if self.ucx != None:
6967 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6968 
      self.ucx.write(oprot)
6969 
      oprot.writeFieldEnd()
6970 
    oprot.writeFieldStop()
6971 
    oprot.writeStructEnd()
6972 
 
6973 
  def __repr__(self):
6974 
    L = ['%s=%r' % (key, value)
6975 
      for key, value in self.__dict__.iteritems()]
6976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6977 
 
6978 
  def __eq__(self, other):
6979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6980 
 
6981 
  def __ne__(self, other):
6982 
    return not (self == other)
6983 
 
1845 vikas 6984 
class createMasterAffiliate_args:
6985 
  """
6986 
  Attributes:
6987 
   - name
1859 vikas 6988 
   - addedOn
1845 vikas 6989 
  """
6990 
 
6991 
  thrift_spec = (
6992 
    None, # 0
6993 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 6994 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 6995 
  )
6996 
 
1859 vikas 6997 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 6998 
    self.name = name
1859 vikas 6999 
    self.addedOn = addedOn
1845 vikas 7000 
 
7001 
  def read(self, iprot):
7002 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7003 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7004 
      return
7005 
    iprot.readStructBegin()
7006 
    while True:
7007 
      (fname, ftype, fid) = iprot.readFieldBegin()
7008 
      if ftype == TType.STOP:
7009 
        break
7010 
      if fid == 1:
7011 
        if ftype == TType.STRING:
7012 
          self.name = iprot.readString();
7013 
        else:
7014 
          iprot.skip(ftype)
1859 vikas 7015 
      elif fid == 2:
7016 
        if ftype == TType.I64:
7017 
          self.addedOn = iprot.readI64();
7018 
        else:
7019 
          iprot.skip(ftype)
1845 vikas 7020 
      else:
7021 
        iprot.skip(ftype)
7022 
      iprot.readFieldEnd()
7023 
    iprot.readStructEnd()
7024 
 
7025 
  def write(self, oprot):
7026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7028 
      return
7029 
    oprot.writeStructBegin('createMasterAffiliate_args')
7030 
    if self.name != None:
7031 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7032 
      oprot.writeString(self.name)
7033 
      oprot.writeFieldEnd()
1859 vikas 7034 
    if self.addedOn != None:
7035 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
7036 
      oprot.writeI64(self.addedOn)
7037 
      oprot.writeFieldEnd()
1845 vikas 7038 
    oprot.writeFieldStop()
7039 
    oprot.writeStructEnd()
7040 
 
7041 
  def __repr__(self):
7042 
    L = ['%s=%r' % (key, value)
7043 
      for key, value in self.__dict__.iteritems()]
7044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7045 
 
7046 
  def __eq__(self, other):
7047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7048 
 
7049 
  def __ne__(self, other):
7050 
    return not (self == other)
7051 
 
7052 
class createMasterAffiliate_result:
7053 
  """
7054 
  Attributes:
7055 
   - success
7056 
   - utx
7057 
  """
7058 
 
7059 
  thrift_spec = (
7060 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
7061 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7062 
  )
7063 
 
7064 
  def __init__(self, success=None, utx=None,):
7065 
    self.success = success
7066 
    self.utx = utx
7067 
 
7068 
  def read(self, iprot):
7069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7071 
      return
7072 
    iprot.readStructBegin()
7073 
    while True:
7074 
      (fname, ftype, fid) = iprot.readFieldBegin()
7075 
      if ftype == TType.STOP:
7076 
        break
7077 
      if fid == 0:
7078 
        if ftype == TType.STRUCT:
7079 
          self.success = MasterAffiliate()
7080 
          self.success.read(iprot)
7081 
        else:
7082 
          iprot.skip(ftype)
7083 
      elif fid == 1:
7084 
        if ftype == TType.STRUCT:
7085 
          self.utx = UserTrackerException()
7086 
          self.utx.read(iprot)
7087 
        else:
7088 
          iprot.skip(ftype)
7089 
      else:
7090 
        iprot.skip(ftype)
7091 
      iprot.readFieldEnd()
7092 
    iprot.readStructEnd()
7093 
 
7094 
  def write(self, oprot):
7095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7097 
      return
7098 
    oprot.writeStructBegin('createMasterAffiliate_result')
7099 
    if self.success != None:
7100 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7101 
      self.success.write(oprot)
7102 
      oprot.writeFieldEnd()
7103 
    if self.utx != None:
7104 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7105 
      self.utx.write(oprot)
7106 
      oprot.writeFieldEnd()
7107 
    oprot.writeFieldStop()
7108 
    oprot.writeStructEnd()
7109 
 
7110 
  def __repr__(self):
7111 
    L = ['%s=%r' % (key, value)
7112 
      for key, value in self.__dict__.iteritems()]
7113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7114 
 
7115 
  def __eq__(self, other):
7116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7117 
 
7118 
  def __ne__(self, other):
7119 
    return not (self == other)
7120 
 
7121 
class getMasterAffiliateById_args:
7122 
  """
7123 
  Attributes:
7124 
   - id
7125 
  """
7126 
 
7127 
  thrift_spec = (
7128 
    None, # 0
7129 
    (1, TType.I64, 'id', None, None, ), # 1
7130 
  )
7131 
 
7132 
  def __init__(self, id=None,):
7133 
    self.id = id
7134 
 
7135 
  def read(self, iprot):
7136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7138 
      return
7139 
    iprot.readStructBegin()
7140 
    while True:
7141 
      (fname, ftype, fid) = iprot.readFieldBegin()
7142 
      if ftype == TType.STOP:
7143 
        break
7144 
      if fid == 1:
7145 
        if ftype == TType.I64:
7146 
          self.id = iprot.readI64();
7147 
        else:
7148 
          iprot.skip(ftype)
7149 
      else:
7150 
        iprot.skip(ftype)
7151 
      iprot.readFieldEnd()
7152 
    iprot.readStructEnd()
7153 
 
7154 
  def write(self, oprot):
7155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7157 
      return
7158 
    oprot.writeStructBegin('getMasterAffiliateById_args')
7159 
    if self.id != None:
7160 
      oprot.writeFieldBegin('id', TType.I64, 1)
7161 
      oprot.writeI64(self.id)
7162 
      oprot.writeFieldEnd()
7163 
    oprot.writeFieldStop()
7164 
    oprot.writeStructEnd()
7165 
 
7166 
  def __repr__(self):
7167 
    L = ['%s=%r' % (key, value)
7168 
      for key, value in self.__dict__.iteritems()]
7169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7170 
 
7171 
  def __eq__(self, other):
7172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7173 
 
7174 
  def __ne__(self, other):
7175 
    return not (self == other)
7176 
 
7177 
class getMasterAffiliateById_result:
7178 
  """
7179 
  Attributes:
7180 
   - success
7181 
   - utx
7182 
  """
7183 
 
7184 
  thrift_spec = (
7185 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
7186 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7187 
  )
7188 
 
7189 
  def __init__(self, success=None, utx=None,):
7190 
    self.success = success
7191 
    self.utx = utx
7192 
 
7193 
  def read(self, iprot):
7194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7196 
      return
7197 
    iprot.readStructBegin()
7198 
    while True:
7199 
      (fname, ftype, fid) = iprot.readFieldBegin()
7200 
      if ftype == TType.STOP:
7201 
        break
7202 
      if fid == 0:
7203 
        if ftype == TType.STRUCT:
7204 
          self.success = MasterAffiliate()
7205 
          self.success.read(iprot)
7206 
        else:
7207 
          iprot.skip(ftype)
7208 
      elif fid == 1:
7209 
        if ftype == TType.STRUCT:
7210 
          self.utx = UserTrackerException()
7211 
          self.utx.read(iprot)
7212 
        else:
7213 
          iprot.skip(ftype)
7214 
      else:
7215 
        iprot.skip(ftype)
7216 
      iprot.readFieldEnd()
7217 
    iprot.readStructEnd()
7218 
 
7219 
  def write(self, oprot):
7220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7222 
      return
7223 
    oprot.writeStructBegin('getMasterAffiliateById_result')
7224 
    if self.success != None:
7225 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7226 
      self.success.write(oprot)
7227 
      oprot.writeFieldEnd()
7228 
    if self.utx != None:
7229 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7230 
      self.utx.write(oprot)
7231 
      oprot.writeFieldEnd()
7232 
    oprot.writeFieldStop()
7233 
    oprot.writeStructEnd()
7234 
 
7235 
  def __repr__(self):
7236 
    L = ['%s=%r' % (key, value)
7237 
      for key, value in self.__dict__.iteritems()]
7238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7239 
 
7240 
  def __eq__(self, other):
7241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7242 
 
7243 
  def __ne__(self, other):
7244 
    return not (self == other)
7245 
 
7246 
class getMasterAffiliateByName_args:
7247 
  """
7248 
  Attributes:
7249 
   - name
7250 
  """
7251 
 
7252 
  thrift_spec = (
7253 
    None, # 0
7254 
    (1, TType.STRING, 'name', None, None, ), # 1
7255 
  )
7256 
 
7257 
  def __init__(self, name=None,):
7258 
    self.name = name
7259 
 
7260 
  def read(self, iprot):
7261 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7262 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7263 
      return
7264 
    iprot.readStructBegin()
7265 
    while True:
7266 
      (fname, ftype, fid) = iprot.readFieldBegin()
7267 
      if ftype == TType.STOP:
7268 
        break
7269 
      if fid == 1:
7270 
        if ftype == TType.STRING:
7271 
          self.name = iprot.readString();
7272 
        else:
7273 
          iprot.skip(ftype)
7274 
      else:
7275 
        iprot.skip(ftype)
7276 
      iprot.readFieldEnd()
7277 
    iprot.readStructEnd()
7278 
 
7279 
  def write(self, oprot):
7280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7282 
      return
7283 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
7284 
    if self.name != None:
7285 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7286 
      oprot.writeString(self.name)
7287 
      oprot.writeFieldEnd()
7288 
    oprot.writeFieldStop()
7289 
    oprot.writeStructEnd()
7290 
 
7291 
  def __repr__(self):
7292 
    L = ['%s=%r' % (key, value)
7293 
      for key, value in self.__dict__.iteritems()]
7294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7295 
 
7296 
  def __eq__(self, other):
7297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7298 
 
7299 
  def __ne__(self, other):
7300 
    return not (self == other)
7301 
 
7302 
class getMasterAffiliateByName_result:
7303 
  """
7304 
  Attributes:
7305 
   - success
7306 
   - utx
7307 
  """
7308 
 
7309 
  thrift_spec = (
7310 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
7311 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7312 
  )
7313 
 
7314 
  def __init__(self, success=None, utx=None,):
7315 
    self.success = success
7316 
    self.utx = utx
7317 
 
7318 
  def read(self, iprot):
7319 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7320 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7321 
      return
7322 
    iprot.readStructBegin()
7323 
    while True:
7324 
      (fname, ftype, fid) = iprot.readFieldBegin()
7325 
      if ftype == TType.STOP:
7326 
        break
7327 
      if fid == 0:
7328 
        if ftype == TType.STRUCT:
7329 
          self.success = MasterAffiliate()
7330 
          self.success.read(iprot)
7331 
        else:
7332 
          iprot.skip(ftype)
7333 
      elif fid == 1:
7334 
        if ftype == TType.STRUCT:
7335 
          self.utx = UserTrackerException()
7336 
          self.utx.read(iprot)
7337 
        else:
7338 
          iprot.skip(ftype)
7339 
      else:
7340 
        iprot.skip(ftype)
7341 
      iprot.readFieldEnd()
7342 
    iprot.readStructEnd()
7343 
 
7344 
  def write(self, oprot):
7345 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7346 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7347 
      return
7348 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
7349 
    if self.success != None:
7350 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7351 
      self.success.write(oprot)
7352 
      oprot.writeFieldEnd()
7353 
    if self.utx != None:
7354 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7355 
      self.utx.write(oprot)
7356 
      oprot.writeFieldEnd()
7357 
    oprot.writeFieldStop()
7358 
    oprot.writeStructEnd()
7359 
 
7360 
  def __repr__(self):
7361 
    L = ['%s=%r' % (key, value)
7362 
      for key, value in self.__dict__.iteritems()]
7363 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7364 
 
7365 
  def __eq__(self, other):
7366 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7367 
 
7368 
  def __ne__(self, other):
7369 
    return not (self == other)
7370 
 
7371 
class createAffiliate_args:
7372 
  """
7373 
  Attributes:
7374 
   - name
7375 
   - url
7376 
   - masterAffiliateId
1859 vikas 7377 
   - addedOn
1845 vikas 7378 
  """
7379 
 
7380 
  thrift_spec = (
7381 
    None, # 0
7382 
    (1, TType.STRING, 'name', None, None, ), # 1
7383 
    (2, TType.STRING, 'url', None, None, ), # 2
7384 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 7385 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 7386 
  )
7387 
 
1859 vikas 7388 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 7389 
    self.name = name
7390 
    self.url = url
7391 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 7392 
    self.addedOn = addedOn
1845 vikas 7393 
 
7394 
  def read(self, iprot):
7395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7397 
      return
7398 
    iprot.readStructBegin()
7399 
    while True:
7400 
      (fname, ftype, fid) = iprot.readFieldBegin()
7401 
      if ftype == TType.STOP:
7402 
        break
7403 
      if fid == 1:
7404 
        if ftype == TType.STRING:
7405 
          self.name = iprot.readString();
7406 
        else:
7407 
          iprot.skip(ftype)
7408 
      elif fid == 2:
7409 
        if ftype == TType.STRING:
7410 
          self.url = iprot.readString();
7411 
        else:
7412 
          iprot.skip(ftype)
7413 
      elif fid == 3:
7414 
        if ftype == TType.I64:
7415 
          self.masterAffiliateId = iprot.readI64();
7416 
        else:
7417 
          iprot.skip(ftype)
1859 vikas 7418 
      elif fid == 4:
7419 
        if ftype == TType.I64:
7420 
          self.addedOn = iprot.readI64();
7421 
        else:
7422 
          iprot.skip(ftype)
1845 vikas 7423 
      else:
7424 
        iprot.skip(ftype)
7425 
      iprot.readFieldEnd()
7426 
    iprot.readStructEnd()
7427 
 
7428 
  def write(self, oprot):
7429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7431 
      return
7432 
    oprot.writeStructBegin('createAffiliate_args')
7433 
    if self.name != None:
7434 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7435 
      oprot.writeString(self.name)
7436 
      oprot.writeFieldEnd()
7437 
    if self.url != None:
7438 
      oprot.writeFieldBegin('url', TType.STRING, 2)
7439 
      oprot.writeString(self.url)
7440 
      oprot.writeFieldEnd()
7441 
    if self.masterAffiliateId != None:
7442 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
7443 
      oprot.writeI64(self.masterAffiliateId)
7444 
      oprot.writeFieldEnd()
1859 vikas 7445 
    if self.addedOn != None:
7446 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
7447 
      oprot.writeI64(self.addedOn)
7448 
      oprot.writeFieldEnd()
1845 vikas 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 createAffiliate_result:
7464 
  """
7465 
  Attributes:
7466 
   - success
7467 
   - utx
7468 
  """
7469 
 
7470 
  thrift_spec = (
7471 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
7472 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
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 = Affiliate()
7491 
          self.success.read(iprot)
7492 
        else:
7493 
          iprot.skip(ftype)
7494 
      elif fid == 1:
7495 
        if ftype == TType.STRUCT:
7496 
          self.utx = UserTrackerException()
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('createAffiliate_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 getAffiliateById_args:
7533 
  """
7534 
  Attributes:
7535 
   - id
7536 
  """
7537 
 
7538 
  thrift_spec = (
7539 
    None, # 0
7540 
    (1, TType.I64, 'id', None, None, ), # 1
7541 
  )
7542 
 
7543 
  def __init__(self, id=None,):
7544 
    self.id = id
7545 
 
7546 
  def read(self, iprot):
7547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7549 
      return
7550 
    iprot.readStructBegin()
7551 
    while True:
7552 
      (fname, ftype, fid) = iprot.readFieldBegin()
7553 
      if ftype == TType.STOP:
7554 
        break
7555 
      if fid == 1:
7556 
        if ftype == TType.I64:
7557 
          self.id = iprot.readI64();
7558 
        else:
7559 
          iprot.skip(ftype)
7560 
      else:
7561 
        iprot.skip(ftype)
7562 
      iprot.readFieldEnd()
7563 
    iprot.readStructEnd()
7564 
 
7565 
  def write(self, oprot):
7566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7568 
      return
7569 
    oprot.writeStructBegin('getAffiliateById_args')
7570 
    if self.id != None:
7571 
      oprot.writeFieldBegin('id', TType.I64, 1)
7572 
      oprot.writeI64(self.id)
7573 
      oprot.writeFieldEnd()
7574 
    oprot.writeFieldStop()
7575 
    oprot.writeStructEnd()
7576 
 
7577 
  def __repr__(self):
7578 
    L = ['%s=%r' % (key, value)
7579 
      for key, value in self.__dict__.iteritems()]
7580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7581 
 
7582 
  def __eq__(self, other):
7583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7584 
 
7585 
  def __ne__(self, other):
7586 
    return not (self == other)
7587 
 
7588 
class getAffiliateById_result:
7589 
  """
7590 
  Attributes:
7591 
   - success
7592 
   - utx
7593 
  """
7594 
 
7595 
  thrift_spec = (
7596 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
7597 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7598 
  )
7599 
 
7600 
  def __init__(self, success=None, utx=None,):
7601 
    self.success = success
7602 
    self.utx = utx
7603 
 
7604 
  def read(self, iprot):
7605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7607 
      return
7608 
    iprot.readStructBegin()
7609 
    while True:
7610 
      (fname, ftype, fid) = iprot.readFieldBegin()
7611 
      if ftype == TType.STOP:
7612 
        break
7613 
      if fid == 0:
7614 
        if ftype == TType.STRUCT:
7615 
          self.success = Affiliate()
7616 
          self.success.read(iprot)
7617 
        else:
7618 
          iprot.skip(ftype)
7619 
      elif fid == 1:
7620 
        if ftype == TType.STRUCT:
7621 
          self.utx = UserTrackerException()
7622 
          self.utx.read(iprot)
7623 
        else:
7624 
          iprot.skip(ftype)
7625 
      else:
7626 
        iprot.skip(ftype)
7627 
      iprot.readFieldEnd()
7628 
    iprot.readStructEnd()
7629 
 
7630 
  def write(self, oprot):
7631 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7632 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7633 
      return
7634 
    oprot.writeStructBegin('getAffiliateById_result')
7635 
    if self.success != None:
7636 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7637 
      self.success.write(oprot)
7638 
      oprot.writeFieldEnd()
7639 
    if self.utx != None:
7640 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7641 
      self.utx.write(oprot)
7642 
      oprot.writeFieldEnd()
7643 
    oprot.writeFieldStop()
7644 
    oprot.writeStructEnd()
7645 
 
7646 
  def __repr__(self):
7647 
    L = ['%s=%r' % (key, value)
7648 
      for key, value in self.__dict__.iteritems()]
7649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7650 
 
7651 
  def __eq__(self, other):
7652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7653 
 
7654 
  def __ne__(self, other):
7655 
    return not (self == other)
7656 
 
7657 
class getAffiliateByName_args:
7658 
  """
7659 
  Attributes:
7660 
   - name
7661 
  """
7662 
 
7663 
  thrift_spec = (
7664 
    None, # 0
7665 
    (1, TType.STRING, 'name', None, None, ), # 1
7666 
  )
7667 
 
7668 
  def __init__(self, name=None,):
7669 
    self.name = name
7670 
 
7671 
  def read(self, iprot):
7672 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7673 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7674 
      return
7675 
    iprot.readStructBegin()
7676 
    while True:
7677 
      (fname, ftype, fid) = iprot.readFieldBegin()
7678 
      if ftype == TType.STOP:
7679 
        break
7680 
      if fid == 1:
7681 
        if ftype == TType.STRING:
7682 
          self.name = iprot.readString();
7683 
        else:
7684 
          iprot.skip(ftype)
7685 
      else:
7686 
        iprot.skip(ftype)
7687 
      iprot.readFieldEnd()
7688 
    iprot.readStructEnd()
7689 
 
7690 
  def write(self, oprot):
7691 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7692 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7693 
      return
7694 
    oprot.writeStructBegin('getAffiliateByName_args')
7695 
    if self.name != None:
7696 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7697 
      oprot.writeString(self.name)
7698 
      oprot.writeFieldEnd()
7699 
    oprot.writeFieldStop()
7700 
    oprot.writeStructEnd()
7701 
 
7702 
  def __repr__(self):
7703 
    L = ['%s=%r' % (key, value)
7704 
      for key, value in self.__dict__.iteritems()]
7705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7706 
 
7707 
  def __eq__(self, other):
7708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7709 
 
7710 
  def __ne__(self, other):
7711 
    return not (self == other)
7712 
 
7713 
class getAffiliateByName_result:
7714 
  """
7715 
  Attributes:
7716 
   - success
7717 
   - utx
7718 
  """
7719 
 
7720 
  thrift_spec = (
7721 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
7722 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7723 
  )
7724 
 
7725 
  def __init__(self, success=None, utx=None,):
7726 
    self.success = success
7727 
    self.utx = utx
7728 
 
7729 
  def read(self, iprot):
7730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7732 
      return
7733 
    iprot.readStructBegin()
7734 
    while True:
7735 
      (fname, ftype, fid) = iprot.readFieldBegin()
7736 
      if ftype == TType.STOP:
7737 
        break
7738 
      if fid == 0:
7739 
        if ftype == TType.STRUCT:
7740 
          self.success = Affiliate()
7741 
          self.success.read(iprot)
7742 
        else:
7743 
          iprot.skip(ftype)
7744 
      elif fid == 1:
7745 
        if ftype == TType.STRUCT:
7746 
          self.utx = UserTrackerException()
7747 
          self.utx.read(iprot)
7748 
        else:
7749 
          iprot.skip(ftype)
7750 
      else:
7751 
        iprot.skip(ftype)
7752 
      iprot.readFieldEnd()
7753 
    iprot.readStructEnd()
7754 
 
7755 
  def write(self, oprot):
7756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7758 
      return
7759 
    oprot.writeStructBegin('getAffiliateByName_result')
7760 
    if self.success != None:
7761 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7762 
      self.success.write(oprot)
7763 
      oprot.writeFieldEnd()
7764 
    if self.utx != None:
7765 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7766 
      self.utx.write(oprot)
7767 
      oprot.writeFieldEnd()
7768 
    oprot.writeFieldStop()
7769 
    oprot.writeStructEnd()
7770 
 
7771 
  def __repr__(self):
7772 
    L = ['%s=%r' % (key, value)
7773 
      for key, value in self.__dict__.iteritems()]
7774 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7775 
 
7776 
  def __eq__(self, other):
7777 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7778 
 
7779 
  def __ne__(self, other):
7780 
    return not (self == other)
7781 
 
7782 
class getAffiliatesByMasterAffiliate_args:
7783 
  """
7784 
  Attributes:
7785 
   - id
7786 
  """
7787 
 
7788 
  thrift_spec = (
7789 
    None, # 0
7790 
    (1, TType.I64, 'id', None, None, ), # 1
7791 
  )
7792 
 
7793 
  def __init__(self, id=None,):
7794 
    self.id = id
7795 
 
7796 
  def read(self, iprot):
7797 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7798 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7799 
      return
7800 
    iprot.readStructBegin()
7801 
    while True:
7802 
      (fname, ftype, fid) = iprot.readFieldBegin()
7803 
      if ftype == TType.STOP:
7804 
        break
7805 
      if fid == 1:
7806 
        if ftype == TType.I64:
7807 
          self.id = iprot.readI64();
7808 
        else:
7809 
          iprot.skip(ftype)
7810 
      else:
7811 
        iprot.skip(ftype)
7812 
      iprot.readFieldEnd()
7813 
    iprot.readStructEnd()
7814 
 
7815 
  def write(self, oprot):
7816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7818 
      return
7819 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
7820 
    if self.id != None:
7821 
      oprot.writeFieldBegin('id', TType.I64, 1)
7822 
      oprot.writeI64(self.id)
7823 
      oprot.writeFieldEnd()
7824 
    oprot.writeFieldStop()
7825 
    oprot.writeStructEnd()
7826 
 
7827 
  def __repr__(self):
7828 
    L = ['%s=%r' % (key, value)
7829 
      for key, value in self.__dict__.iteritems()]
7830 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7831 
 
7832 
  def __eq__(self, other):
7833 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7834 
 
7835 
  def __ne__(self, other):
7836 
    return not (self == other)
7837 
 
7838 
class getAffiliatesByMasterAffiliate_result:
7839 
  """
7840 
  Attributes:
7841 
   - success
7842 
   - utx
7843 
  """
7844 
 
7845 
  thrift_spec = (
7846 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
7847 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7848 
  )
7849 
 
7850 
  def __init__(self, success=None, utx=None,):
7851 
    self.success = success
7852 
    self.utx = utx
7853 
 
7854 
  def read(self, iprot):
7855 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7856 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7857 
      return
7858 
    iprot.readStructBegin()
7859 
    while True:
7860 
      (fname, ftype, fid) = iprot.readFieldBegin()
7861 
      if ftype == TType.STOP:
7862 
        break
7863 
      if fid == 0:
7864 
        if ftype == TType.LIST:
7865 
          self.success = []
7866 
          (_etype52, _size49) = iprot.readListBegin()
7867 
          for _i53 in xrange(_size49):
7868 
            _elem54 = Affiliate()
7869 
            _elem54.read(iprot)
7870 
            self.success.append(_elem54)
7871 
          iprot.readListEnd()
7872 
        else:
7873 
          iprot.skip(ftype)
7874 
      elif fid == 1:
7875 
        if ftype == TType.STRUCT:
7876 
          self.utx = UserTrackerException()
7877 
          self.utx.read(iprot)
7878 
        else:
7879 
          iprot.skip(ftype)
7880 
      else:
7881 
        iprot.skip(ftype)
7882 
      iprot.readFieldEnd()
7883 
    iprot.readStructEnd()
7884 
 
7885 
  def write(self, oprot):
7886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7888 
      return
7889 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
7890 
    if self.success != None:
7891 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7892 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7893 
      for iter55 in self.success:
7894 
        iter55.write(oprot)
7895 
      oprot.writeListEnd()
7896 
      oprot.writeFieldEnd()
7897 
    if self.utx != None:
7898 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7899 
      self.utx.write(oprot)
7900 
      oprot.writeFieldEnd()
7901 
    oprot.writeFieldStop()
7902 
    oprot.writeStructEnd()
7903 
 
7904 
  def __repr__(self):
7905 
    L = ['%s=%r' % (key, value)
7906 
      for key, value in self.__dict__.iteritems()]
7907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7908 
 
7909 
  def __eq__(self, other):
7910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7911 
 
7912 
  def __ne__(self, other):
7913 
    return not (self == other)
7914 
 
7915 
class createTracker_args:
7916 
  """
7917 
  Attributes:
7918 
   - affiliateId
1859 vikas 7919 
   - addedOn
1845 vikas 7920 
  """
7921 
 
7922 
  thrift_spec = (
7923 
    None, # 0
7924 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1859 vikas 7925 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 7926 
  )
7927 
 
1859 vikas 7928 
  def __init__(self, affiliateId=None, addedOn=None,):
1845 vikas 7929 
    self.affiliateId = affiliateId
1859 vikas 7930 
    self.addedOn = addedOn
1845 vikas 7931 
 
7932 
  def read(self, iprot):
7933 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7934 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7935 
      return
7936 
    iprot.readStructBegin()
7937 
    while True:
7938 
      (fname, ftype, fid) = iprot.readFieldBegin()
7939 
      if ftype == TType.STOP:
7940 
        break
7941 
      if fid == 1:
7942 
        if ftype == TType.I64:
7943 
          self.affiliateId = iprot.readI64();
7944 
        else:
7945 
          iprot.skip(ftype)
1859 vikas 7946 
      elif fid == 2:
7947 
        if ftype == TType.I64:
7948 
          self.addedOn = iprot.readI64();
7949 
        else:
7950 
          iprot.skip(ftype)
1845 vikas 7951 
      else:
7952 
        iprot.skip(ftype)
7953 
      iprot.readFieldEnd()
7954 
    iprot.readStructEnd()
7955 
 
7956 
  def write(self, oprot):
7957 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7958 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7959 
      return
7960 
    oprot.writeStructBegin('createTracker_args')
7961 
    if self.affiliateId != None:
7962 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
7963 
      oprot.writeI64(self.affiliateId)
7964 
      oprot.writeFieldEnd()
1859 vikas 7965 
    if self.addedOn != None:
7966 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
7967 
      oprot.writeI64(self.addedOn)
7968 
      oprot.writeFieldEnd()
1845 vikas 7969 
    oprot.writeFieldStop()
7970 
    oprot.writeStructEnd()
7971 
 
7972 
  def __repr__(self):
7973 
    L = ['%s=%r' % (key, value)
7974 
      for key, value in self.__dict__.iteritems()]
7975 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7976 
 
7977 
  def __eq__(self, other):
7978 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7979 
 
7980 
  def __ne__(self, other):
7981 
    return not (self == other)
7982 
 
7983 
class createTracker_result:
7984 
  """
7985 
  Attributes:
7986 
   - success
7987 
   - utx
7988 
  """
7989 
 
7990 
  thrift_spec = (
7991 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
7992 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7993 
  )
7994 
 
7995 
  def __init__(self, success=None, utx=None,):
7996 
    self.success = success
7997 
    self.utx = utx
7998 
 
7999 
  def read(self, iprot):
8000 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8001 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8002 
      return
8003 
    iprot.readStructBegin()
8004 
    while True:
8005 
      (fname, ftype, fid) = iprot.readFieldBegin()
8006 
      if ftype == TType.STOP:
8007 
        break
8008 
      if fid == 0:
8009 
        if ftype == TType.STRUCT:
8010 
          self.success = Tracker()
8011 
          self.success.read(iprot)
8012 
        else:
8013 
          iprot.skip(ftype)
8014 
      elif fid == 1:
8015 
        if ftype == TType.STRUCT:
8016 
          self.utx = UserTrackerException()
8017 
          self.utx.read(iprot)
8018 
        else:
8019 
          iprot.skip(ftype)
8020 
      else:
8021 
        iprot.skip(ftype)
8022 
      iprot.readFieldEnd()
8023 
    iprot.readStructEnd()
8024 
 
8025 
  def write(self, oprot):
8026 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8027 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8028 
      return
8029 
    oprot.writeStructBegin('createTracker_result')
8030 
    if self.success != None:
8031 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8032 
      self.success.write(oprot)
8033 
      oprot.writeFieldEnd()
8034 
    if self.utx != None:
8035 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8036 
      self.utx.write(oprot)
8037 
      oprot.writeFieldEnd()
8038 
    oprot.writeFieldStop()
8039 
    oprot.writeStructEnd()
8040 
 
8041 
  def __repr__(self):
8042 
    L = ['%s=%r' % (key, value)
8043 
      for key, value in self.__dict__.iteritems()]
8044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8045 
 
8046 
  def __eq__(self, other):
8047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8048 
 
8049 
  def __ne__(self, other):
8050 
    return not (self == other)
8051 
 
8052 
class getTrackerById_args:
8053 
  """
8054 
  Attributes:
8055 
   - trackerId
8056 
  """
8057 
 
8058 
  thrift_spec = (
8059 
    None, # 0
8060 
    (1, TType.I64, 'trackerId', None, None, ), # 1
8061 
  )
8062 
 
8063 
  def __init__(self, trackerId=None,):
8064 
    self.trackerId = trackerId
8065 
 
8066 
  def read(self, iprot):
8067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8069 
      return
8070 
    iprot.readStructBegin()
8071 
    while True:
8072 
      (fname, ftype, fid) = iprot.readFieldBegin()
8073 
      if ftype == TType.STOP:
8074 
        break
8075 
      if fid == 1:
8076 
        if ftype == TType.I64:
8077 
          self.trackerId = iprot.readI64();
8078 
        else:
8079 
          iprot.skip(ftype)
8080 
      else:
8081 
        iprot.skip(ftype)
8082 
      iprot.readFieldEnd()
8083 
    iprot.readStructEnd()
8084 
 
8085 
  def write(self, oprot):
8086 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8087 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8088 
      return
8089 
    oprot.writeStructBegin('getTrackerById_args')
8090 
    if self.trackerId != None:
8091 
      oprot.writeFieldBegin('trackerId', TType.I64, 1)
8092 
      oprot.writeI64(self.trackerId)
8093 
      oprot.writeFieldEnd()
8094 
    oprot.writeFieldStop()
8095 
    oprot.writeStructEnd()
8096 
 
8097 
  def __repr__(self):
8098 
    L = ['%s=%r' % (key, value)
8099 
      for key, value in self.__dict__.iteritems()]
8100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8101 
 
8102 
  def __eq__(self, other):
8103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8104 
 
8105 
  def __ne__(self, other):
8106 
    return not (self == other)
8107 
 
8108 
class getTrackerById_result:
8109 
  """
8110 
  Attributes:
8111 
   - success
8112 
   - utx
8113 
  """
8114 
 
8115 
  thrift_spec = (
8116 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
8117 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8118 
  )
8119 
 
8120 
  def __init__(self, success=None, utx=None,):
8121 
    self.success = success
8122 
    self.utx = utx
8123 
 
8124 
  def read(self, iprot):
8125 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8126 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8127 
      return
8128 
    iprot.readStructBegin()
8129 
    while True:
8130 
      (fname, ftype, fid) = iprot.readFieldBegin()
8131 
      if ftype == TType.STOP:
8132 
        break
8133 
      if fid == 0:
8134 
        if ftype == TType.STRUCT:
8135 
          self.success = Tracker()
8136 
          self.success.read(iprot)
8137 
        else:
8138 
          iprot.skip(ftype)
8139 
      elif fid == 1:
8140 
        if ftype == TType.STRUCT:
8141 
          self.utx = UserTrackerException()
8142 
          self.utx.read(iprot)
8143 
        else:
8144 
          iprot.skip(ftype)
8145 
      else:
8146 
        iprot.skip(ftype)
8147 
      iprot.readFieldEnd()
8148 
    iprot.readStructEnd()
8149 
 
8150 
  def write(self, oprot):
8151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8153 
      return
8154 
    oprot.writeStructBegin('getTrackerById_result')
8155 
    if self.success != None:
8156 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8157 
      self.success.write(oprot)
8158 
      oprot.writeFieldEnd()
8159 
    if self.utx != None:
8160 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8161 
      self.utx.write(oprot)
8162 
      oprot.writeFieldEnd()
8163 
    oprot.writeFieldStop()
8164 
    oprot.writeStructEnd()
8165 
 
8166 
  def __repr__(self):
8167 
    L = ['%s=%r' % (key, value)
8168 
      for key, value in self.__dict__.iteritems()]
8169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8170 
 
8171 
  def __eq__(self, other):
8172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8173 
 
8174 
  def __ne__(self, other):
8175 
    return not (self == other)
8176 
 
8177 
class getTrackersByAffiliate_args:
8178 
  """
8179 
  Attributes:
8180 
   - affiliateId
8181 
  """
8182 
 
8183 
  thrift_spec = (
8184 
    None, # 0
8185 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
8186 
  )
8187 
 
8188 
  def __init__(self, affiliateId=None,):
8189 
    self.affiliateId = affiliateId
8190 
 
8191 
  def read(self, iprot):
8192 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8193 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8194 
      return
8195 
    iprot.readStructBegin()
8196 
    while True:
8197 
      (fname, ftype, fid) = iprot.readFieldBegin()
8198 
      if ftype == TType.STOP:
8199 
        break
8200 
      if fid == 1:
8201 
        if ftype == TType.I64:
8202 
          self.affiliateId = iprot.readI64();
8203 
        else:
8204 
          iprot.skip(ftype)
8205 
      else:
8206 
        iprot.skip(ftype)
8207 
      iprot.readFieldEnd()
8208 
    iprot.readStructEnd()
8209 
 
8210 
  def write(self, oprot):
8211 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8212 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8213 
      return
8214 
    oprot.writeStructBegin('getTrackersByAffiliate_args')
8215 
    if self.affiliateId != None:
8216 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
8217 
      oprot.writeI64(self.affiliateId)
8218 
      oprot.writeFieldEnd()
8219 
    oprot.writeFieldStop()
8220 
    oprot.writeStructEnd()
8221 
 
8222 
  def __repr__(self):
8223 
    L = ['%s=%r' % (key, value)
8224 
      for key, value in self.__dict__.iteritems()]
8225 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8226 
 
8227 
  def __eq__(self, other):
8228 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8229 
 
8230 
  def __ne__(self, other):
8231 
    return not (self == other)
8232 
 
8233 
class getTrackersByAffiliate_result:
8234 
  """
8235 
  Attributes:
8236 
   - success
8237 
   - utx
8238 
  """
8239 
 
8240 
  thrift_spec = (
8241 
    (0, TType.LIST, 'success', (TType.STRUCT,(Tracker, Tracker.thrift_spec)), None, ), # 0
8242 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8243 
  )
8244 
 
8245 
  def __init__(self, success=None, utx=None,):
8246 
    self.success = success
8247 
    self.utx = utx
8248 
 
8249 
  def read(self, iprot):
8250 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8251 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8252 
      return
8253 
    iprot.readStructBegin()
8254 
    while True:
8255 
      (fname, ftype, fid) = iprot.readFieldBegin()
8256 
      if ftype == TType.STOP:
8257 
        break
8258 
      if fid == 0:
8259 
        if ftype == TType.LIST:
8260 
          self.success = []
8261 
          (_etype59, _size56) = iprot.readListBegin()
8262 
          for _i60 in xrange(_size56):
8263 
            _elem61 = Tracker()
8264 
            _elem61.read(iprot)
8265 
            self.success.append(_elem61)
8266 
          iprot.readListEnd()
8267 
        else:
8268 
          iprot.skip(ftype)
8269 
      elif fid == 1:
8270 
        if ftype == TType.STRUCT:
8271 
          self.utx = UserTrackerException()
8272 
          self.utx.read(iprot)
8273 
        else:
8274 
          iprot.skip(ftype)
8275 
      else:
8276 
        iprot.skip(ftype)
8277 
      iprot.readFieldEnd()
8278 
    iprot.readStructEnd()
8279 
 
8280 
  def write(self, oprot):
8281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8283 
      return
8284 
    oprot.writeStructBegin('getTrackersByAffiliate_result')
8285 
    if self.success != None:
8286 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8287 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8288 
      for iter62 in self.success:
8289 
        iter62.write(oprot)
8290 
      oprot.writeListEnd()
8291 
      oprot.writeFieldEnd()
8292 
    if self.utx != None:
8293 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8294 
      self.utx.write(oprot)
8295 
      oprot.writeFieldEnd()
8296 
    oprot.writeFieldStop()
8297 
    oprot.writeStructEnd()
8298 
 
8299 
  def __repr__(self):
8300 
    L = ['%s=%r' % (key, value)
8301 
      for key, value in self.__dict__.iteritems()]
8302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8303 
 
8304 
  def __eq__(self, other):
8305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8306 
 
8307 
  def __ne__(self, other):
8308 
    return not (self == other)
8309 
 
8310 
class addTrackLog_args:
8311 
  """
8312 
  Attributes:
8313 
   - trackerId
8314 
   - userId
8315 
   - event
8316 
   - url
8317 
   - data
1859 vikas 8318 
   - addedOn
1845 vikas 8319 
  """
8320 
 
8321 
  thrift_spec = (
8322 
    None, # 0
8323 
    (1, TType.I64, 'trackerId', None, None, ), # 1
8324 
    (2, TType.I64, 'userId', None, None, ), # 2
8325 
    (3, TType.STRING, 'event', None, None, ), # 3
8326 
    (4, TType.STRING, 'url', None, None, ), # 4
8327 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 8328 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 8329 
  )
8330 
 
1859 vikas 8331 
  def __init__(self, trackerId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
1845 vikas 8332 
    self.trackerId = trackerId
8333 
    self.userId = userId
8334 
    self.event = event
8335 
    self.url = url
8336 
    self.data = data
1859 vikas 8337 
    self.addedOn = addedOn
1845 vikas 8338 
 
8339 
  def read(self, iprot):
8340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8342 
      return
8343 
    iprot.readStructBegin()
8344 
    while True:
8345 
      (fname, ftype, fid) = iprot.readFieldBegin()
8346 
      if ftype == TType.STOP:
8347 
        break
8348 
      if fid == 1:
8349 
        if ftype == TType.I64:
8350 
          self.trackerId = iprot.readI64();
8351 
        else:
8352 
          iprot.skip(ftype)
8353 
      elif fid == 2:
8354 
        if ftype == TType.I64:
8355 
          self.userId = iprot.readI64();
8356 
        else:
8357 
          iprot.skip(ftype)
8358 
      elif fid == 3:
8359 
        if ftype == TType.STRING:
8360 
          self.event = iprot.readString();
8361 
        else:
8362 
          iprot.skip(ftype)
8363 
      elif fid == 4:
8364 
        if ftype == TType.STRING:
8365 
          self.url = iprot.readString();
8366 
        else:
8367 
          iprot.skip(ftype)
8368 
      elif fid == 5:
8369 
        if ftype == TType.STRING:
8370 
          self.data = iprot.readString();
8371 
        else:
8372 
          iprot.skip(ftype)
1859 vikas 8373 
      elif fid == 6:
8374 
        if ftype == TType.I64:
8375 
          self.addedOn = iprot.readI64();
8376 
        else:
8377 
          iprot.skip(ftype)
1845 vikas 8378 
      else:
8379 
        iprot.skip(ftype)
8380 
      iprot.readFieldEnd()
8381 
    iprot.readStructEnd()
8382 
 
8383 
  def write(self, oprot):
8384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8386 
      return
8387 
    oprot.writeStructBegin('addTrackLog_args')
8388 
    if self.trackerId != None:
8389 
      oprot.writeFieldBegin('trackerId', TType.I64, 1)
8390 
      oprot.writeI64(self.trackerId)
8391 
      oprot.writeFieldEnd()
8392 
    if self.userId != None:
8393 
      oprot.writeFieldBegin('userId', TType.I64, 2)
8394 
      oprot.writeI64(self.userId)
8395 
      oprot.writeFieldEnd()
8396 
    if self.event != None:
8397 
      oprot.writeFieldBegin('event', TType.STRING, 3)
8398 
      oprot.writeString(self.event)
8399 
      oprot.writeFieldEnd()
8400 
    if self.url != None:
8401 
      oprot.writeFieldBegin('url', TType.STRING, 4)
8402 
      oprot.writeString(self.url)
8403 
      oprot.writeFieldEnd()
8404 
    if self.data != None:
8405 
      oprot.writeFieldBegin('data', TType.STRING, 5)
8406 
      oprot.writeString(self.data)
8407 
      oprot.writeFieldEnd()
1859 vikas 8408 
    if self.addedOn != None:
8409 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
8410 
      oprot.writeI64(self.addedOn)
8411 
      oprot.writeFieldEnd()
1845 vikas 8412 
    oprot.writeFieldStop()
8413 
    oprot.writeStructEnd()
8414 
 
8415 
  def __repr__(self):
8416 
    L = ['%s=%r' % (key, value)
8417 
      for key, value in self.__dict__.iteritems()]
8418 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8419 
 
8420 
  def __eq__(self, other):
8421 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8422 
 
8423 
  def __ne__(self, other):
8424 
    return not (self == other)
8425 
 
8426 
class addTrackLog_result:
8427 
  """
8428 
  Attributes:
8429 
   - success
8430 
   - utx
8431 
  """
8432 
 
8433 
  thrift_spec = (
8434 
    (0, TType.I64, 'success', None, None, ), # 0
8435 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8436 
  )
8437 
 
8438 
  def __init__(self, success=None, utx=None,):
8439 
    self.success = success
8440 
    self.utx = utx
8441 
 
8442 
  def read(self, iprot):
8443 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8444 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8445 
      return
8446 
    iprot.readStructBegin()
8447 
    while True:
8448 
      (fname, ftype, fid) = iprot.readFieldBegin()
8449 
      if ftype == TType.STOP:
8450 
        break
8451 
      if fid == 0:
8452 
        if ftype == TType.I64:
8453 
          self.success = iprot.readI64();
8454 
        else:
8455 
          iprot.skip(ftype)
8456 
      elif fid == 1:
8457 
        if ftype == TType.STRUCT:
8458 
          self.utx = UserTrackerException()
8459 
          self.utx.read(iprot)
8460 
        else:
8461 
          iprot.skip(ftype)
8462 
      else:
8463 
        iprot.skip(ftype)
8464 
      iprot.readFieldEnd()
8465 
    iprot.readStructEnd()
8466 
 
8467 
  def write(self, oprot):
8468 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8469 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8470 
      return
8471 
    oprot.writeStructBegin('addTrackLog_result')
8472 
    if self.success != None:
8473 
      oprot.writeFieldBegin('success', TType.I64, 0)
8474 
      oprot.writeI64(self.success)
8475 
      oprot.writeFieldEnd()
8476 
    if self.utx != None:
8477 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8478 
      self.utx.write(oprot)
8479 
      oprot.writeFieldEnd()
8480 
    oprot.writeFieldStop()
8481 
    oprot.writeStructEnd()
8482 
 
8483 
  def __repr__(self):
8484 
    L = ['%s=%r' % (key, value)
8485 
      for key, value in self.__dict__.iteritems()]
8486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8487 
 
8488 
  def __eq__(self, other):
8489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8490 
 
8491 
  def __ne__(self, other):
8492 
    return not (self == other)
8493 
 
8494 
class getTrackLogById_args:
8495 
  """
8496 
  Attributes:
8497 
   - id
8498 
  """
8499 
 
8500 
  thrift_spec = (
8501 
    None, # 0
8502 
    (1, TType.I64, 'id', None, None, ), # 1
8503 
  )
8504 
 
8505 
  def __init__(self, id=None,):
8506 
    self.id = id
8507 
 
8508 
  def read(self, iprot):
8509 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8510 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8511 
      return
8512 
    iprot.readStructBegin()
8513 
    while True:
8514 
      (fname, ftype, fid) = iprot.readFieldBegin()
8515 
      if ftype == TType.STOP:
8516 
        break
8517 
      if fid == 1:
8518 
        if ftype == TType.I64:
8519 
          self.id = iprot.readI64();
8520 
        else:
8521 
          iprot.skip(ftype)
8522 
      else:
8523 
        iprot.skip(ftype)
8524 
      iprot.readFieldEnd()
8525 
    iprot.readStructEnd()
8526 
 
8527 
  def write(self, oprot):
8528 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8529 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8530 
      return
8531 
    oprot.writeStructBegin('getTrackLogById_args')
8532 
    if self.id != None:
8533 
      oprot.writeFieldBegin('id', TType.I64, 1)
8534 
      oprot.writeI64(self.id)
8535 
      oprot.writeFieldEnd()
8536 
    oprot.writeFieldStop()
8537 
    oprot.writeStructEnd()
8538 
 
8539 
  def __repr__(self):
8540 
    L = ['%s=%r' % (key, value)
8541 
      for key, value in self.__dict__.iteritems()]
8542 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8543 
 
8544 
  def __eq__(self, other):
8545 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8546 
 
8547 
  def __ne__(self, other):
8548 
    return not (self == other)
8549 
 
8550 
class getTrackLogById_result:
8551 
  """
8552 
  Attributes:
8553 
   - success
8554 
   - utx
8555 
  """
8556 
 
8557 
  thrift_spec = (
8558 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
8559 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8560 
  )
8561 
 
8562 
  def __init__(self, success=None, utx=None,):
8563 
    self.success = success
8564 
    self.utx = utx
8565 
 
8566 
  def read(self, iprot):
8567 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8568 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8569 
      return
8570 
    iprot.readStructBegin()
8571 
    while True:
8572 
      (fname, ftype, fid) = iprot.readFieldBegin()
8573 
      if ftype == TType.STOP:
8574 
        break
8575 
      if fid == 0:
8576 
        if ftype == TType.STRUCT:
8577 
          self.success = TrackLog()
8578 
          self.success.read(iprot)
8579 
        else:
8580 
          iprot.skip(ftype)
8581 
      elif fid == 1:
8582 
        if ftype == TType.STRUCT:
8583 
          self.utx = UserTrackerException()
8584 
          self.utx.read(iprot)
8585 
        else:
8586 
          iprot.skip(ftype)
8587 
      else:
8588 
        iprot.skip(ftype)
8589 
      iprot.readFieldEnd()
8590 
    iprot.readStructEnd()
8591 
 
8592 
  def write(self, oprot):
8593 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8594 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8595 
      return
8596 
    oprot.writeStructBegin('getTrackLogById_result')
8597 
    if self.success != None:
8598 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8599 
      self.success.write(oprot)
8600 
      oprot.writeFieldEnd()
8601 
    if self.utx != None:
8602 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8603 
      self.utx.write(oprot)
8604 
      oprot.writeFieldEnd()
8605 
    oprot.writeFieldStop()
8606 
    oprot.writeStructEnd()
8607 
 
8608 
  def __repr__(self):
8609 
    L = ['%s=%r' % (key, value)
8610 
      for key, value in self.__dict__.iteritems()]
8611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8612 
 
8613 
  def __eq__(self, other):
8614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8615 
 
8616 
  def __ne__(self, other):
8617 
    return not (self == other)
8618 
 
8619 
class getTrackLogsByTracker_args:
8620 
  """
8621 
  Attributes:
8622 
   - trackerId
8623 
  """
8624 
 
8625 
  thrift_spec = (
8626 
    None, # 0
8627 
    (1, TType.I64, 'trackerId', None, None, ), # 1
8628 
  )
8629 
 
8630 
  def __init__(self, trackerId=None,):
8631 
    self.trackerId = trackerId
8632 
 
8633 
  def read(self, iprot):
8634 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8635 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8636 
      return
8637 
    iprot.readStructBegin()
8638 
    while True:
8639 
      (fname, ftype, fid) = iprot.readFieldBegin()
8640 
      if ftype == TType.STOP:
8641 
        break
8642 
      if fid == 1:
8643 
        if ftype == TType.I64:
8644 
          self.trackerId = iprot.readI64();
8645 
        else:
8646 
          iprot.skip(ftype)
8647 
      else:
8648 
        iprot.skip(ftype)
8649 
      iprot.readFieldEnd()
8650 
    iprot.readStructEnd()
8651 
 
8652 
  def write(self, oprot):
8653 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8654 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8655 
      return
8656 
    oprot.writeStructBegin('getTrackLogsByTracker_args')
8657 
    if self.trackerId != None:
8658 
      oprot.writeFieldBegin('trackerId', TType.I64, 1)
8659 
      oprot.writeI64(self.trackerId)
8660 
      oprot.writeFieldEnd()
8661 
    oprot.writeFieldStop()
8662 
    oprot.writeStructEnd()
8663 
 
8664 
  def __repr__(self):
8665 
    L = ['%s=%r' % (key, value)
8666 
      for key, value in self.__dict__.iteritems()]
8667 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8668 
 
8669 
  def __eq__(self, other):
8670 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8671 
 
8672 
  def __ne__(self, other):
8673 
    return not (self == other)
8674 
 
8675 
class getTrackLogsByTracker_result:
8676 
  """
8677 
  Attributes:
8678 
   - success
8679 
   - utx
8680 
  """
8681 
 
8682 
  thrift_spec = (
8683 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
8684 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8685 
  )
8686 
 
8687 
  def __init__(self, success=None, utx=None,):
8688 
    self.success = success
8689 
    self.utx = utx
8690 
 
8691 
  def read(self, iprot):
8692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8694 
      return
8695 
    iprot.readStructBegin()
8696 
    while True:
8697 
      (fname, ftype, fid) = iprot.readFieldBegin()
8698 
      if ftype == TType.STOP:
8699 
        break
8700 
      if fid == 0:
8701 
        if ftype == TType.LIST:
8702 
          self.success = []
8703 
          (_etype66, _size63) = iprot.readListBegin()
8704 
          for _i67 in xrange(_size63):
8705 
            _elem68 = TrackLog()
8706 
            _elem68.read(iprot)
8707 
            self.success.append(_elem68)
8708 
          iprot.readListEnd()
8709 
        else:
8710 
          iprot.skip(ftype)
8711 
      elif fid == 1:
8712 
        if ftype == TType.STRUCT:
8713 
          self.utx = UserTrackerException()
8714 
          self.utx.read(iprot)
8715 
        else:
8716 
          iprot.skip(ftype)
8717 
      else:
8718 
        iprot.skip(ftype)
8719 
      iprot.readFieldEnd()
8720 
    iprot.readStructEnd()
8721 
 
8722 
  def write(self, oprot):
8723 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8724 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8725 
      return
8726 
    oprot.writeStructBegin('getTrackLogsByTracker_result')
8727 
    if self.success != None:
8728 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8729 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8730 
      for iter69 in self.success:
8731 
        iter69.write(oprot)
8732 
      oprot.writeListEnd()
8733 
      oprot.writeFieldEnd()
8734 
    if self.utx != None:
8735 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8736 
      self.utx.write(oprot)
8737 
      oprot.writeFieldEnd()
8738 
    oprot.writeFieldStop()
8739 
    oprot.writeStructEnd()
8740 
 
8741 
  def __repr__(self):
8742 
    L = ['%s=%r' % (key, value)
8743 
      for key, value in self.__dict__.iteritems()]
8744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8745 
 
8746 
  def __eq__(self, other):
8747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8748 
 
8749 
  def __ne__(self, other):
8750 
    return not (self == other)
8751 
 
8752 
class getTrackLogsByUser_args:
8753 
  """
8754 
  Attributes:
8755 
   - userId
8756 
  """
8757 
 
8758 
  thrift_spec = (
8759 
    None, # 0
8760 
    (1, TType.I64, 'userId', None, None, ), # 1
8761 
  )
8762 
 
8763 
  def __init__(self, userId=None,):
8764 
    self.userId = userId
8765 
 
8766 
  def read(self, iprot):
8767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8769 
      return
8770 
    iprot.readStructBegin()
8771 
    while True:
8772 
      (fname, ftype, fid) = iprot.readFieldBegin()
8773 
      if ftype == TType.STOP:
8774 
        break
8775 
      if fid == 1:
8776 
        if ftype == TType.I64:
8777 
          self.userId = iprot.readI64();
8778 
        else:
8779 
          iprot.skip(ftype)
8780 
      else:
8781 
        iprot.skip(ftype)
8782 
      iprot.readFieldEnd()
8783 
    iprot.readStructEnd()
8784 
 
8785 
  def write(self, oprot):
8786 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8787 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8788 
      return
8789 
    oprot.writeStructBegin('getTrackLogsByUser_args')
8790 
    if self.userId != None:
8791 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8792 
      oprot.writeI64(self.userId)
8793 
      oprot.writeFieldEnd()
8794 
    oprot.writeFieldStop()
8795 
    oprot.writeStructEnd()
8796 
 
8797 
  def __repr__(self):
8798 
    L = ['%s=%r' % (key, value)
8799 
      for key, value in self.__dict__.iteritems()]
8800 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8801 
 
8802 
  def __eq__(self, other):
8803 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8804 
 
8805 
  def __ne__(self, other):
8806 
    return not (self == other)
8807 
 
8808 
class getTrackLogsByUser_result:
8809 
  """
8810 
  Attributes:
8811 
   - success
8812 
   - utx
8813 
  """
8814 
 
8815 
  thrift_spec = (
8816 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
8817 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8818 
  )
8819 
 
8820 
  def __init__(self, success=None, utx=None,):
8821 
    self.success = success
8822 
    self.utx = utx
8823 
 
8824 
  def read(self, iprot):
8825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8827 
      return
8828 
    iprot.readStructBegin()
8829 
    while True:
8830 
      (fname, ftype, fid) = iprot.readFieldBegin()
8831 
      if ftype == TType.STOP:
8832 
        break
8833 
      if fid == 0:
8834 
        if ftype == TType.LIST:
8835 
          self.success = []
8836 
          (_etype73, _size70) = iprot.readListBegin()
8837 
          for _i74 in xrange(_size70):
8838 
            _elem75 = TrackLog()
8839 
            _elem75.read(iprot)
8840 
            self.success.append(_elem75)
8841 
          iprot.readListEnd()
8842 
        else:
8843 
          iprot.skip(ftype)
8844 
      elif fid == 1:
8845 
        if ftype == TType.STRUCT:
8846 
          self.utx = UserTrackerException()
8847 
          self.utx.read(iprot)
8848 
        else:
8849 
          iprot.skip(ftype)
8850 
      else:
8851 
        iprot.skip(ftype)
8852 
      iprot.readFieldEnd()
8853 
    iprot.readStructEnd()
8854 
 
8855 
  def write(self, oprot):
8856 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8857 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8858 
      return
8859 
    oprot.writeStructBegin('getTrackLogsByUser_result')
8860 
    if self.success != None:
8861 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8862 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
8863 
      for iter76 in self.success:
8864 
        iter76.write(oprot)
8865 
      oprot.writeListEnd()
8866 
      oprot.writeFieldEnd()
8867 
    if self.utx != None:
8868 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8869 
      self.utx.write(oprot)
8870 
      oprot.writeFieldEnd()
8871 
    oprot.writeFieldStop()
8872 
    oprot.writeStructEnd()
8873 
 
8874 
  def __repr__(self):
8875 
    L = ['%s=%r' % (key, value)
8876 
      for key, value in self.__dict__.iteritems()]
8877 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8878 
 
8879 
  def __eq__(self, other):
8880 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8881 
 
8882 
  def __ne__(self, other):
8883 
    return not (self == other)
8884 
 
8885 
class getTrackLogs_args:
8886 
  """
8887 
  Attributes:
8888 
   - trackerId
8889 
   - userId
8890 
   - event
8891 
   - url
8892 
  """
8893 
 
8894 
  thrift_spec = (
8895 
    None, # 0
8896 
    (1, TType.I64, 'trackerId', None, None, ), # 1
8897 
    (2, TType.I64, 'userId', None, None, ), # 2
8898 
    (3, TType.STRING, 'event', None, None, ), # 3
8899 
    (4, TType.STRING, 'url', None, None, ), # 4
8900 
  )
8901 
 
8902 
  def __init__(self, trackerId=None, userId=None, event=None, url=None,):
8903 
    self.trackerId = trackerId
8904 
    self.userId = userId
8905 
    self.event = event
8906 
    self.url = url
8907 
 
8908 
  def read(self, iprot):
8909 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8910 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8911 
      return
8912 
    iprot.readStructBegin()
8913 
    while True:
8914 
      (fname, ftype, fid) = iprot.readFieldBegin()
8915 
      if ftype == TType.STOP:
8916 
        break
8917 
      if fid == 1:
8918 
        if ftype == TType.I64:
8919 
          self.trackerId = iprot.readI64();
8920 
        else:
8921 
          iprot.skip(ftype)
8922 
      elif fid == 2:
8923 
        if ftype == TType.I64:
8924 
          self.userId = iprot.readI64();
8925 
        else:
8926 
          iprot.skip(ftype)
8927 
      elif fid == 3:
8928 
        if ftype == TType.STRING:
8929 
          self.event = iprot.readString();
8930 
        else:
8931 
          iprot.skip(ftype)
8932 
      elif fid == 4:
8933 
        if ftype == TType.STRING:
8934 
          self.url = iprot.readString();
8935 
        else:
8936 
          iprot.skip(ftype)
8937 
      else:
8938 
        iprot.skip(ftype)
8939 
      iprot.readFieldEnd()
8940 
    iprot.readStructEnd()
8941 
 
8942 
  def write(self, oprot):
8943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8945 
      return
8946 
    oprot.writeStructBegin('getTrackLogs_args')
8947 
    if self.trackerId != None:
8948 
      oprot.writeFieldBegin('trackerId', TType.I64, 1)
8949 
      oprot.writeI64(self.trackerId)
8950 
      oprot.writeFieldEnd()
8951 
    if self.userId != None:
8952 
      oprot.writeFieldBegin('userId', TType.I64, 2)
8953 
      oprot.writeI64(self.userId)
8954 
      oprot.writeFieldEnd()
8955 
    if self.event != None:
8956 
      oprot.writeFieldBegin('event', TType.STRING, 3)
8957 
      oprot.writeString(self.event)
8958 
      oprot.writeFieldEnd()
8959 
    if self.url != None:
8960 
      oprot.writeFieldBegin('url', TType.STRING, 4)
8961 
      oprot.writeString(self.url)
8962 
      oprot.writeFieldEnd()
8963 
    oprot.writeFieldStop()
8964 
    oprot.writeStructEnd()
8965 
 
8966 
  def __repr__(self):
8967 
    L = ['%s=%r' % (key, value)
8968 
      for key, value in self.__dict__.iteritems()]
8969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8970 
 
8971 
  def __eq__(self, other):
8972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8973 
 
8974 
  def __ne__(self, other):
8975 
    return not (self == other)
8976 
 
8977 
class getTrackLogs_result:
8978 
  """
8979 
  Attributes:
8980 
   - success
8981 
   - utx
8982 
  """
8983 
 
8984 
  thrift_spec = (
8985 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
8986 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8987 
  )
8988 
 
8989 
  def __init__(self, success=None, utx=None,):
8990 
    self.success = success
8991 
    self.utx = utx
8992 
 
8993 
  def read(self, iprot):
8994 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8995 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8996 
      return
8997 
    iprot.readStructBegin()
8998 
    while True:
8999 
      (fname, ftype, fid) = iprot.readFieldBegin()
9000 
      if ftype == TType.STOP:
9001 
        break
9002 
      if fid == 0:
9003 
        if ftype == TType.LIST:
9004 
          self.success = []
9005 
          (_etype80, _size77) = iprot.readListBegin()
9006 
          for _i81 in xrange(_size77):
9007 
            _elem82 = TrackLog()
9008 
            _elem82.read(iprot)
9009 
            self.success.append(_elem82)
9010 
          iprot.readListEnd()
9011 
        else:
9012 
          iprot.skip(ftype)
9013 
      elif fid == 1:
9014 
        if ftype == TType.STRUCT:
9015 
          self.utx = UserTrackerException()
9016 
          self.utx.read(iprot)
9017 
        else:
9018 
          iprot.skip(ftype)
9019 
      else:
9020 
        iprot.skip(ftype)
9021 
      iprot.readFieldEnd()
9022 
    iprot.readStructEnd()
9023 
 
9024 
  def write(self, oprot):
9025 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9026 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9027 
      return
9028 
    oprot.writeStructBegin('getTrackLogs_result')
9029 
    if self.success != None:
9030 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9031 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
9032 
      for iter83 in self.success:
9033 
        iter83.write(oprot)
9034 
      oprot.writeListEnd()
9035 
      oprot.writeFieldEnd()
9036 
    if self.utx != None:
9037 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9038 
      self.utx.write(oprot)
9039 
      oprot.writeFieldEnd()
9040 
    oprot.writeFieldStop()
9041 
    oprot.writeStructEnd()
9042 
 
9043 
  def __repr__(self):
9044 
    L = ['%s=%r' % (key, value)
9045 
      for key, value in self.__dict__.iteritems()]
9046 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9047 
 
9048 
  def __eq__(self, other):
9049 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9050 
 
9051 
  def __ne__(self, other):
9052 
    return not (self == other)
9053 
 
559 chandransh 9054 
class createCart_args:
94 ashish 9055 
  """
9056 
  Attributes:
559 chandransh 9057 
   - userId
94 ashish 9058 
  """
9059 
 
9060 
  thrift_spec = (
9061 
    None, # 0
559 chandransh 9062 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 9063 
  )
9064 
 
559 chandransh 9065 
  def __init__(self, userId=None,):
9066 
    self.userId = userId
94 ashish 9067 
 
9068 
  def read(self, iprot):
9069 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9070 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9071 
      return
9072 
    iprot.readStructBegin()
9073 
    while True:
9074 
      (fname, ftype, fid) = iprot.readFieldBegin()
9075 
      if ftype == TType.STOP:
9076 
        break
9077 
      if fid == 1:
9078 
        if ftype == TType.I64:
559 chandransh 9079 
          self.userId = iprot.readI64();
94 ashish 9080 
        else:
9081 
          iprot.skip(ftype)
559 chandransh 9082 
      else:
9083 
        iprot.skip(ftype)
9084 
      iprot.readFieldEnd()
9085 
    iprot.readStructEnd()
9086 
 
9087 
  def write(self, oprot):
9088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9090 
      return
9091 
    oprot.writeStructBegin('createCart_args')
9092 
    if self.userId != None:
9093 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9094 
      oprot.writeI64(self.userId)
9095 
      oprot.writeFieldEnd()
9096 
    oprot.writeFieldStop()
9097 
    oprot.writeStructEnd()
9098 
 
9099 
  def __repr__(self):
9100 
    L = ['%s=%r' % (key, value)
9101 
      for key, value in self.__dict__.iteritems()]
9102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9103 
 
9104 
  def __eq__(self, other):
9105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9106 
 
9107 
  def __ne__(self, other):
9108 
    return not (self == other)
9109 
 
9110 
class createCart_result:
9111 
  """
9112 
  Attributes:
9113 
   - success
9114 
   - scx
9115 
  """
9116 
 
9117 
  thrift_spec = (
9118 
    (0, TType.I64, 'success', None, None, ), # 0
9119 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9120 
  )
9121 
 
9122 
  def __init__(self, success=None, scx=None,):
9123 
    self.success = success
9124 
    self.scx = scx
9125 
 
9126 
  def read(self, iprot):
9127 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9128 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9129 
      return
9130 
    iprot.readStructBegin()
9131 
    while True:
9132 
      (fname, ftype, fid) = iprot.readFieldBegin()
9133 
      if ftype == TType.STOP:
9134 
        break
9135 
      if fid == 0:
94 ashish 9136 
        if ftype == TType.I64:
559 chandransh 9137 
          self.success = iprot.readI64();
94 ashish 9138 
        else:
9139 
          iprot.skip(ftype)
559 chandransh 9140 
      elif fid == 1:
9141 
        if ftype == TType.STRUCT:
9142 
          self.scx = ShoppingCartException()
9143 
          self.scx.read(iprot)
9144 
        else:
9145 
          iprot.skip(ftype)
94 ashish 9146 
      else:
9147 
        iprot.skip(ftype)
9148 
      iprot.readFieldEnd()
9149 
    iprot.readStructEnd()
9150 
 
9151 
  def write(self, oprot):
9152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9154 
      return
559 chandransh 9155 
    oprot.writeStructBegin('createCart_result')
9156 
    if self.success != None:
9157 
      oprot.writeFieldBegin('success', TType.I64, 0)
9158 
      oprot.writeI64(self.success)
94 ashish 9159 
      oprot.writeFieldEnd()
559 chandransh 9160 
    if self.scx != None:
9161 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9162 
      self.scx.write(oprot)
94 ashish 9163 
      oprot.writeFieldEnd()
9164 
    oprot.writeFieldStop()
9165 
    oprot.writeStructEnd()
9166 
 
9167 
  def __repr__(self):
9168 
    L = ['%s=%r' % (key, value)
9169 
      for key, value in self.__dict__.iteritems()]
9170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9171 
 
9172 
  def __eq__(self, other):
9173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9174 
 
9175 
  def __ne__(self, other):
9176 
    return not (self == other)
9177 
 
559 chandransh 9178 
class getCurrentCart_args:
94 ashish 9179 
  """
9180 
  Attributes:
559 chandransh 9181 
   - userId
9182 
  """
9183 
 
9184 
  thrift_spec = (
9185 
    None, # 0
9186 
    (1, TType.I64, 'userId', None, None, ), # 1
9187 
  )
9188 
 
9189 
  def __init__(self, userId=None,):
9190 
    self.userId = userId
9191 
 
9192 
  def read(self, iprot):
9193 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9194 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9195 
      return
9196 
    iprot.readStructBegin()
9197 
    while True:
9198 
      (fname, ftype, fid) = iprot.readFieldBegin()
9199 
      if ftype == TType.STOP:
9200 
        break
9201 
      if fid == 1:
9202 
        if ftype == TType.I64:
9203 
          self.userId = iprot.readI64();
9204 
        else:
9205 
          iprot.skip(ftype)
9206 
      else:
9207 
        iprot.skip(ftype)
9208 
      iprot.readFieldEnd()
9209 
    iprot.readStructEnd()
9210 
 
9211 
  def write(self, oprot):
9212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9214 
      return
9215 
    oprot.writeStructBegin('getCurrentCart_args')
9216 
    if self.userId != None:
9217 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9218 
      oprot.writeI64(self.userId)
9219 
      oprot.writeFieldEnd()
9220 
    oprot.writeFieldStop()
9221 
    oprot.writeStructEnd()
9222 
 
9223 
  def __repr__(self):
9224 
    L = ['%s=%r' % (key, value)
9225 
      for key, value in self.__dict__.iteritems()]
9226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9227 
 
9228 
  def __eq__(self, other):
9229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9230 
 
9231 
  def __ne__(self, other):
9232 
    return not (self == other)
9233 
 
9234 
class getCurrentCart_result:
9235 
  """
9236 
  Attributes:
94 ashish 9237 
   - success
559 chandransh 9238 
   - scx
94 ashish 9239 
  """
9240 
 
9241 
  thrift_spec = (
559 chandransh 9242 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9243 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9244 
  )
9245 
 
559 chandransh 9246 
  def __init__(self, success=None, scx=None,):
94 ashish 9247 
    self.success = success
559 chandransh 9248 
    self.scx = scx
94 ashish 9249 
 
9250 
  def read(self, iprot):
9251 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9252 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9253 
      return
9254 
    iprot.readStructBegin()
9255 
    while True:
9256 
      (fname, ftype, fid) = iprot.readFieldBegin()
9257 
      if ftype == TType.STOP:
9258 
        break
9259 
      if fid == 0:
559 chandransh 9260 
        if ftype == TType.STRUCT:
9261 
          self.success = Cart()
9262 
          self.success.read(iprot)
94 ashish 9263 
        else:
9264 
          iprot.skip(ftype)
9265 
      elif fid == 1:
9266 
        if ftype == TType.STRUCT:
559 chandransh 9267 
          self.scx = ShoppingCartException()
9268 
          self.scx.read(iprot)
94 ashish 9269 
        else:
9270 
          iprot.skip(ftype)
9271 
      else:
9272 
        iprot.skip(ftype)
9273 
      iprot.readFieldEnd()
9274 
    iprot.readStructEnd()
9275 
 
9276 
  def write(self, oprot):
9277 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9278 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9279 
      return
559 chandransh 9280 
    oprot.writeStructBegin('getCurrentCart_result')
94 ashish 9281 
    if self.success != None:
559 chandransh 9282 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9283 
      self.success.write(oprot)
94 ashish 9284 
      oprot.writeFieldEnd()
559 chandransh 9285 
    if self.scx != None:
9286 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9287 
      self.scx.write(oprot)
94 ashish 9288 
      oprot.writeFieldEnd()
9289 
    oprot.writeFieldStop()
9290 
    oprot.writeStructEnd()
9291 
 
9292 
  def __repr__(self):
9293 
    L = ['%s=%r' % (key, value)
9294 
      for key, value in self.__dict__.iteritems()]
9295 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9296 
 
9297 
  def __eq__(self, other):
9298 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9299 
 
9300 
  def __ne__(self, other):
9301 
    return not (self == other)
9302 
 
559 chandransh 9303 
class getCart_args:
504 rajveer 9304 
  """
9305 
  Attributes:
559 chandransh 9306 
   - cartId
504 rajveer 9307 
  """
9308 
 
9309 
  thrift_spec = (
9310 
    None, # 0
559 chandransh 9311 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 9312 
  )
9313 
 
559 chandransh 9314 
  def __init__(self, cartId=None,):
9315 
    self.cartId = cartId
504 rajveer 9316 
 
9317 
  def read(self, iprot):
9318 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9319 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9320 
      return
9321 
    iprot.readStructBegin()
9322 
    while True:
9323 
      (fname, ftype, fid) = iprot.readFieldBegin()
9324 
      if ftype == TType.STOP:
9325 
        break
9326 
      if fid == 1:
9327 
        if ftype == TType.I64:
559 chandransh 9328 
          self.cartId = iprot.readI64();
504 rajveer 9329 
        else:
9330 
          iprot.skip(ftype)
9331 
      else:
9332 
        iprot.skip(ftype)
9333 
      iprot.readFieldEnd()
9334 
    iprot.readStructEnd()
9335 
 
9336 
  def write(self, oprot):
9337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9339 
      return
559 chandransh 9340 
    oprot.writeStructBegin('getCart_args')
9341 
    if self.cartId != None:
9342 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9343 
      oprot.writeI64(self.cartId)
504 rajveer 9344 
      oprot.writeFieldEnd()
9345 
    oprot.writeFieldStop()
9346 
    oprot.writeStructEnd()
9347 
 
9348 
  def __repr__(self):
9349 
    L = ['%s=%r' % (key, value)
9350 
      for key, value in self.__dict__.iteritems()]
9351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9352 
 
9353 
  def __eq__(self, other):
9354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9355 
 
9356 
  def __ne__(self, other):
9357 
    return not (self == other)
9358 
 
559 chandransh 9359 
class getCart_result:
504 rajveer 9360 
  """
9361 
  Attributes:
9362 
   - success
559 chandransh 9363 
   - scx
504 rajveer 9364 
  """
9365 
 
9366 
  thrift_spec = (
559 chandransh 9367 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9368 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 9369 
  )
9370 
 
559 chandransh 9371 
  def __init__(self, success=None, scx=None,):
504 rajveer 9372 
    self.success = success
559 chandransh 9373 
    self.scx = scx
504 rajveer 9374 
 
9375 
  def read(self, iprot):
9376 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9377 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9378 
      return
9379 
    iprot.readStructBegin()
9380 
    while True:
9381 
      (fname, ftype, fid) = iprot.readFieldBegin()
9382 
      if ftype == TType.STOP:
9383 
        break
9384 
      if fid == 0:
559 chandransh 9385 
        if ftype == TType.STRUCT:
9386 
          self.success = Cart()
9387 
          self.success.read(iprot)
504 rajveer 9388 
        else:
9389 
          iprot.skip(ftype)
9390 
      elif fid == 1:
9391 
        if ftype == TType.STRUCT:
559 chandransh 9392 
          self.scx = ShoppingCartException()
9393 
          self.scx.read(iprot)
504 rajveer 9394 
        else:
9395 
          iprot.skip(ftype)
9396 
      else:
9397 
        iprot.skip(ftype)
9398 
      iprot.readFieldEnd()
9399 
    iprot.readStructEnd()
9400 
 
9401 
  def write(self, oprot):
9402 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9403 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9404 
      return
559 chandransh 9405 
    oprot.writeStructBegin('getCart_result')
504 rajveer 9406 
    if self.success != None:
559 chandransh 9407 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9408 
      self.success.write(oprot)
504 rajveer 9409 
      oprot.writeFieldEnd()
559 chandransh 9410 
    if self.scx != None:
9411 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9412 
      self.scx.write(oprot)
504 rajveer 9413 
      oprot.writeFieldEnd()
9414 
    oprot.writeFieldStop()
9415 
    oprot.writeStructEnd()
9416 
 
9417 
  def __repr__(self):
9418 
    L = ['%s=%r' % (key, value)
9419 
      for key, value in self.__dict__.iteritems()]
9420 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9421 
 
9422 
  def __eq__(self, other):
9423 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9424 
 
9425 
  def __ne__(self, other):
9426 
    return not (self == other)
9427 
 
559 chandransh 9428 
class getCartsForUser_args:
94 ashish 9429 
  """
9430 
  Attributes:
559 chandransh 9431 
   - userId
9432 
   - status
94 ashish 9433 
  """
9434 
 
9435 
  thrift_spec = (
9436 
    None, # 0
559 chandransh 9437 
    (1, TType.I64, 'userId', None, None, ), # 1
9438 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 9439 
  )
9440 
 
559 chandransh 9441 
  def __init__(self, userId=None, status=None,):
9442 
    self.userId = userId
9443 
    self.status = status
94 ashish 9444 
 
9445 
  def read(self, iprot):
9446 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9447 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9448 
      return
9449 
    iprot.readStructBegin()
9450 
    while True:
9451 
      (fname, ftype, fid) = iprot.readFieldBegin()
9452 
      if ftype == TType.STOP:
9453 
        break
9454 
      if fid == 1:
9455 
        if ftype == TType.I64:
559 chandransh 9456 
          self.userId = iprot.readI64();
94 ashish 9457 
        else:
9458 
          iprot.skip(ftype)
9459 
      elif fid == 2:
559 chandransh 9460 
        if ftype == TType.I32:
9461 
          self.status = iprot.readI32();
94 ashish 9462 
        else:
9463 
          iprot.skip(ftype)
9464 
      else:
9465 
        iprot.skip(ftype)
9466 
      iprot.readFieldEnd()
9467 
    iprot.readStructEnd()
9468 
 
9469 
  def write(self, oprot):
9470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9472 
      return
559 chandransh 9473 
    oprot.writeStructBegin('getCartsForUser_args')
9474 
    if self.userId != None:
9475 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9476 
      oprot.writeI64(self.userId)
94 ashish 9477 
      oprot.writeFieldEnd()
559 chandransh 9478 
    if self.status != None:
9479 
      oprot.writeFieldBegin('status', TType.I32, 2)
9480 
      oprot.writeI32(self.status)
94 ashish 9481 
      oprot.writeFieldEnd()
9482 
    oprot.writeFieldStop()
9483 
    oprot.writeStructEnd()
9484 
 
9485 
  def __repr__(self):
9486 
    L = ['%s=%r' % (key, value)
9487 
      for key, value in self.__dict__.iteritems()]
9488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9489 
 
9490 
  def __eq__(self, other):
9491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9492 
 
9493 
  def __ne__(self, other):
9494 
    return not (self == other)
9495 
 
559 chandransh 9496 
class getCartsForUser_result:
94 ashish 9497 
  """
9498 
  Attributes:
9499 
   - success
559 chandransh 9500 
   - scx
94 ashish 9501 
  """
9502 
 
9503 
  thrift_spec = (
559 chandransh 9504 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9505 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9506 
  )
9507 
 
559 chandransh 9508 
  def __init__(self, success=None, scx=None,):
94 ashish 9509 
    self.success = success
559 chandransh 9510 
    self.scx = scx
94 ashish 9511 
 
9512 
  def read(self, iprot):
9513 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9514 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9515 
      return
9516 
    iprot.readStructBegin()
9517 
    while True:
9518 
      (fname, ftype, fid) = iprot.readFieldBegin()
9519 
      if ftype == TType.STOP:
9520 
        break
9521 
      if fid == 0:
559 chandransh 9522 
        if ftype == TType.LIST:
9523 
          self.success = []
1845 vikas 9524 
          (_etype87, _size84) = iprot.readListBegin()
9525 
          for _i88 in xrange(_size84):
9526 
            _elem89 = Cart()
9527 
            _elem89.read(iprot)
9528 
            self.success.append(_elem89)
559 chandransh 9529 
          iprot.readListEnd()
94 ashish 9530 
        else:
9531 
          iprot.skip(ftype)
9532 
      elif fid == 1:
9533 
        if ftype == TType.STRUCT:
559 chandransh 9534 
          self.scx = ShoppingCartException()
9535 
          self.scx.read(iprot)
94 ashish 9536 
        else:
9537 
          iprot.skip(ftype)
9538 
      else:
9539 
        iprot.skip(ftype)
9540 
      iprot.readFieldEnd()
9541 
    iprot.readStructEnd()
9542 
 
9543 
  def write(self, oprot):
9544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9546 
      return
559 chandransh 9547 
    oprot.writeStructBegin('getCartsForUser_result')
94 ashish 9548 
    if self.success != None:
559 chandransh 9549 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9550 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1845 vikas 9551 
      for iter90 in self.success:
9552 
        iter90.write(oprot)
559 chandransh 9553 
      oprot.writeListEnd()
94 ashish 9554 
      oprot.writeFieldEnd()
559 chandransh 9555 
    if self.scx != None:
9556 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9557 
      self.scx.write(oprot)
94 ashish 9558 
      oprot.writeFieldEnd()
9559 
    oprot.writeFieldStop()
9560 
    oprot.writeStructEnd()
9561 
 
9562 
  def __repr__(self):
9563 
    L = ['%s=%r' % (key, value)
9564 
      for key, value in self.__dict__.iteritems()]
9565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9566 
 
9567 
  def __eq__(self, other):
9568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9569 
 
9570 
  def __ne__(self, other):
9571 
    return not (self == other)
9572 
 
559 chandransh 9573 
class getCartsByStatus_args:
94 ashish 9574 
  """
9575 
  Attributes:
559 chandransh 9576 
   - status
94 ashish 9577 
  """
9578 
 
9579 
  thrift_spec = (
9580 
    None, # 0
559 chandransh 9581 
    (1, TType.I32, 'status', None, None, ), # 1
94 ashish 9582 
  )
9583 
 
559 chandransh 9584 
  def __init__(self, status=None,):
9585 
    self.status = status
94 ashish 9586 
 
9587 
  def read(self, iprot):
9588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9590 
      return
9591 
    iprot.readStructBegin()
9592 
    while True:
9593 
      (fname, ftype, fid) = iprot.readFieldBegin()
9594 
      if ftype == TType.STOP:
9595 
        break
9596 
      if fid == 1:
559 chandransh 9597 
        if ftype == TType.I32:
9598 
          self.status = iprot.readI32();
9599 
        else:
9600 
          iprot.skip(ftype)
9601 
      else:
9602 
        iprot.skip(ftype)
9603 
      iprot.readFieldEnd()
9604 
    iprot.readStructEnd()
9605 
 
9606 
  def write(self, oprot):
9607 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9608 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9609 
      return
9610 
    oprot.writeStructBegin('getCartsByStatus_args')
9611 
    if self.status != None:
9612 
      oprot.writeFieldBegin('status', TType.I32, 1)
9613 
      oprot.writeI32(self.status)
9614 
      oprot.writeFieldEnd()
9615 
    oprot.writeFieldStop()
9616 
    oprot.writeStructEnd()
9617 
 
9618 
  def __repr__(self):
9619 
    L = ['%s=%r' % (key, value)
9620 
      for key, value in self.__dict__.iteritems()]
9621 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9622 
 
9623 
  def __eq__(self, other):
9624 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9625 
 
9626 
  def __ne__(self, other):
9627 
    return not (self == other)
9628 
 
9629 
class getCartsByStatus_result:
9630 
  """
9631 
  Attributes:
9632 
   - success
9633 
   - scx
9634 
  """
9635 
 
9636 
  thrift_spec = (
9637 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9638 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9639 
  )
9640 
 
9641 
  def __init__(self, success=None, scx=None,):
9642 
    self.success = success
9643 
    self.scx = scx
9644 
 
9645 
  def read(self, iprot):
9646 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9647 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9648 
      return
9649 
    iprot.readStructBegin()
9650 
    while True:
9651 
      (fname, ftype, fid) = iprot.readFieldBegin()
9652 
      if ftype == TType.STOP:
9653 
        break
9654 
      if fid == 0:
9655 
        if ftype == TType.LIST:
9656 
          self.success = []
1845 vikas 9657 
          (_etype94, _size91) = iprot.readListBegin()
9658 
          for _i95 in xrange(_size91):
9659 
            _elem96 = Cart()
9660 
            _elem96.read(iprot)
9661 
            self.success.append(_elem96)
559 chandransh 9662 
          iprot.readListEnd()
9663 
        else:
9664 
          iprot.skip(ftype)
9665 
      elif fid == 1:
9666 
        if ftype == TType.STRUCT:
9667 
          self.scx = ShoppingCartException()
9668 
          self.scx.read(iprot)
9669 
        else:
9670 
          iprot.skip(ftype)
9671 
      else:
9672 
        iprot.skip(ftype)
9673 
      iprot.readFieldEnd()
9674 
    iprot.readStructEnd()
9675 
 
9676 
  def write(self, oprot):
9677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9679 
      return
9680 
    oprot.writeStructBegin('getCartsByStatus_result')
9681 
    if self.success != None:
9682 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9683 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1845 vikas 9684 
      for iter97 in self.success:
9685 
        iter97.write(oprot)
559 chandransh 9686 
      oprot.writeListEnd()
9687 
      oprot.writeFieldEnd()
9688 
    if self.scx != None:
9689 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9690 
      self.scx.write(oprot)
9691 
      oprot.writeFieldEnd()
9692 
    oprot.writeFieldStop()
9693 
    oprot.writeStructEnd()
9694 
 
9695 
  def __repr__(self):
9696 
    L = ['%s=%r' % (key, value)
9697 
      for key, value in self.__dict__.iteritems()]
9698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9699 
 
9700 
  def __eq__(self, other):
9701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9702 
 
9703 
  def __ne__(self, other):
9704 
    return not (self == other)
9705 
 
9706 
class getCartsByTime_args:
9707 
  """
9708 
  Attributes:
9709 
   - from_time
9710 
   - to_time
9711 
   - status
9712 
  """
9713 
 
9714 
  thrift_spec = (
9715 
    None, # 0
9716 
    (1, TType.I64, 'from_time', None, None, ), # 1
9717 
    (2, TType.I64, 'to_time', None, None, ), # 2
9718 
    (3, TType.I32, 'status', None, None, ), # 3
9719 
  )
9720 
 
9721 
  def __init__(self, from_time=None, to_time=None, status=None,):
9722 
    self.from_time = from_time
9723 
    self.to_time = to_time
9724 
    self.status = status
9725 
 
9726 
  def read(self, iprot):
9727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9729 
      return
9730 
    iprot.readStructBegin()
9731 
    while True:
9732 
      (fname, ftype, fid) = iprot.readFieldBegin()
9733 
      if ftype == TType.STOP:
9734 
        break
9735 
      if fid == 1:
94 ashish 9736 
        if ftype == TType.I64:
559 chandransh 9737 
          self.from_time = iprot.readI64();
94 ashish 9738 
        else:
9739 
          iprot.skip(ftype)
122 ashish 9740 
      elif fid == 2:
559 chandransh 9741 
        if ftype == TType.I64:
9742 
          self.to_time = iprot.readI64();
122 ashish 9743 
        else:
9744 
          iprot.skip(ftype)
559 chandransh 9745 
      elif fid == 3:
9746 
        if ftype == TType.I32:
9747 
          self.status = iprot.readI32();
9748 
        else:
9749 
          iprot.skip(ftype)
94 ashish 9750 
      else:
9751 
        iprot.skip(ftype)
9752 
      iprot.readFieldEnd()
9753 
    iprot.readStructEnd()
9754 
 
9755 
  def write(self, oprot):
9756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9758 
      return
559 chandransh 9759 
    oprot.writeStructBegin('getCartsByTime_args')
9760 
    if self.from_time != None:
9761 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
9762 
      oprot.writeI64(self.from_time)
94 ashish 9763 
      oprot.writeFieldEnd()
559 chandransh 9764 
    if self.to_time != None:
9765 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
9766 
      oprot.writeI64(self.to_time)
122 ashish 9767 
      oprot.writeFieldEnd()
559 chandransh 9768 
    if self.status != None:
9769 
      oprot.writeFieldBegin('status', TType.I32, 3)
9770 
      oprot.writeI32(self.status)
9771 
      oprot.writeFieldEnd()
94 ashish 9772 
    oprot.writeFieldStop()
9773 
    oprot.writeStructEnd()
9774 
 
9775 
  def __repr__(self):
9776 
    L = ['%s=%r' % (key, value)
9777 
      for key, value in self.__dict__.iteritems()]
9778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9779 
 
9780 
  def __eq__(self, other):
9781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9782 
 
9783 
  def __ne__(self, other):
9784 
    return not (self == other)
9785 
 
559 chandransh 9786 
class getCartsByTime_result:
94 ashish 9787 
  """
9788 
  Attributes:
9789 
   - success
559 chandransh 9790 
   - scx
94 ashish 9791 
  """
9792 
 
9793 
  thrift_spec = (
559 chandransh 9794 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9795 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9796 
  )
9797 
 
559 chandransh 9798 
  def __init__(self, success=None, scx=None,):
94 ashish 9799 
    self.success = success
559 chandransh 9800 
    self.scx = scx
94 ashish 9801 
 
9802 
  def read(self, iprot):
9803 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9804 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9805 
      return
9806 
    iprot.readStructBegin()
9807 
    while True:
9808 
      (fname, ftype, fid) = iprot.readFieldBegin()
9809 
      if ftype == TType.STOP:
9810 
        break
9811 
      if fid == 0:
559 chandransh 9812 
        if ftype == TType.LIST:
9813 
          self.success = []
1845 vikas 9814 
          (_etype101, _size98) = iprot.readListBegin()
9815 
          for _i102 in xrange(_size98):
9816 
            _elem103 = Cart()
9817 
            _elem103.read(iprot)
9818 
            self.success.append(_elem103)
559 chandransh 9819 
          iprot.readListEnd()
94 ashish 9820 
        else:
9821 
          iprot.skip(ftype)
9822 
      elif fid == 1:
9823 
        if ftype == TType.STRUCT:
559 chandransh 9824 
          self.scx = ShoppingCartException()
9825 
          self.scx.read(iprot)
94 ashish 9826 
        else:
9827 
          iprot.skip(ftype)
9828 
      else:
9829 
        iprot.skip(ftype)
9830 
      iprot.readFieldEnd()
9831 
    iprot.readStructEnd()
9832 
 
9833 
  def write(self, oprot):
9834 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9835 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9836 
      return
559 chandransh 9837 
    oprot.writeStructBegin('getCartsByTime_result')
94 ashish 9838 
    if self.success != None:
559 chandransh 9839 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9840 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1845 vikas 9841 
      for iter104 in self.success:
9842 
        iter104.write(oprot)
559 chandransh 9843 
      oprot.writeListEnd()
94 ashish 9844 
      oprot.writeFieldEnd()
559 chandransh 9845 
    if self.scx != None:
9846 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9847 
      self.scx.write(oprot)
94 ashish 9848 
      oprot.writeFieldEnd()
9849 
    oprot.writeFieldStop()
9850 
    oprot.writeStructEnd()
9851 
 
9852 
  def __repr__(self):
9853 
    L = ['%s=%r' % (key, value)
9854 
      for key, value in self.__dict__.iteritems()]
9855 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9856 
 
9857 
  def __eq__(self, other):
9858 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9859 
 
9860 
  def __ne__(self, other):
9861 
    return not (self == other)
9862 
 
559 chandransh 9863 
class changeCartStatus_args:
94 ashish 9864 
  """
9865 
  Attributes:
559 chandransh 9866 
   - cartId
9867 
   - status
94 ashish 9868 
  """
9869 
 
9870 
  thrift_spec = (
9871 
    None, # 0
559 chandransh 9872 
    (1, TType.I64, 'cartId', None, None, ), # 1
9873 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 9874 
  )
9875 
 
559 chandransh 9876 
  def __init__(self, cartId=None, status=None,):
9877 
    self.cartId = cartId
9878 
    self.status = status
94 ashish 9879 
 
9880 
  def read(self, iprot):
9881 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9882 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9883 
      return
9884 
    iprot.readStructBegin()
9885 
    while True:
9886 
      (fname, ftype, fid) = iprot.readFieldBegin()
9887 
      if ftype == TType.STOP:
9888 
        break
9889 
      if fid == 1:
9890 
        if ftype == TType.I64:
559 chandransh 9891 
          self.cartId = iprot.readI64();
94 ashish 9892 
        else:
9893 
          iprot.skip(ftype)
559 chandransh 9894 
      elif fid == 2:
9895 
        if ftype == TType.I32:
9896 
          self.status = iprot.readI32();
9897 
        else:
9898 
          iprot.skip(ftype)
94 ashish 9899 
      else:
9900 
        iprot.skip(ftype)
9901 
      iprot.readFieldEnd()
9902 
    iprot.readStructEnd()
9903 
 
9904 
  def write(self, oprot):
9905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9907 
      return
559 chandransh 9908 
    oprot.writeStructBegin('changeCartStatus_args')
9909 
    if self.cartId != None:
9910 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9911 
      oprot.writeI64(self.cartId)
94 ashish 9912 
      oprot.writeFieldEnd()
559 chandransh 9913 
    if self.status != None:
9914 
      oprot.writeFieldBegin('status', TType.I32, 2)
9915 
      oprot.writeI32(self.status)
9916 
      oprot.writeFieldEnd()
94 ashish 9917 
    oprot.writeFieldStop()
9918 
    oprot.writeStructEnd()
9919 
 
9920 
  def __repr__(self):
9921 
    L = ['%s=%r' % (key, value)
9922 
      for key, value in self.__dict__.iteritems()]
9923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9924 
 
9925 
  def __eq__(self, other):
9926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9927 
 
9928 
  def __ne__(self, other):
9929 
    return not (self == other)
9930 
 
559 chandransh 9931 
class changeCartStatus_result:
94 ashish 9932 
  """
9933 
  Attributes:
559 chandransh 9934 
   - scx
9935 
  """
9936 
 
9937 
  thrift_spec = (
9938 
    None, # 0
9939 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9940 
  )
9941 
 
9942 
  def __init__(self, scx=None,):
9943 
    self.scx = scx
9944 
 
9945 
  def read(self, iprot):
9946 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9947 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9948 
      return
9949 
    iprot.readStructBegin()
9950 
    while True:
9951 
      (fname, ftype, fid) = iprot.readFieldBegin()
9952 
      if ftype == TType.STOP:
9953 
        break
9954 
      if fid == 1:
9955 
        if ftype == TType.STRUCT:
9956 
          self.scx = ShoppingCartException()
9957 
          self.scx.read(iprot)
9958 
        else:
9959 
          iprot.skip(ftype)
9960 
      else:
9961 
        iprot.skip(ftype)
9962 
      iprot.readFieldEnd()
9963 
    iprot.readStructEnd()
9964 
 
9965 
  def write(self, oprot):
9966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9968 
      return
9969 
    oprot.writeStructBegin('changeCartStatus_result')
9970 
    if self.scx != None:
9971 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9972 
      self.scx.write(oprot)
9973 
      oprot.writeFieldEnd()
9974 
    oprot.writeFieldStop()
9975 
    oprot.writeStructEnd()
9976 
 
9977 
  def __repr__(self):
9978 
    L = ['%s=%r' % (key, value)
9979 
      for key, value in self.__dict__.iteritems()]
9980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9981 
 
9982 
  def __eq__(self, other):
9983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9984 
 
9985 
  def __ne__(self, other):
9986 
    return not (self == other)
9987 
 
9988 
class addItemToCart_args:
9989 
  """
9990 
  Attributes:
9991 
   - cartId
9992 
   - itemId
9993 
   - quantity
9994 
  """
9995 
 
9996 
  thrift_spec = (
9997 
    None, # 0
9998 
    (1, TType.I64, 'cartId', None, None, ), # 1
9999 
    (2, TType.I64, 'itemId', None, None, ), # 2
10000 
    (3, TType.I64, 'quantity', None, None, ), # 3
10001 
  )
10002 
 
10003 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
10004 
    self.cartId = cartId
10005 
    self.itemId = itemId
10006 
    self.quantity = quantity
10007 
 
10008 
  def read(self, iprot):
10009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10011 
      return
10012 
    iprot.readStructBegin()
10013 
    while True:
10014 
      (fname, ftype, fid) = iprot.readFieldBegin()
10015 
      if ftype == TType.STOP:
10016 
        break
10017 
      if fid == 1:
10018 
        if ftype == TType.I64:
10019 
          self.cartId = iprot.readI64();
10020 
        else:
10021 
          iprot.skip(ftype)
10022 
      elif fid == 2:
10023 
        if ftype == TType.I64:
10024 
          self.itemId = iprot.readI64();
10025 
        else:
10026 
          iprot.skip(ftype)
10027 
      elif fid == 3:
10028 
        if ftype == TType.I64:
10029 
          self.quantity = iprot.readI64();
10030 
        else:
10031 
          iprot.skip(ftype)
10032 
      else:
10033 
        iprot.skip(ftype)
10034 
      iprot.readFieldEnd()
10035 
    iprot.readStructEnd()
10036 
 
10037 
  def write(self, oprot):
10038 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10039 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10040 
      return
10041 
    oprot.writeStructBegin('addItemToCart_args')
10042 
    if self.cartId != None:
10043 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10044 
      oprot.writeI64(self.cartId)
10045 
      oprot.writeFieldEnd()
10046 
    if self.itemId != None:
10047 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10048 
      oprot.writeI64(self.itemId)
10049 
      oprot.writeFieldEnd()
10050 
    if self.quantity != None:
10051 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10052 
      oprot.writeI64(self.quantity)
10053 
      oprot.writeFieldEnd()
10054 
    oprot.writeFieldStop()
10055 
    oprot.writeStructEnd()
10056 
 
10057 
  def __repr__(self):
10058 
    L = ['%s=%r' % (key, value)
10059 
      for key, value in self.__dict__.iteritems()]
10060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10061 
 
10062 
  def __eq__(self, other):
10063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10064 
 
10065 
  def __ne__(self, other):
10066 
    return not (self == other)
10067 
 
10068 
class addItemToCart_result:
10069 
  """
10070 
  Attributes:
10071 
   - scx
10072 
  """
10073 
 
10074 
  thrift_spec = (
10075 
    None, # 0
10076 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10077 
  )
10078 
 
10079 
  def __init__(self, scx=None,):
10080 
    self.scx = scx
10081 
 
10082 
  def read(self, iprot):
10083 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10084 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10085 
      return
10086 
    iprot.readStructBegin()
10087 
    while True:
10088 
      (fname, ftype, fid) = iprot.readFieldBegin()
10089 
      if ftype == TType.STOP:
10090 
        break
10091 
      if fid == 1:
10092 
        if ftype == TType.STRUCT:
10093 
          self.scx = ShoppingCartException()
10094 
          self.scx.read(iprot)
10095 
        else:
10096 
          iprot.skip(ftype)
10097 
      else:
10098 
        iprot.skip(ftype)
10099 
      iprot.readFieldEnd()
10100 
    iprot.readStructEnd()
10101 
 
10102 
  def write(self, oprot):
10103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10105 
      return
10106 
    oprot.writeStructBegin('addItemToCart_result')
10107 
    if self.scx != None:
10108 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10109 
      self.scx.write(oprot)
10110 
      oprot.writeFieldEnd()
10111 
    oprot.writeFieldStop()
10112 
    oprot.writeStructEnd()
10113 
 
10114 
  def __repr__(self):
10115 
    L = ['%s=%r' % (key, value)
10116 
      for key, value in self.__dict__.iteritems()]
10117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10118 
 
10119 
  def __eq__(self, other):
10120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10121 
 
10122 
  def __ne__(self, other):
10123 
    return not (self == other)
10124 
 
10125 
class deleteItemFromCart_args:
10126 
  """
10127 
  Attributes:
10128 
   - cartId
10129 
   - itemId
10130 
  """
10131 
 
10132 
  thrift_spec = (
10133 
    None, # 0
10134 
    (1, TType.I64, 'cartId', None, None, ), # 1
10135 
    (2, TType.I64, 'itemId', None, None, ), # 2
10136 
  )
10137 
 
10138 
  def __init__(self, cartId=None, itemId=None,):
10139 
    self.cartId = cartId
10140 
    self.itemId = itemId
10141 
 
10142 
  def read(self, iprot):
10143 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10144 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10145 
      return
10146 
    iprot.readStructBegin()
10147 
    while True:
10148 
      (fname, ftype, fid) = iprot.readFieldBegin()
10149 
      if ftype == TType.STOP:
10150 
        break
10151 
      if fid == 1:
10152 
        if ftype == TType.I64:
10153 
          self.cartId = iprot.readI64();
10154 
        else:
10155 
          iprot.skip(ftype)
10156 
      elif fid == 2:
10157 
        if ftype == TType.I64:
10158 
          self.itemId = iprot.readI64();
10159 
        else:
10160 
          iprot.skip(ftype)
10161 
      else:
10162 
        iprot.skip(ftype)
10163 
      iprot.readFieldEnd()
10164 
    iprot.readStructEnd()
10165 
 
10166 
  def write(self, oprot):
10167 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10168 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10169 
      return
10170 
    oprot.writeStructBegin('deleteItemFromCart_args')
10171 
    if self.cartId != None:
10172 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10173 
      oprot.writeI64(self.cartId)
10174 
      oprot.writeFieldEnd()
10175 
    if self.itemId != None:
10176 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10177 
      oprot.writeI64(self.itemId)
10178 
      oprot.writeFieldEnd()
10179 
    oprot.writeFieldStop()
10180 
    oprot.writeStructEnd()
10181 
 
10182 
  def __repr__(self):
10183 
    L = ['%s=%r' % (key, value)
10184 
      for key, value in self.__dict__.iteritems()]
10185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10186 
 
10187 
  def __eq__(self, other):
10188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10189 
 
10190 
  def __ne__(self, other):
10191 
    return not (self == other)
10192 
 
10193 
class deleteItemFromCart_result:
10194 
  """
10195 
  Attributes:
10196 
   - scx
10197 
  """
10198 
 
10199 
  thrift_spec = (
10200 
    None, # 0
10201 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10202 
  )
10203 
 
10204 
  def __init__(self, scx=None,):
10205 
    self.scx = scx
10206 
 
10207 
  def read(self, iprot):
10208 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10209 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10210 
      return
10211 
    iprot.readStructBegin()
10212 
    while True:
10213 
      (fname, ftype, fid) = iprot.readFieldBegin()
10214 
      if ftype == TType.STOP:
10215 
        break
10216 
      if fid == 1:
10217 
        if ftype == TType.STRUCT:
10218 
          self.scx = ShoppingCartException()
10219 
          self.scx.read(iprot)
10220 
        else:
10221 
          iprot.skip(ftype)
10222 
      else:
10223 
        iprot.skip(ftype)
10224 
      iprot.readFieldEnd()
10225 
    iprot.readStructEnd()
10226 
 
10227 
  def write(self, oprot):
10228 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10229 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10230 
      return
10231 
    oprot.writeStructBegin('deleteItemFromCart_result')
10232 
    if self.scx != None:
10233 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10234 
      self.scx.write(oprot)
10235 
      oprot.writeFieldEnd()
10236 
    oprot.writeFieldStop()
10237 
    oprot.writeStructEnd()
10238 
 
10239 
  def __repr__(self):
10240 
    L = ['%s=%r' % (key, value)
10241 
      for key, value in self.__dict__.iteritems()]
10242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10243 
 
10244 
  def __eq__(self, other):
10245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10246 
 
10247 
  def __ne__(self, other):
10248 
    return not (self == other)
10249 
 
10250 
class changeQuantity_args:
10251 
  """
10252 
  Attributes:
10253 
   - cartId
10254 
   - itemId
10255 
   - quantity
10256 
  """
10257 
 
10258 
  thrift_spec = (
10259 
    None, # 0
10260 
    (1, TType.I64, 'cartId', None, None, ), # 1
10261 
    (2, TType.I64, 'itemId', None, None, ), # 2
10262 
    (3, TType.I64, 'quantity', None, None, ), # 3
10263 
  )
10264 
 
10265 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
10266 
    self.cartId = cartId
10267 
    self.itemId = itemId
10268 
    self.quantity = quantity
10269 
 
10270 
  def read(self, iprot):
10271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10273 
      return
10274 
    iprot.readStructBegin()
10275 
    while True:
10276 
      (fname, ftype, fid) = iprot.readFieldBegin()
10277 
      if ftype == TType.STOP:
10278 
        break
10279 
      if fid == 1:
10280 
        if ftype == TType.I64:
10281 
          self.cartId = iprot.readI64();
10282 
        else:
10283 
          iprot.skip(ftype)
10284 
      elif fid == 2:
10285 
        if ftype == TType.I64:
10286 
          self.itemId = iprot.readI64();
10287 
        else:
10288 
          iprot.skip(ftype)
10289 
      elif fid == 3:
10290 
        if ftype == TType.I64:
10291 
          self.quantity = iprot.readI64();
10292 
        else:
10293 
          iprot.skip(ftype)
10294 
      else:
10295 
        iprot.skip(ftype)
10296 
      iprot.readFieldEnd()
10297 
    iprot.readStructEnd()
10298 
 
10299 
  def write(self, oprot):
10300 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10301 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10302 
      return
10303 
    oprot.writeStructBegin('changeQuantity_args')
10304 
    if self.cartId != None:
10305 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10306 
      oprot.writeI64(self.cartId)
10307 
      oprot.writeFieldEnd()
10308 
    if self.itemId != None:
10309 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10310 
      oprot.writeI64(self.itemId)
10311 
      oprot.writeFieldEnd()
10312 
    if self.quantity != None:
10313 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10314 
      oprot.writeI64(self.quantity)
10315 
      oprot.writeFieldEnd()
10316 
    oprot.writeFieldStop()
10317 
    oprot.writeStructEnd()
10318 
 
10319 
  def __repr__(self):
10320 
    L = ['%s=%r' % (key, value)
10321 
      for key, value in self.__dict__.iteritems()]
10322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10323 
 
10324 
  def __eq__(self, other):
10325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10326 
 
10327 
  def __ne__(self, other):
10328 
    return not (self == other)
10329 
 
10330 
class changeQuantity_result:
10331 
  """
10332 
  Attributes:
10333 
   - scx
10334 
  """
10335 
 
10336 
  thrift_spec = (
10337 
    None, # 0
10338 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10339 
  )
10340 
 
10341 
  def __init__(self, scx=None,):
10342 
    self.scx = scx
10343 
 
10344 
  def read(self, iprot):
10345 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10346 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10347 
      return
10348 
    iprot.readStructBegin()
10349 
    while True:
10350 
      (fname, ftype, fid) = iprot.readFieldBegin()
10351 
      if ftype == TType.STOP:
10352 
        break
10353 
      if fid == 1:
10354 
        if ftype == TType.STRUCT:
10355 
          self.scx = ShoppingCartException()
10356 
          self.scx.read(iprot)
10357 
        else:
10358 
          iprot.skip(ftype)
10359 
      else:
10360 
        iprot.skip(ftype)
10361 
      iprot.readFieldEnd()
10362 
    iprot.readStructEnd()
10363 
 
10364 
  def write(self, oprot):
10365 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10366 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10367 
      return
10368 
    oprot.writeStructBegin('changeQuantity_result')
10369 
    if self.scx != None:
10370 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10371 
      self.scx.write(oprot)
10372 
      oprot.writeFieldEnd()
10373 
    oprot.writeFieldStop()
10374 
    oprot.writeStructEnd()
10375 
 
10376 
  def __repr__(self):
10377 
    L = ['%s=%r' % (key, value)
10378 
      for key, value in self.__dict__.iteritems()]
10379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10380 
 
10381 
  def __eq__(self, other):
10382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10383 
 
10384 
  def __ne__(self, other):
10385 
    return not (self == other)
10386 
 
10387 
class changeItemStatus_args:
10388 
  """
10389 
  Attributes:
10390 
   - cartId
10391 
   - itemId
10392 
   - status
10393 
  """
10394 
 
10395 
  thrift_spec = (
10396 
    None, # 0
10397 
    (1, TType.I64, 'cartId', None, None, ), # 1
10398 
    (2, TType.I64, 'itemId', None, None, ), # 2
10399 
    (3, TType.I32, 'status', None, None, ), # 3
10400 
  )
10401 
 
10402 
  def __init__(self, cartId=None, itemId=None, status=None,):
10403 
    self.cartId = cartId
10404 
    self.itemId = itemId
10405 
    self.status = status
10406 
 
10407 
  def read(self, iprot):
10408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10410 
      return
10411 
    iprot.readStructBegin()
10412 
    while True:
10413 
      (fname, ftype, fid) = iprot.readFieldBegin()
10414 
      if ftype == TType.STOP:
10415 
        break
10416 
      if fid == 1:
10417 
        if ftype == TType.I64:
10418 
          self.cartId = iprot.readI64();
10419 
        else:
10420 
          iprot.skip(ftype)
10421 
      elif fid == 2:
10422 
        if ftype == TType.I64:
10423 
          self.itemId = iprot.readI64();
10424 
        else:
10425 
          iprot.skip(ftype)
10426 
      elif fid == 3:
10427 
        if ftype == TType.I32:
10428 
          self.status = iprot.readI32();
10429 
        else:
10430 
          iprot.skip(ftype)
10431 
      else:
10432 
        iprot.skip(ftype)
10433 
      iprot.readFieldEnd()
10434 
    iprot.readStructEnd()
10435 
 
10436 
  def write(self, oprot):
10437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10439 
      return
10440 
    oprot.writeStructBegin('changeItemStatus_args')
10441 
    if self.cartId != None:
10442 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10443 
      oprot.writeI64(self.cartId)
10444 
      oprot.writeFieldEnd()
10445 
    if self.itemId != None:
10446 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10447 
      oprot.writeI64(self.itemId)
10448 
      oprot.writeFieldEnd()
10449 
    if self.status != None:
10450 
      oprot.writeFieldBegin('status', TType.I32, 3)
10451 
      oprot.writeI32(self.status)
10452 
      oprot.writeFieldEnd()
10453 
    oprot.writeFieldStop()
10454 
    oprot.writeStructEnd()
10455 
 
10456 
  def __repr__(self):
10457 
    L = ['%s=%r' % (key, value)
10458 
      for key, value in self.__dict__.iteritems()]
10459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10460 
 
10461 
  def __eq__(self, other):
10462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10463 
 
10464 
  def __ne__(self, other):
10465 
    return not (self == other)
10466 
 
10467 
class changeItemStatus_result:
10468 
  """
10469 
  Attributes:
10470 
   - scx
10471 
  """
10472 
 
10473 
  thrift_spec = (
10474 
    None, # 0
10475 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10476 
  )
10477 
 
10478 
  def __init__(self, scx=None,):
10479 
    self.scx = scx
10480 
 
10481 
  def read(self, iprot):
10482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10484 
      return
10485 
    iprot.readStructBegin()
10486 
    while True:
10487 
      (fname, ftype, fid) = iprot.readFieldBegin()
10488 
      if ftype == TType.STOP:
10489 
        break
10490 
      if fid == 1:
10491 
        if ftype == TType.STRUCT:
10492 
          self.scx = ShoppingCartException()
10493 
          self.scx.read(iprot)
10494 
        else:
10495 
          iprot.skip(ftype)
10496 
      else:
10497 
        iprot.skip(ftype)
10498 
      iprot.readFieldEnd()
10499 
    iprot.readStructEnd()
10500 
 
10501 
  def write(self, oprot):
10502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10504 
      return
10505 
    oprot.writeStructBegin('changeItemStatus_result')
10506 
    if self.scx != None:
10507 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10508 
      self.scx.write(oprot)
10509 
      oprot.writeFieldEnd()
10510 
    oprot.writeFieldStop()
10511 
    oprot.writeStructEnd()
10512 
 
10513 
  def __repr__(self):
10514 
    L = ['%s=%r' % (key, value)
10515 
      for key, value in self.__dict__.iteritems()]
10516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10517 
 
10518 
  def __eq__(self, other):
10519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10520 
 
10521 
  def __ne__(self, other):
10522 
    return not (self == other)
10523 
 
10524 
class addAddressToCart_args:
10525 
  """
10526 
  Attributes:
10527 
   - cartId
10528 
   - addressId
10529 
  """
10530 
 
10531 
  thrift_spec = (
10532 
    None, # 0
10533 
    (1, TType.I64, 'cartId', None, None, ), # 1
10534 
    (2, TType.I64, 'addressId', None, None, ), # 2
10535 
  )
10536 
 
10537 
  def __init__(self, cartId=None, addressId=None,):
10538 
    self.cartId = cartId
10539 
    self.addressId = addressId
10540 
 
10541 
  def read(self, iprot):
10542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10544 
      return
10545 
    iprot.readStructBegin()
10546 
    while True:
10547 
      (fname, ftype, fid) = iprot.readFieldBegin()
10548 
      if ftype == TType.STOP:
10549 
        break
10550 
      if fid == 1:
10551 
        if ftype == TType.I64:
10552 
          self.cartId = iprot.readI64();
10553 
        else:
10554 
          iprot.skip(ftype)
10555 
      elif fid == 2:
10556 
        if ftype == TType.I64:
10557 
          self.addressId = iprot.readI64();
10558 
        else:
10559 
          iprot.skip(ftype)
10560 
      else:
10561 
        iprot.skip(ftype)
10562 
      iprot.readFieldEnd()
10563 
    iprot.readStructEnd()
10564 
 
10565 
  def write(self, oprot):
10566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10568 
      return
10569 
    oprot.writeStructBegin('addAddressToCart_args')
10570 
    if self.cartId != None:
10571 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10572 
      oprot.writeI64(self.cartId)
10573 
      oprot.writeFieldEnd()
10574 
    if self.addressId != None:
10575 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
10576 
      oprot.writeI64(self.addressId)
10577 
      oprot.writeFieldEnd()
10578 
    oprot.writeFieldStop()
10579 
    oprot.writeStructEnd()
10580 
 
10581 
  def __repr__(self):
10582 
    L = ['%s=%r' % (key, value)
10583 
      for key, value in self.__dict__.iteritems()]
10584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10585 
 
10586 
  def __eq__(self, other):
10587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10588 
 
10589 
  def __ne__(self, other):
10590 
    return not (self == other)
10591 
 
10592 
class addAddressToCart_result:
575 chandransh 10593 
  """
10594 
  Attributes:
10595 
   - scx
10596 
  """
559 chandransh 10597 
 
10598 
  thrift_spec = (
575 chandransh 10599 
    None, # 0
10600 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 10601 
  )
10602 
 
575 chandransh 10603 
  def __init__(self, scx=None,):
10604 
    self.scx = scx
10605 
 
559 chandransh 10606 
  def read(self, iprot):
10607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10609 
      return
10610 
    iprot.readStructBegin()
10611 
    while True:
10612 
      (fname, ftype, fid) = iprot.readFieldBegin()
10613 
      if ftype == TType.STOP:
10614 
        break
575 chandransh 10615 
      if fid == 1:
10616 
        if ftype == TType.STRUCT:
10617 
          self.scx = ShoppingCartException()
10618 
          self.scx.read(iprot)
10619 
        else:
10620 
          iprot.skip(ftype)
559 chandransh 10621 
      else:
10622 
        iprot.skip(ftype)
10623 
      iprot.readFieldEnd()
10624 
    iprot.readStructEnd()
10625 
 
10626 
  def write(self, oprot):
10627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10629 
      return
10630 
    oprot.writeStructBegin('addAddressToCart_result')
575 chandransh 10631 
    if self.scx != None:
10632 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10633 
      self.scx.write(oprot)
10634 
      oprot.writeFieldEnd()
559 chandransh 10635 
    oprot.writeFieldStop()
10636 
    oprot.writeStructEnd()
10637 
 
10638 
  def __repr__(self):
10639 
    L = ['%s=%r' % (key, value)
10640 
      for key, value in self.__dict__.iteritems()]
10641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10642 
 
10643 
  def __eq__(self, other):
10644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10645 
 
10646 
  def __ne__(self, other):
10647 
    return not (self == other)
10648 
 
690 chandransh 10649 
class createOrders_args:
559 chandransh 10650 
  """
10651 
  Attributes:
10652 
   - cartId
10653 
  """
10654 
 
10655 
  thrift_spec = (
10656 
    None, # 0
10657 
    (1, TType.I64, 'cartId', None, None, ), # 1
10658 
  )
10659 
 
10660 
  def __init__(self, cartId=None,):
10661 
    self.cartId = cartId
10662 
 
10663 
  def read(self, iprot):
10664 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10665 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10666 
      return
10667 
    iprot.readStructBegin()
10668 
    while True:
10669 
      (fname, ftype, fid) = iprot.readFieldBegin()
10670 
      if ftype == TType.STOP:
10671 
        break
10672 
      if fid == 1:
10673 
        if ftype == TType.I64:
10674 
          self.cartId = iprot.readI64();
10675 
        else:
10676 
          iprot.skip(ftype)
10677 
      else:
10678 
        iprot.skip(ftype)
10679 
      iprot.readFieldEnd()
10680 
    iprot.readStructEnd()
10681 
 
10682 
  def write(self, oprot):
10683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10685 
      return
690 chandransh 10686 
    oprot.writeStructBegin('createOrders_args')
559 chandransh 10687 
    if self.cartId != None:
10688 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10689 
      oprot.writeI64(self.cartId)
10690 
      oprot.writeFieldEnd()
10691 
    oprot.writeFieldStop()
10692 
    oprot.writeStructEnd()
10693 
 
10694 
  def __repr__(self):
10695 
    L = ['%s=%r' % (key, value)
10696 
      for key, value in self.__dict__.iteritems()]
10697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10698 
 
10699 
  def __eq__(self, other):
10700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10701 
 
10702 
  def __ne__(self, other):
10703 
    return not (self == other)
10704 
 
690 chandransh 10705 
class createOrders_result:
559 chandransh 10706 
  """
10707 
  Attributes:
94 ashish 10708 
   - success
559 chandransh 10709 
   - scx
94 ashish 10710 
  """
10711 
 
10712 
  thrift_spec = (
575 chandransh 10713 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 10714 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10715 
  )
10716 
 
559 chandransh 10717 
  def __init__(self, success=None, scx=None,):
94 ashish 10718 
    self.success = success
559 chandransh 10719 
    self.scx = scx
94 ashish 10720 
 
10721 
  def read(self, iprot):
10722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10724 
      return
10725 
    iprot.readStructBegin()
10726 
    while True:
10727 
      (fname, ftype, fid) = iprot.readFieldBegin()
10728 
      if ftype == TType.STOP:
10729 
        break
10730 
      if fid == 0:
575 chandransh 10731 
        if ftype == TType.I64:
10732 
          self.success = iprot.readI64();
94 ashish 10733 
        else:
10734 
          iprot.skip(ftype)
10735 
      elif fid == 1:
10736 
        if ftype == TType.STRUCT:
559 chandransh 10737 
          self.scx = ShoppingCartException()
10738 
          self.scx.read(iprot)
94 ashish 10739 
        else:
10740 
          iprot.skip(ftype)
10741 
      else:
10742 
        iprot.skip(ftype)
10743 
      iprot.readFieldEnd()
10744 
    iprot.readStructEnd()
10745 
 
10746 
  def write(self, oprot):
10747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10749 
      return
690 chandransh 10750 
    oprot.writeStructBegin('createOrders_result')
94 ashish 10751 
    if self.success != None:
575 chandransh 10752 
      oprot.writeFieldBegin('success', TType.I64, 0)
10753 
      oprot.writeI64(self.success)
94 ashish 10754 
      oprot.writeFieldEnd()
559 chandransh 10755 
    if self.scx != None:
10756 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10757 
      self.scx.write(oprot)
94 ashish 10758 
      oprot.writeFieldEnd()
10759 
    oprot.writeFieldStop()
10760 
    oprot.writeStructEnd()
10761 
 
10762 
  def __repr__(self):
10763 
    L = ['%s=%r' % (key, value)
10764 
      for key, value in self.__dict__.iteritems()]
10765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10766 
 
10767 
  def __eq__(self, other):
10768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10769 
 
10770 
  def __ne__(self, other):
10771 
    return not (self == other)
10772 
 
559 chandransh 10773 
class validateCart_args:
94 ashish 10774 
  """
10775 
  Attributes:
559 chandransh 10776 
   - cartId
94 ashish 10777 
  """
10778 
 
10779 
  thrift_spec = (
10780 
    None, # 0
559 chandransh 10781 
    (1, TType.I64, 'cartId', None, None, ), # 1
94 ashish 10782 
  )
10783 
 
559 chandransh 10784 
  def __init__(self, cartId=None,):
10785 
    self.cartId = cartId
94 ashish 10786 
 
10787 
  def read(self, iprot):
10788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10790 
      return
10791 
    iprot.readStructBegin()
10792 
    while True:
10793 
      (fname, ftype, fid) = iprot.readFieldBegin()
10794 
      if ftype == TType.STOP:
10795 
        break
10796 
      if fid == 1:
10797 
        if ftype == TType.I64:
559 chandransh 10798 
          self.cartId = iprot.readI64();
94 ashish 10799 
        else:
10800 
          iprot.skip(ftype)
10801 
      else:
10802 
        iprot.skip(ftype)
10803 
      iprot.readFieldEnd()
10804 
    iprot.readStructEnd()
10805 
 
10806 
  def write(self, oprot):
10807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10809 
      return
559 chandransh 10810 
    oprot.writeStructBegin('validateCart_args')
10811 
    if self.cartId != None:
10812 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10813 
      oprot.writeI64(self.cartId)
94 ashish 10814 
      oprot.writeFieldEnd()
10815 
    oprot.writeFieldStop()
10816 
    oprot.writeStructEnd()
10817 
 
10818 
  def __repr__(self):
10819 
    L = ['%s=%r' % (key, value)
10820 
      for key, value in self.__dict__.iteritems()]
10821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10822 
 
10823 
  def __eq__(self, other):
10824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10825 
 
10826 
  def __ne__(self, other):
10827 
    return not (self == other)
10828 
 
559 chandransh 10829 
class validateCart_result:
94 ashish 10830 
  """
10831 
  Attributes:
10832 
   - success
575 chandransh 10833 
   - scex
94 ashish 10834 
  """
10835 
 
10836 
  thrift_spec = (
1466 ankur.sing 10837 
    (0, TType.STRING, 'success', None, None, ), # 0
575 chandransh 10838 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10839 
  )
10840 
 
575 chandransh 10841 
  def __init__(self, success=None, scex=None,):
94 ashish 10842 
    self.success = success
575 chandransh 10843 
    self.scex = scex
94 ashish 10844 
 
10845 
  def read(self, iprot):
10846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10848 
      return
10849 
    iprot.readStructBegin()
10850 
    while True:
10851 
      (fname, ftype, fid) = iprot.readFieldBegin()
10852 
      if ftype == TType.STOP:
10853 
        break
10854 
      if fid == 0:
1466 ankur.sing 10855 
        if ftype == TType.STRING:
10856 
          self.success = iprot.readString();
94 ashish 10857 
        else:
10858 
          iprot.skip(ftype)
575 chandransh 10859 
      elif fid == 1:
10860 
        if ftype == TType.STRUCT:
10861 
          self.scex = ShoppingCartException()
10862 
          self.scex.read(iprot)
10863 
        else:
10864 
          iprot.skip(ftype)
94 ashish 10865 
      else:
10866 
        iprot.skip(ftype)
10867 
      iprot.readFieldEnd()
10868 
    iprot.readStructEnd()
10869 
 
10870 
  def write(self, oprot):
10871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10873 
      return
559 chandransh 10874 
    oprot.writeStructBegin('validateCart_result')
94 ashish 10875 
    if self.success != None:
1466 ankur.sing 10876 
      oprot.writeFieldBegin('success', TType.STRING, 0)
10877 
      oprot.writeString(self.success)
94 ashish 10878 
      oprot.writeFieldEnd()
575 chandransh 10879 
    if self.scex != None:
10880 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
10881 
      self.scex.write(oprot)
10882 
      oprot.writeFieldEnd()
559 chandransh 10883 
    oprot.writeFieldStop()
10884 
    oprot.writeStructEnd()
10885 
 
10886 
  def __repr__(self):
10887 
    L = ['%s=%r' % (key, value)
10888 
      for key, value in self.__dict__.iteritems()]
10889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10890 
 
10891 
  def __eq__(self, other):
10892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10893 
 
10894 
  def __ne__(self, other):
10895 
    return not (self == other)
10896 
 
690 chandransh 10897 
class mergeCart_args:
575 chandransh 10898 
  """
10899 
  Attributes:
690 chandransh 10900 
   - fromCartId
10901 
   - toCartId
10902 
  """
10903 
 
10904 
  thrift_spec = (
10905 
    None, # 0
10906 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
10907 
    (2, TType.I64, 'toCartId', None, None, ), # 2
10908 
  )
10909 
 
10910 
  def __init__(self, fromCartId=None, toCartId=None,):
10911 
    self.fromCartId = fromCartId
10912 
    self.toCartId = toCartId
10913 
 
10914 
  def read(self, iprot):
10915 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10916 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10917 
      return
10918 
    iprot.readStructBegin()
10919 
    while True:
10920 
      (fname, ftype, fid) = iprot.readFieldBegin()
10921 
      if ftype == TType.STOP:
10922 
        break
10923 
      if fid == 1:
10924 
        if ftype == TType.I64:
10925 
          self.fromCartId = iprot.readI64();
10926 
        else:
10927 
          iprot.skip(ftype)
10928 
      elif fid == 2:
10929 
        if ftype == TType.I64:
10930 
          self.toCartId = iprot.readI64();
10931 
        else:
10932 
          iprot.skip(ftype)
10933 
      else:
10934 
        iprot.skip(ftype)
10935 
      iprot.readFieldEnd()
10936 
    iprot.readStructEnd()
10937 
 
10938 
  def write(self, oprot):
10939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10941 
      return
10942 
    oprot.writeStructBegin('mergeCart_args')
10943 
    if self.fromCartId != None:
10944 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
10945 
      oprot.writeI64(self.fromCartId)
10946 
      oprot.writeFieldEnd()
10947 
    if self.toCartId != None:
10948 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
10949 
      oprot.writeI64(self.toCartId)
10950 
      oprot.writeFieldEnd()
10951 
    oprot.writeFieldStop()
10952 
    oprot.writeStructEnd()
10953 
 
10954 
  def __repr__(self):
10955 
    L = ['%s=%r' % (key, value)
10956 
      for key, value in self.__dict__.iteritems()]
10957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10958 
 
10959 
  def __eq__(self, other):
10960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10961 
 
10962 
  def __ne__(self, other):
10963 
    return not (self == other)
10964 
 
10965 
class mergeCart_result:
10966 
 
10967 
  thrift_spec = (
10968 
  )
10969 
 
10970 
  def read(self, iprot):
10971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10973 
      return
10974 
    iprot.readStructBegin()
10975 
    while True:
10976 
      (fname, ftype, fid) = iprot.readFieldBegin()
10977 
      if ftype == TType.STOP:
10978 
        break
10979 
      else:
10980 
        iprot.skip(ftype)
10981 
      iprot.readFieldEnd()
10982 
    iprot.readStructEnd()
10983 
 
10984 
  def write(self, oprot):
10985 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10986 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10987 
      return
10988 
    oprot.writeStructBegin('mergeCart_result')
10989 
    oprot.writeFieldStop()
10990 
    oprot.writeStructEnd()
10991 
 
10992 
  def __repr__(self):
10993 
    L = ['%s=%r' % (key, value)
10994 
      for key, value in self.__dict__.iteritems()]
10995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10996 
 
10997 
  def __eq__(self, other):
10998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10999 
 
11000 
  def __ne__(self, other):
11001 
    return not (self == other)
11002 
 
11003 
class checkOut_args:
11004 
  """
11005 
  Attributes:
575 chandransh 11006 
   - cartId
11007 
  """
11008 
 
11009 
  thrift_spec = (
11010 
    None, # 0
11011 
    (1, TType.I64, 'cartId', None, None, ), # 1
11012 
  )
11013 
 
11014 
  def __init__(self, cartId=None,):
11015 
    self.cartId = cartId
11016 
 
11017 
  def read(self, iprot):
11018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11020 
      return
11021 
    iprot.readStructBegin()
11022 
    while True:
11023 
      (fname, ftype, fid) = iprot.readFieldBegin()
11024 
      if ftype == TType.STOP:
11025 
        break
11026 
      if fid == 1:
11027 
        if ftype == TType.I64:
11028 
          self.cartId = iprot.readI64();
11029 
        else:
11030 
          iprot.skip(ftype)
11031 
      else:
11032 
        iprot.skip(ftype)
11033 
      iprot.readFieldEnd()
11034 
    iprot.readStructEnd()
11035 
 
11036 
  def write(self, oprot):
11037 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11038 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11039 
      return
690 chandransh 11040 
    oprot.writeStructBegin('checkOut_args')
575 chandransh 11041 
    if self.cartId != None:
11042 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11043 
      oprot.writeI64(self.cartId)
11044 
      oprot.writeFieldEnd()
11045 
    oprot.writeFieldStop()
11046 
    oprot.writeStructEnd()
11047 
 
11048 
  def __repr__(self):
11049 
    L = ['%s=%r' % (key, value)
11050 
      for key, value in self.__dict__.iteritems()]
11051 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11052 
 
11053 
  def __eq__(self, other):
11054 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11055 
 
11056 
  def __ne__(self, other):
11057 
    return not (self == other)
11058 
 
690 chandransh 11059 
class checkOut_result:
575 chandransh 11060 
  """
11061 
  Attributes:
11062 
   - success
11063 
   - scex
11064 
  """
11065 
 
11066 
  thrift_spec = (
11067 
    (0, TType.BOOL, 'success', None, None, ), # 0
11068 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11069 
  )
11070 
 
11071 
  def __init__(self, success=None, scex=None,):
11072 
    self.success = success
11073 
    self.scex = scex
11074 
 
11075 
  def read(self, iprot):
11076 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11077 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11078 
      return
11079 
    iprot.readStructBegin()
11080 
    while True:
11081 
      (fname, ftype, fid) = iprot.readFieldBegin()
11082 
      if ftype == TType.STOP:
11083 
        break
11084 
      if fid == 0:
11085 
        if ftype == TType.BOOL:
11086 
          self.success = iprot.readBool();
11087 
        else:
11088 
          iprot.skip(ftype)
11089 
      elif fid == 1:
11090 
        if ftype == TType.STRUCT:
11091 
          self.scex = ShoppingCartException()
11092 
          self.scex.read(iprot)
11093 
        else:
11094 
          iprot.skip(ftype)
11095 
      else:
11096 
        iprot.skip(ftype)
11097 
      iprot.readFieldEnd()
11098 
    iprot.readStructEnd()
11099 
 
11100 
  def write(self, oprot):
11101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11103 
      return
690 chandransh 11104 
    oprot.writeStructBegin('checkOut_result')
575 chandransh 11105 
    if self.success != None:
11106 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11107 
      oprot.writeBool(self.success)
11108 
      oprot.writeFieldEnd()
11109 
    if self.scex != None:
11110 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11111 
      self.scex.write(oprot)
11112 
      oprot.writeFieldEnd()
11113 
    oprot.writeFieldStop()
11114 
    oprot.writeStructEnd()
11115 
 
11116 
  def __repr__(self):
11117 
    L = ['%s=%r' % (key, value)
11118 
      for key, value in self.__dict__.iteritems()]
11119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11120 
 
11121 
  def __eq__(self, other):
11122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11123 
 
11124 
  def __ne__(self, other):
11125 
    return not (self == other)
11126 
 
690 chandransh 11127 
class resetCart_args:
559 chandransh 11128 
  """
11129 
  Attributes:
690 chandransh 11130 
   - cartId
11131 
   - items
559 chandransh 11132 
  """
11133 
 
11134 
  thrift_spec = (
11135 
    None, # 0
690 chandransh 11136 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 11137 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 11138 
  )
11139 
 
690 chandransh 11140 
  def __init__(self, cartId=None, items=None,):
11141 
    self.cartId = cartId
11142 
    self.items = items
559 chandransh 11143 
 
11144 
  def read(self, iprot):
11145 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11146 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11147 
      return
11148 
    iprot.readStructBegin()
11149 
    while True:
11150 
      (fname, ftype, fid) = iprot.readFieldBegin()
11151 
      if ftype == TType.STOP:
11152 
        break
11153 
      if fid == 1:
11154 
        if ftype == TType.I64:
690 chandransh 11155 
          self.cartId = iprot.readI64();
559 chandransh 11156 
        else:
11157 
          iprot.skip(ftype)
11158 
      elif fid == 2:
690 chandransh 11159 
        if ftype == TType.MAP:
11160 
          self.items = {}
1845 vikas 11161 
          (_ktype106, _vtype107, _size105 ) = iprot.readMapBegin()
11162 
          for _i109 in xrange(_size105):
11163 
            _key110 = iprot.readI64();
11164 
            _val111 = iprot.readDouble();
11165 
            self.items[_key110] = _val111
690 chandransh 11166 
          iprot.readMapEnd()
559 chandransh 11167 
        else:
11168 
          iprot.skip(ftype)
11169 
      else:
11170 
        iprot.skip(ftype)
11171 
      iprot.readFieldEnd()
11172 
    iprot.readStructEnd()
11173 
 
11174 
  def write(self, oprot):
11175 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11176 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11177 
      return
690 chandransh 11178 
    oprot.writeStructBegin('resetCart_args')
11179 
    if self.cartId != None:
11180 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11181 
      oprot.writeI64(self.cartId)
94 ashish 11182 
      oprot.writeFieldEnd()
690 chandransh 11183 
    if self.items != None:
11184 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 11185 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
1845 vikas 11186 
      for kiter112,viter113 in self.items.items():
11187 
        oprot.writeI64(kiter112)
11188 
        oprot.writeDouble(viter113)
690 chandransh 11189 
      oprot.writeMapEnd()
559 chandransh 11190 
      oprot.writeFieldEnd()
94 ashish 11191 
    oprot.writeFieldStop()
11192 
    oprot.writeStructEnd()
11193 
 
11194 
  def __repr__(self):
11195 
    L = ['%s=%r' % (key, value)
11196 
      for key, value in self.__dict__.iteritems()]
11197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11198 
 
11199 
  def __eq__(self, other):
11200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11201 
 
11202 
  def __ne__(self, other):
11203 
    return not (self == other)
11204 
 
690 chandransh 11205 
class resetCart_result:
11206 
  """
11207 
  Attributes:
11208 
   - success
11209 
   - scex
11210 
  """
559 chandransh 11211 
 
11212 
  thrift_spec = (
690 chandransh 11213 
    (0, TType.BOOL, 'success', None, None, ), # 0
11214 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11215 
  )
11216 
 
690 chandransh 11217 
  def __init__(self, success=None, scex=None,):
11218 
    self.success = success
11219 
    self.scex = scex
11220 
 
559 chandransh 11221 
  def read(self, iprot):
11222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11224 
      return
11225 
    iprot.readStructBegin()
11226 
    while True:
11227 
      (fname, ftype, fid) = iprot.readFieldBegin()
11228 
      if ftype == TType.STOP:
11229 
        break
690 chandransh 11230 
      if fid == 0:
11231 
        if ftype == TType.BOOL:
11232 
          self.success = iprot.readBool();
11233 
        else:
11234 
          iprot.skip(ftype)
11235 
      elif fid == 1:
11236 
        if ftype == TType.STRUCT:
11237 
          self.scex = ShoppingCartException()
11238 
          self.scex.read(iprot)
11239 
        else:
11240 
          iprot.skip(ftype)
559 chandransh 11241 
      else:
11242 
        iprot.skip(ftype)
11243 
      iprot.readFieldEnd()
11244 
    iprot.readStructEnd()
11245 
 
11246 
  def write(self, oprot):
11247 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11248 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11249 
      return
690 chandransh 11250 
    oprot.writeStructBegin('resetCart_result')
11251 
    if self.success != None:
11252 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11253 
      oprot.writeBool(self.success)
11254 
      oprot.writeFieldEnd()
11255 
    if self.scex != None:
11256 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11257 
      self.scex.write(oprot)
11258 
      oprot.writeFieldEnd()
559 chandransh 11259 
    oprot.writeFieldStop()
11260 
    oprot.writeStructEnd()
11261 
 
11262 
  def __repr__(self):
11263 
    L = ['%s=%r' % (key, value)
11264 
      for key, value in self.__dict__.iteritems()]
11265 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11266 
 
11267 
  def __eq__(self, other):
11268 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11269 
 
11270 
  def __ne__(self, other):
11271 
    return not (self == other)
11272 
 
772 rajveer 11273 
class getMyResearch_args:
94 ashish 11274 
  """
11275 
  Attributes:
559 chandransh 11276 
   - userId
11277 
  """
11278 
 
11279 
  thrift_spec = (
11280 
    None, # 0
772 rajveer 11281 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 11282 
  )
11283 
 
772 rajveer 11284 
  def __init__(self, userId=None,):
559 chandransh 11285 
    self.userId = userId
11286 
 
11287 
  def read(self, iprot):
11288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11290 
      return
11291 
    iprot.readStructBegin()
11292 
    while True:
11293 
      (fname, ftype, fid) = iprot.readFieldBegin()
11294 
      if ftype == TType.STOP:
11295 
        break
11296 
      if fid == 1:
11297 
        if ftype == TType.I64:
11298 
          self.userId = iprot.readI64();
11299 
        else:
11300 
          iprot.skip(ftype)
11301 
      else:
11302 
        iprot.skip(ftype)
11303 
      iprot.readFieldEnd()
11304 
    iprot.readStructEnd()
11305 
 
11306 
  def write(self, oprot):
11307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11309 
      return
772 rajveer 11310 
    oprot.writeStructBegin('getMyResearch_args')
559 chandransh 11311 
    if self.userId != None:
772 rajveer 11312 
      oprot.writeFieldBegin('userId', TType.I64, 1)
559 chandransh 11313 
      oprot.writeI64(self.userId)
11314 
      oprot.writeFieldEnd()
11315 
    oprot.writeFieldStop()
11316 
    oprot.writeStructEnd()
11317 
 
11318 
  def __repr__(self):
11319 
    L = ['%s=%r' % (key, value)
11320 
      for key, value in self.__dict__.iteritems()]
11321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11322 
 
11323 
  def __eq__(self, other):
11324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11325 
 
11326 
  def __ne__(self, other):
11327 
    return not (self == other)
11328 
 
11329 
class getMyResearch_result:
94 ashish 11330 
  """
11331 
  Attributes:
11332 
   - success
559 chandransh 11333 
   - scx
94 ashish 11334 
  """
11335 
 
11336 
  thrift_spec = (
559 chandransh 11337 
    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
11338 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
94 ashish 11339 
  )
11340 
 
559 chandransh 11341 
  def __init__(self, success=None, scx=None,):
94 ashish 11342 
    self.success = success
559 chandransh 11343 
    self.scx = scx
94 ashish 11344 
 
11345 
  def read(self, iprot):
11346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11348 
      return
11349 
    iprot.readStructBegin()
11350 
    while True:
11351 
      (fname, ftype, fid) = iprot.readFieldBegin()
11352 
      if ftype == TType.STOP:
11353 
        break
11354 
      if fid == 0:
559 chandransh 11355 
        if ftype == TType.STRUCT:
11356 
          self.success = Widget()
11357 
          self.success.read(iprot)
94 ashish 11358 
        else:
11359 
          iprot.skip(ftype)
11360 
      elif fid == 1:
11361 
        if ftype == TType.STRUCT:
559 chandransh 11362 
          self.scx = WidgetException()
11363 
          self.scx.read(iprot)
94 ashish 11364 
        else:
11365 
          iprot.skip(ftype)
11366 
      else:
11367 
        iprot.skip(ftype)
11368 
      iprot.readFieldEnd()
11369 
    iprot.readStructEnd()
11370 
 
11371 
  def write(self, oprot):
11372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11374 
      return
559 chandransh 11375 
    oprot.writeStructBegin('getMyResearch_result')
94 ashish 11376 
    if self.success != None:
559 chandransh 11377 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11378 
      self.success.write(oprot)
94 ashish 11379 
      oprot.writeFieldEnd()
559 chandransh 11380 
    if self.scx != None:
11381 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11382 
      self.scx.write(oprot)
94 ashish 11383 
      oprot.writeFieldEnd()
11384 
    oprot.writeFieldStop()
11385 
    oprot.writeStructEnd()
11386 
 
11387 
  def __repr__(self):
11388 
    L = ['%s=%r' % (key, value)
11389 
      for key, value in self.__dict__.iteritems()]
11390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11391 
 
11392 
  def __eq__(self, other):
11393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11394 
 
11395 
  def __ne__(self, other):
11396 
    return not (self == other)
11397 
 
559 chandransh 11398 
class updateMyResearch_args:
94 ashish 11399 
  """
11400 
  Attributes:
772 rajveer 11401 
   - userId
11402 
   - itemId
94 ashish 11403 
  """
11404 
 
11405 
  thrift_spec = (
11406 
    None, # 0
772 rajveer 11407 
    (1, TType.I64, 'userId', None, None, ), # 1
11408 
    (2, TType.I64, 'itemId', None, None, ), # 2
94 ashish 11409 
  )
11410 
 
772 rajveer 11411 
  def __init__(self, userId=None, itemId=None,):
11412 
    self.userId = userId
11413 
    self.itemId = itemId
94 ashish 11414 
 
11415 
  def read(self, iprot):
11416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11418 
      return
11419 
    iprot.readStructBegin()
11420 
    while True:
11421 
      (fname, ftype, fid) = iprot.readFieldBegin()
11422 
      if ftype == TType.STOP:
11423 
        break
11424 
      if fid == 1:
11425 
        if ftype == TType.I64:
772 rajveer 11426 
          self.userId = iprot.readI64();
94 ashish 11427 
        else:
11428 
          iprot.skip(ftype)
11429 
      elif fid == 2:
559 chandransh 11430 
        if ftype == TType.I64:
772 rajveer 11431 
          self.itemId = iprot.readI64();
94 ashish 11432 
        else:
11433 
          iprot.skip(ftype)
11434 
      else:
11435 
        iprot.skip(ftype)
11436 
      iprot.readFieldEnd()
11437 
    iprot.readStructEnd()
11438 
 
11439 
  def write(self, oprot):
11440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11442 
      return
559 chandransh 11443 
    oprot.writeStructBegin('updateMyResearch_args')
772 rajveer 11444 
    if self.userId != None:
11445 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11446 
      oprot.writeI64(self.userId)
94 ashish 11447 
      oprot.writeFieldEnd()
772 rajveer 11448 
    if self.itemId != None:
11449 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11450 
      oprot.writeI64(self.itemId)
94 ashish 11451 
      oprot.writeFieldEnd()
11452 
    oprot.writeFieldStop()
11453 
    oprot.writeStructEnd()
11454 
 
11455 
  def __repr__(self):
11456 
    L = ['%s=%r' % (key, value)
11457 
      for key, value in self.__dict__.iteritems()]
11458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11459 
 
11460 
  def __eq__(self, other):
11461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11462 
 
11463 
  def __ne__(self, other):
11464 
    return not (self == other)
11465 
 
559 chandransh 11466 
class updateMyResearch_result:
94 ashish 11467 
  """
11468 
  Attributes:
11469 
   - success
559 chandransh 11470 
   - scx
94 ashish 11471 
  """
11472 
 
11473 
  thrift_spec = (
11474 
    (0, TType.BOOL, 'success', None, None, ), # 0
559 chandransh 11475 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
94 ashish 11476 
  )
11477 
 
559 chandransh 11478 
  def __init__(self, success=None, scx=None,):
94 ashish 11479 
    self.success = success
559 chandransh 11480 
    self.scx = scx
94 ashish 11481 
 
11482 
  def read(self, iprot):
11483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11485 
      return
11486 
    iprot.readStructBegin()
11487 
    while True:
11488 
      (fname, ftype, fid) = iprot.readFieldBegin()
11489 
      if ftype == TType.STOP:
11490 
        break
11491 
      if fid == 0:
11492 
        if ftype == TType.BOOL:
11493 
          self.success = iprot.readBool();
11494 
        else:
11495 
          iprot.skip(ftype)
11496 
      elif fid == 1:
11497 
        if ftype == TType.STRUCT:
559 chandransh 11498 
          self.scx = WidgetException()
11499 
          self.scx.read(iprot)
94 ashish 11500 
        else:
11501 
          iprot.skip(ftype)
11502 
      else:
11503 
        iprot.skip(ftype)
11504 
      iprot.readFieldEnd()
11505 
    iprot.readStructEnd()
11506 
 
11507 
  def write(self, oprot):
11508 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11509 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11510 
      return
559 chandransh 11511 
    oprot.writeStructBegin('updateMyResearch_result')
94 ashish 11512 
    if self.success != None:
11513 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11514 
      oprot.writeBool(self.success)
11515 
      oprot.writeFieldEnd()
559 chandransh 11516 
    if self.scx != None:
11517 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11518 
      self.scx.write(oprot)
94 ashish 11519 
      oprot.writeFieldEnd()
11520 
    oprot.writeFieldStop()
11521 
    oprot.writeStructEnd()
11522 
 
11523 
  def __repr__(self):
11524 
    L = ['%s=%r' % (key, value)
11525 
      for key, value in self.__dict__.iteritems()]
11526 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11527 
 
11528 
  def __eq__(self, other):
11529 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11530 
 
11531 
  def __ne__(self, other):
11532 
    return not (self == other)
11533 
 
559 chandransh 11534 
class deleteItemFromMyResearch_args:
130 ashish 11535 
  """
11536 
  Attributes:
772 rajveer 11537 
   - userId
11538 
   - itemId
130 ashish 11539 
  """
94 ashish 11540 
 
130 ashish 11541 
  thrift_spec = (
11542 
    None, # 0
772 rajveer 11543 
    (1, TType.I64, 'userId', None, None, ), # 1
11544 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 11545 
  )
11546 
 
772 rajveer 11547 
  def __init__(self, userId=None, itemId=None,):
11548 
    self.userId = userId
11549 
    self.itemId = itemId
130 ashish 11550 
 
11551 
  def read(self, iprot):
11552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11554 
      return
11555 
    iprot.readStructBegin()
11556 
    while True:
11557 
      (fname, ftype, fid) = iprot.readFieldBegin()
11558 
      if ftype == TType.STOP:
11559 
        break
11560 
      if fid == 1:
11561 
        if ftype == TType.I64:
772 rajveer 11562 
          self.userId = iprot.readI64();
130 ashish 11563 
        else:
11564 
          iprot.skip(ftype)
559 chandransh 11565 
      elif fid == 2:
11566 
        if ftype == TType.I64:
772 rajveer 11567 
          self.itemId = iprot.readI64();
559 chandransh 11568 
        else:
11569 
          iprot.skip(ftype)
130 ashish 11570 
      else:
11571 
        iprot.skip(ftype)
11572 
      iprot.readFieldEnd()
11573 
    iprot.readStructEnd()
11574 
 
11575 
  def write(self, oprot):
11576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11578 
      return
559 chandransh 11579 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
772 rajveer 11580 
    if self.userId != None:
11581 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11582 
      oprot.writeI64(self.userId)
130 ashish 11583 
      oprot.writeFieldEnd()
772 rajveer 11584 
    if self.itemId != None:
11585 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11586 
      oprot.writeI64(self.itemId)
559 chandransh 11587 
      oprot.writeFieldEnd()
130 ashish 11588 
    oprot.writeFieldStop()
11589 
    oprot.writeStructEnd()
11590 
 
11591 
  def __repr__(self):
11592 
    L = ['%s=%r' % (key, value)
11593 
      for key, value in self.__dict__.iteritems()]
11594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11595 
 
11596 
  def __eq__(self, other):
11597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11598 
 
11599 
  def __ne__(self, other):
11600 
    return not (self == other)
11601 
 
559 chandransh 11602 
class deleteItemFromMyResearch_result:
130 ashish 11603 
  """
11604 
  Attributes:
559 chandransh 11605 
   - scx
11606 
  """
11607 
 
11608 
  thrift_spec = (
11609 
    None, # 0
11610 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
11611 
  )
11612 
 
11613 
  def __init__(self, scx=None,):
11614 
    self.scx = scx
11615 
 
11616 
  def read(self, iprot):
11617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11619 
      return
11620 
    iprot.readStructBegin()
11621 
    while True:
11622 
      (fname, ftype, fid) = iprot.readFieldBegin()
11623 
      if ftype == TType.STOP:
11624 
        break
11625 
      if fid == 1:
11626 
        if ftype == TType.STRUCT:
11627 
          self.scx = WidgetException()
11628 
          self.scx.read(iprot)
11629 
        else:
11630 
          iprot.skip(ftype)
11631 
      else:
11632 
        iprot.skip(ftype)
11633 
      iprot.readFieldEnd()
11634 
    iprot.readStructEnd()
11635 
 
11636 
  def write(self, oprot):
11637 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11638 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11639 
      return
11640 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
11641 
    if self.scx != None:
11642 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11643 
      self.scx.write(oprot)
11644 
      oprot.writeFieldEnd()
11645 
    oprot.writeFieldStop()
11646 
    oprot.writeStructEnd()
11647 
 
11648 
  def __repr__(self):
11649 
    L = ['%s=%r' % (key, value)
11650 
      for key, value in self.__dict__.iteritems()]
11651 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11652 
 
11653 
  def __eq__(self, other):
11654 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11655 
 
11656 
  def __ne__(self, other):
11657 
    return not (self == other)
11658 
 
772 rajveer 11659 
class updateBrowseHistory_args:
559 chandransh 11660 
  """
11661 
  Attributes:
772 rajveer 11662 
   - userId
11663 
   - itemId
559 chandransh 11664 
  """
11665 
 
11666 
  thrift_spec = (
11667 
    None, # 0
772 rajveer 11668 
    (1, TType.I64, 'userId', None, None, ), # 1
11669 
    (2, TType.I64, 'itemId', None, None, ), # 2
559 chandransh 11670 
  )
11671 
 
772 rajveer 11672 
  def __init__(self, userId=None, itemId=None,):
11673 
    self.userId = userId
11674 
    self.itemId = itemId
559 chandransh 11675 
 
11676 
  def read(self, iprot):
11677 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11678 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11679 
      return
11680 
    iprot.readStructBegin()
11681 
    while True:
11682 
      (fname, ftype, fid) = iprot.readFieldBegin()
11683 
      if ftype == TType.STOP:
11684 
        break
11685 
      if fid == 1:
11686 
        if ftype == TType.I64:
772 rajveer 11687 
          self.userId = iprot.readI64();
559 chandransh 11688 
        else:
11689 
          iprot.skip(ftype)
11690 
      elif fid == 2:
11691 
        if ftype == TType.I64:
772 rajveer 11692 
          self.itemId = iprot.readI64();
559 chandransh 11693 
        else:
11694 
          iprot.skip(ftype)
11695 
      else:
11696 
        iprot.skip(ftype)
11697 
      iprot.readFieldEnd()
11698 
    iprot.readStructEnd()
11699 
 
11700 
  def write(self, oprot):
11701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11703 
      return
772 rajveer 11704 
    oprot.writeStructBegin('updateBrowseHistory_args')
11705 
    if self.userId != None:
11706 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11707 
      oprot.writeI64(self.userId)
559 chandransh 11708 
      oprot.writeFieldEnd()
772 rajveer 11709 
    if self.itemId != None:
11710 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11711 
      oprot.writeI64(self.itemId)
559 chandransh 11712 
      oprot.writeFieldEnd()
11713 
    oprot.writeFieldStop()
11714 
    oprot.writeStructEnd()
11715 
 
11716 
  def __repr__(self):
11717 
    L = ['%s=%r' % (key, value)
11718 
      for key, value in self.__dict__.iteritems()]
11719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11720 
 
11721 
  def __eq__(self, other):
11722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11723 
 
11724 
  def __ne__(self, other):
11725 
    return not (self == other)
11726 
 
772 rajveer 11727 
class updateBrowseHistory_result:
559 chandransh 11728 
 
11729 
  thrift_spec = (
11730 
  )
11731 
 
11732 
  def read(self, iprot):
11733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11735 
      return
11736 
    iprot.readStructBegin()
11737 
    while True:
11738 
      (fname, ftype, fid) = iprot.readFieldBegin()
11739 
      if ftype == TType.STOP:
11740 
        break
11741 
      else:
11742 
        iprot.skip(ftype)
11743 
      iprot.readFieldEnd()
11744 
    iprot.readStructEnd()
11745 
 
11746 
  def write(self, oprot):
11747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11749 
      return
772 rajveer 11750 
    oprot.writeStructBegin('updateBrowseHistory_result')
559 chandransh 11751 
    oprot.writeFieldStop()
11752 
    oprot.writeStructEnd()
11753 
 
11754 
  def __repr__(self):
11755 
    L = ['%s=%r' % (key, value)
11756 
      for key, value in self.__dict__.iteritems()]
11757 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11758 
 
11759 
  def __eq__(self, other):
11760 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11761 
 
11762 
  def __ne__(self, other):
11763 
    return not (self == other)
11764 
 
772 rajveer 11765 
class getBrowseHistory_args:
559 chandransh 11766 
  """
11767 
  Attributes:
772 rajveer 11768 
   - userId
559 chandransh 11769 
  """
11770 
 
11771 
  thrift_spec = (
11772 
    None, # 0
772 rajveer 11773 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 11774 
  )
11775 
 
772 rajveer 11776 
  def __init__(self, userId=None,):
11777 
    self.userId = userId
559 chandransh 11778 
 
11779 
  def read(self, iprot):
11780 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11781 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11782 
      return
11783 
    iprot.readStructBegin()
11784 
    while True:
11785 
      (fname, ftype, fid) = iprot.readFieldBegin()
11786 
      if ftype == TType.STOP:
11787 
        break
11788 
      if fid == 1:
11789 
        if ftype == TType.I64:
772 rajveer 11790 
          self.userId = iprot.readI64();
559 chandransh 11791 
        else:
11792 
          iprot.skip(ftype)
11793 
      else:
11794 
        iprot.skip(ftype)
11795 
      iprot.readFieldEnd()
11796 
    iprot.readStructEnd()
11797 
 
11798 
  def write(self, oprot):
11799 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11800 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11801 
      return
772 rajveer 11802 
    oprot.writeStructBegin('getBrowseHistory_args')
11803 
    if self.userId != None:
11804 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11805 
      oprot.writeI64(self.userId)
559 chandransh 11806 
      oprot.writeFieldEnd()
11807 
    oprot.writeFieldStop()
11808 
    oprot.writeStructEnd()
11809 
 
11810 
  def __repr__(self):
11811 
    L = ['%s=%r' % (key, value)
11812 
      for key, value in self.__dict__.iteritems()]
11813 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11814 
 
11815 
  def __eq__(self, other):
11816 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11817 
 
11818 
  def __ne__(self, other):
11819 
    return not (self == other)
11820 
 
772 rajveer 11821 
class getBrowseHistory_result:
559 chandransh 11822 
  """
11823 
  Attributes:
130 ashish 11824 
   - success
559 chandransh 11825 
   - scx
130 ashish 11826 
  """
11827 
 
11828 
  thrift_spec = (
772 rajveer 11829 
    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
559 chandransh 11830 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 11831 
  )
11832 
 
559 chandransh 11833 
  def __init__(self, success=None, scx=None,):
130 ashish 11834 
    self.success = success
559 chandransh 11835 
    self.scx = scx
130 ashish 11836 
 
11837 
  def read(self, iprot):
11838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11840 
      return
11841 
    iprot.readStructBegin()
11842 
    while True:
11843 
      (fname, ftype, fid) = iprot.readFieldBegin()
11844 
      if ftype == TType.STOP:
11845 
        break
11846 
      if fid == 0:
559 chandransh 11847 
        if ftype == TType.STRUCT:
772 rajveer 11848 
          self.success = Widget()
559 chandransh 11849 
          self.success.read(iprot)
130 ashish 11850 
        else:
11851 
          iprot.skip(ftype)
11852 
      elif fid == 1:
11853 
        if ftype == TType.STRUCT:
559 chandransh 11854 
          self.scx = WidgetException()
11855 
          self.scx.read(iprot)
130 ashish 11856 
        else:
11857 
          iprot.skip(ftype)
11858 
      else:
11859 
        iprot.skip(ftype)
11860 
      iprot.readFieldEnd()
11861 
    iprot.readStructEnd()
11862 
 
11863 
  def write(self, oprot):
11864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11866 
      return
772 rajveer 11867 
    oprot.writeStructBegin('getBrowseHistory_result')
130 ashish 11868 
    if self.success != None:
559 chandransh 11869 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11870 
      self.success.write(oprot)
130 ashish 11871 
      oprot.writeFieldEnd()
559 chandransh 11872 
    if self.scx != None:
11873 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11874 
      self.scx.write(oprot)
130 ashish 11875 
      oprot.writeFieldEnd()
11876 
    oprot.writeFieldStop()
11877 
    oprot.writeStructEnd()
11878 
 
11879 
  def __repr__(self):
11880 
    L = ['%s=%r' % (key, value)
11881 
      for key, value in self.__dict__.iteritems()]
11882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11883 
 
11884 
  def __eq__(self, other):
11885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11886 
 
11887 
  def __ne__(self, other):
11888 
    return not (self == other)
11889 
 
772 rajveer 11890 
class mergeBrowseHistory_args:
130 ashish 11891 
  """
11892 
  Attributes:
772 rajveer 11893 
   - fromUserId
11894 
   - toUserId
130 ashish 11895 
  """
11896 
 
11897 
  thrift_spec = (
11898 
    None, # 0
772 rajveer 11899 
    (1, TType.I64, 'fromUserId', None, None, ), # 1
11900 
    (2, TType.I64, 'toUserId', None, None, ), # 2
130 ashish 11901 
  )
11902 
 
772 rajveer 11903 
  def __init__(self, fromUserId=None, toUserId=None,):
11904 
    self.fromUserId = fromUserId
11905 
    self.toUserId = toUserId
130 ashish 11906 
 
11907 
  def read(self, iprot):
11908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11910 
      return
11911 
    iprot.readStructBegin()
11912 
    while True:
11913 
      (fname, ftype, fid) = iprot.readFieldBegin()
11914 
      if ftype == TType.STOP:
11915 
        break
11916 
      if fid == 1:
559 chandransh 11917 
        if ftype == TType.I64:
772 rajveer 11918 
          self.fromUserId = iprot.readI64();
130 ashish 11919 
        else:
11920 
          iprot.skip(ftype)
11921 
      elif fid == 2:
559 chandransh 11922 
        if ftype == TType.I64:
772 rajveer 11923 
          self.toUserId = iprot.readI64();
559 chandransh 11924 
        else:
11925 
          iprot.skip(ftype)
130 ashish 11926 
      else:
11927 
        iprot.skip(ftype)
11928 
      iprot.readFieldEnd()
11929 
    iprot.readStructEnd()
11930 
 
11931 
  def write(self, oprot):
11932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11934 
      return
772 rajveer 11935 
    oprot.writeStructBegin('mergeBrowseHistory_args')
11936 
    if self.fromUserId != None:
11937 
      oprot.writeFieldBegin('fromUserId', TType.I64, 1)
11938 
      oprot.writeI64(self.fromUserId)
130 ashish 11939 
      oprot.writeFieldEnd()
772 rajveer 11940 
    if self.toUserId != None:
11941 
      oprot.writeFieldBegin('toUserId', TType.I64, 2)
11942 
      oprot.writeI64(self.toUserId)
130 ashish 11943 
      oprot.writeFieldEnd()
11944 
    oprot.writeFieldStop()
11945 
    oprot.writeStructEnd()
11946 
 
11947 
  def __repr__(self):
11948 
    L = ['%s=%r' % (key, value)
11949 
      for key, value in self.__dict__.iteritems()]
11950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11951 
 
11952 
  def __eq__(self, other):
11953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11954 
 
11955 
  def __ne__(self, other):
11956 
    return not (self == other)
11957 
 
772 rajveer 11958 
class mergeBrowseHistory_result:
559 chandransh 11959 
 
11960 
  thrift_spec = (
11961 
  )
11962 
 
11963 
  def read(self, iprot):
11964 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11965 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11966 
      return
11967 
    iprot.readStructBegin()
11968 
    while True:
11969 
      (fname, ftype, fid) = iprot.readFieldBegin()
11970 
      if ftype == TType.STOP:
11971 
        break
11972 
      else:
11973 
        iprot.skip(ftype)
11974 
      iprot.readFieldEnd()
11975 
    iprot.readStructEnd()
11976 
 
11977 
  def write(self, oprot):
11978 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11979 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11980 
      return
772 rajveer 11981 
    oprot.writeStructBegin('mergeBrowseHistory_result')
559 chandransh 11982 
    oprot.writeFieldStop()
11983 
    oprot.writeStructEnd()
11984 
 
11985 
  def __repr__(self):
11986 
    L = ['%s=%r' % (key, value)
11987 
      for key, value in self.__dict__.iteritems()]
11988 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11989 
 
11990 
  def __eq__(self, other):
11991 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11992 
 
11993 
  def __ne__(self, other):
11994 
    return not (self == other)
11995 
 
1596 ankur.sing 11996 
class getUserCount_args:
11997 
  """
11998 
  Attributes:
11999 
   - userType
12000 
  """
559 chandransh 12001 
 
1596 ankur.sing 12002 
  thrift_spec = (
12003 
    None, # 0
12004 
    (1, TType.I32, 'userType', None, None, ), # 1
12005 
  )
12006 
 
12007 
  def __init__(self, userType=None,):
12008 
    self.userType = userType
12009 
 
12010 
  def read(self, iprot):
12011 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12012 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12013 
      return
12014 
    iprot.readStructBegin()
12015 
    while True:
12016 
      (fname, ftype, fid) = iprot.readFieldBegin()
12017 
      if ftype == TType.STOP:
12018 
        break
12019 
      if fid == 1:
12020 
        if ftype == TType.I32:
12021 
          self.userType = iprot.readI32();
12022 
        else:
12023 
          iprot.skip(ftype)
12024 
      else:
12025 
        iprot.skip(ftype)
12026 
      iprot.readFieldEnd()
12027 
    iprot.readStructEnd()
12028 
 
12029 
  def write(self, oprot):
12030 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12031 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12032 
      return
12033 
    oprot.writeStructBegin('getUserCount_args')
12034 
    if self.userType != None:
12035 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12036 
      oprot.writeI32(self.userType)
12037 
      oprot.writeFieldEnd()
12038 
    oprot.writeFieldStop()
12039 
    oprot.writeStructEnd()
12040 
 
12041 
  def __repr__(self):
12042 
    L = ['%s=%r' % (key, value)
12043 
      for key, value in self.__dict__.iteritems()]
12044 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12045 
 
12046 
  def __eq__(self, other):
12047 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12048 
 
12049 
  def __ne__(self, other):
12050 
    return not (self == other)
12051 
 
12052 
class getUserCount_result:
12053 
  """
12054 
  Attributes:
12055 
   - success
12056 
  """
12057 
 
12058 
  thrift_spec = (
12059 
    (0, TType.I64, 'success', None, None, ), # 0
12060 
  )
12061 
 
12062 
  def __init__(self, success=None,):
12063 
    self.success = success
12064 
 
12065 
  def read(self, iprot):
12066 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12067 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12068 
      return
12069 
    iprot.readStructBegin()
12070 
    while True:
12071 
      (fname, ftype, fid) = iprot.readFieldBegin()
12072 
      if ftype == TType.STOP:
12073 
        break
12074 
      if fid == 0:
12075 
        if ftype == TType.I64:
12076 
          self.success = iprot.readI64();
12077 
        else:
12078 
          iprot.skip(ftype)
12079 
      else:
12080 
        iprot.skip(ftype)
12081 
      iprot.readFieldEnd()
12082 
    iprot.readStructEnd()
12083 
 
12084 
  def write(self, oprot):
12085 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12086 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12087 
      return
12088 
    oprot.writeStructBegin('getUserCount_result')
12089 
    if self.success != None:
12090 
      oprot.writeFieldBegin('success', TType.I64, 0)
12091 
      oprot.writeI64(self.success)
12092 
      oprot.writeFieldEnd()
12093 
    oprot.writeFieldStop()
12094 
    oprot.writeStructEnd()
12095 
 
12096 
  def __repr__(self):
12097 
    L = ['%s=%r' % (key, value)
12098 
      for key, value in self.__dict__.iteritems()]
12099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12100 
 
12101 
  def __eq__(self, other):
12102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12103 
 
12104 
  def __ne__(self, other):
12105 
    return not (self == other)
12106 
 
1673 ankur.sing 12107 
class getAllUsers_args:
12108 
  """
12109 
  Attributes:
12110 
   - userType
1891 ankur.sing 12111 
   - startDate
12112 
   - endDate
1673 ankur.sing 12113 
  """
1596 ankur.sing 12114 
 
1673 ankur.sing 12115 
  thrift_spec = (
12116 
    None, # 0
12117 
    (1, TType.I32, 'userType', None, None, ), # 1
1891 ankur.sing 12118 
    (2, TType.I64, 'startDate', None, None, ), # 2
12119 
    (3, TType.I64, 'endDate', None, None, ), # 3
1673 ankur.sing 12120 
  )
12121 
 
1891 ankur.sing 12122 
  def __init__(self, userType=None, startDate=None, endDate=None,):
1673 ankur.sing 12123 
    self.userType = userType
1891 ankur.sing 12124 
    self.startDate = startDate
12125 
    self.endDate = endDate
1673 ankur.sing 12126 
 
12127 
  def read(self, iprot):
12128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12130 
      return
12131 
    iprot.readStructBegin()
12132 
    while True:
12133 
      (fname, ftype, fid) = iprot.readFieldBegin()
12134 
      if ftype == TType.STOP:
12135 
        break
12136 
      if fid == 1:
12137 
        if ftype == TType.I32:
12138 
          self.userType = iprot.readI32();
12139 
        else:
12140 
          iprot.skip(ftype)
1891 ankur.sing 12141 
      elif fid == 2:
12142 
        if ftype == TType.I64:
12143 
          self.startDate = iprot.readI64();
12144 
        else:
12145 
          iprot.skip(ftype)
12146 
      elif fid == 3:
12147 
        if ftype == TType.I64:
12148 
          self.endDate = iprot.readI64();
12149 
        else:
12150 
          iprot.skip(ftype)
1673 ankur.sing 12151 
      else:
12152 
        iprot.skip(ftype)
12153 
      iprot.readFieldEnd()
12154 
    iprot.readStructEnd()
12155 
 
12156 
  def write(self, oprot):
12157 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12158 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12159 
      return
12160 
    oprot.writeStructBegin('getAllUsers_args')
12161 
    if self.userType != None:
12162 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12163 
      oprot.writeI32(self.userType)
12164 
      oprot.writeFieldEnd()
1891 ankur.sing 12165 
    if self.startDate != None:
12166 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
12167 
      oprot.writeI64(self.startDate)
12168 
      oprot.writeFieldEnd()
12169 
    if self.endDate != None:
12170 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
12171 
      oprot.writeI64(self.endDate)
12172 
      oprot.writeFieldEnd()
1673 ankur.sing 12173 
    oprot.writeFieldStop()
12174 
    oprot.writeStructEnd()
12175 
 
12176 
  def __repr__(self):
12177 
    L = ['%s=%r' % (key, value)
12178 
      for key, value in self.__dict__.iteritems()]
12179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12180 
 
12181 
  def __eq__(self, other):
12182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12183 
 
12184 
  def __ne__(self, other):
12185 
    return not (self == other)
12186 
 
12187 
class getAllUsers_result:
12188 
  """
12189 
  Attributes:
12190 
   - success
12191 
  """
12192 
 
12193 
  thrift_spec = (
12194 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
12195 
  )
12196 
 
12197 
  def __init__(self, success=None,):
12198 
    self.success = success
12199 
 
12200 
  def read(self, iprot):
12201 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12202 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12203 
      return
12204 
    iprot.readStructBegin()
12205 
    while True:
12206 
      (fname, ftype, fid) = iprot.readFieldBegin()
12207 
      if ftype == TType.STOP:
12208 
        break
12209 
      if fid == 0:
12210 
        if ftype == TType.LIST:
12211 
          self.success = []
1845 vikas 12212 
          (_etype117, _size114) = iprot.readListBegin()
12213 
          for _i118 in xrange(_size114):
12214 
            _elem119 = User()
12215 
            _elem119.read(iprot)
12216 
            self.success.append(_elem119)
1673 ankur.sing 12217 
          iprot.readListEnd()
12218 
        else:
12219 
          iprot.skip(ftype)
12220 
      else:
12221 
        iprot.skip(ftype)
12222 
      iprot.readFieldEnd()
12223 
    iprot.readStructEnd()
12224 
 
12225 
  def write(self, oprot):
12226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12228 
      return
12229 
    oprot.writeStructBegin('getAllUsers_result')
12230 
    if self.success != None:
12231 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12232 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1845 vikas 12233 
      for iter120 in self.success:
12234 
        iter120.write(oprot)
1673 ankur.sing 12235 
      oprot.writeListEnd()
12236 
      oprot.writeFieldEnd()
12237 
    oprot.writeFieldStop()
12238 
    oprot.writeStructEnd()
12239 
 
12240 
  def __repr__(self):
12241 
    L = ['%s=%r' % (key, value)
12242 
      for key, value in self.__dict__.iteritems()]
12243 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12244 
 
12245 
  def __eq__(self, other):
12246 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12247 
 
12248 
  def __ne__(self, other):
12249 
    return not (self == other)
12250 
 
12251