Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
2 
# Autogenerated by Thrift
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
from ttypes import *
9 
from thrift.Thrift import TProcessor
10 
from thrift.transport import TTransport
11 
from thrift.protocol import TBinaryProtocol
12 
try:
13 
  from thrift.protocol import fastbinary
14 
except:
15 
  fastbinary = None
16 
 
17 
 
18 
class Iface:
19 
  """
20 
  service
21 
  """
765 rajveer 22 
  def closeSession(self, ):
23 
    """
24 
    For closing the open session in sqlalchemy
25 
    """
26 
    pass
27 
 
559 chandransh 28 
  def createAnonymousUser(self, jsessionId):
94 ashish 29 
    """
30 
    Parameters:
559 chandransh 31 
     - jsessionId
94 ashish 32 
    """
33 
    pass
34 
 
559 chandransh 35 
  def getUserById(self, userId):
94 ashish 36 
    """
37 
    Parameters:
38 
     - userId
39 
    """
40 
    pass
41 
 
1491 vikas 42 
  def getUserByEmail(self, email):
43 
    """
44 
    Parameters:
45 
     - email
46 
    """
47 
    pass
48 
 
559 chandransh 49 
  def createUser(self, user):
94 ashish 50 
    """
51 
    Parameters:
559 chandransh 52 
     - user
94 ashish 53 
    """
54 
    pass
55 
 
559 chandransh 56 
  def updateUser(self, user):
94 ashish 57 
    """
58 
    Parameters:
559 chandransh 59 
     - user
94 ashish 60 
    """
61 
    pass
62 
 
559 chandransh 63 
  def deleteUser(self, userId):
94 ashish 64 
    """
65 
    Parameters:
66 
     - userId
67 
    """
68 
    pass
69 
 
559 chandransh 70 
  def getUserState(self, userId):
94 ashish 71 
    """
72 
    Parameters:
73 
     - userId
74 
    """
75 
    pass
76 
 
559 chandransh 77 
  def authenticateUser(self, email, password):
94 ashish 78 
    """
79 
    Parameters:
80 
     - email
81 
     - password
82 
    """
83 
    pass
84 
 
85 
  def userExists(self, email):
86 
    """
87 
    Parameters:
88 
     - email
89 
    """
90 
    pass
91 
 
567 rajveer 92 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 93 
    """
94 
    Parameters:
95 
     - userId
96 
     - address
513 rajveer 97 
     - setDefault
94 ashish 98 
    """
99 
    pass
100 
 
101 
  def removeAddressForUser(self, userid, addressId):
102 
    """
103 
    Parameters:
104 
     - userid
105 
     - addressId
106 
    """
107 
    pass
108 
 
109 
  def setUserAsLoggedIn(self, userId, timestamp):
110 
    """
111 
    Parameters:
112 
     - userId
113 
     - timestamp
114 
    """
115 
    pass
116 
 
117 
  def setUserAsLoggedOut(self, userid, timestamp):
118 
    """
119 
    Parameters:
120 
     - userid
121 
     - timestamp
122 
    """
123 
    pass
124 
 
504 rajveer 125 
  def setDefaultAddress(self, userid, addressId):
126 
    """
127 
    Parameters:
128 
     - userid
129 
     - addressId
130 
    """
131 
    pass
132 
 
594 rajveer 133 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 134 
    """
135 
    Parameters:
136 
     - userid
594 rajveer 137 
     - oldPassword
138 
     - newPassword
94 ashish 139 
    """
140 
    pass
141 
 
884 rajveer 142 
  def forgotPassword(self, email, newPassword):
581 rajveer 143 
    """
144 
    Parameters:
145 
     - email
884 rajveer 146 
     - newPassword
581 rajveer 147 
    """
148 
    pass
149 
 
594 rajveer 150 
  def getAllAddressesForUser(self, userId):
151 
    """
152 
    Parameters:
153 
     - userId
154 
    """
155 
    pass
156 
 
1894 vikas 157 
  def getAddressById(self, addressId):
158 
    """
159 
    Parameters:
160 
     - addressId
161 
    """
162 
    pass
163 
 
594 rajveer 164 
  def getDefaultAddressId(self, userId):
165 
    """
166 
    Parameters:
167 
     - userId
168 
    """
169 
    pass
170 
 
785 rajveer 171 
  def getDefaultPincode(self, userId):
172 
    """
173 
    Parameters:
174 
     - userId
175 
    """
176 
    pass
177 
 
1274 varun.gupt 178 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
179 
    """
180 
    Parameters:
181 
     - userId
182 
     - replyTo
183 
     - communicationType
184 
     - orderId
185 
     - airwaybillNo
186 
     - productName
187 
     - subject
188 
     - message
189 
    """
190 
    pass
191 
 
1590 varun.gupt 192 
  def getUserCommunicationById(self, id):
193 
    """
194 
    Parameters:
195 
     - id
196 
    """
197 
    pass
198 
 
199 
  def getUserCommunicationByUser(self, userId):
200 
    """
201 
    Parameters:
202 
     - userId
203 
    """
204 
    pass
205 
 
206 
  def getAllUserCommunications(self, ):
207 
    pass
208 
 
1859 vikas 209 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 210 
    """
211 
    Parameters:
212 
     - name
1859 vikas 213 
     - addedOn
1845 vikas 214 
    """
215 
    pass
216 
 
1899 vikas 217 
  def getAllMasterAffiliates(self, ):
218 
    pass
219 
 
1845 vikas 220 
  def getMasterAffiliateById(self, id):
221 
    """
222 
    Parameters:
223 
     - id
224 
    """
225 
    pass
226 
 
227 
  def getMasterAffiliateByName(self, name):
228 
    """
229 
    Parameters:
230 
     - name
231 
    """
232 
    pass
233 
 
1859 vikas 234 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 235 
    """
236 
    Parameters:
237 
     - name
238 
     - url
239 
     - masterAffiliateId
1859 vikas 240 
     - addedOn
1845 vikas 241 
    """
242 
    pass
243 
 
244 
  def getAffiliateById(self, id):
245 
    """
246 
    Parameters:
247 
     - id
248 
    """
249 
    pass
250 
 
251 
  def getAffiliateByName(self, name):
252 
    """
253 
    Parameters:
254 
     - name
255 
    """
256 
    pass
257 
 
258 
  def getAffiliatesByMasterAffiliate(self, id):
259 
    """
260 
    Parameters:
261 
     - id
262 
    """
263 
    pass
264 
 
1859 vikas 265 
  def createTracker(self, affiliateId, addedOn):
1845 vikas 266 
    """
267 
    Parameters:
268 
     - affiliateId
1859 vikas 269 
     - addedOn
1845 vikas 270 
    """
271 
    pass
272 
 
273 
  def getTrackerById(self, trackerId):
274 
    """
275 
    Parameters:
276 
     - trackerId
277 
    """
278 
    pass
279 
 
280 
  def getTrackersByAffiliate(self, affiliateId):
281 
    """
282 
    Parameters:
283 
     - affiliateId
284 
    """
285 
    pass
286 
 
1859 vikas 287 
  def addTrackLog(self, trackerId, userId, event, url, data, addedOn):
1845 vikas 288 
    """
289 
    Parameters:
290 
     - trackerId
291 
     - userId
292 
     - event
293 
     - url
294 
     - data
1859 vikas 295 
     - addedOn
1845 vikas 296 
    """
297 
    pass
298 
 
299 
  def getTrackLogById(self, id):
300 
    """
301 
    Parameters:
302 
     - id
303 
    """
304 
    pass
305 
 
306 
  def getTrackLogsByTracker(self, trackerId):
307 
    """
308 
    Parameters:
309 
     - trackerId
310 
    """
311 
    pass
312 
 
313 
  def getTrackLogsByUser(self, userId):
314 
    """
315 
    Parameters:
316 
     - userId
317 
    """
318 
    pass
319 
 
320 
  def getTrackLogs(self, trackerId, userId, event, url):
321 
    """
322 
    Parameters:
323 
     - trackerId
324 
     - userId
325 
     - event
326 
     - url
327 
    """
328 
    pass
329 
 
559 chandransh 330 
  def createCart(self, userId):
94 ashish 331 
    """
332 
    Parameters:
559 chandransh 333 
     - userId
94 ashish 334 
    """
335 
    pass
336 
 
559 chandransh 337 
  def getCurrentCart(self, userId):
94 ashish 338 
    """
339 
    Parameters:
559 chandransh 340 
     - userId
94 ashish 341 
    """
342 
    pass
343 
 
559 chandransh 344 
  def getCart(self, cartId):
94 ashish 345 
    """
346 
    Parameters:
559 chandransh 347 
     - cartId
94 ashish 348 
    """
349 
    pass
350 
 
559 chandransh 351 
  def getCartsForUser(self, userId, status):
94 ashish 352 
    """
353 
    Parameters:
559 chandransh 354 
     - userId
355 
     - status
94 ashish 356 
    """
357 
    pass
358 
 
559 chandransh 359 
  def getCartsByStatus(self, status):
94 ashish 360 
    """
361 
    Parameters:
559 chandransh 362 
     - status
94 ashish 363 
    """
364 
    pass
365 
 
559 chandransh 366 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 367 
    """
368 
    Parameters:
559 chandransh 369 
     - from_time
370 
     - to_time
371 
     - status
94 ashish 372 
    """
373 
    pass
374 
 
559 chandransh 375 
  def changeCartStatus(self, cartId, status):
130 ashish 376 
    """
377 
    Parameters:
559 chandransh 378 
     - cartId
379 
     - status
130 ashish 380 
    """
381 
    pass
94 ashish 382 
 
559 chandransh 383 
  def addItemToCart(self, cartId, itemId, quantity):
130 ashish 384 
    """
385 
    Parameters:
559 chandransh 386 
     - cartId
387 
     - itemId
388 
     - quantity
130 ashish 389 
    """
390 
    pass
391 
 
559 chandransh 392 
  def deleteItemFromCart(self, cartId, itemId):
393 
    """
394 
    Parameters:
395 
     - cartId
396 
     - itemId
397 
    """
398 
    pass
130 ashish 399 
 
559 chandransh 400 
  def changeQuantity(self, cartId, itemId, quantity):
401 
    """
402 
    Parameters:
403 
     - cartId
404 
     - itemId
405 
     - quantity
406 
    """
407 
    pass
408 
 
409 
  def changeItemStatus(self, cartId, itemId, status):
410 
    """
411 
    Parameters:
412 
     - cartId
413 
     - itemId
414 
     - status
415 
    """
416 
    pass
417 
 
418 
  def addAddressToCart(self, cartId, addressId):
419 
    """
420 
    Parameters:
421 
     - cartId
422 
     - addressId
423 
    """
424 
    pass
425 
 
690 chandransh 426 
  def createOrders(self, cartId):
559 chandransh 427 
    """
690 chandransh 428 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
429 
 
559 chandransh 430 
    Parameters:
431 
     - cartId
432 
    """
433 
    pass
434 
 
435 
  def validateCart(self, cartId):
436 
    """
690 chandransh 437 
    Validates that:
438 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 439 
    2. All of the lines in the cart are active items.
690 chandransh 440 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 441 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 442 
 
559 chandransh 443 
    Parameters:
444 
     - cartId
445 
    """
446 
    pass
447 
 
690 chandransh 448 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 449 
    """
690 chandransh 450 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
451 
 
575 chandransh 452 
    Parameters:
690 chandransh 453 
     - fromCartId
454 
     - toCartId
455 
    """
456 
    pass
457 
 
458 
  def checkOut(self, cartId):
459 
    """
460 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
461 
 
462 
    Parameters:
575 chandransh 463 
     - cartId
464 
    """
465 
    pass
466 
 
690 chandransh 467 
  def resetCart(self, cartId, items):
559 chandransh 468 
    """
690 chandransh 469 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
470 
    This methods removes the specified quantiry of the specified item from the cart.
471 
 
559 chandransh 472 
    Parameters:
690 chandransh 473 
     - cartId
474 
     - items
559 chandransh 475 
    """
476 
    pass
477 
 
772 rajveer 478 
  def getMyResearch(self, userId):
559 chandransh 479 
    """
772 rajveer 480 
    Widgets
481 
 
559 chandransh 482 
    Parameters:
772 rajveer 483 
     - userId
559 chandransh 484 
    """
485 
    pass
486 
 
772 rajveer 487 
  def updateMyResearch(self, userId, itemId):
559 chandransh 488 
    """
489 
    Parameters:
772 rajveer 490 
     - userId
491 
     - itemId
559 chandransh 492 
    """
493 
    pass
494 
 
772 rajveer 495 
  def deleteItemFromMyResearch(self, userId, itemId):
559 chandransh 496 
    """
497 
    Parameters:
772 rajveer 498 
     - userId
499 
     - itemId
559 chandransh 500 
    """
501 
    pass
502 
 
772 rajveer 503 
  def updateBrowseHistory(self, userId, itemId):
559 chandransh 504 
    """
505 
    Parameters:
772 rajveer 506 
     - userId
507 
     - itemId
559 chandransh 508 
    """
509 
    pass
510 
 
772 rajveer 511 
  def getBrowseHistory(self, userId):
559 chandransh 512 
    """
513 
    Parameters:
514 
     - userId
515 
    """
516 
    pass
517 
 
772 rajveer 518 
  def mergeBrowseHistory(self, fromUserId, toUserId):
559 chandransh 519 
    """
520 
    Parameters:
772 rajveer 521 
     - fromUserId
522 
     - toUserId
559 chandransh 523 
    """
524 
    pass
525 
 
1596 ankur.sing 526 
  def getUserCount(self, userType):
527 
    """
528 
    Returns number of registered users.
529 
    If userType = null, then it returns count of all users, including anonymous
530 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
531 
    If userType = UserType.USER, then it returns count of non-anonymous users only
532 
 
533 
    Parameters:
534 
     - userType
535 
    """
536 
    pass
559 chandransh 537 
 
1891 ankur.sing 538 
  def getAllUsers(self, userType, startDate, endDate):
1673 ankur.sing 539 
    """
1891 ankur.sing 540 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
541 
    If any of startDate or endDate is -1, then that filter is ignored.
542 
    If userType is null, then returns all the users, irrespective of anonymous flag
1673 ankur.sing 543 
 
1891 ankur.sing 544 
 
1673 ankur.sing 545 
    Parameters:
546 
     - userType
1891 ankur.sing 547 
     - startDate
548 
     - endDate
1673 ankur.sing 549 
    """
550 
    pass
1596 ankur.sing 551 
 
1673 ankur.sing 552 
 
94 ashish 553 
class Client(Iface):
554 
  """
555 
  service
556 
  """
557 
  def __init__(self, iprot, oprot=None):
558 
    self._iprot = self._oprot = iprot
559 
    if oprot != None:
560 
      self._oprot = oprot
561 
    self._seqid = 0
562 
 
765 rajveer 563 
  def closeSession(self, ):
564 
    """
565 
    For closing the open session in sqlalchemy
566 
    """
567 
    self.send_closeSession()
568 
    self.recv_closeSession()
569 
 
570 
  def send_closeSession(self, ):
571 
    self._oprot.writeMessageBegin('closeSession', TMessageType.CALL, self._seqid)
572 
    args = closeSession_args()
573 
    args.write(self._oprot)
574 
    self._oprot.writeMessageEnd()
575 
    self._oprot.trans.flush()
576 
 
577 
  def recv_closeSession(self, ):
578 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
579 
    if mtype == TMessageType.EXCEPTION:
580 
      x = TApplicationException()
581 
      x.read(self._iprot)
582 
      self._iprot.readMessageEnd()
583 
      raise x
584 
    result = closeSession_result()
585 
    result.read(self._iprot)
586 
    self._iprot.readMessageEnd()
587 
    return
588 
 
559 chandransh 589 
  def createAnonymousUser(self, jsessionId):
94 ashish 590 
    """
591 
    Parameters:
559 chandransh 592 
     - jsessionId
94 ashish 593 
    """
559 chandransh 594 
    self.send_createAnonymousUser(jsessionId)
595 
    return self.recv_createAnonymousUser()
94 ashish 596 
 
559 chandransh 597 
  def send_createAnonymousUser(self, jsessionId):
598 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
599 
    args = createAnonymousUser_args()
600 
    args.jsessionId = jsessionId
94 ashish 601 
    args.write(self._oprot)
602 
    self._oprot.writeMessageEnd()
603 
    self._oprot.trans.flush()
604 
 
559 chandransh 605 
  def recv_createAnonymousUser(self, ):
94 ashish 606 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
607 
    if mtype == TMessageType.EXCEPTION:
608 
      x = TApplicationException()
609 
      x.read(self._iprot)
610 
      self._iprot.readMessageEnd()
611 
      raise x
559 chandransh 612 
    result = createAnonymousUser_result()
94 ashish 613 
    result.read(self._iprot)
614 
    self._iprot.readMessageEnd()
615 
    if result.success != None:
616 
      return result.success
559 chandransh 617 
    if result.ucex != None:
618 
      raise result.ucex
619 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 620 
 
559 chandransh 621 
  def getUserById(self, userId):
94 ashish 622 
    """
623 
    Parameters:
624 
     - userId
625 
    """
559 chandransh 626 
    self.send_getUserById(userId)
627 
    return self.recv_getUserById()
94 ashish 628 
 
559 chandransh 629 
  def send_getUserById(self, userId):
630 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
631 
    args = getUserById_args()
94 ashish 632 
    args.userId = userId
633 
    args.write(self._oprot)
634 
    self._oprot.writeMessageEnd()
635 
    self._oprot.trans.flush()
636 
 
559 chandransh 637 
  def recv_getUserById(self, ):
94 ashish 638 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
639 
    if mtype == TMessageType.EXCEPTION:
640 
      x = TApplicationException()
641 
      x.read(self._iprot)
642 
      self._iprot.readMessageEnd()
643 
      raise x
559 chandransh 644 
    result = getUserById_result()
94 ashish 645 
    result.read(self._iprot)
646 
    self._iprot.readMessageEnd()
647 
    if result.success != None:
648 
      return result.success
559 chandransh 649 
    if result.ucex != None:
650 
      raise result.ucex
651 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 652 
 
1491 vikas 653 
  def getUserByEmail(self, email):
654 
    """
655 
    Parameters:
656 
     - email
657 
    """
658 
    self.send_getUserByEmail(email)
659 
    return self.recv_getUserByEmail()
660 
 
661 
  def send_getUserByEmail(self, email):
662 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
663 
    args = getUserByEmail_args()
664 
    args.email = email
665 
    args.write(self._oprot)
666 
    self._oprot.writeMessageEnd()
667 
    self._oprot.trans.flush()
668 
 
669 
  def recv_getUserByEmail(self, ):
670 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
671 
    if mtype == TMessageType.EXCEPTION:
672 
      x = TApplicationException()
673 
      x.read(self._iprot)
674 
      self._iprot.readMessageEnd()
675 
      raise x
676 
    result = getUserByEmail_result()
677 
    result.read(self._iprot)
678 
    self._iprot.readMessageEnd()
679 
    if result.success != None:
680 
      return result.success
681 
    if result.ucex != None:
682 
      raise result.ucex
683 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
684 
 
559 chandransh 685 
  def createUser(self, user):
94 ashish 686 
    """
687 
    Parameters:
559 chandransh 688 
     - user
94 ashish 689 
    """
559 chandransh 690 
    self.send_createUser(user)
691 
    return self.recv_createUser()
94 ashish 692 
 
559 chandransh 693 
  def send_createUser(self, user):
694 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
695 
    args = createUser_args()
696 
    args.user = user
94 ashish 697 
    args.write(self._oprot)
698 
    self._oprot.writeMessageEnd()
699 
    self._oprot.trans.flush()
700 
 
559 chandransh 701 
  def recv_createUser(self, ):
94 ashish 702 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
703 
    if mtype == TMessageType.EXCEPTION:
704 
      x = TApplicationException()
705 
      x.read(self._iprot)
706 
      self._iprot.readMessageEnd()
707 
      raise x
559 chandransh 708 
    result = createUser_result()
94 ashish 709 
    result.read(self._iprot)
710 
    self._iprot.readMessageEnd()
711 
    if result.success != None:
712 
      return result.success
559 chandransh 713 
    if result.ucex != None:
714 
      raise result.ucex
715 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 716 
 
559 chandransh 717 
  def updateUser(self, user):
94 ashish 718 
    """
719 
    Parameters:
559 chandransh 720 
     - user
94 ashish 721 
    """
559 chandransh 722 
    self.send_updateUser(user)
723 
    return self.recv_updateUser()
94 ashish 724 
 
559 chandransh 725 
  def send_updateUser(self, user):
726 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
727 
    args = updateUser_args()
728 
    args.user = user
94 ashish 729 
    args.write(self._oprot)
730 
    self._oprot.writeMessageEnd()
731 
    self._oprot.trans.flush()
732 
 
559 chandransh 733 
  def recv_updateUser(self, ):
94 ashish 734 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
735 
    if mtype == TMessageType.EXCEPTION:
736 
      x = TApplicationException()
737 
      x.read(self._iprot)
738 
      self._iprot.readMessageEnd()
739 
      raise x
559 chandransh 740 
    result = updateUser_result()
94 ashish 741 
    result.read(self._iprot)
742 
    self._iprot.readMessageEnd()
743 
    if result.success != None:
744 
      return result.success
559 chandransh 745 
    if result.ucex != None:
746 
      raise result.ucex
747 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 748 
 
559 chandransh 749 
  def deleteUser(self, userId):
94 ashish 750 
    """
751 
    Parameters:
752 
     - userId
753 
    """
559 chandransh 754 
    self.send_deleteUser(userId)
755 
    return self.recv_deleteUser()
94 ashish 756 
 
559 chandransh 757 
  def send_deleteUser(self, userId):
758 
    self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
759 
    args = deleteUser_args()
94 ashish 760 
    args.userId = userId
761 
    args.write(self._oprot)
762 
    self._oprot.writeMessageEnd()
763 
    self._oprot.trans.flush()
764 
 
559 chandransh 765 
  def recv_deleteUser(self, ):
94 ashish 766 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
767 
    if mtype == TMessageType.EXCEPTION:
768 
      x = TApplicationException()
769 
      x.read(self._iprot)
770 
      self._iprot.readMessageEnd()
771 
      raise x
559 chandransh 772 
    result = deleteUser_result()
94 ashish 773 
    result.read(self._iprot)
774 
    self._iprot.readMessageEnd()
775 
    if result.success != None:
776 
      return result.success
559 chandransh 777 
    if result.ucex != None:
778 
      raise result.ucex
779 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
94 ashish 780 
 
559 chandransh 781 
  def getUserState(self, userId):
94 ashish 782 
    """
783 
    Parameters:
784 
     - userId
785 
    """
559 chandransh 786 
    self.send_getUserState(userId)
787 
    return self.recv_getUserState()
94 ashish 788 
 
559 chandransh 789 
  def send_getUserState(self, userId):
790 
    self._oprot.writeMessageBegin('getUserState', TMessageType.CALL, self._seqid)
791 
    args = getUserState_args()
94 ashish 792 
    args.userId = userId
793 
    args.write(self._oprot)
794 
    self._oprot.writeMessageEnd()
795 
    self._oprot.trans.flush()
796 
 
559 chandransh 797 
  def recv_getUserState(self, ):
94 ashish 798 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
799 
    if mtype == TMessageType.EXCEPTION:
800 
      x = TApplicationException()
801 
      x.read(self._iprot)
802 
      self._iprot.readMessageEnd()
803 
      raise x
559 chandransh 804 
    result = getUserState_result()
94 ashish 805 
    result.read(self._iprot)
806 
    self._iprot.readMessageEnd()
807 
    if result.success != None:
808 
      return result.success
559 chandransh 809 
    if result.ucex != None:
810 
      raise result.ucex
811 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserState failed: unknown result");
94 ashish 812 
 
559 chandransh 813 
  def authenticateUser(self, email, password):
94 ashish 814 
    """
815 
    Parameters:
816 
     - email
817 
     - password
818 
    """
559 chandransh 819 
    self.send_authenticateUser(email, password)
122 ashish 820 
    return self.recv_authenticateUser()
821 
 
559 chandransh 822 
  def send_authenticateUser(self, email, password):
122 ashish 823 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
824 
    args = authenticateUser_args()
559 chandransh 825 
    args.email = email
122 ashish 826 
    args.password = password
827 
    args.write(self._oprot)
828 
    self._oprot.writeMessageEnd()
829 
    self._oprot.trans.flush()
830 
 
831 
  def recv_authenticateUser(self, ):
832 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
833 
    if mtype == TMessageType.EXCEPTION:
834 
      x = TApplicationException()
835 
      x.read(self._iprot)
836 
      self._iprot.readMessageEnd()
837 
      raise x
838 
    result = authenticateUser_result()
839 
    result.read(self._iprot)
840 
    self._iprot.readMessageEnd()
841 
    if result.success != None:
842 
      return result.success
559 chandransh 843 
    if result.auex != None:
844 
      raise result.auex
122 ashish 845 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
846 
 
94 ashish 847 
  def userExists(self, email):
848 
    """
849 
    Parameters:
850 
     - email
851 
    """
852 
    self.send_userExists(email)
853 
    return self.recv_userExists()
854 
 
855 
  def send_userExists(self, email):
856 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
857 
    args = userExists_args()
858 
    args.email = email
859 
    args.write(self._oprot)
860 
    self._oprot.writeMessageEnd()
861 
    self._oprot.trans.flush()
862 
 
863 
  def recv_userExists(self, ):
864 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
865 
    if mtype == TMessageType.EXCEPTION:
866 
      x = TApplicationException()
867 
      x.read(self._iprot)
868 
      self._iprot.readMessageEnd()
869 
      raise x
870 
    result = userExists_result()
871 
    result.read(self._iprot)
872 
    self._iprot.readMessageEnd()
873 
    if result.success != None:
874 
      return result.success
875 
    if result.ucx != None:
876 
      raise result.ucx
877 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
878 
 
567 rajveer 879 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 880 
    """
881 
    Parameters:
882 
     - userId
883 
     - address
513 rajveer 884 
     - setDefault
94 ashish 885 
    """
567 rajveer 886 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 887 
    return self.recv_addAddressForUser()
888 
 
567 rajveer 889 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 890 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
891 
    args = addAddressForUser_args()
559 chandransh 892 
    args.userId = userId
94 ashish 893 
    args.address = address
513 rajveer 894 
    args.setDefault = setDefault
94 ashish 895 
    args.write(self._oprot)
896 
    self._oprot.writeMessageEnd()
897 
    self._oprot.trans.flush()
898 
 
899 
  def recv_addAddressForUser(self, ):
900 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
901 
    if mtype == TMessageType.EXCEPTION:
902 
      x = TApplicationException()
903 
      x.read(self._iprot)
904 
      self._iprot.readMessageEnd()
905 
      raise x
906 
    result = addAddressForUser_result()
907 
    result.read(self._iprot)
908 
    self._iprot.readMessageEnd()
909 
    if result.success != None:
910 
      return result.success
911 
    if result.ucx != None:
912 
      raise result.ucx
913 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
914 
 
915 
  def removeAddressForUser(self, userid, addressId):
916 
    """
917 
    Parameters:
918 
     - userid
919 
     - addressId
920 
    """
921 
    self.send_removeAddressForUser(userid, addressId)
922 
    return self.recv_removeAddressForUser()
923 
 
924 
  def send_removeAddressForUser(self, userid, addressId):
925 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
926 
    args = removeAddressForUser_args()
927 
    args.userid = userid
928 
    args.addressId = addressId
929 
    args.write(self._oprot)
930 
    self._oprot.writeMessageEnd()
931 
    self._oprot.trans.flush()
932 
 
933 
  def recv_removeAddressForUser(self, ):
934 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
935 
    if mtype == TMessageType.EXCEPTION:
936 
      x = TApplicationException()
937 
      x.read(self._iprot)
938 
      self._iprot.readMessageEnd()
939 
      raise x
940 
    result = removeAddressForUser_result()
941 
    result.read(self._iprot)
942 
    self._iprot.readMessageEnd()
943 
    if result.success != None:
944 
      return result.success
945 
    if result.ucx != None:
946 
      raise result.ucx
947 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
948 
 
949 
  def setUserAsLoggedIn(self, userId, timestamp):
950 
    """
951 
    Parameters:
952 
     - userId
953 
     - timestamp
954 
    """
955 
    self.send_setUserAsLoggedIn(userId, timestamp)
956 
    return self.recv_setUserAsLoggedIn()
957 
 
958 
  def send_setUserAsLoggedIn(self, userId, timestamp):
959 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
960 
    args = setUserAsLoggedIn_args()
961 
    args.userId = userId
962 
    args.timestamp = timestamp
963 
    args.write(self._oprot)
964 
    self._oprot.writeMessageEnd()
965 
    self._oprot.trans.flush()
966 
 
967 
  def recv_setUserAsLoggedIn(self, ):
968 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
969 
    if mtype == TMessageType.EXCEPTION:
970 
      x = TApplicationException()
971 
      x.read(self._iprot)
972 
      self._iprot.readMessageEnd()
973 
      raise x
974 
    result = setUserAsLoggedIn_result()
975 
    result.read(self._iprot)
976 
    self._iprot.readMessageEnd()
977 
    if result.success != None:
978 
      return result.success
979 
    if result.ucx != None:
980 
      raise result.ucx
981 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
982 
 
983 
  def setUserAsLoggedOut(self, userid, timestamp):
984 
    """
985 
    Parameters:
986 
     - userid
987 
     - timestamp
988 
    """
989 
    self.send_setUserAsLoggedOut(userid, timestamp)
990 
    return self.recv_setUserAsLoggedOut()
991 
 
992 
  def send_setUserAsLoggedOut(self, userid, timestamp):
993 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
994 
    args = setUserAsLoggedOut_args()
995 
    args.userid = userid
996 
    args.timestamp = timestamp
997 
    args.write(self._oprot)
998 
    self._oprot.writeMessageEnd()
999 
    self._oprot.trans.flush()
1000 
 
1001 
  def recv_setUserAsLoggedOut(self, ):
1002 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1003 
    if mtype == TMessageType.EXCEPTION:
1004 
      x = TApplicationException()
1005 
      x.read(self._iprot)
1006 
      self._iprot.readMessageEnd()
1007 
      raise x
1008 
    result = setUserAsLoggedOut_result()
1009 
    result.read(self._iprot)
1010 
    self._iprot.readMessageEnd()
1011 
    if result.success != None:
1012 
      return result.success
1013 
    if result.ucx != None:
1014 
      raise result.ucx
1015 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1016 
 
504 rajveer 1017 
  def setDefaultAddress(self, userid, addressId):
1018 
    """
1019 
    Parameters:
1020 
     - userid
1021 
     - addressId
1022 
    """
1023 
    self.send_setDefaultAddress(userid, addressId)
1024 
    return self.recv_setDefaultAddress()
1025 
 
1026 
  def send_setDefaultAddress(self, userid, addressId):
1027 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1028 
    args = setDefaultAddress_args()
1029 
    args.userid = userid
1030 
    args.addressId = addressId
1031 
    args.write(self._oprot)
1032 
    self._oprot.writeMessageEnd()
1033 
    self._oprot.trans.flush()
1034 
 
1035 
  def recv_setDefaultAddress(self, ):
1036 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1037 
    if mtype == TMessageType.EXCEPTION:
1038 
      x = TApplicationException()
1039 
      x.read(self._iprot)
1040 
      self._iprot.readMessageEnd()
1041 
      raise x
1042 
    result = setDefaultAddress_result()
1043 
    result.read(self._iprot)
1044 
    self._iprot.readMessageEnd()
1045 
    if result.success != None:
1046 
      return result.success
1047 
    if result.ucx != None:
1048 
      raise result.ucx
1049 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1050 
 
594 rajveer 1051 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1052 
    """
1053 
    Parameters:
1054 
     - userid
594 rajveer 1055 
     - oldPassword
1056 
     - newPassword
94 ashish 1057 
    """
594 rajveer 1058 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1059 
    return self.recv_updatePassword()
1060 
 
594 rajveer 1061 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1062 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1063 
    args = updatePassword_args()
1064 
    args.userid = userid
594 rajveer 1065 
    args.oldPassword = oldPassword
1066 
    args.newPassword = newPassword
94 ashish 1067 
    args.write(self._oprot)
1068 
    self._oprot.writeMessageEnd()
1069 
    self._oprot.trans.flush()
1070 
 
1071 
  def recv_updatePassword(self, ):
1072 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1073 
    if mtype == TMessageType.EXCEPTION:
1074 
      x = TApplicationException()
1075 
      x.read(self._iprot)
1076 
      self._iprot.readMessageEnd()
1077 
      raise x
1078 
    result = updatePassword_result()
1079 
    result.read(self._iprot)
1080 
    self._iprot.readMessageEnd()
1081 
    if result.success != None:
1082 
      return result.success
1083 
    if result.ucx != None:
1084 
      raise result.ucx
1085 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1086 
 
884 rajveer 1087 
  def forgotPassword(self, email, newPassword):
581 rajveer 1088 
    """
1089 
    Parameters:
1090 
     - email
884 rajveer 1091 
     - newPassword
581 rajveer 1092 
    """
884 rajveer 1093 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1094 
    return self.recv_forgotPassword()
1095 
 
884 rajveer 1096 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1097 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1098 
    args = forgotPassword_args()
1099 
    args.email = email
884 rajveer 1100 
    args.newPassword = newPassword
581 rajveer 1101 
    args.write(self._oprot)
1102 
    self._oprot.writeMessageEnd()
1103 
    self._oprot.trans.flush()
1104 
 
1105 
  def recv_forgotPassword(self, ):
1106 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1107 
    if mtype == TMessageType.EXCEPTION:
1108 
      x = TApplicationException()
1109 
      x.read(self._iprot)
1110 
      self._iprot.readMessageEnd()
1111 
      raise x
1112 
    result = forgotPassword_result()
1113 
    result.read(self._iprot)
1114 
    self._iprot.readMessageEnd()
1115 
    if result.success != None:
1116 
      return result.success
1117 
    if result.ucx != None:
1118 
      raise result.ucx
1119 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1120 
 
594 rajveer 1121 
  def getAllAddressesForUser(self, userId):
1122 
    """
1123 
    Parameters:
1124 
     - userId
1125 
    """
1126 
    self.send_getAllAddressesForUser(userId)
1127 
    return self.recv_getAllAddressesForUser()
1128 
 
1129 
  def send_getAllAddressesForUser(self, userId):
1130 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1131 
    args = getAllAddressesForUser_args()
1132 
    args.userId = userId
1133 
    args.write(self._oprot)
1134 
    self._oprot.writeMessageEnd()
1135 
    self._oprot.trans.flush()
1136 
 
1137 
  def recv_getAllAddressesForUser(self, ):
1138 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1139 
    if mtype == TMessageType.EXCEPTION:
1140 
      x = TApplicationException()
1141 
      x.read(self._iprot)
1142 
      self._iprot.readMessageEnd()
1143 
      raise x
1144 
    result = getAllAddressesForUser_result()
1145 
    result.read(self._iprot)
1146 
    self._iprot.readMessageEnd()
1147 
    if result.success != None:
1148 
      return result.success
1149 
    if result.ucx != None:
1150 
      raise result.ucx
1151 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1152 
 
1894 vikas 1153 
  def getAddressById(self, addressId):
1154 
    """
1155 
    Parameters:
1156 
     - addressId
1157 
    """
1158 
    self.send_getAddressById(addressId)
1159 
    return self.recv_getAddressById()
1160 
 
1161 
  def send_getAddressById(self, addressId):
1162 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1163 
    args = getAddressById_args()
1164 
    args.addressId = addressId
1165 
    args.write(self._oprot)
1166 
    self._oprot.writeMessageEnd()
1167 
    self._oprot.trans.flush()
1168 
 
1169 
  def recv_getAddressById(self, ):
1170 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1171 
    if mtype == TMessageType.EXCEPTION:
1172 
      x = TApplicationException()
1173 
      x.read(self._iprot)
1174 
      self._iprot.readMessageEnd()
1175 
      raise x
1176 
    result = getAddressById_result()
1177 
    result.read(self._iprot)
1178 
    self._iprot.readMessageEnd()
1179 
    if result.success != None:
1180 
      return result.success
1181 
    if result.ucx != None:
1182 
      raise result.ucx
1183 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1184 
 
594 rajveer 1185 
  def getDefaultAddressId(self, userId):
1186 
    """
1187 
    Parameters:
1188 
     - userId
1189 
    """
1190 
    self.send_getDefaultAddressId(userId)
1191 
    return self.recv_getDefaultAddressId()
1192 
 
1193 
  def send_getDefaultAddressId(self, userId):
1194 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1195 
    args = getDefaultAddressId_args()
1196 
    args.userId = userId
1197 
    args.write(self._oprot)
1198 
    self._oprot.writeMessageEnd()
1199 
    self._oprot.trans.flush()
1200 
 
1201 
  def recv_getDefaultAddressId(self, ):
1202 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1203 
    if mtype == TMessageType.EXCEPTION:
1204 
      x = TApplicationException()
1205 
      x.read(self._iprot)
1206 
      self._iprot.readMessageEnd()
1207 
      raise x
1208 
    result = getDefaultAddressId_result()
1209 
    result.read(self._iprot)
1210 
    self._iprot.readMessageEnd()
1211 
    if result.success != None:
1212 
      return result.success
1213 
    if result.ucx != None:
1214 
      raise result.ucx
1215 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1216 
 
785 rajveer 1217 
  def getDefaultPincode(self, userId):
1218 
    """
1219 
    Parameters:
1220 
     - userId
1221 
    """
1222 
    self.send_getDefaultPincode(userId)
1223 
    return self.recv_getDefaultPincode()
1224 
 
1225 
  def send_getDefaultPincode(self, userId):
1226 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1227 
    args = getDefaultPincode_args()
1228 
    args.userId = userId
1229 
    args.write(self._oprot)
1230 
    self._oprot.writeMessageEnd()
1231 
    self._oprot.trans.flush()
1232 
 
1233 
  def recv_getDefaultPincode(self, ):
1234 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1235 
    if mtype == TMessageType.EXCEPTION:
1236 
      x = TApplicationException()
1237 
      x.read(self._iprot)
1238 
      self._iprot.readMessageEnd()
1239 
      raise x
1240 
    result = getDefaultPincode_result()
1241 
    result.read(self._iprot)
1242 
    self._iprot.readMessageEnd()
1243 
    if result.success != None:
1244 
      return result.success
1245 
    if result.ucx != None:
1246 
      raise result.ucx
1247 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1248 
 
1274 varun.gupt 1249 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1250 
    """
1251 
    Parameters:
1252 
     - userId
1253 
     - replyTo
1254 
     - communicationType
1255 
     - orderId
1256 
     - airwaybillNo
1257 
     - productName
1258 
     - subject
1259 
     - message
1260 
    """
1261 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1262 
    return self.recv_saveUserCommunication()
1263 
 
1264 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1265 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1266 
    args = saveUserCommunication_args()
1267 
    args.userId = userId
1268 
    args.replyTo = replyTo
1269 
    args.communicationType = communicationType
1270 
    args.orderId = orderId
1271 
    args.airwaybillNo = airwaybillNo
1272 
    args.productName = productName
1273 
    args.subject = subject
1274 
    args.message = message
1275 
    args.write(self._oprot)
1276 
    self._oprot.writeMessageEnd()
1277 
    self._oprot.trans.flush()
1278 
 
1279 
  def recv_saveUserCommunication(self, ):
1280 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1281 
    if mtype == TMessageType.EXCEPTION:
1282 
      x = TApplicationException()
1283 
      x.read(self._iprot)
1284 
      self._iprot.readMessageEnd()
1285 
      raise x
1286 
    result = saveUserCommunication_result()
1287 
    result.read(self._iprot)
1288 
    self._iprot.readMessageEnd()
1289 
    if result.success != None:
1290 
      return result.success
1291 
    if result.ucx != None:
1292 
      raise result.ucx
1293 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1294 
 
1590 varun.gupt 1295 
  def getUserCommunicationById(self, id):
1296 
    """
1297 
    Parameters:
1298 
     - id
1299 
    """
1300 
    self.send_getUserCommunicationById(id)
1301 
    return self.recv_getUserCommunicationById()
1302 
 
1303 
  def send_getUserCommunicationById(self, id):
1304 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1305 
    args = getUserCommunicationById_args()
1306 
    args.id = id
1307 
    args.write(self._oprot)
1308 
    self._oprot.writeMessageEnd()
1309 
    self._oprot.trans.flush()
1310 
 
1311 
  def recv_getUserCommunicationById(self, ):
1312 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1313 
    if mtype == TMessageType.EXCEPTION:
1314 
      x = TApplicationException()
1315 
      x.read(self._iprot)
1316 
      self._iprot.readMessageEnd()
1317 
      raise x
1318 
    result = getUserCommunicationById_result()
1319 
    result.read(self._iprot)
1320 
    self._iprot.readMessageEnd()
1321 
    if result.success != None:
1322 
      return result.success
1323 
    if result.ucx != None:
1324 
      raise result.ucx
1325 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1326 
 
1327 
  def getUserCommunicationByUser(self, userId):
1328 
    """
1329 
    Parameters:
1330 
     - userId
1331 
    """
1332 
    self.send_getUserCommunicationByUser(userId)
1333 
    return self.recv_getUserCommunicationByUser()
1334 
 
1335 
  def send_getUserCommunicationByUser(self, userId):
1336 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1337 
    args = getUserCommunicationByUser_args()
1338 
    args.userId = userId
1339 
    args.write(self._oprot)
1340 
    self._oprot.writeMessageEnd()
1341 
    self._oprot.trans.flush()
1342 
 
1343 
  def recv_getUserCommunicationByUser(self, ):
1344 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1345 
    if mtype == TMessageType.EXCEPTION:
1346 
      x = TApplicationException()
1347 
      x.read(self._iprot)
1348 
      self._iprot.readMessageEnd()
1349 
      raise x
1350 
    result = getUserCommunicationByUser_result()
1351 
    result.read(self._iprot)
1352 
    self._iprot.readMessageEnd()
1353 
    if result.success != None:
1354 
      return result.success
1355 
    if result.ucx != None:
1356 
      raise result.ucx
1357 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1358 
 
1359 
  def getAllUserCommunications(self, ):
1360 
    self.send_getAllUserCommunications()
1361 
    return self.recv_getAllUserCommunications()
1362 
 
1363 
  def send_getAllUserCommunications(self, ):
1364 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1365 
    args = getAllUserCommunications_args()
1366 
    args.write(self._oprot)
1367 
    self._oprot.writeMessageEnd()
1368 
    self._oprot.trans.flush()
1369 
 
1370 
  def recv_getAllUserCommunications(self, ):
1371 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1372 
    if mtype == TMessageType.EXCEPTION:
1373 
      x = TApplicationException()
1374 
      x.read(self._iprot)
1375 
      self._iprot.readMessageEnd()
1376 
      raise x
1377 
    result = getAllUserCommunications_result()
1378 
    result.read(self._iprot)
1379 
    self._iprot.readMessageEnd()
1380 
    if result.success != None:
1381 
      return result.success
1382 
    if result.ucx != None:
1383 
      raise result.ucx
1384 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1385 
 
1859 vikas 1386 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1387 
    """
1388 
    Parameters:
1389 
     - name
1859 vikas 1390 
     - addedOn
1845 vikas 1391 
    """
1859 vikas 1392 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1393 
    return self.recv_createMasterAffiliate()
1394 
 
1859 vikas 1395 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1396 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1397 
    args = createMasterAffiliate_args()
1398 
    args.name = name
1859 vikas 1399 
    args.addedOn = addedOn
1845 vikas 1400 
    args.write(self._oprot)
1401 
    self._oprot.writeMessageEnd()
1402 
    self._oprot.trans.flush()
1403 
 
1404 
  def recv_createMasterAffiliate(self, ):
1405 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1406 
    if mtype == TMessageType.EXCEPTION:
1407 
      x = TApplicationException()
1408 
      x.read(self._iprot)
1409 
      self._iprot.readMessageEnd()
1410 
      raise x
1411 
    result = createMasterAffiliate_result()
1412 
    result.read(self._iprot)
1413 
    self._iprot.readMessageEnd()
1414 
    if result.success != None:
1415 
      return result.success
1416 
    if result.utx != None:
1417 
      raise result.utx
1418 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1419 
 
1899 vikas 1420 
  def getAllMasterAffiliates(self, ):
1421 
    self.send_getAllMasterAffiliates()
1422 
    return self.recv_getAllMasterAffiliates()
1423 
 
1424 
  def send_getAllMasterAffiliates(self, ):
1425 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1426 
    args = getAllMasterAffiliates_args()
1427 
    args.write(self._oprot)
1428 
    self._oprot.writeMessageEnd()
1429 
    self._oprot.trans.flush()
1430 
 
1431 
  def recv_getAllMasterAffiliates(self, ):
1432 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1433 
    if mtype == TMessageType.EXCEPTION:
1434 
      x = TApplicationException()
1435 
      x.read(self._iprot)
1436 
      self._iprot.readMessageEnd()
1437 
      raise x
1438 
    result = getAllMasterAffiliates_result()
1439 
    result.read(self._iprot)
1440 
    self._iprot.readMessageEnd()
1441 
    if result.success != None:
1442 
      return result.success
1443 
    if result.utx != None:
1444 
      raise result.utx
1445 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1446 
 
1845 vikas 1447 
  def getMasterAffiliateById(self, id):
1448 
    """
1449 
    Parameters:
1450 
     - id
1451 
    """
1452 
    self.send_getMasterAffiliateById(id)
1453 
    return self.recv_getMasterAffiliateById()
1454 
 
1455 
  def send_getMasterAffiliateById(self, id):
1456 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1457 
    args = getMasterAffiliateById_args()
1458 
    args.id = id
1459 
    args.write(self._oprot)
1460 
    self._oprot.writeMessageEnd()
1461 
    self._oprot.trans.flush()
1462 
 
1463 
  def recv_getMasterAffiliateById(self, ):
1464 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1465 
    if mtype == TMessageType.EXCEPTION:
1466 
      x = TApplicationException()
1467 
      x.read(self._iprot)
1468 
      self._iprot.readMessageEnd()
1469 
      raise x
1470 
    result = getMasterAffiliateById_result()
1471 
    result.read(self._iprot)
1472 
    self._iprot.readMessageEnd()
1473 
    if result.success != None:
1474 
      return result.success
1475 
    if result.utx != None:
1476 
      raise result.utx
1477 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1478 
 
1479 
  def getMasterAffiliateByName(self, name):
1480 
    """
1481 
    Parameters:
1482 
     - name
1483 
    """
1484 
    self.send_getMasterAffiliateByName(name)
1485 
    return self.recv_getMasterAffiliateByName()
1486 
 
1487 
  def send_getMasterAffiliateByName(self, name):
1488 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1489 
    args = getMasterAffiliateByName_args()
1490 
    args.name = name
1491 
    args.write(self._oprot)
1492 
    self._oprot.writeMessageEnd()
1493 
    self._oprot.trans.flush()
1494 
 
1495 
  def recv_getMasterAffiliateByName(self, ):
1496 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1497 
    if mtype == TMessageType.EXCEPTION:
1498 
      x = TApplicationException()
1499 
      x.read(self._iprot)
1500 
      self._iprot.readMessageEnd()
1501 
      raise x
1502 
    result = getMasterAffiliateByName_result()
1503 
    result.read(self._iprot)
1504 
    self._iprot.readMessageEnd()
1505 
    if result.success != None:
1506 
      return result.success
1507 
    if result.utx != None:
1508 
      raise result.utx
1509 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1510 
 
1859 vikas 1511 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1512 
    """
1513 
    Parameters:
1514 
     - name
1515 
     - url
1516 
     - masterAffiliateId
1859 vikas 1517 
     - addedOn
1845 vikas 1518 
    """
1859 vikas 1519 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1520 
    return self.recv_createAffiliate()
1521 
 
1859 vikas 1522 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1523 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1524 
    args = createAffiliate_args()
1525 
    args.name = name
1526 
    args.url = url
1527 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1528 
    args.addedOn = addedOn
1845 vikas 1529 
    args.write(self._oprot)
1530 
    self._oprot.writeMessageEnd()
1531 
    self._oprot.trans.flush()
1532 
 
1533 
  def recv_createAffiliate(self, ):
1534 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1535 
    if mtype == TMessageType.EXCEPTION:
1536 
      x = TApplicationException()
1537 
      x.read(self._iprot)
1538 
      self._iprot.readMessageEnd()
1539 
      raise x
1540 
    result = createAffiliate_result()
1541 
    result.read(self._iprot)
1542 
    self._iprot.readMessageEnd()
1543 
    if result.success != None:
1544 
      return result.success
1545 
    if result.utx != None:
1546 
      raise result.utx
1547 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1548 
 
1549 
  def getAffiliateById(self, id):
1550 
    """
1551 
    Parameters:
1552 
     - id
1553 
    """
1554 
    self.send_getAffiliateById(id)
1555 
    return self.recv_getAffiliateById()
1556 
 
1557 
  def send_getAffiliateById(self, id):
1558 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1559 
    args = getAffiliateById_args()
1560 
    args.id = id
1561 
    args.write(self._oprot)
1562 
    self._oprot.writeMessageEnd()
1563 
    self._oprot.trans.flush()
1564 
 
1565 
  def recv_getAffiliateById(self, ):
1566 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1567 
    if mtype == TMessageType.EXCEPTION:
1568 
      x = TApplicationException()
1569 
      x.read(self._iprot)
1570 
      self._iprot.readMessageEnd()
1571 
      raise x
1572 
    result = getAffiliateById_result()
1573 
    result.read(self._iprot)
1574 
    self._iprot.readMessageEnd()
1575 
    if result.success != None:
1576 
      return result.success
1577 
    if result.utx != None:
1578 
      raise result.utx
1579 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1580 
 
1581 
  def getAffiliateByName(self, name):
1582 
    """
1583 
    Parameters:
1584 
     - name
1585 
    """
1586 
    self.send_getAffiliateByName(name)
1587 
    return self.recv_getAffiliateByName()
1588 
 
1589 
  def send_getAffiliateByName(self, name):
1590 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1591 
    args = getAffiliateByName_args()
1592 
    args.name = name
1593 
    args.write(self._oprot)
1594 
    self._oprot.writeMessageEnd()
1595 
    self._oprot.trans.flush()
1596 
 
1597 
  def recv_getAffiliateByName(self, ):
1598 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1599 
    if mtype == TMessageType.EXCEPTION:
1600 
      x = TApplicationException()
1601 
      x.read(self._iprot)
1602 
      self._iprot.readMessageEnd()
1603 
      raise x
1604 
    result = getAffiliateByName_result()
1605 
    result.read(self._iprot)
1606 
    self._iprot.readMessageEnd()
1607 
    if result.success != None:
1608 
      return result.success
1609 
    if result.utx != None:
1610 
      raise result.utx
1611 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1612 
 
1613 
  def getAffiliatesByMasterAffiliate(self, id):
1614 
    """
1615 
    Parameters:
1616 
     - id
1617 
    """
1618 
    self.send_getAffiliatesByMasterAffiliate(id)
1619 
    return self.recv_getAffiliatesByMasterAffiliate()
1620 
 
1621 
  def send_getAffiliatesByMasterAffiliate(self, id):
1622 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1623 
    args = getAffiliatesByMasterAffiliate_args()
1624 
    args.id = id
1625 
    args.write(self._oprot)
1626 
    self._oprot.writeMessageEnd()
1627 
    self._oprot.trans.flush()
1628 
 
1629 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1630 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1631 
    if mtype == TMessageType.EXCEPTION:
1632 
      x = TApplicationException()
1633 
      x.read(self._iprot)
1634 
      self._iprot.readMessageEnd()
1635 
      raise x
1636 
    result = getAffiliatesByMasterAffiliate_result()
1637 
    result.read(self._iprot)
1638 
    self._iprot.readMessageEnd()
1639 
    if result.success != None:
1640 
      return result.success
1641 
    if result.utx != None:
1642 
      raise result.utx
1643 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1644 
 
1859 vikas 1645 
  def createTracker(self, affiliateId, addedOn):
1845 vikas 1646 
    """
1647 
    Parameters:
1648 
     - affiliateId
1859 vikas 1649 
     - addedOn
1845 vikas 1650 
    """
1859 vikas 1651 
    self.send_createTracker(affiliateId, addedOn)
1845 vikas 1652 
    return self.recv_createTracker()
1653 
 
1859 vikas 1654 
  def send_createTracker(self, affiliateId, addedOn):
1845 vikas 1655 
    self._oprot.writeMessageBegin('createTracker', TMessageType.CALL, self._seqid)
1656 
    args = createTracker_args()
1657 
    args.affiliateId = affiliateId
1859 vikas 1658 
    args.addedOn = addedOn
1845 vikas 1659 
    args.write(self._oprot)
1660 
    self._oprot.writeMessageEnd()
1661 
    self._oprot.trans.flush()
1662 
 
1663 
  def recv_createTracker(self, ):
1664 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1665 
    if mtype == TMessageType.EXCEPTION:
1666 
      x = TApplicationException()
1667 
      x.read(self._iprot)
1668 
      self._iprot.readMessageEnd()
1669 
      raise x
1670 
    result = createTracker_result()
1671 
    result.read(self._iprot)
1672 
    self._iprot.readMessageEnd()
1673 
    if result.success != None:
1674 
      return result.success
1675 
    if result.utx != None:
1676 
      raise result.utx
1677 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createTracker failed: unknown result");
1678 
 
1679 
  def getTrackerById(self, trackerId):
1680 
    """
1681 
    Parameters:
1682 
     - trackerId
1683 
    """
1684 
    self.send_getTrackerById(trackerId)
1685 
    return self.recv_getTrackerById()
1686 
 
1687 
  def send_getTrackerById(self, trackerId):
1688 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1689 
    args = getTrackerById_args()
1690 
    args.trackerId = trackerId
1691 
    args.write(self._oprot)
1692 
    self._oprot.writeMessageEnd()
1693 
    self._oprot.trans.flush()
1694 
 
1695 
  def recv_getTrackerById(self, ):
1696 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1697 
    if mtype == TMessageType.EXCEPTION:
1698 
      x = TApplicationException()
1699 
      x.read(self._iprot)
1700 
      self._iprot.readMessageEnd()
1701 
      raise x
1702 
    result = getTrackerById_result()
1703 
    result.read(self._iprot)
1704 
    self._iprot.readMessageEnd()
1705 
    if result.success != None:
1706 
      return result.success
1707 
    if result.utx != None:
1708 
      raise result.utx
1709 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1710 
 
1711 
  def getTrackersByAffiliate(self, affiliateId):
1712 
    """
1713 
    Parameters:
1714 
     - affiliateId
1715 
    """
1716 
    self.send_getTrackersByAffiliate(affiliateId)
1717 
    return self.recv_getTrackersByAffiliate()
1718 
 
1719 
  def send_getTrackersByAffiliate(self, affiliateId):
1720 
    self._oprot.writeMessageBegin('getTrackersByAffiliate', TMessageType.CALL, self._seqid)
1721 
    args = getTrackersByAffiliate_args()
1722 
    args.affiliateId = affiliateId
1723 
    args.write(self._oprot)
1724 
    self._oprot.writeMessageEnd()
1725 
    self._oprot.trans.flush()
1726 
 
1727 
  def recv_getTrackersByAffiliate(self, ):
1728 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1729 
    if mtype == TMessageType.EXCEPTION:
1730 
      x = TApplicationException()
1731 
      x.read(self._iprot)
1732 
      self._iprot.readMessageEnd()
1733 
      raise x
1734 
    result = getTrackersByAffiliate_result()
1735 
    result.read(self._iprot)
1736 
    self._iprot.readMessageEnd()
1737 
    if result.success != None:
1738 
      return result.success
1739 
    if result.utx != None:
1740 
      raise result.utx
1741 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackersByAffiliate failed: unknown result");
1742 
 
1859 vikas 1743 
  def addTrackLog(self, trackerId, userId, event, url, data, addedOn):
1845 vikas 1744 
    """
1745 
    Parameters:
1746 
     - trackerId
1747 
     - userId
1748 
     - event
1749 
     - url
1750 
     - data
1859 vikas 1751 
     - addedOn
1845 vikas 1752 
    """
1859 vikas 1753 
    self.send_addTrackLog(trackerId, userId, event, url, data, addedOn)
1845 vikas 1754 
    return self.recv_addTrackLog()
1755 
 
1859 vikas 1756 
  def send_addTrackLog(self, trackerId, userId, event, url, data, addedOn):
1845 vikas 1757 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1758 
    args = addTrackLog_args()
1759 
    args.trackerId = trackerId
1760 
    args.userId = userId
1761 
    args.event = event
1762 
    args.url = url
1763 
    args.data = data
1859 vikas 1764 
    args.addedOn = addedOn
1845 vikas 1765 
    args.write(self._oprot)
1766 
    self._oprot.writeMessageEnd()
1767 
    self._oprot.trans.flush()
1768 
 
1769 
  def recv_addTrackLog(self, ):
1770 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1771 
    if mtype == TMessageType.EXCEPTION:
1772 
      x = TApplicationException()
1773 
      x.read(self._iprot)
1774 
      self._iprot.readMessageEnd()
1775 
      raise x
1776 
    result = addTrackLog_result()
1777 
    result.read(self._iprot)
1778 
    self._iprot.readMessageEnd()
1779 
    if result.success != None:
1780 
      return result.success
1781 
    if result.utx != None:
1782 
      raise result.utx
1783 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1784 
 
1785 
  def getTrackLogById(self, id):
1786 
    """
1787 
    Parameters:
1788 
     - id
1789 
    """
1790 
    self.send_getTrackLogById(id)
1791 
    return self.recv_getTrackLogById()
1792 
 
1793 
  def send_getTrackLogById(self, id):
1794 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1795 
    args = getTrackLogById_args()
1796 
    args.id = id
1797 
    args.write(self._oprot)
1798 
    self._oprot.writeMessageEnd()
1799 
    self._oprot.trans.flush()
1800 
 
1801 
  def recv_getTrackLogById(self, ):
1802 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1803 
    if mtype == TMessageType.EXCEPTION:
1804 
      x = TApplicationException()
1805 
      x.read(self._iprot)
1806 
      self._iprot.readMessageEnd()
1807 
      raise x
1808 
    result = getTrackLogById_result()
1809 
    result.read(self._iprot)
1810 
    self._iprot.readMessageEnd()
1811 
    if result.success != None:
1812 
      return result.success
1813 
    if result.utx != None:
1814 
      raise result.utx
1815 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1816 
 
1817 
  def getTrackLogsByTracker(self, trackerId):
1818 
    """
1819 
    Parameters:
1820 
     - trackerId
1821 
    """
1822 
    self.send_getTrackLogsByTracker(trackerId)
1823 
    return self.recv_getTrackLogsByTracker()
1824 
 
1825 
  def send_getTrackLogsByTracker(self, trackerId):
1826 
    self._oprot.writeMessageBegin('getTrackLogsByTracker', TMessageType.CALL, self._seqid)
1827 
    args = getTrackLogsByTracker_args()
1828 
    args.trackerId = trackerId
1829 
    args.write(self._oprot)
1830 
    self._oprot.writeMessageEnd()
1831 
    self._oprot.trans.flush()
1832 
 
1833 
  def recv_getTrackLogsByTracker(self, ):
1834 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1835 
    if mtype == TMessageType.EXCEPTION:
1836 
      x = TApplicationException()
1837 
      x.read(self._iprot)
1838 
      self._iprot.readMessageEnd()
1839 
      raise x
1840 
    result = getTrackLogsByTracker_result()
1841 
    result.read(self._iprot)
1842 
    self._iprot.readMessageEnd()
1843 
    if result.success != None:
1844 
      return result.success
1845 
    if result.utx != None:
1846 
      raise result.utx
1847 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByTracker failed: unknown result");
1848 
 
1849 
  def getTrackLogsByUser(self, userId):
1850 
    """
1851 
    Parameters:
1852 
     - userId
1853 
    """
1854 
    self.send_getTrackLogsByUser(userId)
1855 
    return self.recv_getTrackLogsByUser()
1856 
 
1857 
  def send_getTrackLogsByUser(self, userId):
1858 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
1859 
    args = getTrackLogsByUser_args()
1860 
    args.userId = userId
1861 
    args.write(self._oprot)
1862 
    self._oprot.writeMessageEnd()
1863 
    self._oprot.trans.flush()
1864 
 
1865 
  def recv_getTrackLogsByUser(self, ):
1866 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1867 
    if mtype == TMessageType.EXCEPTION:
1868 
      x = TApplicationException()
1869 
      x.read(self._iprot)
1870 
      self._iprot.readMessageEnd()
1871 
      raise x
1872 
    result = getTrackLogsByUser_result()
1873 
    result.read(self._iprot)
1874 
    self._iprot.readMessageEnd()
1875 
    if result.success != None:
1876 
      return result.success
1877 
    if result.utx != None:
1878 
      raise result.utx
1879 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
1880 
 
1881 
  def getTrackLogs(self, trackerId, userId, event, url):
1882 
    """
1883 
    Parameters:
1884 
     - trackerId
1885 
     - userId
1886 
     - event
1887 
     - url
1888 
    """
1889 
    self.send_getTrackLogs(trackerId, userId, event, url)
1890 
    return self.recv_getTrackLogs()
1891 
 
1892 
  def send_getTrackLogs(self, trackerId, userId, event, url):
1893 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
1894 
    args = getTrackLogs_args()
1895 
    args.trackerId = trackerId
1896 
    args.userId = userId
1897 
    args.event = event
1898 
    args.url = url
1899 
    args.write(self._oprot)
1900 
    self._oprot.writeMessageEnd()
1901 
    self._oprot.trans.flush()
1902 
 
1903 
  def recv_getTrackLogs(self, ):
1904 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1905 
    if mtype == TMessageType.EXCEPTION:
1906 
      x = TApplicationException()
1907 
      x.read(self._iprot)
1908 
      self._iprot.readMessageEnd()
1909 
      raise x
1910 
    result = getTrackLogs_result()
1911 
    result.read(self._iprot)
1912 
    self._iprot.readMessageEnd()
1913 
    if result.success != None:
1914 
      return result.success
1915 
    if result.utx != None:
1916 
      raise result.utx
1917 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
1918 
 
559 chandransh 1919 
  def createCart(self, userId):
94 ashish 1920 
    """
1921 
    Parameters:
559 chandransh 1922 
     - userId
94 ashish 1923 
    """
559 chandransh 1924 
    self.send_createCart(userId)
1925 
    return self.recv_createCart()
94 ashish 1926 
 
559 chandransh 1927 
  def send_createCart(self, userId):
1928 
    self._oprot.writeMessageBegin('createCart', TMessageType.CALL, self._seqid)
1929 
    args = createCart_args()
1930 
    args.userId = userId
94 ashish 1931 
    args.write(self._oprot)
1932 
    self._oprot.writeMessageEnd()
1933 
    self._oprot.trans.flush()
1934 
 
559 chandransh 1935 
  def recv_createCart(self, ):
94 ashish 1936 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1937 
    if mtype == TMessageType.EXCEPTION:
1938 
      x = TApplicationException()
1939 
      x.read(self._iprot)
1940 
      self._iprot.readMessageEnd()
1941 
      raise x
559 chandransh 1942 
    result = createCart_result()
94 ashish 1943 
    result.read(self._iprot)
1944 
    self._iprot.readMessageEnd()
1945 
    if result.success != None:
1946 
      return result.success
559 chandransh 1947 
    if result.scx != None:
1948 
      raise result.scx
1949 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createCart failed: unknown result");
94 ashish 1950 
 
559 chandransh 1951 
  def getCurrentCart(self, userId):
94 ashish 1952 
    """
1953 
    Parameters:
559 chandransh 1954 
     - userId
94 ashish 1955 
    """
559 chandransh 1956 
    self.send_getCurrentCart(userId)
1957 
    return self.recv_getCurrentCart()
94 ashish 1958 
 
559 chandransh 1959 
  def send_getCurrentCart(self, userId):
1960 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
1961 
    args = getCurrentCart_args()
1962 
    args.userId = userId
94 ashish 1963 
    args.write(self._oprot)
1964 
    self._oprot.writeMessageEnd()
1965 
    self._oprot.trans.flush()
1966 
 
559 chandransh 1967 
  def recv_getCurrentCart(self, ):
94 ashish 1968 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1969 
    if mtype == TMessageType.EXCEPTION:
1970 
      x = TApplicationException()
1971 
      x.read(self._iprot)
1972 
      self._iprot.readMessageEnd()
1973 
      raise x
559 chandransh 1974 
    result = getCurrentCart_result()
94 ashish 1975 
    result.read(self._iprot)
1976 
    self._iprot.readMessageEnd()
1977 
    if result.success != None:
1978 
      return result.success
559 chandransh 1979 
    if result.scx != None:
1980 
      raise result.scx
1981 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 1982 
 
559 chandransh 1983 
  def getCart(self, cartId):
94 ashish 1984 
    """
1985 
    Parameters:
559 chandransh 1986 
     - cartId
94 ashish 1987 
    """
559 chandransh 1988 
    self.send_getCart(cartId)
1989 
    return self.recv_getCart()
94 ashish 1990 
 
559 chandransh 1991 
  def send_getCart(self, cartId):
1992 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
1993 
    args = getCart_args()
1994 
    args.cartId = cartId
94 ashish 1995 
    args.write(self._oprot)
1996 
    self._oprot.writeMessageEnd()
1997 
    self._oprot.trans.flush()
1998 
 
559 chandransh 1999 
  def recv_getCart(self, ):
94 ashish 2000 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2001 
    if mtype == TMessageType.EXCEPTION:
2002 
      x = TApplicationException()
2003 
      x.read(self._iprot)
2004 
      self._iprot.readMessageEnd()
2005 
      raise x
559 chandransh 2006 
    result = getCart_result()
94 ashish 2007 
    result.read(self._iprot)
2008 
    self._iprot.readMessageEnd()
2009 
    if result.success != None:
2010 
      return result.success
559 chandransh 2011 
    if result.scx != None:
2012 
      raise result.scx
2013 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 2014 
 
559 chandransh 2015 
  def getCartsForUser(self, userId, status):
94 ashish 2016 
    """
2017 
    Parameters:
559 chandransh 2018 
     - userId
2019 
     - status
94 ashish 2020 
    """
559 chandransh 2021 
    self.send_getCartsForUser(userId, status)
2022 
    return self.recv_getCartsForUser()
94 ashish 2023 
 
559 chandransh 2024 
  def send_getCartsForUser(self, userId, status):
2025 
    self._oprot.writeMessageBegin('getCartsForUser', TMessageType.CALL, self._seqid)
2026 
    args = getCartsForUser_args()
2027 
    args.userId = userId
2028 
    args.status = status
94 ashish 2029 
    args.write(self._oprot)
2030 
    self._oprot.writeMessageEnd()
2031 
    self._oprot.trans.flush()
2032 
 
559 chandransh 2033 
  def recv_getCartsForUser(self, ):
94 ashish 2034 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2035 
    if mtype == TMessageType.EXCEPTION:
2036 
      x = TApplicationException()
2037 
      x.read(self._iprot)
2038 
      self._iprot.readMessageEnd()
2039 
      raise x
559 chandransh 2040 
    result = getCartsForUser_result()
94 ashish 2041 
    result.read(self._iprot)
2042 
    self._iprot.readMessageEnd()
2043 
    if result.success != None:
2044 
      return result.success
559 chandransh 2045 
    if result.scx != None:
2046 
      raise result.scx
2047 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsForUser failed: unknown result");
94 ashish 2048 
 
559 chandransh 2049 
  def getCartsByStatus(self, status):
94 ashish 2050 
    """
2051 
    Parameters:
559 chandransh 2052 
     - status
94 ashish 2053 
    """
559 chandransh 2054 
    self.send_getCartsByStatus(status)
2055 
    return self.recv_getCartsByStatus()
94 ashish 2056 
 
559 chandransh 2057 
  def send_getCartsByStatus(self, status):
2058 
    self._oprot.writeMessageBegin('getCartsByStatus', TMessageType.CALL, self._seqid)
2059 
    args = getCartsByStatus_args()
2060 
    args.status = status
94 ashish 2061 
    args.write(self._oprot)
2062 
    self._oprot.writeMessageEnd()
2063 
    self._oprot.trans.flush()
2064 
 
559 chandransh 2065 
  def recv_getCartsByStatus(self, ):
94 ashish 2066 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2067 
    if mtype == TMessageType.EXCEPTION:
2068 
      x = TApplicationException()
2069 
      x.read(self._iprot)
2070 
      self._iprot.readMessageEnd()
2071 
      raise x
559 chandransh 2072 
    result = getCartsByStatus_result()
94 ashish 2073 
    result.read(self._iprot)
2074 
    self._iprot.readMessageEnd()
2075 
    if result.success != None:
2076 
      return result.success
559 chandransh 2077 
    if result.scx != None:
2078 
      raise result.scx
2079 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByStatus failed: unknown result");
94 ashish 2080 
 
559 chandransh 2081 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2082 
    """
2083 
    Parameters:
559 chandransh 2084 
     - from_time
2085 
     - to_time
2086 
     - status
94 ashish 2087 
    """
559 chandransh 2088 
    self.send_getCartsByTime(from_time, to_time, status)
2089 
    return self.recv_getCartsByTime()
94 ashish 2090 
 
559 chandransh 2091 
  def send_getCartsByTime(self, from_time, to_time, status):
2092 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2093 
    args = getCartsByTime_args()
2094 
    args.from_time = from_time
2095 
    args.to_time = to_time
2096 
    args.status = status
94 ashish 2097 
    args.write(self._oprot)
2098 
    self._oprot.writeMessageEnd()
2099 
    self._oprot.trans.flush()
2100 
 
559 chandransh 2101 
  def recv_getCartsByTime(self, ):
94 ashish 2102 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2103 
    if mtype == TMessageType.EXCEPTION:
2104 
      x = TApplicationException()
2105 
      x.read(self._iprot)
2106 
      self._iprot.readMessageEnd()
2107 
      raise x
559 chandransh 2108 
    result = getCartsByTime_result()
94 ashish 2109 
    result.read(self._iprot)
2110 
    self._iprot.readMessageEnd()
2111 
    if result.success != None:
2112 
      return result.success
559 chandransh 2113 
    if result.scx != None:
2114 
      raise result.scx
2115 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2116 
 
559 chandransh 2117 
  def changeCartStatus(self, cartId, status):
130 ashish 2118 
    """
2119 
    Parameters:
559 chandransh 2120 
     - cartId
2121 
     - status
130 ashish 2122 
    """
559 chandransh 2123 
    self.send_changeCartStatus(cartId, status)
2124 
    self.recv_changeCartStatus()
94 ashish 2125 
 
559 chandransh 2126 
  def send_changeCartStatus(self, cartId, status):
2127 
    self._oprot.writeMessageBegin('changeCartStatus', TMessageType.CALL, self._seqid)
2128 
    args = changeCartStatus_args()
2129 
    args.cartId = cartId
2130 
    args.status = status
130 ashish 2131 
    args.write(self._oprot)
2132 
    self._oprot.writeMessageEnd()
2133 
    self._oprot.trans.flush()
2134 
 
559 chandransh 2135 
  def recv_changeCartStatus(self, ):
130 ashish 2136 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2137 
    if mtype == TMessageType.EXCEPTION:
2138 
      x = TApplicationException()
2139 
      x.read(self._iprot)
2140 
      self._iprot.readMessageEnd()
2141 
      raise x
559 chandransh 2142 
    result = changeCartStatus_result()
130 ashish 2143 
    result.read(self._iprot)
2144 
    self._iprot.readMessageEnd()
559 chandransh 2145 
    if result.scx != None:
2146 
      raise result.scx
2147 
    return
2148 
 
2149 
  def addItemToCart(self, cartId, itemId, quantity):
2150 
    """
2151 
    Parameters:
2152 
     - cartId
2153 
     - itemId
2154 
     - quantity
2155 
    """
2156 
    self.send_addItemToCart(cartId, itemId, quantity)
2157 
    self.recv_addItemToCart()
2158 
 
2159 
  def send_addItemToCart(self, cartId, itemId, quantity):
2160 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2161 
    args = addItemToCart_args()
2162 
    args.cartId = cartId
2163 
    args.itemId = itemId
2164 
    args.quantity = quantity
2165 
    args.write(self._oprot)
2166 
    self._oprot.writeMessageEnd()
2167 
    self._oprot.trans.flush()
2168 
 
2169 
  def recv_addItemToCart(self, ):
2170 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2171 
    if mtype == TMessageType.EXCEPTION:
2172 
      x = TApplicationException()
2173 
      x.read(self._iprot)
2174 
      self._iprot.readMessageEnd()
2175 
      raise x
2176 
    result = addItemToCart_result()
2177 
    result.read(self._iprot)
2178 
    self._iprot.readMessageEnd()
2179 
    if result.scx != None:
2180 
      raise result.scx
2181 
    return
2182 
 
2183 
  def deleteItemFromCart(self, cartId, itemId):
2184 
    """
2185 
    Parameters:
2186 
     - cartId
2187 
     - itemId
2188 
    """
2189 
    self.send_deleteItemFromCart(cartId, itemId)
2190 
    self.recv_deleteItemFromCart()
2191 
 
2192 
  def send_deleteItemFromCart(self, cartId, itemId):
2193 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2194 
    args = deleteItemFromCart_args()
2195 
    args.cartId = cartId
2196 
    args.itemId = itemId
2197 
    args.write(self._oprot)
2198 
    self._oprot.writeMessageEnd()
2199 
    self._oprot.trans.flush()
2200 
 
2201 
  def recv_deleteItemFromCart(self, ):
2202 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2203 
    if mtype == TMessageType.EXCEPTION:
2204 
      x = TApplicationException()
2205 
      x.read(self._iprot)
2206 
      self._iprot.readMessageEnd()
2207 
      raise x
2208 
    result = deleteItemFromCart_result()
2209 
    result.read(self._iprot)
2210 
    self._iprot.readMessageEnd()
2211 
    if result.scx != None:
2212 
      raise result.scx
2213 
    return
2214 
 
2215 
  def changeQuantity(self, cartId, itemId, quantity):
2216 
    """
2217 
    Parameters:
2218 
     - cartId
2219 
     - itemId
2220 
     - quantity
2221 
    """
2222 
    self.send_changeQuantity(cartId, itemId, quantity)
2223 
    self.recv_changeQuantity()
2224 
 
2225 
  def send_changeQuantity(self, cartId, itemId, quantity):
2226 
    self._oprot.writeMessageBegin('changeQuantity', TMessageType.CALL, self._seqid)
2227 
    args = changeQuantity_args()
2228 
    args.cartId = cartId
2229 
    args.itemId = itemId
2230 
    args.quantity = quantity
2231 
    args.write(self._oprot)
2232 
    self._oprot.writeMessageEnd()
2233 
    self._oprot.trans.flush()
2234 
 
2235 
  def recv_changeQuantity(self, ):
2236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2237 
    if mtype == TMessageType.EXCEPTION:
2238 
      x = TApplicationException()
2239 
      x.read(self._iprot)
2240 
      self._iprot.readMessageEnd()
2241 
      raise x
2242 
    result = changeQuantity_result()
2243 
    result.read(self._iprot)
2244 
    self._iprot.readMessageEnd()
2245 
    if result.scx != None:
2246 
      raise result.scx
2247 
    return
2248 
 
2249 
  def changeItemStatus(self, cartId, itemId, status):
2250 
    """
2251 
    Parameters:
2252 
     - cartId
2253 
     - itemId
2254 
     - status
2255 
    """
2256 
    self.send_changeItemStatus(cartId, itemId, status)
2257 
    self.recv_changeItemStatus()
2258 
 
2259 
  def send_changeItemStatus(self, cartId, itemId, status):
2260 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
2261 
    args = changeItemStatus_args()
2262 
    args.cartId = cartId
2263 
    args.itemId = itemId
2264 
    args.status = status
2265 
    args.write(self._oprot)
2266 
    self._oprot.writeMessageEnd()
2267 
    self._oprot.trans.flush()
2268 
 
2269 
  def recv_changeItemStatus(self, ):
2270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2271 
    if mtype == TMessageType.EXCEPTION:
2272 
      x = TApplicationException()
2273 
      x.read(self._iprot)
2274 
      self._iprot.readMessageEnd()
2275 
      raise x
2276 
    result = changeItemStatus_result()
2277 
    result.read(self._iprot)
2278 
    self._iprot.readMessageEnd()
2279 
    if result.scx != None:
2280 
      raise result.scx
2281 
    return
2282 
 
2283 
  def addAddressToCart(self, cartId, addressId):
2284 
    """
2285 
    Parameters:
2286 
     - cartId
2287 
     - addressId
2288 
    """
2289 
    self.send_addAddressToCart(cartId, addressId)
2290 
    self.recv_addAddressToCart()
2291 
 
2292 
  def send_addAddressToCart(self, cartId, addressId):
2293 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2294 
    args = addAddressToCart_args()
2295 
    args.cartId = cartId
2296 
    args.addressId = addressId
2297 
    args.write(self._oprot)
2298 
    self._oprot.writeMessageEnd()
2299 
    self._oprot.trans.flush()
2300 
 
2301 
  def recv_addAddressToCart(self, ):
2302 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2303 
    if mtype == TMessageType.EXCEPTION:
2304 
      x = TApplicationException()
2305 
      x.read(self._iprot)
2306 
      self._iprot.readMessageEnd()
2307 
      raise x
2308 
    result = addAddressToCart_result()
2309 
    result.read(self._iprot)
2310 
    self._iprot.readMessageEnd()
575 chandransh 2311 
    if result.scx != None:
2312 
      raise result.scx
559 chandransh 2313 
    return
2314 
 
690 chandransh 2315 
  def createOrders(self, cartId):
559 chandransh 2316 
    """
690 chandransh 2317 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
2318 
 
559 chandransh 2319 
    Parameters:
2320 
     - cartId
2321 
    """
690 chandransh 2322 
    self.send_createOrders(cartId)
2323 
    return self.recv_createOrders()
559 chandransh 2324 
 
690 chandransh 2325 
  def send_createOrders(self, cartId):
2326 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2327 
    args = createOrders_args()
559 chandransh 2328 
    args.cartId = cartId
2329 
    args.write(self._oprot)
2330 
    self._oprot.writeMessageEnd()
2331 
    self._oprot.trans.flush()
2332 
 
690 chandransh 2333 
  def recv_createOrders(self, ):
559 chandransh 2334 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2335 
    if mtype == TMessageType.EXCEPTION:
2336 
      x = TApplicationException()
2337 
      x.read(self._iprot)
2338 
      self._iprot.readMessageEnd()
2339 
      raise x
690 chandransh 2340 
    result = createOrders_result()
559 chandransh 2341 
    result.read(self._iprot)
2342 
    self._iprot.readMessageEnd()
130 ashish 2343 
    if result.success != None:
2344 
      return result.success
559 chandransh 2345 
    if result.scx != None:
2346 
      raise result.scx
690 chandransh 2347 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2348 
 
559 chandransh 2349 
  def validateCart(self, cartId):
130 ashish 2350 
    """
690 chandransh 2351 
    Validates that:
2352 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2353 
    2. All of the lines in the cart are active items.
690 chandransh 2354 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2355 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 2356 
 
130 ashish 2357 
    Parameters:
559 chandransh 2358 
     - cartId
130 ashish 2359 
    """
559 chandransh 2360 
    self.send_validateCart(cartId)
2361 
    return self.recv_validateCart()
130 ashish 2362 
 
559 chandransh 2363 
  def send_validateCart(self, cartId):
2364 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2365 
    args = validateCart_args()
2366 
    args.cartId = cartId
130 ashish 2367 
    args.write(self._oprot)
2368 
    self._oprot.writeMessageEnd()
2369 
    self._oprot.trans.flush()
2370 
 
559 chandransh 2371 
  def recv_validateCart(self, ):
130 ashish 2372 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2373 
    if mtype == TMessageType.EXCEPTION:
2374 
      x = TApplicationException()
2375 
      x.read(self._iprot)
2376 
      self._iprot.readMessageEnd()
2377 
      raise x
559 chandransh 2378 
    result = validateCart_result()
130 ashish 2379 
    result.read(self._iprot)
2380 
    self._iprot.readMessageEnd()
2381 
    if result.success != None:
2382 
      return result.success
575 chandransh 2383 
    if result.scex != None:
2384 
      raise result.scex
559 chandransh 2385 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2386 
 
690 chandransh 2387 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2388 
    """
690 chandransh 2389 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
2390 
 
575 chandransh 2391 
    Parameters:
690 chandransh 2392 
     - fromCartId
2393 
     - toCartId
2394 
    """
2395 
    self.send_mergeCart(fromCartId, toCartId)
2396 
    self.recv_mergeCart()
2397 
 
2398 
  def send_mergeCart(self, fromCartId, toCartId):
2399 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2400 
    args = mergeCart_args()
2401 
    args.fromCartId = fromCartId
2402 
    args.toCartId = toCartId
2403 
    args.write(self._oprot)
2404 
    self._oprot.writeMessageEnd()
2405 
    self._oprot.trans.flush()
2406 
 
2407 
  def recv_mergeCart(self, ):
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
2414 
    result = mergeCart_result()
2415 
    result.read(self._iprot)
2416 
    self._iprot.readMessageEnd()
2417 
    return
2418 
 
2419 
  def checkOut(self, cartId):
2420 
    """
2421 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
2422 
 
2423 
    Parameters:
575 chandransh 2424 
     - cartId
2425 
    """
690 chandransh 2426 
    self.send_checkOut(cartId)
2427 
    return self.recv_checkOut()
575 chandransh 2428 
 
690 chandransh 2429 
  def send_checkOut(self, cartId):
2430 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2431 
    args = checkOut_args()
575 chandransh 2432 
    args.cartId = cartId
2433 
    args.write(self._oprot)
2434 
    self._oprot.writeMessageEnd()
2435 
    self._oprot.trans.flush()
2436 
 
690 chandransh 2437 
  def recv_checkOut(self, ):
575 chandransh 2438 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2439 
    if mtype == TMessageType.EXCEPTION:
2440 
      x = TApplicationException()
2441 
      x.read(self._iprot)
2442 
      self._iprot.readMessageEnd()
2443 
      raise x
690 chandransh 2444 
    result = checkOut_result()
575 chandransh 2445 
    result.read(self._iprot)
2446 
    self._iprot.readMessageEnd()
2447 
    if result.success != None:
2448 
      return result.success
2449 
    if result.scex != None:
2450 
      raise result.scex
690 chandransh 2451 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2452 
 
690 chandransh 2453 
  def resetCart(self, cartId, items):
559 chandransh 2454 
    """
690 chandransh 2455 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2456 
    This methods removes the specified quantiry of the specified item from the cart.
2457 
 
559 chandransh 2458 
    Parameters:
690 chandransh 2459 
     - cartId
2460 
     - items
559 chandransh 2461 
    """
690 chandransh 2462 
    self.send_resetCart(cartId, items)
2463 
    return self.recv_resetCart()
130 ashish 2464 
 
690 chandransh 2465 
  def send_resetCart(self, cartId, items):
2466 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2467 
    args = resetCart_args()
2468 
    args.cartId = cartId
2469 
    args.items = items
559 chandransh 2470 
    args.write(self._oprot)
2471 
    self._oprot.writeMessageEnd()
2472 
    self._oprot.trans.flush()
2473 
 
690 chandransh 2474 
  def recv_resetCart(self, ):
559 chandransh 2475 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2476 
    if mtype == TMessageType.EXCEPTION:
2477 
      x = TApplicationException()
2478 
      x.read(self._iprot)
2479 
      self._iprot.readMessageEnd()
2480 
      raise x
690 chandransh 2481 
    result = resetCart_result()
559 chandransh 2482 
    result.read(self._iprot)
2483 
    self._iprot.readMessageEnd()
690 chandransh 2484 
    if result.success != None:
2485 
      return result.success
2486 
    if result.scex != None:
2487 
      raise result.scex
2488 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2489 
 
772 rajveer 2490 
  def getMyResearch(self, userId):
559 chandransh 2491 
    """
772 rajveer 2492 
    Widgets
2493 
 
559 chandransh 2494 
    Parameters:
2495 
     - userId
2496 
    """
772 rajveer 2497 
    self.send_getMyResearch(userId)
559 chandransh 2498 
    return self.recv_getMyResearch()
2499 
 
772 rajveer 2500 
  def send_getMyResearch(self, userId):
559 chandransh 2501 
    self._oprot.writeMessageBegin('getMyResearch', TMessageType.CALL, self._seqid)
2502 
    args = getMyResearch_args()
772 rajveer 2503 
    args.userId = userId
559 chandransh 2504 
    args.write(self._oprot)
2505 
    self._oprot.writeMessageEnd()
2506 
    self._oprot.trans.flush()
2507 
 
2508 
  def recv_getMyResearch(self, ):
2509 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2510 
    if mtype == TMessageType.EXCEPTION:
2511 
      x = TApplicationException()
2512 
      x.read(self._iprot)
2513 
      self._iprot.readMessageEnd()
2514 
      raise x
2515 
    result = getMyResearch_result()
2516 
    result.read(self._iprot)
2517 
    self._iprot.readMessageEnd()
2518 
    if result.success != None:
2519 
      return result.success
2520 
    if result.scx != None:
2521 
      raise result.scx
2522 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearch failed: unknown result");
2523 
 
772 rajveer 2524 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2525 
    """
2526 
    Parameters:
772 rajveer 2527 
     - userId
2528 
     - itemId
559 chandransh 2529 
    """
772 rajveer 2530 
    self.send_updateMyResearch(userId, itemId)
559 chandransh 2531 
    return self.recv_updateMyResearch()
2532 
 
772 rajveer 2533 
  def send_updateMyResearch(self, userId, itemId):
559 chandransh 2534 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2535 
    args = updateMyResearch_args()
772 rajveer 2536 
    args.userId = userId
2537 
    args.itemId = itemId
559 chandransh 2538 
    args.write(self._oprot)
2539 
    self._oprot.writeMessageEnd()
2540 
    self._oprot.trans.flush()
2541 
 
2542 
  def recv_updateMyResearch(self, ):
2543 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2544 
    if mtype == TMessageType.EXCEPTION:
2545 
      x = TApplicationException()
2546 
      x.read(self._iprot)
2547 
      self._iprot.readMessageEnd()
2548 
      raise x
2549 
    result = updateMyResearch_result()
2550 
    result.read(self._iprot)
2551 
    self._iprot.readMessageEnd()
2552 
    if result.success != None:
2553 
      return result.success
2554 
    if result.scx != None:
2555 
      raise result.scx
2556 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
2557 
 
772 rajveer 2558 
  def deleteItemFromMyResearch(self, userId, itemId):
559 chandransh 2559 
    """
2560 
    Parameters:
772 rajveer 2561 
     - userId
2562 
     - itemId
559 chandransh 2563 
    """
772 rajveer 2564 
    self.send_deleteItemFromMyResearch(userId, itemId)
559 chandransh 2565 
    self.recv_deleteItemFromMyResearch()
2566 
 
772 rajveer 2567 
  def send_deleteItemFromMyResearch(self, userId, itemId):
559 chandransh 2568 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2569 
    args = deleteItemFromMyResearch_args()
772 rajveer 2570 
    args.userId = userId
2571 
    args.itemId = itemId
559 chandransh 2572 
    args.write(self._oprot)
2573 
    self._oprot.writeMessageEnd()
2574 
    self._oprot.trans.flush()
2575 
 
2576 
  def recv_deleteItemFromMyResearch(self, ):
2577 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2578 
    if mtype == TMessageType.EXCEPTION:
2579 
      x = TApplicationException()
2580 
      x.read(self._iprot)
2581 
      self._iprot.readMessageEnd()
2582 
      raise x
2583 
    result = deleteItemFromMyResearch_result()
2584 
    result.read(self._iprot)
2585 
    self._iprot.readMessageEnd()
2586 
    if result.scx != None:
2587 
      raise result.scx
2588 
    return
2589 
 
772 rajveer 2590 
  def updateBrowseHistory(self, userId, itemId):
559 chandransh 2591 
    """
2592 
    Parameters:
772 rajveer 2593 
     - userId
2594 
     - itemId
559 chandransh 2595 
    """
772 rajveer 2596 
    self.send_updateBrowseHistory(userId, itemId)
2597 
    self.recv_updateBrowseHistory()
559 chandransh 2598 
 
772 rajveer 2599 
  def send_updateBrowseHistory(self, userId, itemId):
2600 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2601 
    args = updateBrowseHistory_args()
2602 
    args.userId = userId
2603 
    args.itemId = itemId
559 chandransh 2604 
    args.write(self._oprot)
2605 
    self._oprot.writeMessageEnd()
2606 
    self._oprot.trans.flush()
2607 
 
772 rajveer 2608 
  def recv_updateBrowseHistory(self, ):
559 chandransh 2609 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2610 
    if mtype == TMessageType.EXCEPTION:
2611 
      x = TApplicationException()
2612 
      x.read(self._iprot)
2613 
      self._iprot.readMessageEnd()
2614 
      raise x
772 rajveer 2615 
    result = updateBrowseHistory_result()
559 chandransh 2616 
    result.read(self._iprot)
2617 
    self._iprot.readMessageEnd()
2618 
    return
2619 
 
772 rajveer 2620 
  def getBrowseHistory(self, userId):
559 chandransh 2621 
    """
2622 
    Parameters:
772 rajveer 2623 
     - userId
559 chandransh 2624 
    """
772 rajveer 2625 
    self.send_getBrowseHistory(userId)
2626 
    return self.recv_getBrowseHistory()
559 chandransh 2627 
 
772 rajveer 2628 
  def send_getBrowseHistory(self, userId):
2629 
    self._oprot.writeMessageBegin('getBrowseHistory', TMessageType.CALL, self._seqid)
2630 
    args = getBrowseHistory_args()
2631 
    args.userId = userId
559 chandransh 2632 
    args.write(self._oprot)
2633 
    self._oprot.writeMessageEnd()
2634 
    self._oprot.trans.flush()
2635 
 
772 rajveer 2636 
  def recv_getBrowseHistory(self, ):
559 chandransh 2637 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2638 
    if mtype == TMessageType.EXCEPTION:
2639 
      x = TApplicationException()
2640 
      x.read(self._iprot)
2641 
      self._iprot.readMessageEnd()
2642 
      raise x
772 rajveer 2643 
    result = getBrowseHistory_result()
559 chandransh 2644 
    result.read(self._iprot)
2645 
    self._iprot.readMessageEnd()
2646 
    if result.success != None:
2647 
      return result.success
2648 
    if result.scx != None:
2649 
      raise result.scx
772 rajveer 2650 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistory failed: unknown result");
559 chandransh 2651 
 
772 rajveer 2652 
  def mergeBrowseHistory(self, fromUserId, toUserId):
559 chandransh 2653 
    """
2654 
    Parameters:
772 rajveer 2655 
     - fromUserId
2656 
     - toUserId
559 chandransh 2657 
    """
772 rajveer 2658 
    self.send_mergeBrowseHistory(fromUserId, toUserId)
2659 
    self.recv_mergeBrowseHistory()
559 chandransh 2660 
 
772 rajveer 2661 
  def send_mergeBrowseHistory(self, fromUserId, toUserId):
2662 
    self._oprot.writeMessageBegin('mergeBrowseHistory', TMessageType.CALL, self._seqid)
2663 
    args = mergeBrowseHistory_args()
2664 
    args.fromUserId = fromUserId
2665 
    args.toUserId = toUserId
559 chandransh 2666 
    args.write(self._oprot)
2667 
    self._oprot.writeMessageEnd()
2668 
    self._oprot.trans.flush()
2669 
 
772 rajveer 2670 
  def recv_mergeBrowseHistory(self, ):
559 chandransh 2671 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2672 
    if mtype == TMessageType.EXCEPTION:
2673 
      x = TApplicationException()
2674 
      x.read(self._iprot)
2675 
      self._iprot.readMessageEnd()
2676 
      raise x
772 rajveer 2677 
    result = mergeBrowseHistory_result()
559 chandransh 2678 
    result.read(self._iprot)
2679 
    self._iprot.readMessageEnd()
2680 
    return
2681 
 
1596 ankur.sing 2682 
  def getUserCount(self, userType):
2683 
    """
2684 
    Returns number of registered users.
2685 
    If userType = null, then it returns count of all users, including anonymous
2686 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2687 
    If userType = UserType.USER, then it returns count of non-anonymous users only
2688 
 
2689 
    Parameters:
2690 
     - userType
2691 
    """
2692 
    self.send_getUserCount(userType)
2693 
    return self.recv_getUserCount()
559 chandransh 2694 
 
1596 ankur.sing 2695 
  def send_getUserCount(self, userType):
2696 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2697 
    args = getUserCount_args()
2698 
    args.userType = userType
2699 
    args.write(self._oprot)
2700 
    self._oprot.writeMessageEnd()
2701 
    self._oprot.trans.flush()
2702 
 
2703 
  def recv_getUserCount(self, ):
2704 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2705 
    if mtype == TMessageType.EXCEPTION:
2706 
      x = TApplicationException()
2707 
      x.read(self._iprot)
2708 
      self._iprot.readMessageEnd()
2709 
      raise x
2710 
    result = getUserCount_result()
2711 
    result.read(self._iprot)
2712 
    self._iprot.readMessageEnd()
2713 
    if result.success != None:
2714 
      return result.success
2715 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
2716 
 
1891 ankur.sing 2717 
  def getAllUsers(self, userType, startDate, endDate):
1673 ankur.sing 2718 
    """
1891 ankur.sing 2719 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2720 
    If any of startDate or endDate is -1, then that filter is ignored.
2721 
    If userType is null, then returns all the users, irrespective of anonymous flag
1673 ankur.sing 2722 
 
1891 ankur.sing 2723 
 
1673 ankur.sing 2724 
    Parameters:
2725 
     - userType
1891 ankur.sing 2726 
     - startDate
2727 
     - endDate
1673 ankur.sing 2728 
    """
1891 ankur.sing 2729 
    self.send_getAllUsers(userType, startDate, endDate)
1673 ankur.sing 2730 
    return self.recv_getAllUsers()
1596 ankur.sing 2731 
 
1891 ankur.sing 2732 
  def send_getAllUsers(self, userType, startDate, endDate):
1673 ankur.sing 2733 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2734 
    args = getAllUsers_args()
2735 
    args.userType = userType
1891 ankur.sing 2736 
    args.startDate = startDate
2737 
    args.endDate = endDate
1673 ankur.sing 2738 
    args.write(self._oprot)
2739 
    self._oprot.writeMessageEnd()
2740 
    self._oprot.trans.flush()
2741 
 
2742 
  def recv_getAllUsers(self, ):
2743 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2744 
    if mtype == TMessageType.EXCEPTION:
2745 
      x = TApplicationException()
2746 
      x.read(self._iprot)
2747 
      self._iprot.readMessageEnd()
2748 
      raise x
2749 
    result = getAllUsers_result()
2750 
    result.read(self._iprot)
2751 
    self._iprot.readMessageEnd()
2752 
    if result.success != None:
2753 
      return result.success
2754 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
2755 
 
2756 
 
94 ashish 2757 
class Processor(Iface, TProcessor):
2758 
  def __init__(self, handler):
2759 
    self._handler = handler
2760 
    self._processMap = {}
765 rajveer 2761 
    self._processMap["closeSession"] = Processor.process_closeSession
559 chandransh 2762 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
2763 
    self._processMap["getUserById"] = Processor.process_getUserById
1491 vikas 2764 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
559 chandransh 2765 
    self._processMap["createUser"] = Processor.process_createUser
2766 
    self._processMap["updateUser"] = Processor.process_updateUser
2767 
    self._processMap["deleteUser"] = Processor.process_deleteUser
2768 
    self._processMap["getUserState"] = Processor.process_getUserState
122 ashish 2769 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 2770 
    self._processMap["userExists"] = Processor.process_userExists
2771 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
2772 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
2773 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
2774 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 2775 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 2776 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 2777 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 2778 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 2779 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 2780 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 2781 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 2782 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 2783 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
2784 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
2785 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
1845 vikas 2786 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 2787 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 2788 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
2789 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
2790 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
2791 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
2792 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
2793 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
2794 
    self._processMap["createTracker"] = Processor.process_createTracker
2795 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
2796 
    self._processMap["getTrackersByAffiliate"] = Processor.process_getTrackersByAffiliate
2797 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
2798 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
2799 
    self._processMap["getTrackLogsByTracker"] = Processor.process_getTrackLogsByTracker
2800 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
2801 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 2802 
    self._processMap["createCart"] = Processor.process_createCart
2803 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
2804 
    self._processMap["getCart"] = Processor.process_getCart
2805 
    self._processMap["getCartsForUser"] = Processor.process_getCartsForUser
2806 
    self._processMap["getCartsByStatus"] = Processor.process_getCartsByStatus
2807 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
2808 
    self._processMap["changeCartStatus"] = Processor.process_changeCartStatus
2809 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
2810 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
2811 
    self._processMap["changeQuantity"] = Processor.process_changeQuantity
2812 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
2813 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
690 chandransh 2814 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 2815 
    self._processMap["validateCart"] = Processor.process_validateCart
2816 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 2817 
    self._processMap["checkOut"] = Processor.process_checkOut
2818 
    self._processMap["resetCart"] = Processor.process_resetCart
559 chandransh 2819 
    self._processMap["getMyResearch"] = Processor.process_getMyResearch
2820 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
2821 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
2822 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
2823 
    self._processMap["getBrowseHistory"] = Processor.process_getBrowseHistory
772 rajveer 2824 
    self._processMap["mergeBrowseHistory"] = Processor.process_mergeBrowseHistory
1596 ankur.sing 2825 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 2826 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
94 ashish 2827 
 
2828 
  def process(self, iprot, oprot):
2829 
    (name, type, seqid) = iprot.readMessageBegin()
2830 
    if name not in self._processMap:
2831 
      iprot.skip(TType.STRUCT)
2832 
      iprot.readMessageEnd()
2833 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
2834 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
2835 
      x.write(oprot)
2836 
      oprot.writeMessageEnd()
2837 
      oprot.trans.flush()
2838 
      return
2839 
    else:
2840 
      self._processMap[name](self, seqid, iprot, oprot)
2841 
    return True
2842 
 
765 rajveer 2843 
  def process_closeSession(self, seqid, iprot, oprot):
2844 
    args = closeSession_args()
2845 
    args.read(iprot)
2846 
    iprot.readMessageEnd()
2847 
    result = closeSession_result()
2848 
    self._handler.closeSession()
2849 
    oprot.writeMessageBegin("closeSession", TMessageType.REPLY, seqid)
2850 
    result.write(oprot)
2851 
    oprot.writeMessageEnd()
2852 
    oprot.trans.flush()
2853 
 
559 chandransh 2854 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
2855 
    args = createAnonymousUser_args()
94 ashish 2856 
    args.read(iprot)
2857 
    iprot.readMessageEnd()
559 chandransh 2858 
    result = createAnonymousUser_result()
94 ashish 2859 
    try:
559 chandransh 2860 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
2861 
    except UserContextException, ucex:
2862 
      result.ucex = ucex
2863 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 2864 
    result.write(oprot)
2865 
    oprot.writeMessageEnd()
2866 
    oprot.trans.flush()
2867 
 
559 chandransh 2868 
  def process_getUserById(self, seqid, iprot, oprot):
2869 
    args = getUserById_args()
94 ashish 2870 
    args.read(iprot)
2871 
    iprot.readMessageEnd()
559 chandransh 2872 
    result = getUserById_result()
94 ashish 2873 
    try:
559 chandransh 2874 
      result.success = self._handler.getUserById(args.userId)
2875 
    except UserContextException, ucex:
2876 
      result.ucex = ucex
2877 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 2878 
    result.write(oprot)
2879 
    oprot.writeMessageEnd()
2880 
    oprot.trans.flush()
2881 
 
1491 vikas 2882 
  def process_getUserByEmail(self, seqid, iprot, oprot):
2883 
    args = getUserByEmail_args()
2884 
    args.read(iprot)
2885 
    iprot.readMessageEnd()
2886 
    result = getUserByEmail_result()
2887 
    try:
2888 
      result.success = self._handler.getUserByEmail(args.email)
2889 
    except UserContextException, ucex:
2890 
      result.ucex = ucex
2891 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
2892 
    result.write(oprot)
2893 
    oprot.writeMessageEnd()
2894 
    oprot.trans.flush()
2895 
 
559 chandransh 2896 
  def process_createUser(self, seqid, iprot, oprot):
2897 
    args = createUser_args()
94 ashish 2898 
    args.read(iprot)
2899 
    iprot.readMessageEnd()
559 chandransh 2900 
    result = createUser_result()
94 ashish 2901 
    try:
559 chandransh 2902 
      result.success = self._handler.createUser(args.user)
2903 
    except UserContextException, ucex:
2904 
      result.ucex = ucex
2905 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 2906 
    result.write(oprot)
2907 
    oprot.writeMessageEnd()
2908 
    oprot.trans.flush()
2909 
 
559 chandransh 2910 
  def process_updateUser(self, seqid, iprot, oprot):
2911 
    args = updateUser_args()
94 ashish 2912 
    args.read(iprot)
2913 
    iprot.readMessageEnd()
559 chandransh 2914 
    result = updateUser_result()
94 ashish 2915 
    try:
559 chandransh 2916 
      result.success = self._handler.updateUser(args.user)
2917 
    except UserContextException, ucex:
2918 
      result.ucex = ucex
2919 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 2920 
    result.write(oprot)
2921 
    oprot.writeMessageEnd()
2922 
    oprot.trans.flush()
2923 
 
559 chandransh 2924 
  def process_deleteUser(self, seqid, iprot, oprot):
2925 
    args = deleteUser_args()
94 ashish 2926 
    args.read(iprot)
2927 
    iprot.readMessageEnd()
559 chandransh 2928 
    result = deleteUser_result()
94 ashish 2929 
    try:
559 chandransh 2930 
      result.success = self._handler.deleteUser(args.userId)
2931 
    except UserContextException, ucex:
2932 
      result.ucex = ucex
2933 
    oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
94 ashish 2934 
    result.write(oprot)
2935 
    oprot.writeMessageEnd()
2936 
    oprot.trans.flush()
2937 
 
559 chandransh 2938 
  def process_getUserState(self, seqid, iprot, oprot):
2939 
    args = getUserState_args()
94 ashish 2940 
    args.read(iprot)
2941 
    iprot.readMessageEnd()
559 chandransh 2942 
    result = getUserState_result()
94 ashish 2943 
    try:
559 chandransh 2944 
      result.success = self._handler.getUserState(args.userId)
2945 
    except UserContextException, ucex:
2946 
      result.ucex = ucex
2947 
    oprot.writeMessageBegin("getUserState", TMessageType.REPLY, seqid)
94 ashish 2948 
    result.write(oprot)
2949 
    oprot.writeMessageEnd()
2950 
    oprot.trans.flush()
2951 
 
122 ashish 2952 
  def process_authenticateUser(self, seqid, iprot, oprot):
2953 
    args = authenticateUser_args()
2954 
    args.read(iprot)
2955 
    iprot.readMessageEnd()
2956 
    result = authenticateUser_result()
2957 
    try:
559 chandransh 2958 
      result.success = self._handler.authenticateUser(args.email, args.password)
2959 
    except AuthenticationException, auex:
2960 
      result.auex = auex
122 ashish 2961 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
2962 
    result.write(oprot)
2963 
    oprot.writeMessageEnd()
2964 
    oprot.trans.flush()
2965 
 
94 ashish 2966 
  def process_userExists(self, seqid, iprot, oprot):
2967 
    args = userExists_args()
2968 
    args.read(iprot)
2969 
    iprot.readMessageEnd()
2970 
    result = userExists_result()
2971 
    try:
2972 
      result.success = self._handler.userExists(args.email)
2973 
    except UserContextException, ucx:
2974 
      result.ucx = ucx
2975 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
2976 
    result.write(oprot)
2977 
    oprot.writeMessageEnd()
2978 
    oprot.trans.flush()
2979 
 
2980 
  def process_addAddressForUser(self, seqid, iprot, oprot):
2981 
    args = addAddressForUser_args()
2982 
    args.read(iprot)
2983 
    iprot.readMessageEnd()
2984 
    result = addAddressForUser_result()
2985 
    try:
567 rajveer 2986 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 2987 
    except UserContextException, ucx:
2988 
      result.ucx = ucx
2989 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
2990 
    result.write(oprot)
2991 
    oprot.writeMessageEnd()
2992 
    oprot.trans.flush()
2993 
 
2994 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
2995 
    args = removeAddressForUser_args()
2996 
    args.read(iprot)
2997 
    iprot.readMessageEnd()
2998 
    result = removeAddressForUser_result()
2999 
    try:
3000 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
3001 
    except UserContextException, ucx:
3002 
      result.ucx = ucx
3003 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
3004 
    result.write(oprot)
3005 
    oprot.writeMessageEnd()
3006 
    oprot.trans.flush()
3007 
 
3008 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
3009 
    args = setUserAsLoggedIn_args()
3010 
    args.read(iprot)
3011 
    iprot.readMessageEnd()
3012 
    result = setUserAsLoggedIn_result()
3013 
    try:
3014 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
3015 
    except UserContextException, ucx:
3016 
      result.ucx = ucx
3017 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
3018 
    result.write(oprot)
3019 
    oprot.writeMessageEnd()
3020 
    oprot.trans.flush()
3021 
 
3022 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
3023 
    args = setUserAsLoggedOut_args()
3024 
    args.read(iprot)
3025 
    iprot.readMessageEnd()
3026 
    result = setUserAsLoggedOut_result()
3027 
    try:
3028 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
3029 
    except UserContextException, ucx:
3030 
      result.ucx = ucx
3031 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
3032 
    result.write(oprot)
3033 
    oprot.writeMessageEnd()
3034 
    oprot.trans.flush()
3035 
 
504 rajveer 3036 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
3037 
    args = setDefaultAddress_args()
3038 
    args.read(iprot)
3039 
    iprot.readMessageEnd()
3040 
    result = setDefaultAddress_result()
3041 
    try:
3042 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
3043 
    except UserContextException, ucx:
3044 
      result.ucx = ucx
3045 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
3046 
    result.write(oprot)
3047 
    oprot.writeMessageEnd()
3048 
    oprot.trans.flush()
3049 
 
94 ashish 3050 
  def process_updatePassword(self, seqid, iprot, oprot):
3051 
    args = updatePassword_args()
3052 
    args.read(iprot)
3053 
    iprot.readMessageEnd()
3054 
    result = updatePassword_result()
3055 
    try:
594 rajveer 3056 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 3057 
    except UserContextException, ucx:
3058 
      result.ucx = ucx
3059 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
3060 
    result.write(oprot)
3061 
    oprot.writeMessageEnd()
3062 
    oprot.trans.flush()
3063 
 
581 rajveer 3064 
  def process_forgotPassword(self, seqid, iprot, oprot):
3065 
    args = forgotPassword_args()
3066 
    args.read(iprot)
3067 
    iprot.readMessageEnd()
3068 
    result = forgotPassword_result()
3069 
    try:
884 rajveer 3070 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 3071 
    except UserContextException, ucx:
3072 
      result.ucx = ucx
3073 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
3074 
    result.write(oprot)
3075 
    oprot.writeMessageEnd()
3076 
    oprot.trans.flush()
3077 
 
594 rajveer 3078 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
3079 
    args = getAllAddressesForUser_args()
3080 
    args.read(iprot)
3081 
    iprot.readMessageEnd()
3082 
    result = getAllAddressesForUser_result()
3083 
    try:
3084 
      result.success = self._handler.getAllAddressesForUser(args.userId)
3085 
    except UserContextException, ucx:
3086 
      result.ucx = ucx
3087 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
3088 
    result.write(oprot)
3089 
    oprot.writeMessageEnd()
3090 
    oprot.trans.flush()
3091 
 
1894 vikas 3092 
  def process_getAddressById(self, seqid, iprot, oprot):
3093 
    args = getAddressById_args()
3094 
    args.read(iprot)
3095 
    iprot.readMessageEnd()
3096 
    result = getAddressById_result()
3097 
    try:
3098 
      result.success = self._handler.getAddressById(args.addressId)
3099 
    except UserContextException, ucx:
3100 
      result.ucx = ucx
3101 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
3102 
    result.write(oprot)
3103 
    oprot.writeMessageEnd()
3104 
    oprot.trans.flush()
3105 
 
594 rajveer 3106 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
3107 
    args = getDefaultAddressId_args()
3108 
    args.read(iprot)
3109 
    iprot.readMessageEnd()
3110 
    result = getDefaultAddressId_result()
3111 
    try:
3112 
      result.success = self._handler.getDefaultAddressId(args.userId)
3113 
    except UserContextException, ucx:
3114 
      result.ucx = ucx
3115 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
3116 
    result.write(oprot)
3117 
    oprot.writeMessageEnd()
3118 
    oprot.trans.flush()
3119 
 
785 rajveer 3120 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
3121 
    args = getDefaultPincode_args()
3122 
    args.read(iprot)
3123 
    iprot.readMessageEnd()
3124 
    result = getDefaultPincode_result()
3125 
    try:
3126 
      result.success = self._handler.getDefaultPincode(args.userId)
3127 
    except UserContextException, ucx:
3128 
      result.ucx = ucx
3129 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
3130 
    result.write(oprot)
3131 
    oprot.writeMessageEnd()
3132 
    oprot.trans.flush()
3133 
 
1274 varun.gupt 3134 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
3135 
    args = saveUserCommunication_args()
3136 
    args.read(iprot)
3137 
    iprot.readMessageEnd()
3138 
    result = saveUserCommunication_result()
3139 
    try:
3140 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
3141 
    except UserCommunicationException, ucx:
3142 
      result.ucx = ucx
3143 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
3144 
    result.write(oprot)
3145 
    oprot.writeMessageEnd()
3146 
    oprot.trans.flush()
3147 
 
1590 varun.gupt 3148 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
3149 
    args = getUserCommunicationById_args()
3150 
    args.read(iprot)
3151 
    iprot.readMessageEnd()
3152 
    result = getUserCommunicationById_result()
3153 
    try:
3154 
      result.success = self._handler.getUserCommunicationById(args.id)
3155 
    except UserCommunicationException, ucx:
3156 
      result.ucx = ucx
3157 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
3158 
    result.write(oprot)
3159 
    oprot.writeMessageEnd()
3160 
    oprot.trans.flush()
3161 
 
3162 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
3163 
    args = getUserCommunicationByUser_args()
3164 
    args.read(iprot)
3165 
    iprot.readMessageEnd()
3166 
    result = getUserCommunicationByUser_result()
3167 
    try:
3168 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
3169 
    except UserCommunicationException, ucx:
3170 
      result.ucx = ucx
3171 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
3172 
    result.write(oprot)
3173 
    oprot.writeMessageEnd()
3174 
    oprot.trans.flush()
3175 
 
3176 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
3177 
    args = getAllUserCommunications_args()
3178 
    args.read(iprot)
3179 
    iprot.readMessageEnd()
3180 
    result = getAllUserCommunications_result()
3181 
    try:
3182 
      result.success = self._handler.getAllUserCommunications()
3183 
    except UserCommunicationException, ucx:
3184 
      result.ucx = ucx
3185 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
3186 
    result.write(oprot)
3187 
    oprot.writeMessageEnd()
3188 
    oprot.trans.flush()
3189 
 
1845 vikas 3190 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
3191 
    args = createMasterAffiliate_args()
3192 
    args.read(iprot)
3193 
    iprot.readMessageEnd()
3194 
    result = createMasterAffiliate_result()
3195 
    try:
1859 vikas 3196 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1845 vikas 3197 
    except UserTrackerException, utx:
3198 
      result.utx = utx
3199 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
3200 
    result.write(oprot)
3201 
    oprot.writeMessageEnd()
3202 
    oprot.trans.flush()
3203 
 
1899 vikas 3204 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
3205 
    args = getAllMasterAffiliates_args()
3206 
    args.read(iprot)
3207 
    iprot.readMessageEnd()
3208 
    result = getAllMasterAffiliates_result()
3209 
    try:
3210 
      result.success = self._handler.getAllMasterAffiliates()
3211 
    except UserTrackerException, utx:
3212 
      result.utx = utx
3213 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
3214 
    result.write(oprot)
3215 
    oprot.writeMessageEnd()
3216 
    oprot.trans.flush()
3217 
 
1845 vikas 3218 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
3219 
    args = getMasterAffiliateById_args()
3220 
    args.read(iprot)
3221 
    iprot.readMessageEnd()
3222 
    result = getMasterAffiliateById_result()
3223 
    try:
3224 
      result.success = self._handler.getMasterAffiliateById(args.id)
3225 
    except UserTrackerException, utx:
3226 
      result.utx = utx
3227 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
3228 
    result.write(oprot)
3229 
    oprot.writeMessageEnd()
3230 
    oprot.trans.flush()
3231 
 
3232 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
3233 
    args = getMasterAffiliateByName_args()
3234 
    args.read(iprot)
3235 
    iprot.readMessageEnd()
3236 
    result = getMasterAffiliateByName_result()
3237 
    try:
3238 
      result.success = self._handler.getMasterAffiliateByName(args.name)
3239 
    except UserTrackerException, utx:
3240 
      result.utx = utx
3241 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
3242 
    result.write(oprot)
3243 
    oprot.writeMessageEnd()
3244 
    oprot.trans.flush()
3245 
 
3246 
  def process_createAffiliate(self, seqid, iprot, oprot):
3247 
    args = createAffiliate_args()
3248 
    args.read(iprot)
3249 
    iprot.readMessageEnd()
3250 
    result = createAffiliate_result()
3251 
    try:
1859 vikas 3252 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1845 vikas 3253 
    except UserTrackerException, utx:
3254 
      result.utx = utx
3255 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
3256 
    result.write(oprot)
3257 
    oprot.writeMessageEnd()
3258 
    oprot.trans.flush()
3259 
 
3260 
  def process_getAffiliateById(self, seqid, iprot, oprot):
3261 
    args = getAffiliateById_args()
3262 
    args.read(iprot)
3263 
    iprot.readMessageEnd()
3264 
    result = getAffiliateById_result()
3265 
    try:
3266 
      result.success = self._handler.getAffiliateById(args.id)
3267 
    except UserTrackerException, utx:
3268 
      result.utx = utx
3269 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
3270 
    result.write(oprot)
3271 
    oprot.writeMessageEnd()
3272 
    oprot.trans.flush()
3273 
 
3274 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
3275 
    args = getAffiliateByName_args()
3276 
    args.read(iprot)
3277 
    iprot.readMessageEnd()
3278 
    result = getAffiliateByName_result()
3279 
    try:
3280 
      result.success = self._handler.getAffiliateByName(args.name)
3281 
    except UserTrackerException, utx:
3282 
      result.utx = utx
3283 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
3284 
    result.write(oprot)
3285 
    oprot.writeMessageEnd()
3286 
    oprot.trans.flush()
3287 
 
3288 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
3289 
    args = getAffiliatesByMasterAffiliate_args()
3290 
    args.read(iprot)
3291 
    iprot.readMessageEnd()
3292 
    result = getAffiliatesByMasterAffiliate_result()
3293 
    try:
3294 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
3295 
    except UserTrackerException, utx:
3296 
      result.utx = utx
3297 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
3298 
    result.write(oprot)
3299 
    oprot.writeMessageEnd()
3300 
    oprot.trans.flush()
3301 
 
3302 
  def process_createTracker(self, seqid, iprot, oprot):
3303 
    args = createTracker_args()
3304 
    args.read(iprot)
3305 
    iprot.readMessageEnd()
3306 
    result = createTracker_result()
3307 
    try:
1859 vikas 3308 
      result.success = self._handler.createTracker(args.affiliateId, args.addedOn)
1845 vikas 3309 
    except UserTrackerException, utx:
3310 
      result.utx = utx
3311 
    oprot.writeMessageBegin("createTracker", TMessageType.REPLY, seqid)
3312 
    result.write(oprot)
3313 
    oprot.writeMessageEnd()
3314 
    oprot.trans.flush()
3315 
 
3316 
  def process_getTrackerById(self, seqid, iprot, oprot):
3317 
    args = getTrackerById_args()
3318 
    args.read(iprot)
3319 
    iprot.readMessageEnd()
3320 
    result = getTrackerById_result()
3321 
    try:
3322 
      result.success = self._handler.getTrackerById(args.trackerId)
3323 
    except UserTrackerException, utx:
3324 
      result.utx = utx
3325 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
3326 
    result.write(oprot)
3327 
    oprot.writeMessageEnd()
3328 
    oprot.trans.flush()
3329 
 
3330 
  def process_getTrackersByAffiliate(self, seqid, iprot, oprot):
3331 
    args = getTrackersByAffiliate_args()
3332 
    args.read(iprot)
3333 
    iprot.readMessageEnd()
3334 
    result = getTrackersByAffiliate_result()
3335 
    try:
3336 
      result.success = self._handler.getTrackersByAffiliate(args.affiliateId)
3337 
    except UserTrackerException, utx:
3338 
      result.utx = utx
3339 
    oprot.writeMessageBegin("getTrackersByAffiliate", TMessageType.REPLY, seqid)
3340 
    result.write(oprot)
3341 
    oprot.writeMessageEnd()
3342 
    oprot.trans.flush()
3343 
 
3344 
  def process_addTrackLog(self, seqid, iprot, oprot):
3345 
    args = addTrackLog_args()
3346 
    args.read(iprot)
3347 
    iprot.readMessageEnd()
3348 
    result = addTrackLog_result()
3349 
    try:
1859 vikas 3350 
      result.success = self._handler.addTrackLog(args.trackerId, args.userId, args.event, args.url, args.data, args.addedOn)
1845 vikas 3351 
    except UserTrackerException, utx:
3352 
      result.utx = utx
3353 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
3354 
    result.write(oprot)
3355 
    oprot.writeMessageEnd()
3356 
    oprot.trans.flush()
3357 
 
3358 
  def process_getTrackLogById(self, seqid, iprot, oprot):
3359 
    args = getTrackLogById_args()
3360 
    args.read(iprot)
3361 
    iprot.readMessageEnd()
3362 
    result = getTrackLogById_result()
3363 
    try:
3364 
      result.success = self._handler.getTrackLogById(args.id)
3365 
    except UserTrackerException, utx:
3366 
      result.utx = utx
3367 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
3368 
    result.write(oprot)
3369 
    oprot.writeMessageEnd()
3370 
    oprot.trans.flush()
3371 
 
3372 
  def process_getTrackLogsByTracker(self, seqid, iprot, oprot):
3373 
    args = getTrackLogsByTracker_args()
3374 
    args.read(iprot)
3375 
    iprot.readMessageEnd()
3376 
    result = getTrackLogsByTracker_result()
3377 
    try:
3378 
      result.success = self._handler.getTrackLogsByTracker(args.trackerId)
3379 
    except UserTrackerException, utx:
3380 
      result.utx = utx
3381 
    oprot.writeMessageBegin("getTrackLogsByTracker", TMessageType.REPLY, seqid)
3382 
    result.write(oprot)
3383 
    oprot.writeMessageEnd()
3384 
    oprot.trans.flush()
3385 
 
3386 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
3387 
    args = getTrackLogsByUser_args()
3388 
    args.read(iprot)
3389 
    iprot.readMessageEnd()
3390 
    result = getTrackLogsByUser_result()
3391 
    try:
3392 
      result.success = self._handler.getTrackLogsByUser(args.userId)
3393 
    except UserTrackerException, utx:
3394 
      result.utx = utx
3395 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
3396 
    result.write(oprot)
3397 
    oprot.writeMessageEnd()
3398 
    oprot.trans.flush()
3399 
 
3400 
  def process_getTrackLogs(self, seqid, iprot, oprot):
3401 
    args = getTrackLogs_args()
3402 
    args.read(iprot)
3403 
    iprot.readMessageEnd()
3404 
    result = getTrackLogs_result()
3405 
    try:
3406 
      result.success = self._handler.getTrackLogs(args.trackerId, args.userId, args.event, args.url)
3407 
    except UserTrackerException, utx:
3408 
      result.utx = utx
3409 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
3410 
    result.write(oprot)
3411 
    oprot.writeMessageEnd()
3412 
    oprot.trans.flush()
3413 
 
559 chandransh 3414 
  def process_createCart(self, seqid, iprot, oprot):
3415 
    args = createCart_args()
94 ashish 3416 
    args.read(iprot)
3417 
    iprot.readMessageEnd()
559 chandransh 3418 
    result = createCart_result()
94 ashish 3419 
    try:
559 chandransh 3420 
      result.success = self._handler.createCart(args.userId)
3421 
    except ShoppingCartException, scx:
3422 
      result.scx = scx
3423 
    oprot.writeMessageBegin("createCart", TMessageType.REPLY, seqid)
94 ashish 3424 
    result.write(oprot)
3425 
    oprot.writeMessageEnd()
3426 
    oprot.trans.flush()
3427 
 
559 chandransh 3428 
  def process_getCurrentCart(self, seqid, iprot, oprot):
3429 
    args = getCurrentCart_args()
94 ashish 3430 
    args.read(iprot)
3431 
    iprot.readMessageEnd()
559 chandransh 3432 
    result = getCurrentCart_result()
94 ashish 3433 
    try:
559 chandransh 3434 
      result.success = self._handler.getCurrentCart(args.userId)
3435 
    except ShoppingCartException, scx:
3436 
      result.scx = scx
3437 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 3438 
    result.write(oprot)
3439 
    oprot.writeMessageEnd()
3440 
    oprot.trans.flush()
3441 
 
559 chandransh 3442 
  def process_getCart(self, seqid, iprot, oprot):
3443 
    args = getCart_args()
94 ashish 3444 
    args.read(iprot)
3445 
    iprot.readMessageEnd()
559 chandransh 3446 
    result = getCart_result()
94 ashish 3447 
    try:
559 chandransh 3448 
      result.success = self._handler.getCart(args.cartId)
3449 
    except ShoppingCartException, scx:
3450 
      result.scx = scx
3451 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 3452 
    result.write(oprot)
3453 
    oprot.writeMessageEnd()
3454 
    oprot.trans.flush()
3455 
 
559 chandransh 3456 
  def process_getCartsForUser(self, seqid, iprot, oprot):
3457 
    args = getCartsForUser_args()
94 ashish 3458 
    args.read(iprot)
3459 
    iprot.readMessageEnd()
559 chandransh 3460 
    result = getCartsForUser_result()
94 ashish 3461 
    try:
559 chandransh 3462 
      result.success = self._handler.getCartsForUser(args.userId, args.status)
3463 
    except ShoppingCartException, scx:
3464 
      result.scx = scx
3465 
    oprot.writeMessageBegin("getCartsForUser", TMessageType.REPLY, seqid)
94 ashish 3466 
    result.write(oprot)
3467 
    oprot.writeMessageEnd()
3468 
    oprot.trans.flush()
3469 
 
559 chandransh 3470 
  def process_getCartsByStatus(self, seqid, iprot, oprot):
3471 
    args = getCartsByStatus_args()
94 ashish 3472 
    args.read(iprot)
3473 
    iprot.readMessageEnd()
559 chandransh 3474 
    result = getCartsByStatus_result()
94 ashish 3475 
    try:
559 chandransh 3476 
      result.success = self._handler.getCartsByStatus(args.status)
3477 
    except ShoppingCartException, scx:
3478 
      result.scx = scx
3479 
    oprot.writeMessageBegin("getCartsByStatus", TMessageType.REPLY, seqid)
94 ashish 3480 
    result.write(oprot)
3481 
    oprot.writeMessageEnd()
3482 
    oprot.trans.flush()
3483 
 
559 chandransh 3484 
  def process_getCartsByTime(self, seqid, iprot, oprot):
3485 
    args = getCartsByTime_args()
94 ashish 3486 
    args.read(iprot)
3487 
    iprot.readMessageEnd()
559 chandransh 3488 
    result = getCartsByTime_result()
94 ashish 3489 
    try:
559 chandransh 3490 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
3491 
    except ShoppingCartException, scx:
3492 
      result.scx = scx
3493 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 3494 
    result.write(oprot)
3495 
    oprot.writeMessageEnd()
3496 
    oprot.trans.flush()
3497 
 
559 chandransh 3498 
  def process_changeCartStatus(self, seqid, iprot, oprot):
3499 
    args = changeCartStatus_args()
130 ashish 3500 
    args.read(iprot)
3501 
    iprot.readMessageEnd()
559 chandransh 3502 
    result = changeCartStatus_result()
130 ashish 3503 
    try:
559 chandransh 3504 
      self._handler.changeCartStatus(args.cartId, args.status)
3505 
    except ShoppingCartException, scx:
3506 
      result.scx = scx
3507 
    oprot.writeMessageBegin("changeCartStatus", TMessageType.REPLY, seqid)
130 ashish 3508 
    result.write(oprot)
3509 
    oprot.writeMessageEnd()
3510 
    oprot.trans.flush()
94 ashish 3511 
 
559 chandransh 3512 
  def process_addItemToCart(self, seqid, iprot, oprot):
3513 
    args = addItemToCart_args()
130 ashish 3514 
    args.read(iprot)
3515 
    iprot.readMessageEnd()
559 chandransh 3516 
    result = addItemToCart_result()
130 ashish 3517 
    try:
559 chandransh 3518 
      self._handler.addItemToCart(args.cartId, args.itemId, args.quantity)
3519 
    except ShoppingCartException, scx:
3520 
      result.scx = scx
3521 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 3522 
    result.write(oprot)
3523 
    oprot.writeMessageEnd()
3524 
    oprot.trans.flush()
3525 
 
559 chandransh 3526 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
3527 
    args = deleteItemFromCart_args()
3528 
    args.read(iprot)
3529 
    iprot.readMessageEnd()
3530 
    result = deleteItemFromCart_result()
3531 
    try:
3532 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
3533 
    except ShoppingCartException, scx:
3534 
      result.scx = scx
3535 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
3536 
    result.write(oprot)
3537 
    oprot.writeMessageEnd()
3538 
    oprot.trans.flush()
130 ashish 3539 
 
559 chandransh 3540 
  def process_changeQuantity(self, seqid, iprot, oprot):
3541 
    args = changeQuantity_args()
3542 
    args.read(iprot)
3543 
    iprot.readMessageEnd()
3544 
    result = changeQuantity_result()
3545 
    try:
3546 
      self._handler.changeQuantity(args.cartId, args.itemId, args.quantity)
3547 
    except ShoppingCartException, scx:
3548 
      result.scx = scx
3549 
    oprot.writeMessageBegin("changeQuantity", TMessageType.REPLY, seqid)
3550 
    result.write(oprot)
3551 
    oprot.writeMessageEnd()
3552 
    oprot.trans.flush()
3553 
 
3554 
  def process_changeItemStatus(self, seqid, iprot, oprot):
3555 
    args = changeItemStatus_args()
3556 
    args.read(iprot)
3557 
    iprot.readMessageEnd()
3558 
    result = changeItemStatus_result()
3559 
    try:
3560 
      self._handler.changeItemStatus(args.cartId, args.itemId, args.status)
3561 
    except ShoppingCartException, scx:
3562 
      result.scx = scx
3563 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
3564 
    result.write(oprot)
3565 
    oprot.writeMessageEnd()
3566 
    oprot.trans.flush()
3567 
 
3568 
  def process_addAddressToCart(self, seqid, iprot, oprot):
3569 
    args = addAddressToCart_args()
3570 
    args.read(iprot)
3571 
    iprot.readMessageEnd()
3572 
    result = addAddressToCart_result()
575 chandransh 3573 
    try:
3574 
      self._handler.addAddressToCart(args.cartId, args.addressId)
3575 
    except ShoppingCartException, scx:
3576 
      result.scx = scx
559 chandransh 3577 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
3578 
    result.write(oprot)
3579 
    oprot.writeMessageEnd()
3580 
    oprot.trans.flush()
3581 
 
690 chandransh 3582 
  def process_createOrders(self, seqid, iprot, oprot):
3583 
    args = createOrders_args()
559 chandransh 3584 
    args.read(iprot)
3585 
    iprot.readMessageEnd()
690 chandransh 3586 
    result = createOrders_result()
559 chandransh 3587 
    try:
690 chandransh 3588 
      result.success = self._handler.createOrders(args.cartId)
559 chandransh 3589 
    except ShoppingCartException, scx:
3590 
      result.scx = scx
690 chandransh 3591 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 3592 
    result.write(oprot)
3593 
    oprot.writeMessageEnd()
3594 
    oprot.trans.flush()
3595 
 
3596 
  def process_validateCart(self, seqid, iprot, oprot):
3597 
    args = validateCart_args()
3598 
    args.read(iprot)
3599 
    iprot.readMessageEnd()
3600 
    result = validateCart_result()
575 chandransh 3601 
    try:
3602 
      result.success = self._handler.validateCart(args.cartId)
3603 
    except ShoppingCartException, scex:
3604 
      result.scex = scex
559 chandransh 3605 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
3606 
    result.write(oprot)
3607 
    oprot.writeMessageEnd()
3608 
    oprot.trans.flush()
3609 
 
690 chandransh 3610 
  def process_mergeCart(self, seqid, iprot, oprot):
3611 
    args = mergeCart_args()
575 chandransh 3612 
    args.read(iprot)
3613 
    iprot.readMessageEnd()
690 chandransh 3614 
    result = mergeCart_result()
3615 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
3616 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
3617 
    result.write(oprot)
3618 
    oprot.writeMessageEnd()
3619 
    oprot.trans.flush()
3620 
 
3621 
  def process_checkOut(self, seqid, iprot, oprot):
3622 
    args = checkOut_args()
3623 
    args.read(iprot)
3624 
    iprot.readMessageEnd()
3625 
    result = checkOut_result()
575 chandransh 3626 
    try:
690 chandransh 3627 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 3628 
    except ShoppingCartException, scex:
3629 
      result.scex = scex
690 chandransh 3630 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 3631 
    result.write(oprot)
3632 
    oprot.writeMessageEnd()
3633 
    oprot.trans.flush()
3634 
 
690 chandransh 3635 
  def process_resetCart(self, seqid, iprot, oprot):
3636 
    args = resetCart_args()
559 chandransh 3637 
    args.read(iprot)
3638 
    iprot.readMessageEnd()
690 chandransh 3639 
    result = resetCart_result()
3640 
    try:
3641 
      result.success = self._handler.resetCart(args.cartId, args.items)
3642 
    except ShoppingCartException, scex:
3643 
      result.scex = scex
3644 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 3645 
    result.write(oprot)
3646 
    oprot.writeMessageEnd()
3647 
    oprot.trans.flush()
3648 
 
3649 
  def process_getMyResearch(self, seqid, iprot, oprot):
3650 
    args = getMyResearch_args()
3651 
    args.read(iprot)
3652 
    iprot.readMessageEnd()
3653 
    result = getMyResearch_result()
3654 
    try:
772 rajveer 3655 
      result.success = self._handler.getMyResearch(args.userId)
559 chandransh 3656 
    except WidgetException, scx:
3657 
      result.scx = scx
3658 
    oprot.writeMessageBegin("getMyResearch", TMessageType.REPLY, seqid)
3659 
    result.write(oprot)
3660 
    oprot.writeMessageEnd()
3661 
    oprot.trans.flush()
3662 
 
3663 
  def process_updateMyResearch(self, seqid, iprot, oprot):
3664 
    args = updateMyResearch_args()
3665 
    args.read(iprot)
3666 
    iprot.readMessageEnd()
3667 
    result = updateMyResearch_result()
3668 
    try:
772 rajveer 3669 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
559 chandransh 3670 
    except WidgetException, scx:
3671 
      result.scx = scx
3672 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
3673 
    result.write(oprot)
3674 
    oprot.writeMessageEnd()
3675 
    oprot.trans.flush()
3676 
 
3677 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
3678 
    args = deleteItemFromMyResearch_args()
3679 
    args.read(iprot)
3680 
    iprot.readMessageEnd()
3681 
    result = deleteItemFromMyResearch_result()
3682 
    try:
772 rajveer 3683 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
559 chandransh 3684 
    except WidgetException, scx:
3685 
      result.scx = scx
3686 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
3687 
    result.write(oprot)
3688 
    oprot.writeMessageEnd()
3689 
    oprot.trans.flush()
3690 
 
3691 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
3692 
    args = updateBrowseHistory_args()
3693 
    args.read(iprot)
3694 
    iprot.readMessageEnd()
3695 
    result = updateBrowseHistory_result()
772 rajveer 3696 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
559 chandransh 3697 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
3698 
    result.write(oprot)
3699 
    oprot.writeMessageEnd()
3700 
    oprot.trans.flush()
3701 
 
3702 
  def process_getBrowseHistory(self, seqid, iprot, oprot):
3703 
    args = getBrowseHistory_args()
3704 
    args.read(iprot)
3705 
    iprot.readMessageEnd()
3706 
    result = getBrowseHistory_result()
3707 
    try:
772 rajveer 3708 
      result.success = self._handler.getBrowseHistory(args.userId)
559 chandransh 3709 
    except WidgetException, scx:
3710 
      result.scx = scx
3711 
    oprot.writeMessageBegin("getBrowseHistory", TMessageType.REPLY, seqid)
3712 
    result.write(oprot)
3713 
    oprot.writeMessageEnd()
3714 
    oprot.trans.flush()
3715 
 
772 rajveer 3716 
  def process_mergeBrowseHistory(self, seqid, iprot, oprot):
3717 
    args = mergeBrowseHistory_args()
3718 
    args.read(iprot)
3719 
    iprot.readMessageEnd()
3720 
    result = mergeBrowseHistory_result()
3721 
    self._handler.mergeBrowseHistory(args.fromUserId, args.toUserId)
3722 
    oprot.writeMessageBegin("mergeBrowseHistory", TMessageType.REPLY, seqid)
3723 
    result.write(oprot)
3724 
    oprot.writeMessageEnd()
3725 
    oprot.trans.flush()
559 chandransh 3726 
 
1596 ankur.sing 3727 
  def process_getUserCount(self, seqid, iprot, oprot):
3728 
    args = getUserCount_args()
3729 
    args.read(iprot)
3730 
    iprot.readMessageEnd()
3731 
    result = getUserCount_result()
3732 
    result.success = self._handler.getUserCount(args.userType)
3733 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
3734 
    result.write(oprot)
3735 
    oprot.writeMessageEnd()
3736 
    oprot.trans.flush()
772 rajveer 3737 
 
1673 ankur.sing 3738 
  def process_getAllUsers(self, seqid, iprot, oprot):
3739 
    args = getAllUsers_args()
3740 
    args.read(iprot)
3741 
    iprot.readMessageEnd()
3742 
    result = getAllUsers_result()
1891 ankur.sing 3743 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
1673 ankur.sing 3744 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
3745 
    result.write(oprot)
3746 
    oprot.writeMessageEnd()
3747 
    oprot.trans.flush()
1596 ankur.sing 3748 
 
1673 ankur.sing 3749 
 
94 ashish 3750 
# HELPER FUNCTIONS AND STRUCTURES
3751 
 
765 rajveer 3752 
class closeSession_args:
3753 
 
3754 
  thrift_spec = (
3755 
  )
3756 
 
3757 
  def read(self, iprot):
3758 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3759 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3760 
      return
3761 
    iprot.readStructBegin()
3762 
    while True:
3763 
      (fname, ftype, fid) = iprot.readFieldBegin()
3764 
      if ftype == TType.STOP:
3765 
        break
3766 
      else:
3767 
        iprot.skip(ftype)
3768 
      iprot.readFieldEnd()
3769 
    iprot.readStructEnd()
3770 
 
3771 
  def write(self, oprot):
3772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3774 
      return
3775 
    oprot.writeStructBegin('closeSession_args')
3776 
    oprot.writeFieldStop()
3777 
    oprot.writeStructEnd()
3778 
 
3779 
  def __repr__(self):
3780 
    L = ['%s=%r' % (key, value)
3781 
      for key, value in self.__dict__.iteritems()]
3782 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3783 
 
3784 
  def __eq__(self, other):
3785 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3786 
 
3787 
  def __ne__(self, other):
3788 
    return not (self == other)
3789 
 
3790 
class closeSession_result:
3791 
 
3792 
  thrift_spec = (
3793 
  )
3794 
 
3795 
  def read(self, iprot):
3796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3798 
      return
3799 
    iprot.readStructBegin()
3800 
    while True:
3801 
      (fname, ftype, fid) = iprot.readFieldBegin()
3802 
      if ftype == TType.STOP:
3803 
        break
3804 
      else:
3805 
        iprot.skip(ftype)
3806 
      iprot.readFieldEnd()
3807 
    iprot.readStructEnd()
3808 
 
3809 
  def write(self, oprot):
3810 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3811 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3812 
      return
3813 
    oprot.writeStructBegin('closeSession_result')
3814 
    oprot.writeFieldStop()
3815 
    oprot.writeStructEnd()
3816 
 
3817 
  def __repr__(self):
3818 
    L = ['%s=%r' % (key, value)
3819 
      for key, value in self.__dict__.iteritems()]
3820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3821 
 
3822 
  def __eq__(self, other):
3823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3824 
 
3825 
  def __ne__(self, other):
3826 
    return not (self == other)
3827 
 
559 chandransh 3828 
class createAnonymousUser_args:
94 ashish 3829 
  """
3830 
  Attributes:
559 chandransh 3831 
   - jsessionId
94 ashish 3832 
  """
3833 
 
3834 
  thrift_spec = (
3835 
    None, # 0
559 chandransh 3836 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 3837 
  )
3838 
 
559 chandransh 3839 
  def __init__(self, jsessionId=None,):
3840 
    self.jsessionId = jsessionId
94 ashish 3841 
 
3842 
  def read(self, iprot):
3843 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3844 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3845 
      return
3846 
    iprot.readStructBegin()
3847 
    while True:
3848 
      (fname, ftype, fid) = iprot.readFieldBegin()
3849 
      if ftype == TType.STOP:
3850 
        break
3851 
      if fid == 1:
559 chandransh 3852 
        if ftype == TType.STRING:
3853 
          self.jsessionId = iprot.readString();
94 ashish 3854 
        else:
3855 
          iprot.skip(ftype)
3856 
      else:
3857 
        iprot.skip(ftype)
3858 
      iprot.readFieldEnd()
3859 
    iprot.readStructEnd()
3860 
 
3861 
  def write(self, oprot):
3862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3864 
      return
559 chandransh 3865 
    oprot.writeStructBegin('createAnonymousUser_args')
3866 
    if self.jsessionId != None:
3867 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
3868 
      oprot.writeString(self.jsessionId)
94 ashish 3869 
      oprot.writeFieldEnd()
3870 
    oprot.writeFieldStop()
3871 
    oprot.writeStructEnd()
3872 
 
3873 
  def __repr__(self):
3874 
    L = ['%s=%r' % (key, value)
3875 
      for key, value in self.__dict__.iteritems()]
3876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3877 
 
3878 
  def __eq__(self, other):
3879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3880 
 
3881 
  def __ne__(self, other):
3882 
    return not (self == other)
3883 
 
559 chandransh 3884 
class createAnonymousUser_result:
94 ashish 3885 
  """
3886 
  Attributes:
3887 
   - success
559 chandransh 3888 
   - ucex
94 ashish 3889 
  """
3890 
 
3891 
  thrift_spec = (
559 chandransh 3892 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
3893 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 3894 
  )
3895 
 
559 chandransh 3896 
  def __init__(self, success=None, ucex=None,):
94 ashish 3897 
    self.success = success
559 chandransh 3898 
    self.ucex = ucex
94 ashish 3899 
 
3900 
  def read(self, iprot):
3901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3903 
      return
3904 
    iprot.readStructBegin()
3905 
    while True:
3906 
      (fname, ftype, fid) = iprot.readFieldBegin()
3907 
      if ftype == TType.STOP:
3908 
        break
3909 
      if fid == 0:
3910 
        if ftype == TType.STRUCT:
559 chandransh 3911 
          self.success = User()
94 ashish 3912 
          self.success.read(iprot)
3913 
        else:
3914 
          iprot.skip(ftype)
3915 
      elif fid == 1:
3916 
        if ftype == TType.STRUCT:
559 chandransh 3917 
          self.ucex = UserContextException()
3918 
          self.ucex.read(iprot)
94 ashish 3919 
        else:
3920 
          iprot.skip(ftype)
3921 
      else:
3922 
        iprot.skip(ftype)
3923 
      iprot.readFieldEnd()
3924 
    iprot.readStructEnd()
3925 
 
3926 
  def write(self, oprot):
3927 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3928 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3929 
      return
559 chandransh 3930 
    oprot.writeStructBegin('createAnonymousUser_result')
94 ashish 3931 
    if self.success != None:
3932 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3933 
      self.success.write(oprot)
3934 
      oprot.writeFieldEnd()
559 chandransh 3935 
    if self.ucex != None:
3936 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
3937 
      self.ucex.write(oprot)
94 ashish 3938 
      oprot.writeFieldEnd()
3939 
    oprot.writeFieldStop()
3940 
    oprot.writeStructEnd()
3941 
 
3942 
  def __repr__(self):
3943 
    L = ['%s=%r' % (key, value)
3944 
      for key, value in self.__dict__.iteritems()]
3945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3946 
 
3947 
  def __eq__(self, other):
3948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3949 
 
3950 
  def __ne__(self, other):
3951 
    return not (self == other)
3952 
 
559 chandransh 3953 
class getUserById_args:
94 ashish 3954 
  """
3955 
  Attributes:
3956 
   - userId
3957 
  """
3958 
 
3959 
  thrift_spec = (
3960 
    None, # 0
3961 
    (1, TType.I64, 'userId', None, None, ), # 1
3962 
  )
3963 
 
559 chandransh 3964 
  def __init__(self, userId=None,):
94 ashish 3965 
    self.userId = userId
3966 
 
3967 
  def read(self, iprot):
3968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3970 
      return
3971 
    iprot.readStructBegin()
3972 
    while True:
3973 
      (fname, ftype, fid) = iprot.readFieldBegin()
3974 
      if ftype == TType.STOP:
3975 
        break
3976 
      if fid == 1:
3977 
        if ftype == TType.I64:
3978 
          self.userId = iprot.readI64();
3979 
        else:
3980 
          iprot.skip(ftype)
3981 
      else:
3982 
        iprot.skip(ftype)
3983 
      iprot.readFieldEnd()
3984 
    iprot.readStructEnd()
3985 
 
3986 
  def write(self, oprot):
3987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3989 
      return
559 chandransh 3990 
    oprot.writeStructBegin('getUserById_args')
94 ashish 3991 
    if self.userId != None:
3992 
      oprot.writeFieldBegin('userId', TType.I64, 1)
3993 
      oprot.writeI64(self.userId)
3994 
      oprot.writeFieldEnd()
3995 
    oprot.writeFieldStop()
3996 
    oprot.writeStructEnd()
3997 
 
3998 
  def __repr__(self):
3999 
    L = ['%s=%r' % (key, value)
4000 
      for key, value in self.__dict__.iteritems()]
4001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4002 
 
4003 
  def __eq__(self, other):
4004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4005 
 
4006 
  def __ne__(self, other):
4007 
    return not (self == other)
4008 
 
559 chandransh 4009 
class getUserById_result:
94 ashish 4010 
  """
4011 
  Attributes:
4012 
   - success
559 chandransh 4013 
   - ucex
94 ashish 4014 
  """
4015 
 
4016 
  thrift_spec = (
559 chandransh 4017 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4018 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4019 
  )
4020 
 
559 chandransh 4021 
  def __init__(self, success=None, ucex=None,):
94 ashish 4022 
    self.success = success
559 chandransh 4023 
    self.ucex = ucex
94 ashish 4024 
 
4025 
  def read(self, iprot):
4026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4028 
      return
4029 
    iprot.readStructBegin()
4030 
    while True:
4031 
      (fname, ftype, fid) = iprot.readFieldBegin()
4032 
      if ftype == TType.STOP:
4033 
        break
4034 
      if fid == 0:
4035 
        if ftype == TType.STRUCT:
559 chandransh 4036 
          self.success = User()
94 ashish 4037 
          self.success.read(iprot)
4038 
        else:
4039 
          iprot.skip(ftype)
4040 
      elif fid == 1:
4041 
        if ftype == TType.STRUCT:
559 chandransh 4042 
          self.ucex = UserContextException()
4043 
          self.ucex.read(iprot)
94 ashish 4044 
        else:
4045 
          iprot.skip(ftype)
4046 
      else:
4047 
        iprot.skip(ftype)
4048 
      iprot.readFieldEnd()
4049 
    iprot.readStructEnd()
4050 
 
4051 
  def write(self, oprot):
4052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4054 
      return
559 chandransh 4055 
    oprot.writeStructBegin('getUserById_result')
94 ashish 4056 
    if self.success != None:
4057 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4058 
      self.success.write(oprot)
4059 
      oprot.writeFieldEnd()
559 chandransh 4060 
    if self.ucex != None:
4061 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4062 
      self.ucex.write(oprot)
94 ashish 4063 
      oprot.writeFieldEnd()
4064 
    oprot.writeFieldStop()
4065 
    oprot.writeStructEnd()
4066 
 
4067 
  def __repr__(self):
4068 
    L = ['%s=%r' % (key, value)
4069 
      for key, value in self.__dict__.iteritems()]
4070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4071 
 
4072 
  def __eq__(self, other):
4073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4074 
 
4075 
  def __ne__(self, other):
4076 
    return not (self == other)
4077 
 
1491 vikas 4078 
class getUserByEmail_args:
4079 
  """
4080 
  Attributes:
4081 
   - email
4082 
  """
4083 
 
4084 
  thrift_spec = (
4085 
    None, # 0
4086 
    (1, TType.STRING, 'email', None, None, ), # 1
4087 
  )
4088 
 
4089 
  def __init__(self, email=None,):
4090 
    self.email = email
4091 
 
4092 
  def read(self, iprot):
4093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4095 
      return
4096 
    iprot.readStructBegin()
4097 
    while True:
4098 
      (fname, ftype, fid) = iprot.readFieldBegin()
4099 
      if ftype == TType.STOP:
4100 
        break
4101 
      if fid == 1:
4102 
        if ftype == TType.STRING:
4103 
          self.email = iprot.readString();
4104 
        else:
4105 
          iprot.skip(ftype)
4106 
      else:
4107 
        iprot.skip(ftype)
4108 
      iprot.readFieldEnd()
4109 
    iprot.readStructEnd()
4110 
 
4111 
  def write(self, oprot):
4112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4114 
      return
4115 
    oprot.writeStructBegin('getUserByEmail_args')
4116 
    if self.email != None:
4117 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4118 
      oprot.writeString(self.email)
4119 
      oprot.writeFieldEnd()
4120 
    oprot.writeFieldStop()
4121 
    oprot.writeStructEnd()
4122 
 
4123 
  def __repr__(self):
4124 
    L = ['%s=%r' % (key, value)
4125 
      for key, value in self.__dict__.iteritems()]
4126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4127 
 
4128 
  def __eq__(self, other):
4129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4130 
 
4131 
  def __ne__(self, other):
4132 
    return not (self == other)
4133 
 
4134 
class getUserByEmail_result:
4135 
  """
4136 
  Attributes:
4137 
   - success
4138 
   - ucex
4139 
  """
4140 
 
4141 
  thrift_spec = (
4142 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4143 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4144 
  )
4145 
 
4146 
  def __init__(self, success=None, ucex=None,):
4147 
    self.success = success
4148 
    self.ucex = ucex
4149 
 
4150 
  def read(self, iprot):
4151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4153 
      return
4154 
    iprot.readStructBegin()
4155 
    while True:
4156 
      (fname, ftype, fid) = iprot.readFieldBegin()
4157 
      if ftype == TType.STOP:
4158 
        break
4159 
      if fid == 0:
4160 
        if ftype == TType.STRUCT:
4161 
          self.success = User()
4162 
          self.success.read(iprot)
4163 
        else:
4164 
          iprot.skip(ftype)
4165 
      elif fid == 1:
4166 
        if ftype == TType.STRUCT:
4167 
          self.ucex = UserContextException()
4168 
          self.ucex.read(iprot)
4169 
        else:
4170 
          iprot.skip(ftype)
4171 
      else:
4172 
        iprot.skip(ftype)
4173 
      iprot.readFieldEnd()
4174 
    iprot.readStructEnd()
4175 
 
4176 
  def write(self, oprot):
4177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4179 
      return
4180 
    oprot.writeStructBegin('getUserByEmail_result')
4181 
    if self.success != None:
4182 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4183 
      self.success.write(oprot)
4184 
      oprot.writeFieldEnd()
4185 
    if self.ucex != None:
4186 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4187 
      self.ucex.write(oprot)
4188 
      oprot.writeFieldEnd()
4189 
    oprot.writeFieldStop()
4190 
    oprot.writeStructEnd()
4191 
 
4192 
  def __repr__(self):
4193 
    L = ['%s=%r' % (key, value)
4194 
      for key, value in self.__dict__.iteritems()]
4195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4196 
 
4197 
  def __eq__(self, other):
4198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4199 
 
4200 
  def __ne__(self, other):
4201 
    return not (self == other)
4202 
 
559 chandransh 4203 
class createUser_args:
94 ashish 4204 
  """
4205 
  Attributes:
559 chandransh 4206 
   - user
94 ashish 4207 
  """
4208 
 
4209 
  thrift_spec = (
4210 
    None, # 0
559 chandransh 4211 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4212 
  )
4213 
 
559 chandransh 4214 
  def __init__(self, user=None,):
4215 
    self.user = user
94 ashish 4216 
 
4217 
  def read(self, iprot):
4218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4220 
      return
4221 
    iprot.readStructBegin()
4222 
    while True:
4223 
      (fname, ftype, fid) = iprot.readFieldBegin()
4224 
      if ftype == TType.STOP:
4225 
        break
4226 
      if fid == 1:
559 chandransh 4227 
        if ftype == TType.STRUCT:
4228 
          self.user = User()
4229 
          self.user.read(iprot)
94 ashish 4230 
        else:
4231 
          iprot.skip(ftype)
4232 
      else:
4233 
        iprot.skip(ftype)
4234 
      iprot.readFieldEnd()
4235 
    iprot.readStructEnd()
4236 
 
4237 
  def write(self, oprot):
4238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4240 
      return
559 chandransh 4241 
    oprot.writeStructBegin('createUser_args')
4242 
    if self.user != None:
4243 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4244 
      self.user.write(oprot)
94 ashish 4245 
      oprot.writeFieldEnd()
4246 
    oprot.writeFieldStop()
4247 
    oprot.writeStructEnd()
4248 
 
4249 
  def __repr__(self):
4250 
    L = ['%s=%r' % (key, value)
4251 
      for key, value in self.__dict__.iteritems()]
4252 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4253 
 
4254 
  def __eq__(self, other):
4255 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4256 
 
4257 
  def __ne__(self, other):
4258 
    return not (self == other)
4259 
 
559 chandransh 4260 
class createUser_result:
94 ashish 4261 
  """
4262 
  Attributes:
4263 
   - success
559 chandransh 4264 
   - ucex
94 ashish 4265 
  """
4266 
 
4267 
  thrift_spec = (
559 chandransh 4268 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4269 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4270 
  )
4271 
 
559 chandransh 4272 
  def __init__(self, success=None, ucex=None,):
94 ashish 4273 
    self.success = success
559 chandransh 4274 
    self.ucex = ucex
94 ashish 4275 
 
4276 
  def read(self, iprot):
4277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4279 
      return
4280 
    iprot.readStructBegin()
4281 
    while True:
4282 
      (fname, ftype, fid) = iprot.readFieldBegin()
4283 
      if ftype == TType.STOP:
4284 
        break
4285 
      if fid == 0:
4286 
        if ftype == TType.STRUCT:
559 chandransh 4287 
          self.success = User()
94 ashish 4288 
          self.success.read(iprot)
4289 
        else:
4290 
          iprot.skip(ftype)
4291 
      elif fid == 1:
4292 
        if ftype == TType.STRUCT:
559 chandransh 4293 
          self.ucex = UserContextException()
4294 
          self.ucex.read(iprot)
94 ashish 4295 
        else:
4296 
          iprot.skip(ftype)
4297 
      else:
4298 
        iprot.skip(ftype)
4299 
      iprot.readFieldEnd()
4300 
    iprot.readStructEnd()
4301 
 
4302 
  def write(self, oprot):
4303 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4304 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4305 
      return
559 chandransh 4306 
    oprot.writeStructBegin('createUser_result')
94 ashish 4307 
    if self.success != None:
4308 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4309 
      self.success.write(oprot)
4310 
      oprot.writeFieldEnd()
559 chandransh 4311 
    if self.ucex != None:
4312 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4313 
      self.ucex.write(oprot)
94 ashish 4314 
      oprot.writeFieldEnd()
4315 
    oprot.writeFieldStop()
4316 
    oprot.writeStructEnd()
4317 
 
4318 
  def __repr__(self):
4319 
    L = ['%s=%r' % (key, value)
4320 
      for key, value in self.__dict__.iteritems()]
4321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4322 
 
4323 
  def __eq__(self, other):
4324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4325 
 
4326 
  def __ne__(self, other):
4327 
    return not (self == other)
4328 
 
559 chandransh 4329 
class updateUser_args:
94 ashish 4330 
  """
4331 
  Attributes:
559 chandransh 4332 
   - user
94 ashish 4333 
  """
4334 
 
4335 
  thrift_spec = (
4336 
    None, # 0
559 chandransh 4337 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4338 
  )
4339 
 
559 chandransh 4340 
  def __init__(self, user=None,):
4341 
    self.user = user
94 ashish 4342 
 
4343 
  def read(self, iprot):
4344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4346 
      return
4347 
    iprot.readStructBegin()
4348 
    while True:
4349 
      (fname, ftype, fid) = iprot.readFieldBegin()
4350 
      if ftype == TType.STOP:
4351 
        break
4352 
      if fid == 1:
559 chandransh 4353 
        if ftype == TType.STRUCT:
4354 
          self.user = User()
4355 
          self.user.read(iprot)
94 ashish 4356 
        else:
4357 
          iprot.skip(ftype)
4358 
      else:
4359 
        iprot.skip(ftype)
4360 
      iprot.readFieldEnd()
4361 
    iprot.readStructEnd()
4362 
 
4363 
  def write(self, oprot):
4364 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4365 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4366 
      return
559 chandransh 4367 
    oprot.writeStructBegin('updateUser_args')
4368 
    if self.user != None:
4369 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4370 
      self.user.write(oprot)
94 ashish 4371 
      oprot.writeFieldEnd()
4372 
    oprot.writeFieldStop()
4373 
    oprot.writeStructEnd()
4374 
 
4375 
  def __repr__(self):
4376 
    L = ['%s=%r' % (key, value)
4377 
      for key, value in self.__dict__.iteritems()]
4378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4379 
 
4380 
  def __eq__(self, other):
4381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4382 
 
4383 
  def __ne__(self, other):
4384 
    return not (self == other)
4385 
 
559 chandransh 4386 
class updateUser_result:
94 ashish 4387 
  """
4388 
  Attributes:
4389 
   - success
559 chandransh 4390 
   - ucex
94 ashish 4391 
  """
4392 
 
4393 
  thrift_spec = (
559 chandransh 4394 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4395 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4396 
  )
4397 
 
559 chandransh 4398 
  def __init__(self, success=None, ucex=None,):
94 ashish 4399 
    self.success = success
559 chandransh 4400 
    self.ucex = ucex
94 ashish 4401 
 
4402 
  def read(self, iprot):
4403 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4404 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4405 
      return
4406 
    iprot.readStructBegin()
4407 
    while True:
4408 
      (fname, ftype, fid) = iprot.readFieldBegin()
4409 
      if ftype == TType.STOP:
4410 
        break
4411 
      if fid == 0:
4412 
        if ftype == TType.STRUCT:
559 chandransh 4413 
          self.success = User()
94 ashish 4414 
          self.success.read(iprot)
4415 
        else:
4416 
          iprot.skip(ftype)
4417 
      elif fid == 1:
4418 
        if ftype == TType.STRUCT:
559 chandransh 4419 
          self.ucex = UserContextException()
4420 
          self.ucex.read(iprot)
94 ashish 4421 
        else:
4422 
          iprot.skip(ftype)
4423 
      else:
4424 
        iprot.skip(ftype)
4425 
      iprot.readFieldEnd()
4426 
    iprot.readStructEnd()
4427 
 
4428 
  def write(self, oprot):
4429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4431 
      return
559 chandransh 4432 
    oprot.writeStructBegin('updateUser_result')
94 ashish 4433 
    if self.success != None:
4434 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4435 
      self.success.write(oprot)
4436 
      oprot.writeFieldEnd()
559 chandransh 4437 
    if self.ucex != None:
4438 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4439 
      self.ucex.write(oprot)
94 ashish 4440 
      oprot.writeFieldEnd()
4441 
    oprot.writeFieldStop()
4442 
    oprot.writeStructEnd()
4443 
 
4444 
  def __repr__(self):
4445 
    L = ['%s=%r' % (key, value)
4446 
      for key, value in self.__dict__.iteritems()]
4447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4448 
 
4449 
  def __eq__(self, other):
4450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4451 
 
4452 
  def __ne__(self, other):
4453 
    return not (self == other)
4454 
 
559 chandransh 4455 
class deleteUser_args:
94 ashish 4456 
  """
4457 
  Attributes:
4458 
   - userId
4459 
  """
4460 
 
4461 
  thrift_spec = (
4462 
    None, # 0
4463 
    (1, TType.I64, 'userId', None, None, ), # 1
4464 
  )
4465 
 
559 chandransh 4466 
  def __init__(self, userId=None,):
94 ashish 4467 
    self.userId = userId
4468 
 
4469 
  def read(self, iprot):
4470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4472 
      return
4473 
    iprot.readStructBegin()
4474 
    while True:
4475 
      (fname, ftype, fid) = iprot.readFieldBegin()
4476 
      if ftype == TType.STOP:
4477 
        break
4478 
      if fid == 1:
4479 
        if ftype == TType.I64:
4480 
          self.userId = iprot.readI64();
4481 
        else:
4482 
          iprot.skip(ftype)
4483 
      else:
4484 
        iprot.skip(ftype)
4485 
      iprot.readFieldEnd()
4486 
    iprot.readStructEnd()
4487 
 
4488 
  def write(self, oprot):
4489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4491 
      return
559 chandransh 4492 
    oprot.writeStructBegin('deleteUser_args')
94 ashish 4493 
    if self.userId != None:
4494 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4495 
      oprot.writeI64(self.userId)
4496 
      oprot.writeFieldEnd()
4497 
    oprot.writeFieldStop()
4498 
    oprot.writeStructEnd()
4499 
 
4500 
  def __repr__(self):
4501 
    L = ['%s=%r' % (key, value)
4502 
      for key, value in self.__dict__.iteritems()]
4503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4504 
 
4505 
  def __eq__(self, other):
4506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4507 
 
4508 
  def __ne__(self, other):
4509 
    return not (self == other)
4510 
 
559 chandransh 4511 
class deleteUser_result:
94 ashish 4512 
  """
4513 
  Attributes:
4514 
   - success
559 chandransh 4515 
   - ucex
94 ashish 4516 
  """
4517 
 
4518 
  thrift_spec = (
559 chandransh 4519 
    (0, TType.BOOL, 'success', None, None, ), # 0
4520 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4521 
  )
4522 
 
559 chandransh 4523 
  def __init__(self, success=None, ucex=None,):
94 ashish 4524 
    self.success = success
559 chandransh 4525 
    self.ucex = ucex
94 ashish 4526 
 
4527 
  def read(self, iprot):
4528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4530 
      return
4531 
    iprot.readStructBegin()
4532 
    while True:
4533 
      (fname, ftype, fid) = iprot.readFieldBegin()
4534 
      if ftype == TType.STOP:
4535 
        break
4536 
      if fid == 0:
559 chandransh 4537 
        if ftype == TType.BOOL:
4538 
          self.success = iprot.readBool();
94 ashish 4539 
        else:
4540 
          iprot.skip(ftype)
4541 
      elif fid == 1:
4542 
        if ftype == TType.STRUCT:
559 chandransh 4543 
          self.ucex = UserContextException()
4544 
          self.ucex.read(iprot)
94 ashish 4545 
        else:
4546 
          iprot.skip(ftype)
4547 
      else:
4548 
        iprot.skip(ftype)
4549 
      iprot.readFieldEnd()
4550 
    iprot.readStructEnd()
4551 
 
4552 
  def write(self, oprot):
4553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4555 
      return
559 chandransh 4556 
    oprot.writeStructBegin('deleteUser_result')
94 ashish 4557 
    if self.success != None:
559 chandransh 4558 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4559 
      oprot.writeBool(self.success)
94 ashish 4560 
      oprot.writeFieldEnd()
559 chandransh 4561 
    if self.ucex != None:
4562 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4563 
      self.ucex.write(oprot)
94 ashish 4564 
      oprot.writeFieldEnd()
4565 
    oprot.writeFieldStop()
4566 
    oprot.writeStructEnd()
4567 
 
4568 
  def __repr__(self):
4569 
    L = ['%s=%r' % (key, value)
4570 
      for key, value in self.__dict__.iteritems()]
4571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4572 
 
4573 
  def __eq__(self, other):
4574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4575 
 
4576 
  def __ne__(self, other):
4577 
    return not (self == other)
4578 
 
559 chandransh 4579 
class getUserState_args:
94 ashish 4580 
  """
4581 
  Attributes:
4582 
   - userId
4583 
  """
4584 
 
4585 
  thrift_spec = (
4586 
    None, # 0
4587 
    (1, TType.I64, 'userId', None, None, ), # 1
4588 
  )
4589 
 
559 chandransh 4590 
  def __init__(self, userId=None,):
94 ashish 4591 
    self.userId = userId
4592 
 
4593 
  def read(self, iprot):
4594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4596 
      return
4597 
    iprot.readStructBegin()
4598 
    while True:
4599 
      (fname, ftype, fid) = iprot.readFieldBegin()
4600 
      if ftype == TType.STOP:
4601 
        break
4602 
      if fid == 1:
4603 
        if ftype == TType.I64:
4604 
          self.userId = iprot.readI64();
4605 
        else:
4606 
          iprot.skip(ftype)
4607 
      else:
4608 
        iprot.skip(ftype)
4609 
      iprot.readFieldEnd()
4610 
    iprot.readStructEnd()
4611 
 
4612 
  def write(self, oprot):
4613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4615 
      return
559 chandransh 4616 
    oprot.writeStructBegin('getUserState_args')
94 ashish 4617 
    if self.userId != None:
4618 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4619 
      oprot.writeI64(self.userId)
4620 
      oprot.writeFieldEnd()
4621 
    oprot.writeFieldStop()
4622 
    oprot.writeStructEnd()
4623 
 
4624 
  def __repr__(self):
4625 
    L = ['%s=%r' % (key, value)
4626 
      for key, value in self.__dict__.iteritems()]
4627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4628 
 
4629 
  def __eq__(self, other):
4630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4631 
 
4632 
  def __ne__(self, other):
4633 
    return not (self == other)
4634 
 
559 chandransh 4635 
class getUserState_result:
94 ashish 4636 
  """
4637 
  Attributes:
4638 
   - success
559 chandransh 4639 
   - ucex
94 ashish 4640 
  """
4641 
 
4642 
  thrift_spec = (
559 chandransh 4643 
    (0, TType.STRUCT, 'success', (UserState, UserState.thrift_spec), None, ), # 0
4644 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4645 
  )
4646 
 
559 chandransh 4647 
  def __init__(self, success=None, ucex=None,):
94 ashish 4648 
    self.success = success
559 chandransh 4649 
    self.ucex = ucex
94 ashish 4650 
 
4651 
  def read(self, iprot):
4652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4654 
      return
4655 
    iprot.readStructBegin()
4656 
    while True:
4657 
      (fname, ftype, fid) = iprot.readFieldBegin()
4658 
      if ftype == TType.STOP:
4659 
        break
4660 
      if fid == 0:
4661 
        if ftype == TType.STRUCT:
559 chandransh 4662 
          self.success = UserState()
94 ashish 4663 
          self.success.read(iprot)
4664 
        else:
4665 
          iprot.skip(ftype)
4666 
      elif fid == 1:
4667 
        if ftype == TType.STRUCT:
559 chandransh 4668 
          self.ucex = UserContextException()
4669 
          self.ucex.read(iprot)
94 ashish 4670 
        else:
4671 
          iprot.skip(ftype)
4672 
      else:
4673 
        iprot.skip(ftype)
4674 
      iprot.readFieldEnd()
4675 
    iprot.readStructEnd()
4676 
 
4677 
  def write(self, oprot):
4678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4680 
      return
559 chandransh 4681 
    oprot.writeStructBegin('getUserState_result')
94 ashish 4682 
    if self.success != None:
4683 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4684 
      self.success.write(oprot)
4685 
      oprot.writeFieldEnd()
559 chandransh 4686 
    if self.ucex != None:
4687 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4688 
      self.ucex.write(oprot)
94 ashish 4689 
      oprot.writeFieldEnd()
4690 
    oprot.writeFieldStop()
4691 
    oprot.writeStructEnd()
4692 
 
4693 
  def __repr__(self):
4694 
    L = ['%s=%r' % (key, value)
4695 
      for key, value in self.__dict__.iteritems()]
4696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4697 
 
4698 
  def __eq__(self, other):
4699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4700 
 
4701 
  def __ne__(self, other):
4702 
    return not (self == other)
4703 
 
559 chandransh 4704 
class authenticateUser_args:
94 ashish 4705 
  """
4706 
  Attributes:
4707 
   - email
4708 
   - password
4709 
  """
4710 
 
4711 
  thrift_spec = (
4712 
    None, # 0
4713 
    (1, TType.STRING, 'email', None, None, ), # 1
4714 
    (2, TType.STRING, 'password', None, None, ), # 2
4715 
  )
4716 
 
4717 
  def __init__(self, email=None, password=None,):
4718 
    self.email = email
4719 
    self.password = password
4720 
 
4721 
  def read(self, iprot):
4722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4724 
      return
4725 
    iprot.readStructBegin()
4726 
    while True:
4727 
      (fname, ftype, fid) = iprot.readFieldBegin()
4728 
      if ftype == TType.STOP:
4729 
        break
4730 
      if fid == 1:
4731 
        if ftype == TType.STRING:
4732 
          self.email = iprot.readString();
4733 
        else:
4734 
          iprot.skip(ftype)
4735 
      elif fid == 2:
4736 
        if ftype == TType.STRING:
4737 
          self.password = iprot.readString();
4738 
        else:
4739 
          iprot.skip(ftype)
4740 
      else:
4741 
        iprot.skip(ftype)
4742 
      iprot.readFieldEnd()
4743 
    iprot.readStructEnd()
4744 
 
4745 
  def write(self, oprot):
4746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4748 
      return
559 chandransh 4749 
    oprot.writeStructBegin('authenticateUser_args')
94 ashish 4750 
    if self.email != None:
4751 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4752 
      oprot.writeString(self.email)
4753 
      oprot.writeFieldEnd()
4754 
    if self.password != None:
4755 
      oprot.writeFieldBegin('password', TType.STRING, 2)
4756 
      oprot.writeString(self.password)
4757 
      oprot.writeFieldEnd()
4758 
    oprot.writeFieldStop()
4759 
    oprot.writeStructEnd()
4760 
 
4761 
  def __repr__(self):
4762 
    L = ['%s=%r' % (key, value)
4763 
      for key, value in self.__dict__.iteritems()]
4764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4765 
 
4766 
  def __eq__(self, other):
4767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4768 
 
4769 
  def __ne__(self, other):
4770 
    return not (self == other)
4771 
 
559 chandransh 4772 
class authenticateUser_result:
94 ashish 4773 
  """
4774 
  Attributes:
4775 
   - success
559 chandransh 4776 
   - auex
94 ashish 4777 
  """
4778 
 
4779 
  thrift_spec = (
559 chandransh 4780 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4781 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 4782 
  )
4783 
 
559 chandransh 4784 
  def __init__(self, success=None, auex=None,):
94 ashish 4785 
    self.success = success
559 chandransh 4786 
    self.auex = auex
94 ashish 4787 
 
4788 
  def read(self, iprot):
4789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4791 
      return
4792 
    iprot.readStructBegin()
4793 
    while True:
4794 
      (fname, ftype, fid) = iprot.readFieldBegin()
4795 
      if ftype == TType.STOP:
4796 
        break
4797 
      if fid == 0:
4798 
        if ftype == TType.STRUCT:
559 chandransh 4799 
          self.success = User()
94 ashish 4800 
          self.success.read(iprot)
4801 
        else:
4802 
          iprot.skip(ftype)
4803 
      elif fid == 1:
4804 
        if ftype == TType.STRUCT:
559 chandransh 4805 
          self.auex = AuthenticationException()
4806 
          self.auex.read(iprot)
94 ashish 4807 
        else:
4808 
          iprot.skip(ftype)
4809 
      else:
4810 
        iprot.skip(ftype)
4811 
      iprot.readFieldEnd()
4812 
    iprot.readStructEnd()
4813 
 
4814 
  def write(self, oprot):
4815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4817 
      return
559 chandransh 4818 
    oprot.writeStructBegin('authenticateUser_result')
94 ashish 4819 
    if self.success != None:
4820 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4821 
      self.success.write(oprot)
4822 
      oprot.writeFieldEnd()
559 chandransh 4823 
    if self.auex != None:
4824 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
4825 
      self.auex.write(oprot)
94 ashish 4826 
      oprot.writeFieldEnd()
4827 
    oprot.writeFieldStop()
4828 
    oprot.writeStructEnd()
4829 
 
4830 
  def __repr__(self):
4831 
    L = ['%s=%r' % (key, value)
4832 
      for key, value in self.__dict__.iteritems()]
4833 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4834 
 
4835 
  def __eq__(self, other):
4836 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4837 
 
4838 
  def __ne__(self, other):
4839 
    return not (self == other)
4840 
 
559 chandransh 4841 
class userExists_args:
122 ashish 4842 
  """
4843 
  Attributes:
559 chandransh 4844 
   - email
122 ashish 4845 
  """
4846 
 
4847 
  thrift_spec = (
4848 
    None, # 0
559 chandransh 4849 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 4850 
  )
4851 
 
559 chandransh 4852 
  def __init__(self, email=None,):
4853 
    self.email = email
122 ashish 4854 
 
4855 
  def read(self, iprot):
4856 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4857 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4858 
      return
4859 
    iprot.readStructBegin()
4860 
    while True:
4861 
      (fname, ftype, fid) = iprot.readFieldBegin()
4862 
      if ftype == TType.STOP:
4863 
        break
4864 
      if fid == 1:
4865 
        if ftype == TType.STRING:
559 chandransh 4866 
          self.email = iprot.readString();
122 ashish 4867 
        else:
4868 
          iprot.skip(ftype)
559 chandransh 4869 
      else:
4870 
        iprot.skip(ftype)
4871 
      iprot.readFieldEnd()
4872 
    iprot.readStructEnd()
4873 
 
4874 
  def write(self, oprot):
4875 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4876 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4877 
      return
4878 
    oprot.writeStructBegin('userExists_args')
4879 
    if self.email != None:
4880 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4881 
      oprot.writeString(self.email)
4882 
      oprot.writeFieldEnd()
4883 
    oprot.writeFieldStop()
4884 
    oprot.writeStructEnd()
4885 
 
4886 
  def __repr__(self):
4887 
    L = ['%s=%r' % (key, value)
4888 
      for key, value in self.__dict__.iteritems()]
4889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4890 
 
4891 
  def __eq__(self, other):
4892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4893 
 
4894 
  def __ne__(self, other):
4895 
    return not (self == other)
4896 
 
4897 
class userExists_result:
4898 
  """
4899 
  Attributes:
4900 
   - success
4901 
   - ucx
4902 
  """
4903 
 
4904 
  thrift_spec = (
4905 
    (0, TType.BOOL, 'success', None, None, ), # 0
4906 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4907 
  )
4908 
 
4909 
  def __init__(self, success=None, ucx=None,):
4910 
    self.success = success
4911 
    self.ucx = ucx
4912 
 
4913 
  def read(self, iprot):
4914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4916 
      return
4917 
    iprot.readStructBegin()
4918 
    while True:
4919 
      (fname, ftype, fid) = iprot.readFieldBegin()
4920 
      if ftype == TType.STOP:
4921 
        break
4922 
      if fid == 0:
4923 
        if ftype == TType.BOOL:
4924 
          self.success = iprot.readBool();
4925 
        else:
4926 
          iprot.skip(ftype)
4927 
      elif fid == 1:
4928 
        if ftype == TType.STRUCT:
4929 
          self.ucx = UserContextException()
4930 
          self.ucx.read(iprot)
4931 
        else:
4932 
          iprot.skip(ftype)
4933 
      else:
4934 
        iprot.skip(ftype)
4935 
      iprot.readFieldEnd()
4936 
    iprot.readStructEnd()
4937 
 
4938 
  def write(self, oprot):
4939 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4940 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4941 
      return
4942 
    oprot.writeStructBegin('userExists_result')
4943 
    if self.success != None:
4944 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4945 
      oprot.writeBool(self.success)
4946 
      oprot.writeFieldEnd()
4947 
    if self.ucx != None:
4948 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
4949 
      self.ucx.write(oprot)
4950 
      oprot.writeFieldEnd()
4951 
    oprot.writeFieldStop()
4952 
    oprot.writeStructEnd()
4953 
 
4954 
  def __repr__(self):
4955 
    L = ['%s=%r' % (key, value)
4956 
      for key, value in self.__dict__.iteritems()]
4957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4958 
 
4959 
  def __eq__(self, other):
4960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4961 
 
4962 
  def __ne__(self, other):
4963 
    return not (self == other)
4964 
 
4965 
class addAddressForUser_args:
4966 
  """
4967 
  Attributes:
4968 
   - userId
4969 
   - address
4970 
   - setDefault
4971 
  """
4972 
 
4973 
  thrift_spec = (
4974 
    None, # 0
4975 
    (1, TType.I64, 'userId', None, None, ), # 1
4976 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 4977 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 4978 
  )
4979 
 
567 rajveer 4980 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 4981 
    self.userId = userId
4982 
    self.address = address
4983 
    self.setDefault = setDefault
4984 
 
4985 
  def read(self, iprot):
4986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4988 
      return
4989 
    iprot.readStructBegin()
4990 
    while True:
4991 
      (fname, ftype, fid) = iprot.readFieldBegin()
4992 
      if ftype == TType.STOP:
4993 
        break
4994 
      if fid == 1:
4995 
        if ftype == TType.I64:
4996 
          self.userId = iprot.readI64();
4997 
        else:
4998 
          iprot.skip(ftype)
122 ashish 4999 
      elif fid == 2:
559 chandransh 5000 
        if ftype == TType.STRUCT:
5001 
          self.address = Address()
5002 
          self.address.read(iprot)
122 ashish 5003 
        else:
5004 
          iprot.skip(ftype)
5005 
      elif fid == 3:
5006 
        if ftype == TType.BOOL:
559 chandransh 5007 
          self.setDefault = iprot.readBool();
122 ashish 5008 
        else:
5009 
          iprot.skip(ftype)
5010 
      else:
5011 
        iprot.skip(ftype)
5012 
      iprot.readFieldEnd()
5013 
    iprot.readStructEnd()
5014 
 
5015 
  def write(self, oprot):
5016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5018 
      return
559 chandransh 5019 
    oprot.writeStructBegin('addAddressForUser_args')
5020 
    if self.userId != None:
5021 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5022 
      oprot.writeI64(self.userId)
122 ashish 5023 
      oprot.writeFieldEnd()
559 chandransh 5024 
    if self.address != None:
5025 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
5026 
      self.address.write(oprot)
122 ashish 5027 
      oprot.writeFieldEnd()
559 chandransh 5028 
    if self.setDefault != None:
567 rajveer 5029 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 5030 
      oprot.writeBool(self.setDefault)
5031 
      oprot.writeFieldEnd()
122 ashish 5032 
    oprot.writeFieldStop()
5033 
    oprot.writeStructEnd()
5034 
 
5035 
  def __repr__(self):
5036 
    L = ['%s=%r' % (key, value)
5037 
      for key, value in self.__dict__.iteritems()]
5038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5039 
 
5040 
  def __eq__(self, other):
5041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5042 
 
5043 
  def __ne__(self, other):
5044 
    return not (self == other)
5045 
 
559 chandransh 5046 
class addAddressForUser_result:
122 ashish 5047 
  """
5048 
  Attributes:
5049 
   - success
559 chandransh 5050 
   - ucx
122 ashish 5051 
  """
5052 
 
5053 
  thrift_spec = (
567 rajveer 5054 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 5055 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 5056 
  )
5057 
 
559 chandransh 5058 
  def __init__(self, success=None, ucx=None,):
122 ashish 5059 
    self.success = success
559 chandransh 5060 
    self.ucx = ucx
122 ashish 5061 
 
5062 
  def read(self, iprot):
5063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5065 
      return
5066 
    iprot.readStructBegin()
5067 
    while True:
5068 
      (fname, ftype, fid) = iprot.readFieldBegin()
5069 
      if ftype == TType.STOP:
5070 
        break
5071 
      if fid == 0:
567 rajveer 5072 
        if ftype == TType.I64:
5073 
          self.success = iprot.readI64();
122 ashish 5074 
        else:
5075 
          iprot.skip(ftype)
5076 
      elif fid == 1:
5077 
        if ftype == TType.STRUCT:
559 chandransh 5078 
          self.ucx = UserContextException()
5079 
          self.ucx.read(iprot)
122 ashish 5080 
        else:
5081 
          iprot.skip(ftype)
5082 
      else:
5083 
        iprot.skip(ftype)
5084 
      iprot.readFieldEnd()
5085 
    iprot.readStructEnd()
5086 
 
5087 
  def write(self, oprot):
5088 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5089 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5090 
      return
559 chandransh 5091 
    oprot.writeStructBegin('addAddressForUser_result')
122 ashish 5092 
    if self.success != None:
567 rajveer 5093 
      oprot.writeFieldBegin('success', TType.I64, 0)
5094 
      oprot.writeI64(self.success)
122 ashish 5095 
      oprot.writeFieldEnd()
559 chandransh 5096 
    if self.ucx != None:
5097 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5098 
      self.ucx.write(oprot)
122 ashish 5099 
      oprot.writeFieldEnd()
5100 
    oprot.writeFieldStop()
5101 
    oprot.writeStructEnd()
5102 
 
5103 
  def __repr__(self):
5104 
    L = ['%s=%r' % (key, value)
5105 
      for key, value in self.__dict__.iteritems()]
5106 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5107 
 
5108 
  def __eq__(self, other):
5109 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5110 
 
5111 
  def __ne__(self, other):
5112 
    return not (self == other)
5113 
 
559 chandransh 5114 
class removeAddressForUser_args:
94 ashish 5115 
  """
5116 
  Attributes:
559 chandransh 5117 
   - userid
5118 
   - addressId
94 ashish 5119 
  """
5120 
 
5121 
  thrift_spec = (
5122 
    None, # 0
559 chandransh 5123 
    (1, TType.I64, 'userid', None, None, ), # 1
5124 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 5125 
  )
5126 
 
559 chandransh 5127 
  def __init__(self, userid=None, addressId=None,):
5128 
    self.userid = userid
5129 
    self.addressId = addressId
94 ashish 5130 
 
5131 
  def read(self, iprot):
5132 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5133 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5134 
      return
5135 
    iprot.readStructBegin()
5136 
    while True:
5137 
      (fname, ftype, fid) = iprot.readFieldBegin()
5138 
      if ftype == TType.STOP:
5139 
        break
5140 
      if fid == 1:
559 chandransh 5141 
        if ftype == TType.I64:
5142 
          self.userid = iprot.readI64();
94 ashish 5143 
        else:
5144 
          iprot.skip(ftype)
559 chandransh 5145 
      elif fid == 2:
5146 
        if ftype == TType.I64:
5147 
          self.addressId = iprot.readI64();
5148 
        else:
5149 
          iprot.skip(ftype)
94 ashish 5150 
      else:
5151 
        iprot.skip(ftype)
5152 
      iprot.readFieldEnd()
5153 
    iprot.readStructEnd()
5154 
 
5155 
  def write(self, oprot):
5156 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5157 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5158 
      return
559 chandransh 5159 
    oprot.writeStructBegin('removeAddressForUser_args')
5160 
    if self.userid != None:
5161 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5162 
      oprot.writeI64(self.userid)
94 ashish 5163 
      oprot.writeFieldEnd()
559 chandransh 5164 
    if self.addressId != None:
5165 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5166 
      oprot.writeI64(self.addressId)
5167 
      oprot.writeFieldEnd()
94 ashish 5168 
    oprot.writeFieldStop()
5169 
    oprot.writeStructEnd()
5170 
 
5171 
  def __repr__(self):
5172 
    L = ['%s=%r' % (key, value)
5173 
      for key, value in self.__dict__.iteritems()]
5174 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5175 
 
5176 
  def __eq__(self, other):
5177 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5178 
 
5179 
  def __ne__(self, other):
5180 
    return not (self == other)
5181 
 
559 chandransh 5182 
class removeAddressForUser_result:
94 ashish 5183 
  """
5184 
  Attributes:
5185 
   - success
5186 
   - ucx
5187 
  """
5188 
 
5189 
  thrift_spec = (
5190 
    (0, TType.BOOL, 'success', None, None, ), # 0
5191 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5192 
  )
5193 
 
5194 
  def __init__(self, success=None, ucx=None,):
5195 
    self.success = success
5196 
    self.ucx = ucx
5197 
 
5198 
  def read(self, iprot):
5199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5201 
      return
5202 
    iprot.readStructBegin()
5203 
    while True:
5204 
      (fname, ftype, fid) = iprot.readFieldBegin()
5205 
      if ftype == TType.STOP:
5206 
        break
5207 
      if fid == 0:
5208 
        if ftype == TType.BOOL:
5209 
          self.success = iprot.readBool();
5210 
        else:
5211 
          iprot.skip(ftype)
5212 
      elif fid == 1:
5213 
        if ftype == TType.STRUCT:
5214 
          self.ucx = UserContextException()
5215 
          self.ucx.read(iprot)
5216 
        else:
5217 
          iprot.skip(ftype)
5218 
      else:
5219 
        iprot.skip(ftype)
5220 
      iprot.readFieldEnd()
5221 
    iprot.readStructEnd()
5222 
 
5223 
  def write(self, oprot):
5224 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5225 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5226 
      return
559 chandransh 5227 
    oprot.writeStructBegin('removeAddressForUser_result')
94 ashish 5228 
    if self.success != None:
5229 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5230 
      oprot.writeBool(self.success)
5231 
      oprot.writeFieldEnd()
5232 
    if self.ucx != None:
5233 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5234 
      self.ucx.write(oprot)
5235 
      oprot.writeFieldEnd()
5236 
    oprot.writeFieldStop()
5237 
    oprot.writeStructEnd()
5238 
 
5239 
  def __repr__(self):
5240 
    L = ['%s=%r' % (key, value)
5241 
      for key, value in self.__dict__.iteritems()]
5242 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5243 
 
5244 
  def __eq__(self, other):
5245 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5246 
 
5247 
  def __ne__(self, other):
5248 
    return not (self == other)
5249 
 
559 chandransh 5250 
class setUserAsLoggedIn_args:
94 ashish 5251 
  """
5252 
  Attributes:
559 chandransh 5253 
   - userId
94 ashish 5254 
   - timestamp
5255 
  """
5256 
 
5257 
  thrift_spec = (
5258 
    None, # 0
559 chandransh 5259 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 5260 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5261 
  )
5262 
 
559 chandransh 5263 
  def __init__(self, userId=None, timestamp=None,):
5264 
    self.userId = userId
94 ashish 5265 
    self.timestamp = timestamp
5266 
 
5267 
  def read(self, iprot):
5268 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5269 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5270 
      return
5271 
    iprot.readStructBegin()
5272 
    while True:
5273 
      (fname, ftype, fid) = iprot.readFieldBegin()
5274 
      if ftype == TType.STOP:
5275 
        break
5276 
      if fid == 1:
559 chandransh 5277 
        if ftype == TType.I64:
5278 
          self.userId = iprot.readI64();
94 ashish 5279 
        else:
5280 
          iprot.skip(ftype)
5281 
      elif fid == 2:
5282 
        if ftype == TType.I64:
5283 
          self.timestamp = iprot.readI64();
5284 
        else:
5285 
          iprot.skip(ftype)
5286 
      else:
5287 
        iprot.skip(ftype)
5288 
      iprot.readFieldEnd()
5289 
    iprot.readStructEnd()
5290 
 
5291 
  def write(self, oprot):
5292 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5293 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5294 
      return
559 chandransh 5295 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
5296 
    if self.userId != None:
5297 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5298 
      oprot.writeI64(self.userId)
94 ashish 5299 
      oprot.writeFieldEnd()
5300 
    if self.timestamp != None:
5301 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5302 
      oprot.writeI64(self.timestamp)
5303 
      oprot.writeFieldEnd()
5304 
    oprot.writeFieldStop()
5305 
    oprot.writeStructEnd()
5306 
 
5307 
  def __repr__(self):
5308 
    L = ['%s=%r' % (key, value)
5309 
      for key, value in self.__dict__.iteritems()]
5310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5311 
 
5312 
  def __eq__(self, other):
5313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5314 
 
5315 
  def __ne__(self, other):
5316 
    return not (self == other)
5317 
 
559 chandransh 5318 
class setUserAsLoggedIn_result:
94 ashish 5319 
  """
5320 
  Attributes:
5321 
   - success
5322 
   - ucx
5323 
  """
5324 
 
5325 
  thrift_spec = (
5326 
    (0, TType.BOOL, 'success', None, None, ), # 0
5327 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5328 
  )
5329 
 
5330 
  def __init__(self, success=None, ucx=None,):
5331 
    self.success = success
5332 
    self.ucx = ucx
5333 
 
5334 
  def read(self, iprot):
5335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5337 
      return
5338 
    iprot.readStructBegin()
5339 
    while True:
5340 
      (fname, ftype, fid) = iprot.readFieldBegin()
5341 
      if ftype == TType.STOP:
5342 
        break
5343 
      if fid == 0:
5344 
        if ftype == TType.BOOL:
5345 
          self.success = iprot.readBool();
5346 
        else:
5347 
          iprot.skip(ftype)
5348 
      elif fid == 1:
5349 
        if ftype == TType.STRUCT:
5350 
          self.ucx = UserContextException()
5351 
          self.ucx.read(iprot)
5352 
        else:
5353 
          iprot.skip(ftype)
5354 
      else:
5355 
        iprot.skip(ftype)
5356 
      iprot.readFieldEnd()
5357 
    iprot.readStructEnd()
5358 
 
5359 
  def write(self, oprot):
5360 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5361 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5362 
      return
559 chandransh 5363 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
94 ashish 5364 
    if self.success != None:
5365 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5366 
      oprot.writeBool(self.success)
5367 
      oprot.writeFieldEnd()
5368 
    if self.ucx != None:
5369 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5370 
      self.ucx.write(oprot)
5371 
      oprot.writeFieldEnd()
5372 
    oprot.writeFieldStop()
5373 
    oprot.writeStructEnd()
5374 
 
5375 
  def __repr__(self):
5376 
    L = ['%s=%r' % (key, value)
5377 
      for key, value in self.__dict__.iteritems()]
5378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5379 
 
5380 
  def __eq__(self, other):
5381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5382 
 
5383 
  def __ne__(self, other):
5384 
    return not (self == other)
5385 
 
559 chandransh 5386 
class setUserAsLoggedOut_args:
94 ashish 5387 
  """
5388 
  Attributes:
5389 
   - userid
5390 
   - timestamp
5391 
  """
5392 
 
5393 
  thrift_spec = (
5394 
    None, # 0
559 chandransh 5395 
    (1, TType.I64, 'userid', None, None, ), # 1
5396 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 5397 
  )
5398 
 
559 chandransh 5399 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 5400 
    self.userid = userid
5401 
    self.timestamp = timestamp
5402 
 
5403 
  def read(self, iprot):
5404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5406 
      return
5407 
    iprot.readStructBegin()
5408 
    while True:
5409 
      (fname, ftype, fid) = iprot.readFieldBegin()
5410 
      if ftype == TType.STOP:
5411 
        break
5412 
      if fid == 1:
5413 
        if ftype == TType.I64:
5414 
          self.userid = iprot.readI64();
5415 
        else:
5416 
          iprot.skip(ftype)
559 chandransh 5417 
      elif fid == 2:
94 ashish 5418 
        if ftype == TType.I64:
5419 
          self.timestamp = iprot.readI64();
5420 
        else:
5421 
          iprot.skip(ftype)
5422 
      else:
5423 
        iprot.skip(ftype)
5424 
      iprot.readFieldEnd()
5425 
    iprot.readStructEnd()
5426 
 
5427 
  def write(self, oprot):
5428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5430 
      return
559 chandransh 5431 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
94 ashish 5432 
    if self.userid != None:
559 chandransh 5433 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 5434 
      oprot.writeI64(self.userid)
5435 
      oprot.writeFieldEnd()
5436 
    if self.timestamp != None:
559 chandransh 5437 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 5438 
      oprot.writeI64(self.timestamp)
5439 
      oprot.writeFieldEnd()
5440 
    oprot.writeFieldStop()
5441 
    oprot.writeStructEnd()
5442 
 
5443 
  def __repr__(self):
5444 
    L = ['%s=%r' % (key, value)
5445 
      for key, value in self.__dict__.iteritems()]
5446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5447 
 
5448 
  def __eq__(self, other):
5449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5450 
 
5451 
  def __ne__(self, other):
5452 
    return not (self == other)
5453 
 
559 chandransh 5454 
class setUserAsLoggedOut_result:
94 ashish 5455 
  """
5456 
  Attributes:
5457 
   - success
5458 
   - ucx
5459 
  """
5460 
 
5461 
  thrift_spec = (
5462 
    (0, TType.BOOL, 'success', None, None, ), # 0
5463 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5464 
  )
5465 
 
5466 
  def __init__(self, success=None, ucx=None,):
5467 
    self.success = success
5468 
    self.ucx = ucx
5469 
 
5470 
  def read(self, iprot):
5471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5473 
      return
5474 
    iprot.readStructBegin()
5475 
    while True:
5476 
      (fname, ftype, fid) = iprot.readFieldBegin()
5477 
      if ftype == TType.STOP:
5478 
        break
5479 
      if fid == 0:
5480 
        if ftype == TType.BOOL:
5481 
          self.success = iprot.readBool();
5482 
        else:
5483 
          iprot.skip(ftype)
5484 
      elif fid == 1:
5485 
        if ftype == TType.STRUCT:
5486 
          self.ucx = UserContextException()
5487 
          self.ucx.read(iprot)
5488 
        else:
5489 
          iprot.skip(ftype)
5490 
      else:
5491 
        iprot.skip(ftype)
5492 
      iprot.readFieldEnd()
5493 
    iprot.readStructEnd()
5494 
 
5495 
  def write(self, oprot):
5496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5498 
      return
559 chandransh 5499 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
94 ashish 5500 
    if self.success != None:
5501 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5502 
      oprot.writeBool(self.success)
5503 
      oprot.writeFieldEnd()
5504 
    if self.ucx != None:
5505 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5506 
      self.ucx.write(oprot)
5507 
      oprot.writeFieldEnd()
5508 
    oprot.writeFieldStop()
5509 
    oprot.writeStructEnd()
5510 
 
5511 
  def __repr__(self):
5512 
    L = ['%s=%r' % (key, value)
5513 
      for key, value in self.__dict__.iteritems()]
5514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5515 
 
5516 
  def __eq__(self, other):
5517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5518 
 
5519 
  def __ne__(self, other):
5520 
    return not (self == other)
5521 
 
559 chandransh 5522 
class setDefaultAddress_args:
94 ashish 5523 
  """
5524 
  Attributes:
5525 
   - userid
5526 
   - addressId
5527 
  """
5528 
 
5529 
  thrift_spec = (
5530 
    None, # 0
5531 
    (1, TType.I64, 'userid', None, None, ), # 1
5532 
    (2, TType.I64, 'addressId', None, None, ), # 2
5533 
  )
5534 
 
5535 
  def __init__(self, userid=None, addressId=None,):
5536 
    self.userid = userid
5537 
    self.addressId = addressId
5538 
 
5539 
  def read(self, iprot):
5540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5542 
      return
5543 
    iprot.readStructBegin()
5544 
    while True:
5545 
      (fname, ftype, fid) = iprot.readFieldBegin()
5546 
      if ftype == TType.STOP:
5547 
        break
5548 
      if fid == 1:
5549 
        if ftype == TType.I64:
5550 
          self.userid = iprot.readI64();
5551 
        else:
5552 
          iprot.skip(ftype)
5553 
      elif fid == 2:
5554 
        if ftype == TType.I64:
5555 
          self.addressId = iprot.readI64();
5556 
        else:
5557 
          iprot.skip(ftype)
5558 
      else:
5559 
        iprot.skip(ftype)
5560 
      iprot.readFieldEnd()
5561 
    iprot.readStructEnd()
5562 
 
5563 
  def write(self, oprot):
5564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5566 
      return
559 chandransh 5567 
    oprot.writeStructBegin('setDefaultAddress_args')
94 ashish 5568 
    if self.userid != None:
5569 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5570 
      oprot.writeI64(self.userid)
5571 
      oprot.writeFieldEnd()
5572 
    if self.addressId != None:
5573 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5574 
      oprot.writeI64(self.addressId)
5575 
      oprot.writeFieldEnd()
5576 
    oprot.writeFieldStop()
5577 
    oprot.writeStructEnd()
5578 
 
5579 
  def __repr__(self):
5580 
    L = ['%s=%r' % (key, value)
5581 
      for key, value in self.__dict__.iteritems()]
5582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5583 
 
5584 
  def __eq__(self, other):
5585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5586 
 
5587 
  def __ne__(self, other):
5588 
    return not (self == other)
5589 
 
559 chandransh 5590 
class setDefaultAddress_result:
94 ashish 5591 
  """
5592 
  Attributes:
5593 
   - success
5594 
   - ucx
5595 
  """
5596 
 
5597 
  thrift_spec = (
5598 
    (0, TType.BOOL, 'success', None, None, ), # 0
5599 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5600 
  )
5601 
 
5602 
  def __init__(self, success=None, ucx=None,):
5603 
    self.success = success
5604 
    self.ucx = ucx
5605 
 
5606 
  def read(self, iprot):
5607 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5608 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5609 
      return
5610 
    iprot.readStructBegin()
5611 
    while True:
5612 
      (fname, ftype, fid) = iprot.readFieldBegin()
5613 
      if ftype == TType.STOP:
5614 
        break
5615 
      if fid == 0:
5616 
        if ftype == TType.BOOL:
5617 
          self.success = iprot.readBool();
5618 
        else:
5619 
          iprot.skip(ftype)
5620 
      elif fid == 1:
5621 
        if ftype == TType.STRUCT:
5622 
          self.ucx = UserContextException()
5623 
          self.ucx.read(iprot)
5624 
        else:
5625 
          iprot.skip(ftype)
5626 
      else:
5627 
        iprot.skip(ftype)
5628 
      iprot.readFieldEnd()
5629 
    iprot.readStructEnd()
5630 
 
5631 
  def write(self, oprot):
5632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5634 
      return
559 chandransh 5635 
    oprot.writeStructBegin('setDefaultAddress_result')
94 ashish 5636 
    if self.success != None:
5637 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5638 
      oprot.writeBool(self.success)
5639 
      oprot.writeFieldEnd()
5640 
    if self.ucx != None:
5641 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5642 
      self.ucx.write(oprot)
5643 
      oprot.writeFieldEnd()
5644 
    oprot.writeFieldStop()
5645 
    oprot.writeStructEnd()
5646 
 
5647 
  def __repr__(self):
5648 
    L = ['%s=%r' % (key, value)
5649 
      for key, value in self.__dict__.iteritems()]
5650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5651 
 
5652 
  def __eq__(self, other):
5653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5654 
 
5655 
  def __ne__(self, other):
5656 
    return not (self == other)
5657 
 
559 chandransh 5658 
class updatePassword_args:
94 ashish 5659 
  """
5660 
  Attributes:
559 chandransh 5661 
   - userid
594 rajveer 5662 
   - oldPassword
5663 
   - newPassword
94 ashish 5664 
  """
5665 
 
5666 
  thrift_spec = (
5667 
    None, # 0
559 chandransh 5668 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 5669 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
5670 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 5671 
  )
5672 
 
594 rajveer 5673 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 5674 
    self.userid = userid
594 rajveer 5675 
    self.oldPassword = oldPassword
5676 
    self.newPassword = newPassword
94 ashish 5677 
 
5678 
  def read(self, iprot):
5679 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5680 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5681 
      return
5682 
    iprot.readStructBegin()
5683 
    while True:
5684 
      (fname, ftype, fid) = iprot.readFieldBegin()
5685 
      if ftype == TType.STOP:
5686 
        break
5687 
      if fid == 1:
5688 
        if ftype == TType.I64:
559 chandransh 5689 
          self.userid = iprot.readI64();
94 ashish 5690 
        else:
5691 
          iprot.skip(ftype)
5692 
      elif fid == 2:
559 chandransh 5693 
        if ftype == TType.STRING:
594 rajveer 5694 
          self.oldPassword = iprot.readString();
94 ashish 5695 
        else:
5696 
          iprot.skip(ftype)
594 rajveer 5697 
      elif fid == 3:
5698 
        if ftype == TType.STRING:
5699 
          self.newPassword = iprot.readString();
5700 
        else:
5701 
          iprot.skip(ftype)
94 ashish 5702 
      else:
5703 
        iprot.skip(ftype)
5704 
      iprot.readFieldEnd()
5705 
    iprot.readStructEnd()
5706 
 
5707 
  def write(self, oprot):
5708 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5709 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5710 
      return
559 chandransh 5711 
    oprot.writeStructBegin('updatePassword_args')
5712 
    if self.userid != None:
5713 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5714 
      oprot.writeI64(self.userid)
94 ashish 5715 
      oprot.writeFieldEnd()
594 rajveer 5716 
    if self.oldPassword != None:
5717 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
5718 
      oprot.writeString(self.oldPassword)
94 ashish 5719 
      oprot.writeFieldEnd()
594 rajveer 5720 
    if self.newPassword != None:
5721 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
5722 
      oprot.writeString(self.newPassword)
5723 
      oprot.writeFieldEnd()
94 ashish 5724 
    oprot.writeFieldStop()
5725 
    oprot.writeStructEnd()
5726 
 
5727 
  def __repr__(self):
5728 
    L = ['%s=%r' % (key, value)
5729 
      for key, value in self.__dict__.iteritems()]
5730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5731 
 
5732 
  def __eq__(self, other):
5733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5734 
 
5735 
  def __ne__(self, other):
5736 
    return not (self == other)
5737 
 
559 chandransh 5738 
class updatePassword_result:
94 ashish 5739 
  """
5740 
  Attributes:
5741 
   - success
5742 
   - ucx
5743 
  """
5744 
 
5745 
  thrift_spec = (
5746 
    (0, TType.BOOL, 'success', None, None, ), # 0
5747 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5748 
  )
5749 
 
5750 
  def __init__(self, success=None, ucx=None,):
5751 
    self.success = success
5752 
    self.ucx = ucx
5753 
 
5754 
  def read(self, iprot):
5755 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5756 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5757 
      return
5758 
    iprot.readStructBegin()
5759 
    while True:
5760 
      (fname, ftype, fid) = iprot.readFieldBegin()
5761 
      if ftype == TType.STOP:
5762 
        break
5763 
      if fid == 0:
5764 
        if ftype == TType.BOOL:
5765 
          self.success = iprot.readBool();
5766 
        else:
5767 
          iprot.skip(ftype)
5768 
      elif fid == 1:
5769 
        if ftype == TType.STRUCT:
5770 
          self.ucx = UserContextException()
5771 
          self.ucx.read(iprot)
5772 
        else:
5773 
          iprot.skip(ftype)
5774 
      else:
5775 
        iprot.skip(ftype)
5776 
      iprot.readFieldEnd()
5777 
    iprot.readStructEnd()
5778 
 
5779 
  def write(self, oprot):
5780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5782 
      return
559 chandransh 5783 
    oprot.writeStructBegin('updatePassword_result')
94 ashish 5784 
    if self.success != None:
5785 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5786 
      oprot.writeBool(self.success)
5787 
      oprot.writeFieldEnd()
5788 
    if self.ucx != None:
5789 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5790 
      self.ucx.write(oprot)
5791 
      oprot.writeFieldEnd()
5792 
    oprot.writeFieldStop()
5793 
    oprot.writeStructEnd()
5794 
 
5795 
  def __repr__(self):
5796 
    L = ['%s=%r' % (key, value)
5797 
      for key, value in self.__dict__.iteritems()]
5798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5799 
 
5800 
  def __eq__(self, other):
5801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5802 
 
5803 
  def __ne__(self, other):
5804 
    return not (self == other)
5805 
 
581 rajveer 5806 
class forgotPassword_args:
5807 
  """
5808 
  Attributes:
5809 
   - email
884 rajveer 5810 
   - newPassword
581 rajveer 5811 
  """
5812 
 
5813 
  thrift_spec = (
5814 
    None, # 0
5815 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 5816 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 5817 
  )
5818 
 
884 rajveer 5819 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 5820 
    self.email = email
884 rajveer 5821 
    self.newPassword = newPassword
581 rajveer 5822 
 
5823 
  def read(self, iprot):
5824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5826 
      return
5827 
    iprot.readStructBegin()
5828 
    while True:
5829 
      (fname, ftype, fid) = iprot.readFieldBegin()
5830 
      if ftype == TType.STOP:
5831 
        break
5832 
      if fid == 1:
5833 
        if ftype == TType.STRING:
5834 
          self.email = iprot.readString();
5835 
        else:
5836 
          iprot.skip(ftype)
884 rajveer 5837 
      elif fid == 2:
5838 
        if ftype == TType.STRING:
5839 
          self.newPassword = iprot.readString();
5840 
        else:
5841 
          iprot.skip(ftype)
581 rajveer 5842 
      else:
5843 
        iprot.skip(ftype)
5844 
      iprot.readFieldEnd()
5845 
    iprot.readStructEnd()
5846 
 
5847 
  def write(self, oprot):
5848 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5849 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5850 
      return
5851 
    oprot.writeStructBegin('forgotPassword_args')
5852 
    if self.email != None:
5853 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5854 
      oprot.writeString(self.email)
5855 
      oprot.writeFieldEnd()
884 rajveer 5856 
    if self.newPassword != None:
5857 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
5858 
      oprot.writeString(self.newPassword)
5859 
      oprot.writeFieldEnd()
581 rajveer 5860 
    oprot.writeFieldStop()
5861 
    oprot.writeStructEnd()
5862 
 
5863 
  def __repr__(self):
5864 
    L = ['%s=%r' % (key, value)
5865 
      for key, value in self.__dict__.iteritems()]
5866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5867 
 
5868 
  def __eq__(self, other):
5869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5870 
 
5871 
  def __ne__(self, other):
5872 
    return not (self == other)
5873 
 
5874 
class forgotPassword_result:
5875 
  """
5876 
  Attributes:
5877 
   - success
5878 
   - ucx
5879 
  """
5880 
 
5881 
  thrift_spec = (
5882 
    (0, TType.BOOL, 'success', None, None, ), # 0
5883 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5884 
  )
5885 
 
5886 
  def __init__(self, success=None, ucx=None,):
5887 
    self.success = success
5888 
    self.ucx = ucx
5889 
 
5890 
  def read(self, iprot):
5891 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5892 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5893 
      return
5894 
    iprot.readStructBegin()
5895 
    while True:
5896 
      (fname, ftype, fid) = iprot.readFieldBegin()
5897 
      if ftype == TType.STOP:
5898 
        break
5899 
      if fid == 0:
5900 
        if ftype == TType.BOOL:
5901 
          self.success = iprot.readBool();
5902 
        else:
5903 
          iprot.skip(ftype)
5904 
      elif fid == 1:
5905 
        if ftype == TType.STRUCT:
5906 
          self.ucx = UserContextException()
5907 
          self.ucx.read(iprot)
5908 
        else:
5909 
          iprot.skip(ftype)
5910 
      else:
5911 
        iprot.skip(ftype)
5912 
      iprot.readFieldEnd()
5913 
    iprot.readStructEnd()
5914 
 
5915 
  def write(self, oprot):
5916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5918 
      return
5919 
    oprot.writeStructBegin('forgotPassword_result')
5920 
    if self.success != None:
5921 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5922 
      oprot.writeBool(self.success)
5923 
      oprot.writeFieldEnd()
5924 
    if self.ucx != None:
5925 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5926 
      self.ucx.write(oprot)
5927 
      oprot.writeFieldEnd()
5928 
    oprot.writeFieldStop()
5929 
    oprot.writeStructEnd()
5930 
 
5931 
  def __repr__(self):
5932 
    L = ['%s=%r' % (key, value)
5933 
      for key, value in self.__dict__.iteritems()]
5934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5935 
 
5936 
  def __eq__(self, other):
5937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5938 
 
5939 
  def __ne__(self, other):
5940 
    return not (self == other)
5941 
 
594 rajveer 5942 
class getAllAddressesForUser_args:
5943 
  """
5944 
  Attributes:
5945 
   - userId
5946 
  """
5947 
 
5948 
  thrift_spec = (
5949 
    None, # 0
5950 
    (1, TType.I64, 'userId', None, None, ), # 1
5951 
  )
5952 
 
5953 
  def __init__(self, userId=None,):
5954 
    self.userId = userId
5955 
 
5956 
  def read(self, iprot):
5957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5959 
      return
5960 
    iprot.readStructBegin()
5961 
    while True:
5962 
      (fname, ftype, fid) = iprot.readFieldBegin()
5963 
      if ftype == TType.STOP:
5964 
        break
5965 
      if fid == 1:
5966 
        if ftype == TType.I64:
5967 
          self.userId = iprot.readI64();
5968 
        else:
5969 
          iprot.skip(ftype)
5970 
      else:
5971 
        iprot.skip(ftype)
5972 
      iprot.readFieldEnd()
5973 
    iprot.readStructEnd()
5974 
 
5975 
  def write(self, oprot):
5976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5978 
      return
5979 
    oprot.writeStructBegin('getAllAddressesForUser_args')
5980 
    if self.userId != None:
5981 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5982 
      oprot.writeI64(self.userId)
5983 
      oprot.writeFieldEnd()
5984 
    oprot.writeFieldStop()
5985 
    oprot.writeStructEnd()
5986 
 
5987 
  def __repr__(self):
5988 
    L = ['%s=%r' % (key, value)
5989 
      for key, value in self.__dict__.iteritems()]
5990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5991 
 
5992 
  def __eq__(self, other):
5993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5994 
 
5995 
  def __ne__(self, other):
5996 
    return not (self == other)
5997 
 
5998 
class getAllAddressesForUser_result:
5999 
  """
6000 
  Attributes:
6001 
   - success
6002 
   - ucx
6003 
  """
6004 
 
6005 
  thrift_spec = (
6006 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
6007 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6008 
  )
6009 
 
6010 
  def __init__(self, success=None, ucx=None,):
6011 
    self.success = success
6012 
    self.ucx = ucx
6013 
 
6014 
  def read(self, iprot):
6015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6017 
      return
6018 
    iprot.readStructBegin()
6019 
    while True:
6020 
      (fname, ftype, fid) = iprot.readFieldBegin()
6021 
      if ftype == TType.STOP:
6022 
        break
6023 
      if fid == 0:
6024 
        if ftype == TType.LIST:
6025 
          self.success = []
772 rajveer 6026 
          (_etype31, _size28) = iprot.readListBegin()
6027 
          for _i32 in xrange(_size28):
6028 
            _elem33 = Address()
6029 
            _elem33.read(iprot)
6030 
            self.success.append(_elem33)
594 rajveer 6031 
          iprot.readListEnd()
6032 
        else:
6033 
          iprot.skip(ftype)
6034 
      elif fid == 1:
6035 
        if ftype == TType.STRUCT:
6036 
          self.ucx = UserContextException()
6037 
          self.ucx.read(iprot)
6038 
        else:
6039 
          iprot.skip(ftype)
6040 
      else:
6041 
        iprot.skip(ftype)
6042 
      iprot.readFieldEnd()
6043 
    iprot.readStructEnd()
6044 
 
6045 
  def write(self, oprot):
6046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6048 
      return
6049 
    oprot.writeStructBegin('getAllAddressesForUser_result')
6050 
    if self.success != None:
6051 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6052 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
772 rajveer 6053 
      for iter34 in self.success:
6054 
        iter34.write(oprot)
594 rajveer 6055 
      oprot.writeListEnd()
6056 
      oprot.writeFieldEnd()
6057 
    if self.ucx != None:
6058 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6059 
      self.ucx.write(oprot)
6060 
      oprot.writeFieldEnd()
6061 
    oprot.writeFieldStop()
6062 
    oprot.writeStructEnd()
6063 
 
6064 
  def __repr__(self):
6065 
    L = ['%s=%r' % (key, value)
6066 
      for key, value in self.__dict__.iteritems()]
6067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6068 
 
6069 
  def __eq__(self, other):
6070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6071 
 
6072 
  def __ne__(self, other):
6073 
    return not (self == other)
6074 
 
1894 vikas 6075 
class getAddressById_args:
6076 
  """
6077 
  Attributes:
6078 
   - addressId
6079 
  """
6080 
 
6081 
  thrift_spec = (
6082 
    None, # 0
6083 
    (1, TType.I64, 'addressId', None, None, ), # 1
6084 
  )
6085 
 
6086 
  def __init__(self, addressId=None,):
6087 
    self.addressId = addressId
6088 
 
6089 
  def read(self, iprot):
6090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6092 
      return
6093 
    iprot.readStructBegin()
6094 
    while True:
6095 
      (fname, ftype, fid) = iprot.readFieldBegin()
6096 
      if ftype == TType.STOP:
6097 
        break
6098 
      if fid == 1:
6099 
        if ftype == TType.I64:
6100 
          self.addressId = iprot.readI64();
6101 
        else:
6102 
          iprot.skip(ftype)
6103 
      else:
6104 
        iprot.skip(ftype)
6105 
      iprot.readFieldEnd()
6106 
    iprot.readStructEnd()
6107 
 
6108 
  def write(self, oprot):
6109 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6110 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6111 
      return
6112 
    oprot.writeStructBegin('getAddressById_args')
6113 
    if self.addressId != None:
6114 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
6115 
      oprot.writeI64(self.addressId)
6116 
      oprot.writeFieldEnd()
6117 
    oprot.writeFieldStop()
6118 
    oprot.writeStructEnd()
6119 
 
6120 
  def __repr__(self):
6121 
    L = ['%s=%r' % (key, value)
6122 
      for key, value in self.__dict__.iteritems()]
6123 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6124 
 
6125 
  def __eq__(self, other):
6126 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6127 
 
6128 
  def __ne__(self, other):
6129 
    return not (self == other)
6130 
 
6131 
class getAddressById_result:
6132 
  """
6133 
  Attributes:
6134 
   - success
6135 
   - ucx
6136 
  """
6137 
 
6138 
  thrift_spec = (
6139 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
6140 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6141 
  )
6142 
 
6143 
  def __init__(self, success=None, ucx=None,):
6144 
    self.success = success
6145 
    self.ucx = ucx
6146 
 
6147 
  def read(self, iprot):
6148 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6149 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6150 
      return
6151 
    iprot.readStructBegin()
6152 
    while True:
6153 
      (fname, ftype, fid) = iprot.readFieldBegin()
6154 
      if ftype == TType.STOP:
6155 
        break
6156 
      if fid == 0:
6157 
        if ftype == TType.STRUCT:
6158 
          self.success = Address()
6159 
          self.success.read(iprot)
6160 
        else:
6161 
          iprot.skip(ftype)
6162 
      elif fid == 1:
6163 
        if ftype == TType.STRUCT:
6164 
          self.ucx = UserContextException()
6165 
          self.ucx.read(iprot)
6166 
        else:
6167 
          iprot.skip(ftype)
6168 
      else:
6169 
        iprot.skip(ftype)
6170 
      iprot.readFieldEnd()
6171 
    iprot.readStructEnd()
6172 
 
6173 
  def write(self, oprot):
6174 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6175 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6176 
      return
6177 
    oprot.writeStructBegin('getAddressById_result')
6178 
    if self.success != None:
6179 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6180 
      self.success.write(oprot)
6181 
      oprot.writeFieldEnd()
6182 
    if self.ucx != None:
6183 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6184 
      self.ucx.write(oprot)
6185 
      oprot.writeFieldEnd()
6186 
    oprot.writeFieldStop()
6187 
    oprot.writeStructEnd()
6188 
 
6189 
  def __repr__(self):
6190 
    L = ['%s=%r' % (key, value)
6191 
      for key, value in self.__dict__.iteritems()]
6192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6193 
 
6194 
  def __eq__(self, other):
6195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6196 
 
6197 
  def __ne__(self, other):
6198 
    return not (self == other)
6199 
 
594 rajveer 6200 
class getDefaultAddressId_args:
6201 
  """
6202 
  Attributes:
6203 
   - userId
6204 
  """
6205 
 
6206 
  thrift_spec = (
6207 
    None, # 0
6208 
    (1, TType.I64, 'userId', None, None, ), # 1
6209 
  )
6210 
 
6211 
  def __init__(self, userId=None,):
6212 
    self.userId = userId
6213 
 
6214 
  def read(self, iprot):
6215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6217 
      return
6218 
    iprot.readStructBegin()
6219 
    while True:
6220 
      (fname, ftype, fid) = iprot.readFieldBegin()
6221 
      if ftype == TType.STOP:
6222 
        break
6223 
      if fid == 1:
6224 
        if ftype == TType.I64:
6225 
          self.userId = iprot.readI64();
6226 
        else:
6227 
          iprot.skip(ftype)
6228 
      else:
6229 
        iprot.skip(ftype)
6230 
      iprot.readFieldEnd()
6231 
    iprot.readStructEnd()
6232 
 
6233 
  def write(self, oprot):
6234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6236 
      return
6237 
    oprot.writeStructBegin('getDefaultAddressId_args')
6238 
    if self.userId != None:
6239 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6240 
      oprot.writeI64(self.userId)
6241 
      oprot.writeFieldEnd()
6242 
    oprot.writeFieldStop()
6243 
    oprot.writeStructEnd()
6244 
 
6245 
  def __repr__(self):
6246 
    L = ['%s=%r' % (key, value)
6247 
      for key, value in self.__dict__.iteritems()]
6248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6249 
 
6250 
  def __eq__(self, other):
6251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6252 
 
6253 
  def __ne__(self, other):
6254 
    return not (self == other)
6255 
 
6256 
class getDefaultAddressId_result:
6257 
  """
6258 
  Attributes:
6259 
   - success
6260 
   - ucx
6261 
  """
6262 
 
6263 
  thrift_spec = (
6264 
    (0, TType.I64, 'success', None, None, ), # 0
6265 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6266 
  )
6267 
 
6268 
  def __init__(self, success=None, ucx=None,):
6269 
    self.success = success
6270 
    self.ucx = ucx
6271 
 
6272 
  def read(self, iprot):
6273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6275 
      return
6276 
    iprot.readStructBegin()
6277 
    while True:
6278 
      (fname, ftype, fid) = iprot.readFieldBegin()
6279 
      if ftype == TType.STOP:
6280 
        break
6281 
      if fid == 0:
6282 
        if ftype == TType.I64:
6283 
          self.success = iprot.readI64();
6284 
        else:
6285 
          iprot.skip(ftype)
6286 
      elif fid == 1:
6287 
        if ftype == TType.STRUCT:
6288 
          self.ucx = UserContextException()
6289 
          self.ucx.read(iprot)
6290 
        else:
6291 
          iprot.skip(ftype)
6292 
      else:
6293 
        iprot.skip(ftype)
6294 
      iprot.readFieldEnd()
6295 
    iprot.readStructEnd()
6296 
 
6297 
  def write(self, oprot):
6298 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6299 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6300 
      return
6301 
    oprot.writeStructBegin('getDefaultAddressId_result')
6302 
    if self.success != None:
6303 
      oprot.writeFieldBegin('success', TType.I64, 0)
6304 
      oprot.writeI64(self.success)
6305 
      oprot.writeFieldEnd()
6306 
    if self.ucx != None:
6307 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6308 
      self.ucx.write(oprot)
6309 
      oprot.writeFieldEnd()
6310 
    oprot.writeFieldStop()
6311 
    oprot.writeStructEnd()
6312 
 
6313 
  def __repr__(self):
6314 
    L = ['%s=%r' % (key, value)
6315 
      for key, value in self.__dict__.iteritems()]
6316 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6317 
 
6318 
  def __eq__(self, other):
6319 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6320 
 
6321 
  def __ne__(self, other):
6322 
    return not (self == other)
6323 
 
785 rajveer 6324 
class getDefaultPincode_args:
6325 
  """
6326 
  Attributes:
6327 
   - userId
6328 
  """
6329 
 
6330 
  thrift_spec = (
6331 
    None, # 0
6332 
    (1, TType.I64, 'userId', None, None, ), # 1
6333 
  )
6334 
 
6335 
  def __init__(self, userId=None,):
6336 
    self.userId = userId
6337 
 
6338 
  def read(self, iprot):
6339 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6340 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6341 
      return
6342 
    iprot.readStructBegin()
6343 
    while True:
6344 
      (fname, ftype, fid) = iprot.readFieldBegin()
6345 
      if ftype == TType.STOP:
6346 
        break
6347 
      if fid == 1:
6348 
        if ftype == TType.I64:
6349 
          self.userId = iprot.readI64();
6350 
        else:
6351 
          iprot.skip(ftype)
6352 
      else:
6353 
        iprot.skip(ftype)
6354 
      iprot.readFieldEnd()
6355 
    iprot.readStructEnd()
6356 
 
6357 
  def write(self, oprot):
6358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6360 
      return
6361 
    oprot.writeStructBegin('getDefaultPincode_args')
6362 
    if self.userId != None:
6363 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6364 
      oprot.writeI64(self.userId)
6365 
      oprot.writeFieldEnd()
6366 
    oprot.writeFieldStop()
6367 
    oprot.writeStructEnd()
6368 
 
6369 
  def __repr__(self):
6370 
    L = ['%s=%r' % (key, value)
6371 
      for key, value in self.__dict__.iteritems()]
6372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6373 
 
6374 
  def __eq__(self, other):
6375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6376 
 
6377 
  def __ne__(self, other):
6378 
    return not (self == other)
6379 
 
6380 
class getDefaultPincode_result:
6381 
  """
6382 
  Attributes:
6383 
   - success
6384 
   - ucx
6385 
  """
6386 
 
6387 
  thrift_spec = (
6388 
    (0, TType.STRING, 'success', None, None, ), # 0
6389 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6390 
  )
6391 
 
6392 
  def __init__(self, success=None, ucx=None,):
6393 
    self.success = success
6394 
    self.ucx = ucx
6395 
 
6396 
  def read(self, iprot):
6397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6399 
      return
6400 
    iprot.readStructBegin()
6401 
    while True:
6402 
      (fname, ftype, fid) = iprot.readFieldBegin()
6403 
      if ftype == TType.STOP:
6404 
        break
6405 
      if fid == 0:
6406 
        if ftype == TType.STRING:
6407 
          self.success = iprot.readString();
6408 
        else:
6409 
          iprot.skip(ftype)
6410 
      elif fid == 1:
6411 
        if ftype == TType.STRUCT:
6412 
          self.ucx = UserContextException()
6413 
          self.ucx.read(iprot)
6414 
        else:
6415 
          iprot.skip(ftype)
6416 
      else:
6417 
        iprot.skip(ftype)
6418 
      iprot.readFieldEnd()
6419 
    iprot.readStructEnd()
6420 
 
6421 
  def write(self, oprot):
6422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6424 
      return
6425 
    oprot.writeStructBegin('getDefaultPincode_result')
6426 
    if self.success != None:
6427 
      oprot.writeFieldBegin('success', TType.STRING, 0)
6428 
      oprot.writeString(self.success)
6429 
      oprot.writeFieldEnd()
6430 
    if self.ucx != None:
6431 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6432 
      self.ucx.write(oprot)
6433 
      oprot.writeFieldEnd()
6434 
    oprot.writeFieldStop()
6435 
    oprot.writeStructEnd()
6436 
 
6437 
  def __repr__(self):
6438 
    L = ['%s=%r' % (key, value)
6439 
      for key, value in self.__dict__.iteritems()]
6440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6441 
 
6442 
  def __eq__(self, other):
6443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6444 
 
6445 
  def __ne__(self, other):
6446 
    return not (self == other)
6447 
 
1274 varun.gupt 6448 
class saveUserCommunication_args:
6449 
  """
6450 
  Attributes:
6451 
   - userId
6452 
   - replyTo
6453 
   - communicationType
6454 
   - orderId
6455 
   - airwaybillNo
6456 
   - productName
6457 
   - subject
6458 
   - message
6459 
  """
6460 
 
6461 
  thrift_spec = (
6462 
    None, # 0
6463 
    (1, TType.I64, 'userId', None, None, ), # 1
6464 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
6465 
    (3, TType.I64, 'communicationType', None, None, ), # 3
6466 
    (4, TType.I64, 'orderId', None, None, ), # 4
6467 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
6468 
    (6, TType.STRING, 'productName', None, None, ), # 6
6469 
    (7, TType.STRING, 'subject', None, None, ), # 7
6470 
    (8, TType.STRING, 'message', None, None, ), # 8
6471 
  )
6472 
 
6473 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
6474 
    self.userId = userId
6475 
    self.replyTo = replyTo
6476 
    self.communicationType = communicationType
6477 
    self.orderId = orderId
6478 
    self.airwaybillNo = airwaybillNo
6479 
    self.productName = productName
6480 
    self.subject = subject
6481 
    self.message = message
6482 
 
6483 
  def read(self, iprot):
6484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6486 
      return
6487 
    iprot.readStructBegin()
6488 
    while True:
6489 
      (fname, ftype, fid) = iprot.readFieldBegin()
6490 
      if ftype == TType.STOP:
6491 
        break
6492 
      if fid == 1:
6493 
        if ftype == TType.I64:
6494 
          self.userId = iprot.readI64();
6495 
        else:
6496 
          iprot.skip(ftype)
6497 
      elif fid == 2:
6498 
        if ftype == TType.STRING:
6499 
          self.replyTo = iprot.readString();
6500 
        else:
6501 
          iprot.skip(ftype)
6502 
      elif fid == 3:
6503 
        if ftype == TType.I64:
6504 
          self.communicationType = iprot.readI64();
6505 
        else:
6506 
          iprot.skip(ftype)
6507 
      elif fid == 4:
6508 
        if ftype == TType.I64:
6509 
          self.orderId = iprot.readI64();
6510 
        else:
6511 
          iprot.skip(ftype)
6512 
      elif fid == 5:
6513 
        if ftype == TType.STRING:
6514 
          self.airwaybillNo = iprot.readString();
6515 
        else:
6516 
          iprot.skip(ftype)
6517 
      elif fid == 6:
6518 
        if ftype == TType.STRING:
6519 
          self.productName = iprot.readString();
6520 
        else:
6521 
          iprot.skip(ftype)
6522 
      elif fid == 7:
6523 
        if ftype == TType.STRING:
6524 
          self.subject = iprot.readString();
6525 
        else:
6526 
          iprot.skip(ftype)
6527 
      elif fid == 8:
6528 
        if ftype == TType.STRING:
6529 
          self.message = iprot.readString();
6530 
        else:
6531 
          iprot.skip(ftype)
6532 
      else:
6533 
        iprot.skip(ftype)
6534 
      iprot.readFieldEnd()
6535 
    iprot.readStructEnd()
6536 
 
6537 
  def write(self, oprot):
6538 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6539 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6540 
      return
6541 
    oprot.writeStructBegin('saveUserCommunication_args')
6542 
    if self.userId != None:
6543 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6544 
      oprot.writeI64(self.userId)
6545 
      oprot.writeFieldEnd()
6546 
    if self.replyTo != None:
6547 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
6548 
      oprot.writeString(self.replyTo)
6549 
      oprot.writeFieldEnd()
6550 
    if self.communicationType != None:
6551 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
6552 
      oprot.writeI64(self.communicationType)
6553 
      oprot.writeFieldEnd()
6554 
    if self.orderId != None:
6555 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
6556 
      oprot.writeI64(self.orderId)
6557 
      oprot.writeFieldEnd()
6558 
    if self.airwaybillNo != None:
6559 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
6560 
      oprot.writeString(self.airwaybillNo)
6561 
      oprot.writeFieldEnd()
6562 
    if self.productName != None:
6563 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
6564 
      oprot.writeString(self.productName)
6565 
      oprot.writeFieldEnd()
6566 
    if self.subject != None:
6567 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
6568 
      oprot.writeString(self.subject)
6569 
      oprot.writeFieldEnd()
6570 
    if self.message != None:
6571 
      oprot.writeFieldBegin('message', TType.STRING, 8)
6572 
      oprot.writeString(self.message)
6573 
      oprot.writeFieldEnd()
6574 
    oprot.writeFieldStop()
6575 
    oprot.writeStructEnd()
6576 
 
6577 
  def __repr__(self):
6578 
    L = ['%s=%r' % (key, value)
6579 
      for key, value in self.__dict__.iteritems()]
6580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6581 
 
6582 
  def __eq__(self, other):
6583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6584 
 
6585 
  def __ne__(self, other):
6586 
    return not (self == other)
6587 
 
6588 
class saveUserCommunication_result:
6589 
  """
6590 
  Attributes:
6591 
   - success
6592 
   - ucx
6593 
  """
6594 
 
6595 
  thrift_spec = (
6596 
    (0, TType.BOOL, 'success', None, None, ), # 0
6597 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6598 
  )
6599 
 
6600 
  def __init__(self, success=None, ucx=None,):
6601 
    self.success = success
6602 
    self.ucx = ucx
6603 
 
6604 
  def read(self, iprot):
6605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6607 
      return
6608 
    iprot.readStructBegin()
6609 
    while True:
6610 
      (fname, ftype, fid) = iprot.readFieldBegin()
6611 
      if ftype == TType.STOP:
6612 
        break
6613 
      if fid == 0:
6614 
        if ftype == TType.BOOL:
6615 
          self.success = iprot.readBool();
6616 
        else:
6617 
          iprot.skip(ftype)
6618 
      elif fid == 1:
6619 
        if ftype == TType.STRUCT:
6620 
          self.ucx = UserCommunicationException()
6621 
          self.ucx.read(iprot)
6622 
        else:
6623 
          iprot.skip(ftype)
6624 
      else:
6625 
        iprot.skip(ftype)
6626 
      iprot.readFieldEnd()
6627 
    iprot.readStructEnd()
6628 
 
6629 
  def write(self, oprot):
6630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6632 
      return
6633 
    oprot.writeStructBegin('saveUserCommunication_result')
6634 
    if self.success != None:
6635 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6636 
      oprot.writeBool(self.success)
6637 
      oprot.writeFieldEnd()
6638 
    if self.ucx != None:
6639 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6640 
      self.ucx.write(oprot)
6641 
      oprot.writeFieldEnd()
6642 
    oprot.writeFieldStop()
6643 
    oprot.writeStructEnd()
6644 
 
6645 
  def __repr__(self):
6646 
    L = ['%s=%r' % (key, value)
6647 
      for key, value in self.__dict__.iteritems()]
6648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6649 
 
6650 
  def __eq__(self, other):
6651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6652 
 
6653 
  def __ne__(self, other):
6654 
    return not (self == other)
6655 
 
1590 varun.gupt 6656 
class getUserCommunicationById_args:
6657 
  """
6658 
  Attributes:
6659 
   - id
6660 
  """
6661 
 
6662 
  thrift_spec = (
6663 
    None, # 0
6664 
    (1, TType.I64, 'id', None, None, ), # 1
6665 
  )
6666 
 
6667 
  def __init__(self, id=None,):
6668 
    self.id = id
6669 
 
6670 
  def read(self, iprot):
6671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6673 
      return
6674 
    iprot.readStructBegin()
6675 
    while True:
6676 
      (fname, ftype, fid) = iprot.readFieldBegin()
6677 
      if ftype == TType.STOP:
6678 
        break
6679 
      if fid == 1:
6680 
        if ftype == TType.I64:
6681 
          self.id = iprot.readI64();
6682 
        else:
6683 
          iprot.skip(ftype)
6684 
      else:
6685 
        iprot.skip(ftype)
6686 
      iprot.readFieldEnd()
6687 
    iprot.readStructEnd()
6688 
 
6689 
  def write(self, oprot):
6690 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6691 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6692 
      return
6693 
    oprot.writeStructBegin('getUserCommunicationById_args')
6694 
    if self.id != None:
6695 
      oprot.writeFieldBegin('id', TType.I64, 1)
6696 
      oprot.writeI64(self.id)
6697 
      oprot.writeFieldEnd()
6698 
    oprot.writeFieldStop()
6699 
    oprot.writeStructEnd()
6700 
 
6701 
  def __repr__(self):
6702 
    L = ['%s=%r' % (key, value)
6703 
      for key, value in self.__dict__.iteritems()]
6704 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6705 
 
6706 
  def __eq__(self, other):
6707 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6708 
 
6709 
  def __ne__(self, other):
6710 
    return not (self == other)
6711 
 
6712 
class getUserCommunicationById_result:
6713 
  """
6714 
  Attributes:
6715 
   - success
6716 
   - ucx
6717 
  """
6718 
 
6719 
  thrift_spec = (
6720 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
6721 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6722 
  )
6723 
 
6724 
  def __init__(self, success=None, ucx=None,):
6725 
    self.success = success
6726 
    self.ucx = ucx
6727 
 
6728 
  def read(self, iprot):
6729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6731 
      return
6732 
    iprot.readStructBegin()
6733 
    while True:
6734 
      (fname, ftype, fid) = iprot.readFieldBegin()
6735 
      if ftype == TType.STOP:
6736 
        break
6737 
      if fid == 0:
6738 
        if ftype == TType.STRUCT:
6739 
          self.success = UserCommunication()
6740 
          self.success.read(iprot)
6741 
        else:
6742 
          iprot.skip(ftype)
6743 
      elif fid == 1:
6744 
        if ftype == TType.STRUCT:
6745 
          self.ucx = UserCommunicationException()
6746 
          self.ucx.read(iprot)
6747 
        else:
6748 
          iprot.skip(ftype)
6749 
      else:
6750 
        iprot.skip(ftype)
6751 
      iprot.readFieldEnd()
6752 
    iprot.readStructEnd()
6753 
 
6754 
  def write(self, oprot):
6755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6757 
      return
6758 
    oprot.writeStructBegin('getUserCommunicationById_result')
6759 
    if self.success != None:
6760 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6761 
      self.success.write(oprot)
6762 
      oprot.writeFieldEnd()
6763 
    if self.ucx != None:
6764 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6765 
      self.ucx.write(oprot)
6766 
      oprot.writeFieldEnd()
6767 
    oprot.writeFieldStop()
6768 
    oprot.writeStructEnd()
6769 
 
6770 
  def __repr__(self):
6771 
    L = ['%s=%r' % (key, value)
6772 
      for key, value in self.__dict__.iteritems()]
6773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6774 
 
6775 
  def __eq__(self, other):
6776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6777 
 
6778 
  def __ne__(self, other):
6779 
    return not (self == other)
6780 
 
6781 
class getUserCommunicationByUser_args:
6782 
  """
6783 
  Attributes:
6784 
   - userId
6785 
  """
6786 
 
6787 
  thrift_spec = (
6788 
    None, # 0
6789 
    (1, TType.I64, 'userId', None, None, ), # 1
6790 
  )
6791 
 
6792 
  def __init__(self, userId=None,):
6793 
    self.userId = userId
6794 
 
6795 
  def read(self, iprot):
6796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6798 
      return
6799 
    iprot.readStructBegin()
6800 
    while True:
6801 
      (fname, ftype, fid) = iprot.readFieldBegin()
6802 
      if ftype == TType.STOP:
6803 
        break
6804 
      if fid == 1:
6805 
        if ftype == TType.I64:
6806 
          self.userId = iprot.readI64();
6807 
        else:
6808 
          iprot.skip(ftype)
6809 
      else:
6810 
        iprot.skip(ftype)
6811 
      iprot.readFieldEnd()
6812 
    iprot.readStructEnd()
6813 
 
6814 
  def write(self, oprot):
6815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6817 
      return
6818 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
6819 
    if self.userId != None:
6820 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6821 
      oprot.writeI64(self.userId)
6822 
      oprot.writeFieldEnd()
6823 
    oprot.writeFieldStop()
6824 
    oprot.writeStructEnd()
6825 
 
6826 
  def __repr__(self):
6827 
    L = ['%s=%r' % (key, value)
6828 
      for key, value in self.__dict__.iteritems()]
6829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6830 
 
6831 
  def __eq__(self, other):
6832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6833 
 
6834 
  def __ne__(self, other):
6835 
    return not (self == other)
6836 
 
6837 
class getUserCommunicationByUser_result:
6838 
  """
6839 
  Attributes:
6840 
   - success
6841 
   - ucx
6842 
  """
6843 
 
6844 
  thrift_spec = (
6845 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
6846 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6847 
  )
6848 
 
6849 
  def __init__(self, success=None, ucx=None,):
6850 
    self.success = success
6851 
    self.ucx = ucx
6852 
 
6853 
  def read(self, iprot):
6854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6856 
      return
6857 
    iprot.readStructBegin()
6858 
    while True:
6859 
      (fname, ftype, fid) = iprot.readFieldBegin()
6860 
      if ftype == TType.STOP:
6861 
        break
6862 
      if fid == 0:
6863 
        if ftype == TType.LIST:
6864 
          self.success = []
6865 
          (_etype38, _size35) = iprot.readListBegin()
6866 
          for _i39 in xrange(_size35):
6867 
            _elem40 = UserCommunication()
6868 
            _elem40.read(iprot)
6869 
            self.success.append(_elem40)
6870 
          iprot.readListEnd()
6871 
        else:
6872 
          iprot.skip(ftype)
6873 
      elif fid == 1:
6874 
        if ftype == TType.STRUCT:
6875 
          self.ucx = UserCommunicationException()
6876 
          self.ucx.read(iprot)
6877 
        else:
6878 
          iprot.skip(ftype)
6879 
      else:
6880 
        iprot.skip(ftype)
6881 
      iprot.readFieldEnd()
6882 
    iprot.readStructEnd()
6883 
 
6884 
  def write(self, oprot):
6885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6887 
      return
6888 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
6889 
    if self.success != None:
6890 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6891 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
6892 
      for iter41 in self.success:
6893 
        iter41.write(oprot)
6894 
      oprot.writeListEnd()
6895 
      oprot.writeFieldEnd()
6896 
    if self.ucx != None:
6897 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6898 
      self.ucx.write(oprot)
6899 
      oprot.writeFieldEnd()
6900 
    oprot.writeFieldStop()
6901 
    oprot.writeStructEnd()
6902 
 
6903 
  def __repr__(self):
6904 
    L = ['%s=%r' % (key, value)
6905 
      for key, value in self.__dict__.iteritems()]
6906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6907 
 
6908 
  def __eq__(self, other):
6909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6910 
 
6911 
  def __ne__(self, other):
6912 
    return not (self == other)
6913 
 
6914 
class getAllUserCommunications_args:
6915 
 
6916 
  thrift_spec = (
6917 
  )
6918 
 
6919 
  def read(self, iprot):
6920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6922 
      return
6923 
    iprot.readStructBegin()
6924 
    while True:
6925 
      (fname, ftype, fid) = iprot.readFieldBegin()
6926 
      if ftype == TType.STOP:
6927 
        break
6928 
      else:
6929 
        iprot.skip(ftype)
6930 
      iprot.readFieldEnd()
6931 
    iprot.readStructEnd()
6932 
 
6933 
  def write(self, oprot):
6934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6936 
      return
6937 
    oprot.writeStructBegin('getAllUserCommunications_args')
6938 
    oprot.writeFieldStop()
6939 
    oprot.writeStructEnd()
6940 
 
6941 
  def __repr__(self):
6942 
    L = ['%s=%r' % (key, value)
6943 
      for key, value in self.__dict__.iteritems()]
6944 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6945 
 
6946 
  def __eq__(self, other):
6947 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6948 
 
6949 
  def __ne__(self, other):
6950 
    return not (self == other)
6951 
 
6952 
class getAllUserCommunications_result:
6953 
  """
6954 
  Attributes:
6955 
   - success
6956 
   - ucx
6957 
  """
6958 
 
6959 
  thrift_spec = (
6960 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
6961 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6962 
  )
6963 
 
6964 
  def __init__(self, success=None, ucx=None,):
6965 
    self.success = success
6966 
    self.ucx = ucx
6967 
 
6968 
  def read(self, iprot):
6969 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6970 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6971 
      return
6972 
    iprot.readStructBegin()
6973 
    while True:
6974 
      (fname, ftype, fid) = iprot.readFieldBegin()
6975 
      if ftype == TType.STOP:
6976 
        break
6977 
      if fid == 0:
6978 
        if ftype == TType.LIST:
6979 
          self.success = []
6980 
          (_etype45, _size42) = iprot.readListBegin()
6981 
          for _i46 in xrange(_size42):
6982 
            _elem47 = UserCommunication()
6983 
            _elem47.read(iprot)
6984 
            self.success.append(_elem47)
6985 
          iprot.readListEnd()
6986 
        else:
6987 
          iprot.skip(ftype)
6988 
      elif fid == 1:
6989 
        if ftype == TType.STRUCT:
6990 
          self.ucx = UserCommunicationException()
6991 
          self.ucx.read(iprot)
6992 
        else:
6993 
          iprot.skip(ftype)
6994 
      else:
6995 
        iprot.skip(ftype)
6996 
      iprot.readFieldEnd()
6997 
    iprot.readStructEnd()
6998 
 
6999 
  def write(self, oprot):
7000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7002 
      return
7003 
    oprot.writeStructBegin('getAllUserCommunications_result')
7004 
    if self.success != None:
7005 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7006 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7007 
      for iter48 in self.success:
7008 
        iter48.write(oprot)
7009 
      oprot.writeListEnd()
7010 
      oprot.writeFieldEnd()
7011 
    if self.ucx != None:
7012 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7013 
      self.ucx.write(oprot)
7014 
      oprot.writeFieldEnd()
7015 
    oprot.writeFieldStop()
7016 
    oprot.writeStructEnd()
7017 
 
7018 
  def __repr__(self):
7019 
    L = ['%s=%r' % (key, value)
7020 
      for key, value in self.__dict__.iteritems()]
7021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7022 
 
7023 
  def __eq__(self, other):
7024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7025 
 
7026 
  def __ne__(self, other):
7027 
    return not (self == other)
7028 
 
1845 vikas 7029 
class createMasterAffiliate_args:
7030 
  """
7031 
  Attributes:
7032 
   - name
1859 vikas 7033 
   - addedOn
1845 vikas 7034 
  """
7035 
 
7036 
  thrift_spec = (
7037 
    None, # 0
7038 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 7039 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 7040 
  )
7041 
 
1859 vikas 7042 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 7043 
    self.name = name
1859 vikas 7044 
    self.addedOn = addedOn
1845 vikas 7045 
 
7046 
  def read(self, iprot):
7047 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7048 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7049 
      return
7050 
    iprot.readStructBegin()
7051 
    while True:
7052 
      (fname, ftype, fid) = iprot.readFieldBegin()
7053 
      if ftype == TType.STOP:
7054 
        break
7055 
      if fid == 1:
7056 
        if ftype == TType.STRING:
7057 
          self.name = iprot.readString();
7058 
        else:
7059 
          iprot.skip(ftype)
1859 vikas 7060 
      elif fid == 2:
7061 
        if ftype == TType.I64:
7062 
          self.addedOn = iprot.readI64();
7063 
        else:
7064 
          iprot.skip(ftype)
1845 vikas 7065 
      else:
7066 
        iprot.skip(ftype)
7067 
      iprot.readFieldEnd()
7068 
    iprot.readStructEnd()
7069 
 
7070 
  def write(self, oprot):
7071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7073 
      return
7074 
    oprot.writeStructBegin('createMasterAffiliate_args')
7075 
    if self.name != None:
7076 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7077 
      oprot.writeString(self.name)
7078 
      oprot.writeFieldEnd()
1859 vikas 7079 
    if self.addedOn != None:
7080 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
7081 
      oprot.writeI64(self.addedOn)
7082 
      oprot.writeFieldEnd()
1845 vikas 7083 
    oprot.writeFieldStop()
7084 
    oprot.writeStructEnd()
7085 
 
7086 
  def __repr__(self):
7087 
    L = ['%s=%r' % (key, value)
7088 
      for key, value in self.__dict__.iteritems()]
7089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7090 
 
7091 
  def __eq__(self, other):
7092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7093 
 
7094 
  def __ne__(self, other):
7095 
    return not (self == other)
7096 
 
7097 
class createMasterAffiliate_result:
7098 
  """
7099 
  Attributes:
7100 
   - success
7101 
   - utx
7102 
  """
7103 
 
7104 
  thrift_spec = (
7105 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
7106 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7107 
  )
7108 
 
7109 
  def __init__(self, success=None, utx=None,):
7110 
    self.success = success
7111 
    self.utx = utx
7112 
 
7113 
  def read(self, iprot):
7114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7116 
      return
7117 
    iprot.readStructBegin()
7118 
    while True:
7119 
      (fname, ftype, fid) = iprot.readFieldBegin()
7120 
      if ftype == TType.STOP:
7121 
        break
7122 
      if fid == 0:
7123 
        if ftype == TType.STRUCT:
7124 
          self.success = MasterAffiliate()
7125 
          self.success.read(iprot)
7126 
        else:
7127 
          iprot.skip(ftype)
7128 
      elif fid == 1:
7129 
        if ftype == TType.STRUCT:
7130 
          self.utx = UserTrackerException()
7131 
          self.utx.read(iprot)
7132 
        else:
7133 
          iprot.skip(ftype)
7134 
      else:
7135 
        iprot.skip(ftype)
7136 
      iprot.readFieldEnd()
7137 
    iprot.readStructEnd()
7138 
 
7139 
  def write(self, oprot):
7140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7142 
      return
7143 
    oprot.writeStructBegin('createMasterAffiliate_result')
7144 
    if self.success != None:
7145 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7146 
      self.success.write(oprot)
7147 
      oprot.writeFieldEnd()
7148 
    if self.utx != None:
7149 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7150 
      self.utx.write(oprot)
7151 
      oprot.writeFieldEnd()
7152 
    oprot.writeFieldStop()
7153 
    oprot.writeStructEnd()
7154 
 
7155 
  def __repr__(self):
7156 
    L = ['%s=%r' % (key, value)
7157 
      for key, value in self.__dict__.iteritems()]
7158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7159 
 
7160 
  def __eq__(self, other):
7161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7162 
 
7163 
  def __ne__(self, other):
7164 
    return not (self == other)
7165 
 
1899 vikas 7166 
class getAllMasterAffiliates_args:
7167 
 
7168 
  thrift_spec = (
7169 
  )
7170 
 
7171 
  def read(self, iprot):
7172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7174 
      return
7175 
    iprot.readStructBegin()
7176 
    while True:
7177 
      (fname, ftype, fid) = iprot.readFieldBegin()
7178 
      if ftype == TType.STOP:
7179 
        break
7180 
      else:
7181 
        iprot.skip(ftype)
7182 
      iprot.readFieldEnd()
7183 
    iprot.readStructEnd()
7184 
 
7185 
  def write(self, oprot):
7186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7188 
      return
7189 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
7190 
    oprot.writeFieldStop()
7191 
    oprot.writeStructEnd()
7192 
 
7193 
  def __repr__(self):
7194 
    L = ['%s=%r' % (key, value)
7195 
      for key, value in self.__dict__.iteritems()]
7196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7197 
 
7198 
  def __eq__(self, other):
7199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7200 
 
7201 
  def __ne__(self, other):
7202 
    return not (self == other)
7203 
 
7204 
class getAllMasterAffiliates_result:
7205 
  """
7206 
  Attributes:
7207 
   - success
7208 
   - utx
7209 
  """
7210 
 
7211 
  thrift_spec = (
7212 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
7213 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7214 
  )
7215 
 
7216 
  def __init__(self, success=None, utx=None,):
7217 
    self.success = success
7218 
    self.utx = utx
7219 
 
7220 
  def read(self, iprot):
7221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7223 
      return
7224 
    iprot.readStructBegin()
7225 
    while True:
7226 
      (fname, ftype, fid) = iprot.readFieldBegin()
7227 
      if ftype == TType.STOP:
7228 
        break
7229 
      if fid == 0:
7230 
        if ftype == TType.LIST:
7231 
          self.success = []
7232 
          (_etype52, _size49) = iprot.readListBegin()
7233 
          for _i53 in xrange(_size49):
7234 
            _elem54 = MasterAffiliate()
7235 
            _elem54.read(iprot)
7236 
            self.success.append(_elem54)
7237 
          iprot.readListEnd()
7238 
        else:
7239 
          iprot.skip(ftype)
7240 
      elif fid == 1:
7241 
        if ftype == TType.STRUCT:
7242 
          self.utx = UserTrackerException()
7243 
          self.utx.read(iprot)
7244 
        else:
7245 
          iprot.skip(ftype)
7246 
      else:
7247 
        iprot.skip(ftype)
7248 
      iprot.readFieldEnd()
7249 
    iprot.readStructEnd()
7250 
 
7251 
  def write(self, oprot):
7252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7254 
      return
7255 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
7256 
    if self.success != None:
7257 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7258 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
7259 
      for iter55 in self.success:
7260 
        iter55.write(oprot)
7261 
      oprot.writeListEnd()
7262 
      oprot.writeFieldEnd()
7263 
    if self.utx != None:
7264 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7265 
      self.utx.write(oprot)
7266 
      oprot.writeFieldEnd()
7267 
    oprot.writeFieldStop()
7268 
    oprot.writeStructEnd()
7269 
 
7270 
  def __repr__(self):
7271 
    L = ['%s=%r' % (key, value)
7272 
      for key, value in self.__dict__.iteritems()]
7273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7274 
 
7275 
  def __eq__(self, other):
7276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7277 
 
7278 
  def __ne__(self, other):
7279 
    return not (self == other)
7280 
 
1845 vikas 7281 
class getMasterAffiliateById_args:
7282 
  """
7283 
  Attributes:
7284 
   - id
7285 
  """
7286 
 
7287 
  thrift_spec = (
7288 
    None, # 0
7289 
    (1, TType.I64, 'id', None, None, ), # 1
7290 
  )
7291 
 
7292 
  def __init__(self, id=None,):
7293 
    self.id = id
7294 
 
7295 
  def read(self, iprot):
7296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7298 
      return
7299 
    iprot.readStructBegin()
7300 
    while True:
7301 
      (fname, ftype, fid) = iprot.readFieldBegin()
7302 
      if ftype == TType.STOP:
7303 
        break
7304 
      if fid == 1:
7305 
        if ftype == TType.I64:
7306 
          self.id = iprot.readI64();
7307 
        else:
7308 
          iprot.skip(ftype)
7309 
      else:
7310 
        iprot.skip(ftype)
7311 
      iprot.readFieldEnd()
7312 
    iprot.readStructEnd()
7313 
 
7314 
  def write(self, oprot):
7315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7317 
      return
7318 
    oprot.writeStructBegin('getMasterAffiliateById_args')
7319 
    if self.id != None:
7320 
      oprot.writeFieldBegin('id', TType.I64, 1)
7321 
      oprot.writeI64(self.id)
7322 
      oprot.writeFieldEnd()
7323 
    oprot.writeFieldStop()
7324 
    oprot.writeStructEnd()
7325 
 
7326 
  def __repr__(self):
7327 
    L = ['%s=%r' % (key, value)
7328 
      for key, value in self.__dict__.iteritems()]
7329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7330 
 
7331 
  def __eq__(self, other):
7332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7333 
 
7334 
  def __ne__(self, other):
7335 
    return not (self == other)
7336 
 
7337 
class getMasterAffiliateById_result:
7338 
  """
7339 
  Attributes:
7340 
   - success
7341 
   - utx
7342 
  """
7343 
 
7344 
  thrift_spec = (
7345 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
7346 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7347 
  )
7348 
 
7349 
  def __init__(self, success=None, utx=None,):
7350 
    self.success = success
7351 
    self.utx = utx
7352 
 
7353 
  def read(self, iprot):
7354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7356 
      return
7357 
    iprot.readStructBegin()
7358 
    while True:
7359 
      (fname, ftype, fid) = iprot.readFieldBegin()
7360 
      if ftype == TType.STOP:
7361 
        break
7362 
      if fid == 0:
7363 
        if ftype == TType.STRUCT:
7364 
          self.success = MasterAffiliate()
7365 
          self.success.read(iprot)
7366 
        else:
7367 
          iprot.skip(ftype)
7368 
      elif fid == 1:
7369 
        if ftype == TType.STRUCT:
7370 
          self.utx = UserTrackerException()
7371 
          self.utx.read(iprot)
7372 
        else:
7373 
          iprot.skip(ftype)
7374 
      else:
7375 
        iprot.skip(ftype)
7376 
      iprot.readFieldEnd()
7377 
    iprot.readStructEnd()
7378 
 
7379 
  def write(self, oprot):
7380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7382 
      return
7383 
    oprot.writeStructBegin('getMasterAffiliateById_result')
7384 
    if self.success != None:
7385 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7386 
      self.success.write(oprot)
7387 
      oprot.writeFieldEnd()
7388 
    if self.utx != None:
7389 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7390 
      self.utx.write(oprot)
7391 
      oprot.writeFieldEnd()
7392 
    oprot.writeFieldStop()
7393 
    oprot.writeStructEnd()
7394 
 
7395 
  def __repr__(self):
7396 
    L = ['%s=%r' % (key, value)
7397 
      for key, value in self.__dict__.iteritems()]
7398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7399 
 
7400 
  def __eq__(self, other):
7401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7402 
 
7403 
  def __ne__(self, other):
7404 
    return not (self == other)
7405 
 
7406 
class getMasterAffiliateByName_args:
7407 
  """
7408 
  Attributes:
7409 
   - name
7410 
  """
7411 
 
7412 
  thrift_spec = (
7413 
    None, # 0
7414 
    (1, TType.STRING, 'name', None, None, ), # 1
7415 
  )
7416 
 
7417 
  def __init__(self, name=None,):
7418 
    self.name = name
7419 
 
7420 
  def read(self, iprot):
7421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7423 
      return
7424 
    iprot.readStructBegin()
7425 
    while True:
7426 
      (fname, ftype, fid) = iprot.readFieldBegin()
7427 
      if ftype == TType.STOP:
7428 
        break
7429 
      if fid == 1:
7430 
        if ftype == TType.STRING:
7431 
          self.name = iprot.readString();
7432 
        else:
7433 
          iprot.skip(ftype)
7434 
      else:
7435 
        iprot.skip(ftype)
7436 
      iprot.readFieldEnd()
7437 
    iprot.readStructEnd()
7438 
 
7439 
  def write(self, oprot):
7440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7442 
      return
7443 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
7444 
    if self.name != None:
7445 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7446 
      oprot.writeString(self.name)
7447 
      oprot.writeFieldEnd()
7448 
    oprot.writeFieldStop()
7449 
    oprot.writeStructEnd()
7450 
 
7451 
  def __repr__(self):
7452 
    L = ['%s=%r' % (key, value)
7453 
      for key, value in self.__dict__.iteritems()]
7454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7455 
 
7456 
  def __eq__(self, other):
7457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7458 
 
7459 
  def __ne__(self, other):
7460 
    return not (self == other)
7461 
 
7462 
class getMasterAffiliateByName_result:
7463 
  """
7464 
  Attributes:
7465 
   - success
7466 
   - utx
7467 
  """
7468 
 
7469 
  thrift_spec = (
7470 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
7471 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7472 
  )
7473 
 
7474 
  def __init__(self, success=None, utx=None,):
7475 
    self.success = success
7476 
    self.utx = utx
7477 
 
7478 
  def read(self, iprot):
7479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7481 
      return
7482 
    iprot.readStructBegin()
7483 
    while True:
7484 
      (fname, ftype, fid) = iprot.readFieldBegin()
7485 
      if ftype == TType.STOP:
7486 
        break
7487 
      if fid == 0:
7488 
        if ftype == TType.STRUCT:
7489 
          self.success = MasterAffiliate()
7490 
          self.success.read(iprot)
7491 
        else:
7492 
          iprot.skip(ftype)
7493 
      elif fid == 1:
7494 
        if ftype == TType.STRUCT:
7495 
          self.utx = UserTrackerException()
7496 
          self.utx.read(iprot)
7497 
        else:
7498 
          iprot.skip(ftype)
7499 
      else:
7500 
        iprot.skip(ftype)
7501 
      iprot.readFieldEnd()
7502 
    iprot.readStructEnd()
7503 
 
7504 
  def write(self, oprot):
7505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7507 
      return
7508 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
7509 
    if self.success != None:
7510 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7511 
      self.success.write(oprot)
7512 
      oprot.writeFieldEnd()
7513 
    if self.utx != None:
7514 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7515 
      self.utx.write(oprot)
7516 
      oprot.writeFieldEnd()
7517 
    oprot.writeFieldStop()
7518 
    oprot.writeStructEnd()
7519 
 
7520 
  def __repr__(self):
7521 
    L = ['%s=%r' % (key, value)
7522 
      for key, value in self.__dict__.iteritems()]
7523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7524 
 
7525 
  def __eq__(self, other):
7526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7527 
 
7528 
  def __ne__(self, other):
7529 
    return not (self == other)
7530 
 
7531 
class createAffiliate_args:
7532 
  """
7533 
  Attributes:
7534 
   - name
7535 
   - url
7536 
   - masterAffiliateId
1859 vikas 7537 
   - addedOn
1845 vikas 7538 
  """
7539 
 
7540 
  thrift_spec = (
7541 
    None, # 0
7542 
    (1, TType.STRING, 'name', None, None, ), # 1
7543 
    (2, TType.STRING, 'url', None, None, ), # 2
7544 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 7545 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 7546 
  )
7547 
 
1859 vikas 7548 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 7549 
    self.name = name
7550 
    self.url = url
7551 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 7552 
    self.addedOn = addedOn
1845 vikas 7553 
 
7554 
  def read(self, iprot):
7555 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7556 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7557 
      return
7558 
    iprot.readStructBegin()
7559 
    while True:
7560 
      (fname, ftype, fid) = iprot.readFieldBegin()
7561 
      if ftype == TType.STOP:
7562 
        break
7563 
      if fid == 1:
7564 
        if ftype == TType.STRING:
7565 
          self.name = iprot.readString();
7566 
        else:
7567 
          iprot.skip(ftype)
7568 
      elif fid == 2:
7569 
        if ftype == TType.STRING:
7570 
          self.url = iprot.readString();
7571 
        else:
7572 
          iprot.skip(ftype)
7573 
      elif fid == 3:
7574 
        if ftype == TType.I64:
7575 
          self.masterAffiliateId = iprot.readI64();
7576 
        else:
7577 
          iprot.skip(ftype)
1859 vikas 7578 
      elif fid == 4:
7579 
        if ftype == TType.I64:
7580 
          self.addedOn = iprot.readI64();
7581 
        else:
7582 
          iprot.skip(ftype)
1845 vikas 7583 
      else:
7584 
        iprot.skip(ftype)
7585 
      iprot.readFieldEnd()
7586 
    iprot.readStructEnd()
7587 
 
7588 
  def write(self, oprot):
7589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7591 
      return
7592 
    oprot.writeStructBegin('createAffiliate_args')
7593 
    if self.name != None:
7594 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7595 
      oprot.writeString(self.name)
7596 
      oprot.writeFieldEnd()
7597 
    if self.url != None:
7598 
      oprot.writeFieldBegin('url', TType.STRING, 2)
7599 
      oprot.writeString(self.url)
7600 
      oprot.writeFieldEnd()
7601 
    if self.masterAffiliateId != None:
7602 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
7603 
      oprot.writeI64(self.masterAffiliateId)
7604 
      oprot.writeFieldEnd()
1859 vikas 7605 
    if self.addedOn != None:
7606 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
7607 
      oprot.writeI64(self.addedOn)
7608 
      oprot.writeFieldEnd()
1845 vikas 7609 
    oprot.writeFieldStop()
7610 
    oprot.writeStructEnd()
7611 
 
7612 
  def __repr__(self):
7613 
    L = ['%s=%r' % (key, value)
7614 
      for key, value in self.__dict__.iteritems()]
7615 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7616 
 
7617 
  def __eq__(self, other):
7618 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7619 
 
7620 
  def __ne__(self, other):
7621 
    return not (self == other)
7622 
 
7623 
class createAffiliate_result:
7624 
  """
7625 
  Attributes:
7626 
   - success
7627 
   - utx
7628 
  """
7629 
 
7630 
  thrift_spec = (
7631 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
7632 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7633 
  )
7634 
 
7635 
  def __init__(self, success=None, utx=None,):
7636 
    self.success = success
7637 
    self.utx = utx
7638 
 
7639 
  def read(self, iprot):
7640 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7641 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7642 
      return
7643 
    iprot.readStructBegin()
7644 
    while True:
7645 
      (fname, ftype, fid) = iprot.readFieldBegin()
7646 
      if ftype == TType.STOP:
7647 
        break
7648 
      if fid == 0:
7649 
        if ftype == TType.STRUCT:
7650 
          self.success = Affiliate()
7651 
          self.success.read(iprot)
7652 
        else:
7653 
          iprot.skip(ftype)
7654 
      elif fid == 1:
7655 
        if ftype == TType.STRUCT:
7656 
          self.utx = UserTrackerException()
7657 
          self.utx.read(iprot)
7658 
        else:
7659 
          iprot.skip(ftype)
7660 
      else:
7661 
        iprot.skip(ftype)
7662 
      iprot.readFieldEnd()
7663 
    iprot.readStructEnd()
7664 
 
7665 
  def write(self, oprot):
7666 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7667 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7668 
      return
7669 
    oprot.writeStructBegin('createAffiliate_result')
7670 
    if self.success != None:
7671 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7672 
      self.success.write(oprot)
7673 
      oprot.writeFieldEnd()
7674 
    if self.utx != None:
7675 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7676 
      self.utx.write(oprot)
7677 
      oprot.writeFieldEnd()
7678 
    oprot.writeFieldStop()
7679 
    oprot.writeStructEnd()
7680 
 
7681 
  def __repr__(self):
7682 
    L = ['%s=%r' % (key, value)
7683 
      for key, value in self.__dict__.iteritems()]
7684 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7685 
 
7686 
  def __eq__(self, other):
7687 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7688 
 
7689 
  def __ne__(self, other):
7690 
    return not (self == other)
7691 
 
7692 
class getAffiliateById_args:
7693 
  """
7694 
  Attributes:
7695 
   - id
7696 
  """
7697 
 
7698 
  thrift_spec = (
7699 
    None, # 0
7700 
    (1, TType.I64, 'id', None, None, ), # 1
7701 
  )
7702 
 
7703 
  def __init__(self, id=None,):
7704 
    self.id = id
7705 
 
7706 
  def read(self, iprot):
7707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7709 
      return
7710 
    iprot.readStructBegin()
7711 
    while True:
7712 
      (fname, ftype, fid) = iprot.readFieldBegin()
7713 
      if ftype == TType.STOP:
7714 
        break
7715 
      if fid == 1:
7716 
        if ftype == TType.I64:
7717 
          self.id = iprot.readI64();
7718 
        else:
7719 
          iprot.skip(ftype)
7720 
      else:
7721 
        iprot.skip(ftype)
7722 
      iprot.readFieldEnd()
7723 
    iprot.readStructEnd()
7724 
 
7725 
  def write(self, oprot):
7726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7728 
      return
7729 
    oprot.writeStructBegin('getAffiliateById_args')
7730 
    if self.id != None:
7731 
      oprot.writeFieldBegin('id', TType.I64, 1)
7732 
      oprot.writeI64(self.id)
7733 
      oprot.writeFieldEnd()
7734 
    oprot.writeFieldStop()
7735 
    oprot.writeStructEnd()
7736 
 
7737 
  def __repr__(self):
7738 
    L = ['%s=%r' % (key, value)
7739 
      for key, value in self.__dict__.iteritems()]
7740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7741 
 
7742 
  def __eq__(self, other):
7743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7744 
 
7745 
  def __ne__(self, other):
7746 
    return not (self == other)
7747 
 
7748 
class getAffiliateById_result:
7749 
  """
7750 
  Attributes:
7751 
   - success
7752 
   - utx
7753 
  """
7754 
 
7755 
  thrift_spec = (
7756 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
7757 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7758 
  )
7759 
 
7760 
  def __init__(self, success=None, utx=None,):
7761 
    self.success = success
7762 
    self.utx = utx
7763 
 
7764 
  def read(self, iprot):
7765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7767 
      return
7768 
    iprot.readStructBegin()
7769 
    while True:
7770 
      (fname, ftype, fid) = iprot.readFieldBegin()
7771 
      if ftype == TType.STOP:
7772 
        break
7773 
      if fid == 0:
7774 
        if ftype == TType.STRUCT:
7775 
          self.success = Affiliate()
7776 
          self.success.read(iprot)
7777 
        else:
7778 
          iprot.skip(ftype)
7779 
      elif fid == 1:
7780 
        if ftype == TType.STRUCT:
7781 
          self.utx = UserTrackerException()
7782 
          self.utx.read(iprot)
7783 
        else:
7784 
          iprot.skip(ftype)
7785 
      else:
7786 
        iprot.skip(ftype)
7787 
      iprot.readFieldEnd()
7788 
    iprot.readStructEnd()
7789 
 
7790 
  def write(self, oprot):
7791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7793 
      return
7794 
    oprot.writeStructBegin('getAffiliateById_result')
7795 
    if self.success != None:
7796 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7797 
      self.success.write(oprot)
7798 
      oprot.writeFieldEnd()
7799 
    if self.utx != None:
7800 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7801 
      self.utx.write(oprot)
7802 
      oprot.writeFieldEnd()
7803 
    oprot.writeFieldStop()
7804 
    oprot.writeStructEnd()
7805 
 
7806 
  def __repr__(self):
7807 
    L = ['%s=%r' % (key, value)
7808 
      for key, value in self.__dict__.iteritems()]
7809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7810 
 
7811 
  def __eq__(self, other):
7812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7813 
 
7814 
  def __ne__(self, other):
7815 
    return not (self == other)
7816 
 
7817 
class getAffiliateByName_args:
7818 
  """
7819 
  Attributes:
7820 
   - name
7821 
  """
7822 
 
7823 
  thrift_spec = (
7824 
    None, # 0
7825 
    (1, TType.STRING, 'name', None, None, ), # 1
7826 
  )
7827 
 
7828 
  def __init__(self, name=None,):
7829 
    self.name = name
7830 
 
7831 
  def read(self, iprot):
7832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7834 
      return
7835 
    iprot.readStructBegin()
7836 
    while True:
7837 
      (fname, ftype, fid) = iprot.readFieldBegin()
7838 
      if ftype == TType.STOP:
7839 
        break
7840 
      if fid == 1:
7841 
        if ftype == TType.STRING:
7842 
          self.name = iprot.readString();
7843 
        else:
7844 
          iprot.skip(ftype)
7845 
      else:
7846 
        iprot.skip(ftype)
7847 
      iprot.readFieldEnd()
7848 
    iprot.readStructEnd()
7849 
 
7850 
  def write(self, oprot):
7851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7853 
      return
7854 
    oprot.writeStructBegin('getAffiliateByName_args')
7855 
    if self.name != None:
7856 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7857 
      oprot.writeString(self.name)
7858 
      oprot.writeFieldEnd()
7859 
    oprot.writeFieldStop()
7860 
    oprot.writeStructEnd()
7861 
 
7862 
  def __repr__(self):
7863 
    L = ['%s=%r' % (key, value)
7864 
      for key, value in self.__dict__.iteritems()]
7865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7866 
 
7867 
  def __eq__(self, other):
7868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7869 
 
7870 
  def __ne__(self, other):
7871 
    return not (self == other)
7872 
 
7873 
class getAffiliateByName_result:
7874 
  """
7875 
  Attributes:
7876 
   - success
7877 
   - utx
7878 
  """
7879 
 
7880 
  thrift_spec = (
7881 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
7882 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
7883 
  )
7884 
 
7885 
  def __init__(self, success=None, utx=None,):
7886 
    self.success = success
7887 
    self.utx = utx
7888 
 
7889 
  def read(self, iprot):
7890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7892 
      return
7893 
    iprot.readStructBegin()
7894 
    while True:
7895 
      (fname, ftype, fid) = iprot.readFieldBegin()
7896 
      if ftype == TType.STOP:
7897 
        break
7898 
      if fid == 0:
7899 
        if ftype == TType.STRUCT:
7900 
          self.success = Affiliate()
7901 
          self.success.read(iprot)
7902 
        else:
7903 
          iprot.skip(ftype)
7904 
      elif fid == 1:
7905 
        if ftype == TType.STRUCT:
7906 
          self.utx = UserTrackerException()
7907 
          self.utx.read(iprot)
7908 
        else:
7909 
          iprot.skip(ftype)
7910 
      else:
7911 
        iprot.skip(ftype)
7912 
      iprot.readFieldEnd()
7913 
    iprot.readStructEnd()
7914 
 
7915 
  def write(self, oprot):
7916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7918 
      return
7919 
    oprot.writeStructBegin('getAffiliateByName_result')
7920 
    if self.success != None:
7921 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7922 
      self.success.write(oprot)
7923 
      oprot.writeFieldEnd()
7924 
    if self.utx != None:
7925 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7926 
      self.utx.write(oprot)
7927 
      oprot.writeFieldEnd()
7928 
    oprot.writeFieldStop()
7929 
    oprot.writeStructEnd()
7930 
 
7931 
  def __repr__(self):
7932 
    L = ['%s=%r' % (key, value)
7933 
      for key, value in self.__dict__.iteritems()]
7934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7935 
 
7936 
  def __eq__(self, other):
7937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7938 
 
7939 
  def __ne__(self, other):
7940 
    return not (self == other)
7941 
 
7942 
class getAffiliatesByMasterAffiliate_args:
7943 
  """
7944 
  Attributes:
7945 
   - id
7946 
  """
7947 
 
7948 
  thrift_spec = (
7949 
    None, # 0
7950 
    (1, TType.I64, 'id', None, None, ), # 1
7951 
  )
7952 
 
7953 
  def __init__(self, id=None,):
7954 
    self.id = id
7955 
 
7956 
  def read(self, iprot):
7957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7959 
      return
7960 
    iprot.readStructBegin()
7961 
    while True:
7962 
      (fname, ftype, fid) = iprot.readFieldBegin()
7963 
      if ftype == TType.STOP:
7964 
        break
7965 
      if fid == 1:
7966 
        if ftype == TType.I64:
7967 
          self.id = iprot.readI64();
7968 
        else:
7969 
          iprot.skip(ftype)
7970 
      else:
7971 
        iprot.skip(ftype)
7972 
      iprot.readFieldEnd()
7973 
    iprot.readStructEnd()
7974 
 
7975 
  def write(self, oprot):
7976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7978 
      return
7979 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
7980 
    if self.id != None:
7981 
      oprot.writeFieldBegin('id', TType.I64, 1)
7982 
      oprot.writeI64(self.id)
7983 
      oprot.writeFieldEnd()
7984 
    oprot.writeFieldStop()
7985 
    oprot.writeStructEnd()
7986 
 
7987 
  def __repr__(self):
7988 
    L = ['%s=%r' % (key, value)
7989 
      for key, value in self.__dict__.iteritems()]
7990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7991 
 
7992 
  def __eq__(self, other):
7993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7994 
 
7995 
  def __ne__(self, other):
7996 
    return not (self == other)
7997 
 
7998 
class getAffiliatesByMasterAffiliate_result:
7999 
  """
8000 
  Attributes:
8001 
   - success
8002 
   - utx
8003 
  """
8004 
 
8005 
  thrift_spec = (
8006 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
8007 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8008 
  )
8009 
 
8010 
  def __init__(self, success=None, utx=None,):
8011 
    self.success = success
8012 
    self.utx = utx
8013 
 
8014 
  def read(self, iprot):
8015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8017 
      return
8018 
    iprot.readStructBegin()
8019 
    while True:
8020 
      (fname, ftype, fid) = iprot.readFieldBegin()
8021 
      if ftype == TType.STOP:
8022 
        break
8023 
      if fid == 0:
8024 
        if ftype == TType.LIST:
8025 
          self.success = []
1899 vikas 8026 
          (_etype59, _size56) = iprot.readListBegin()
8027 
          for _i60 in xrange(_size56):
8028 
            _elem61 = Affiliate()
8029 
            _elem61.read(iprot)
8030 
            self.success.append(_elem61)
1845 vikas 8031 
          iprot.readListEnd()
8032 
        else:
8033 
          iprot.skip(ftype)
8034 
      elif fid == 1:
8035 
        if ftype == TType.STRUCT:
8036 
          self.utx = UserTrackerException()
8037 
          self.utx.read(iprot)
8038 
        else:
8039 
          iprot.skip(ftype)
8040 
      else:
8041 
        iprot.skip(ftype)
8042 
      iprot.readFieldEnd()
8043 
    iprot.readStructEnd()
8044 
 
8045 
  def write(self, oprot):
8046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8048 
      return
8049 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
8050 
    if self.success != None:
8051 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8052 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1899 vikas 8053 
      for iter62 in self.success:
8054 
        iter62.write(oprot)
1845 vikas 8055 
      oprot.writeListEnd()
8056 
      oprot.writeFieldEnd()
8057 
    if self.utx != None:
8058 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8059 
      self.utx.write(oprot)
8060 
      oprot.writeFieldEnd()
8061 
    oprot.writeFieldStop()
8062 
    oprot.writeStructEnd()
8063 
 
8064 
  def __repr__(self):
8065 
    L = ['%s=%r' % (key, value)
8066 
      for key, value in self.__dict__.iteritems()]
8067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8068 
 
8069 
  def __eq__(self, other):
8070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8071 
 
8072 
  def __ne__(self, other):
8073 
    return not (self == other)
8074 
 
8075 
class createTracker_args:
8076 
  """
8077 
  Attributes:
8078 
   - affiliateId
1859 vikas 8079 
   - addedOn
1845 vikas 8080 
  """
8081 
 
8082 
  thrift_spec = (
8083 
    None, # 0
8084 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1859 vikas 8085 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 8086 
  )
8087 
 
1859 vikas 8088 
  def __init__(self, affiliateId=None, addedOn=None,):
1845 vikas 8089 
    self.affiliateId = affiliateId
1859 vikas 8090 
    self.addedOn = addedOn
1845 vikas 8091 
 
8092 
  def read(self, iprot):
8093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8095 
      return
8096 
    iprot.readStructBegin()
8097 
    while True:
8098 
      (fname, ftype, fid) = iprot.readFieldBegin()
8099 
      if ftype == TType.STOP:
8100 
        break
8101 
      if fid == 1:
8102 
        if ftype == TType.I64:
8103 
          self.affiliateId = iprot.readI64();
8104 
        else:
8105 
          iprot.skip(ftype)
1859 vikas 8106 
      elif fid == 2:
8107 
        if ftype == TType.I64:
8108 
          self.addedOn = iprot.readI64();
8109 
        else:
8110 
          iprot.skip(ftype)
1845 vikas 8111 
      else:
8112 
        iprot.skip(ftype)
8113 
      iprot.readFieldEnd()
8114 
    iprot.readStructEnd()
8115 
 
8116 
  def write(self, oprot):
8117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8119 
      return
8120 
    oprot.writeStructBegin('createTracker_args')
8121 
    if self.affiliateId != None:
8122 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
8123 
      oprot.writeI64(self.affiliateId)
8124 
      oprot.writeFieldEnd()
1859 vikas 8125 
    if self.addedOn != None:
8126 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
8127 
      oprot.writeI64(self.addedOn)
8128 
      oprot.writeFieldEnd()
1845 vikas 8129 
    oprot.writeFieldStop()
8130 
    oprot.writeStructEnd()
8131 
 
8132 
  def __repr__(self):
8133 
    L = ['%s=%r' % (key, value)
8134 
      for key, value in self.__dict__.iteritems()]
8135 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8136 
 
8137 
  def __eq__(self, other):
8138 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8139 
 
8140 
  def __ne__(self, other):
8141 
    return not (self == other)
8142 
 
8143 
class createTracker_result:
8144 
  """
8145 
  Attributes:
8146 
   - success
8147 
   - utx
8148 
  """
8149 
 
8150 
  thrift_spec = (
8151 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
8152 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8153 
  )
8154 
 
8155 
  def __init__(self, success=None, utx=None,):
8156 
    self.success = success
8157 
    self.utx = utx
8158 
 
8159 
  def read(self, iprot):
8160 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8161 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8162 
      return
8163 
    iprot.readStructBegin()
8164 
    while True:
8165 
      (fname, ftype, fid) = iprot.readFieldBegin()
8166 
      if ftype == TType.STOP:
8167 
        break
8168 
      if fid == 0:
8169 
        if ftype == TType.STRUCT:
8170 
          self.success = Tracker()
8171 
          self.success.read(iprot)
8172 
        else:
8173 
          iprot.skip(ftype)
8174 
      elif fid == 1:
8175 
        if ftype == TType.STRUCT:
8176 
          self.utx = UserTrackerException()
8177 
          self.utx.read(iprot)
8178 
        else:
8179 
          iprot.skip(ftype)
8180 
      else:
8181 
        iprot.skip(ftype)
8182 
      iprot.readFieldEnd()
8183 
    iprot.readStructEnd()
8184 
 
8185 
  def write(self, oprot):
8186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8188 
      return
8189 
    oprot.writeStructBegin('createTracker_result')
8190 
    if self.success != None:
8191 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8192 
      self.success.write(oprot)
8193 
      oprot.writeFieldEnd()
8194 
    if self.utx != None:
8195 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8196 
      self.utx.write(oprot)
8197 
      oprot.writeFieldEnd()
8198 
    oprot.writeFieldStop()
8199 
    oprot.writeStructEnd()
8200 
 
8201 
  def __repr__(self):
8202 
    L = ['%s=%r' % (key, value)
8203 
      for key, value in self.__dict__.iteritems()]
8204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8205 
 
8206 
  def __eq__(self, other):
8207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8208 
 
8209 
  def __ne__(self, other):
8210 
    return not (self == other)
8211 
 
8212 
class getTrackerById_args:
8213 
  """
8214 
  Attributes:
8215 
   - trackerId
8216 
  """
8217 
 
8218 
  thrift_spec = (
8219 
    None, # 0
8220 
    (1, TType.I64, 'trackerId', None, None, ), # 1
8221 
  )
8222 
 
8223 
  def __init__(self, trackerId=None,):
8224 
    self.trackerId = trackerId
8225 
 
8226 
  def read(self, iprot):
8227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8229 
      return
8230 
    iprot.readStructBegin()
8231 
    while True:
8232 
      (fname, ftype, fid) = iprot.readFieldBegin()
8233 
      if ftype == TType.STOP:
8234 
        break
8235 
      if fid == 1:
8236 
        if ftype == TType.I64:
8237 
          self.trackerId = iprot.readI64();
8238 
        else:
8239 
          iprot.skip(ftype)
8240 
      else:
8241 
        iprot.skip(ftype)
8242 
      iprot.readFieldEnd()
8243 
    iprot.readStructEnd()
8244 
 
8245 
  def write(self, oprot):
8246 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8247 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8248 
      return
8249 
    oprot.writeStructBegin('getTrackerById_args')
8250 
    if self.trackerId != None:
8251 
      oprot.writeFieldBegin('trackerId', TType.I64, 1)
8252 
      oprot.writeI64(self.trackerId)
8253 
      oprot.writeFieldEnd()
8254 
    oprot.writeFieldStop()
8255 
    oprot.writeStructEnd()
8256 
 
8257 
  def __repr__(self):
8258 
    L = ['%s=%r' % (key, value)
8259 
      for key, value in self.__dict__.iteritems()]
8260 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8261 
 
8262 
  def __eq__(self, other):
8263 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8264 
 
8265 
  def __ne__(self, other):
8266 
    return not (self == other)
8267 
 
8268 
class getTrackerById_result:
8269 
  """
8270 
  Attributes:
8271 
   - success
8272 
   - utx
8273 
  """
8274 
 
8275 
  thrift_spec = (
8276 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
8277 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8278 
  )
8279 
 
8280 
  def __init__(self, success=None, utx=None,):
8281 
    self.success = success
8282 
    self.utx = utx
8283 
 
8284 
  def read(self, iprot):
8285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8287 
      return
8288 
    iprot.readStructBegin()
8289 
    while True:
8290 
      (fname, ftype, fid) = iprot.readFieldBegin()
8291 
      if ftype == TType.STOP:
8292 
        break
8293 
      if fid == 0:
8294 
        if ftype == TType.STRUCT:
8295 
          self.success = Tracker()
8296 
          self.success.read(iprot)
8297 
        else:
8298 
          iprot.skip(ftype)
8299 
      elif fid == 1:
8300 
        if ftype == TType.STRUCT:
8301 
          self.utx = UserTrackerException()
8302 
          self.utx.read(iprot)
8303 
        else:
8304 
          iprot.skip(ftype)
8305 
      else:
8306 
        iprot.skip(ftype)
8307 
      iprot.readFieldEnd()
8308 
    iprot.readStructEnd()
8309 
 
8310 
  def write(self, oprot):
8311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8313 
      return
8314 
    oprot.writeStructBegin('getTrackerById_result')
8315 
    if self.success != None:
8316 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8317 
      self.success.write(oprot)
8318 
      oprot.writeFieldEnd()
8319 
    if self.utx != None:
8320 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8321 
      self.utx.write(oprot)
8322 
      oprot.writeFieldEnd()
8323 
    oprot.writeFieldStop()
8324 
    oprot.writeStructEnd()
8325 
 
8326 
  def __repr__(self):
8327 
    L = ['%s=%r' % (key, value)
8328 
      for key, value in self.__dict__.iteritems()]
8329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8330 
 
8331 
  def __eq__(self, other):
8332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8333 
 
8334 
  def __ne__(self, other):
8335 
    return not (self == other)
8336 
 
8337 
class getTrackersByAffiliate_args:
8338 
  """
8339 
  Attributes:
8340 
   - affiliateId
8341 
  """
8342 
 
8343 
  thrift_spec = (
8344 
    None, # 0
8345 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
8346 
  )
8347 
 
8348 
  def __init__(self, affiliateId=None,):
8349 
    self.affiliateId = affiliateId
8350 
 
8351 
  def read(self, iprot):
8352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8354 
      return
8355 
    iprot.readStructBegin()
8356 
    while True:
8357 
      (fname, ftype, fid) = iprot.readFieldBegin()
8358 
      if ftype == TType.STOP:
8359 
        break
8360 
      if fid == 1:
8361 
        if ftype == TType.I64:
8362 
          self.affiliateId = iprot.readI64();
8363 
        else:
8364 
          iprot.skip(ftype)
8365 
      else:
8366 
        iprot.skip(ftype)
8367 
      iprot.readFieldEnd()
8368 
    iprot.readStructEnd()
8369 
 
8370 
  def write(self, oprot):
8371 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8372 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8373 
      return
8374 
    oprot.writeStructBegin('getTrackersByAffiliate_args')
8375 
    if self.affiliateId != None:
8376 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
8377 
      oprot.writeI64(self.affiliateId)
8378 
      oprot.writeFieldEnd()
8379 
    oprot.writeFieldStop()
8380 
    oprot.writeStructEnd()
8381 
 
8382 
  def __repr__(self):
8383 
    L = ['%s=%r' % (key, value)
8384 
      for key, value in self.__dict__.iteritems()]
8385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8386 
 
8387 
  def __eq__(self, other):
8388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8389 
 
8390 
  def __ne__(self, other):
8391 
    return not (self == other)
8392 
 
8393 
class getTrackersByAffiliate_result:
8394 
  """
8395 
  Attributes:
8396 
   - success
8397 
   - utx
8398 
  """
8399 
 
8400 
  thrift_spec = (
8401 
    (0, TType.LIST, 'success', (TType.STRUCT,(Tracker, Tracker.thrift_spec)), None, ), # 0
8402 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8403 
  )
8404 
 
8405 
  def __init__(self, success=None, utx=None,):
8406 
    self.success = success
8407 
    self.utx = utx
8408 
 
8409 
  def read(self, iprot):
8410 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8411 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8412 
      return
8413 
    iprot.readStructBegin()
8414 
    while True:
8415 
      (fname, ftype, fid) = iprot.readFieldBegin()
8416 
      if ftype == TType.STOP:
8417 
        break
8418 
      if fid == 0:
8419 
        if ftype == TType.LIST:
8420 
          self.success = []
1899 vikas 8421 
          (_etype66, _size63) = iprot.readListBegin()
8422 
          for _i67 in xrange(_size63):
8423 
            _elem68 = Tracker()
8424 
            _elem68.read(iprot)
8425 
            self.success.append(_elem68)
1845 vikas 8426 
          iprot.readListEnd()
8427 
        else:
8428 
          iprot.skip(ftype)
8429 
      elif fid == 1:
8430 
        if ftype == TType.STRUCT:
8431 
          self.utx = UserTrackerException()
8432 
          self.utx.read(iprot)
8433 
        else:
8434 
          iprot.skip(ftype)
8435 
      else:
8436 
        iprot.skip(ftype)
8437 
      iprot.readFieldEnd()
8438 
    iprot.readStructEnd()
8439 
 
8440 
  def write(self, oprot):
8441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8443 
      return
8444 
    oprot.writeStructBegin('getTrackersByAffiliate_result')
8445 
    if self.success != None:
8446 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8447 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1899 vikas 8448 
      for iter69 in self.success:
8449 
        iter69.write(oprot)
1845 vikas 8450 
      oprot.writeListEnd()
8451 
      oprot.writeFieldEnd()
8452 
    if self.utx != None:
8453 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8454 
      self.utx.write(oprot)
8455 
      oprot.writeFieldEnd()
8456 
    oprot.writeFieldStop()
8457 
    oprot.writeStructEnd()
8458 
 
8459 
  def __repr__(self):
8460 
    L = ['%s=%r' % (key, value)
8461 
      for key, value in self.__dict__.iteritems()]
8462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8463 
 
8464 
  def __eq__(self, other):
8465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8466 
 
8467 
  def __ne__(self, other):
8468 
    return not (self == other)
8469 
 
8470 
class addTrackLog_args:
8471 
  """
8472 
  Attributes:
8473 
   - trackerId
8474 
   - userId
8475 
   - event
8476 
   - url
8477 
   - data
1859 vikas 8478 
   - addedOn
1845 vikas 8479 
  """
8480 
 
8481 
  thrift_spec = (
8482 
    None, # 0
8483 
    (1, TType.I64, 'trackerId', None, None, ), # 1
8484 
    (2, TType.I64, 'userId', None, None, ), # 2
8485 
    (3, TType.STRING, 'event', None, None, ), # 3
8486 
    (4, TType.STRING, 'url', None, None, ), # 4
8487 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 8488 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 8489 
  )
8490 
 
1859 vikas 8491 
  def __init__(self, trackerId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
1845 vikas 8492 
    self.trackerId = trackerId
8493 
    self.userId = userId
8494 
    self.event = event
8495 
    self.url = url
8496 
    self.data = data
1859 vikas 8497 
    self.addedOn = addedOn
1845 vikas 8498 
 
8499 
  def read(self, iprot):
8500 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8501 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8502 
      return
8503 
    iprot.readStructBegin()
8504 
    while True:
8505 
      (fname, ftype, fid) = iprot.readFieldBegin()
8506 
      if ftype == TType.STOP:
8507 
        break
8508 
      if fid == 1:
8509 
        if ftype == TType.I64:
8510 
          self.trackerId = iprot.readI64();
8511 
        else:
8512 
          iprot.skip(ftype)
8513 
      elif fid == 2:
8514 
        if ftype == TType.I64:
8515 
          self.userId = iprot.readI64();
8516 
        else:
8517 
          iprot.skip(ftype)
8518 
      elif fid == 3:
8519 
        if ftype == TType.STRING:
8520 
          self.event = iprot.readString();
8521 
        else:
8522 
          iprot.skip(ftype)
8523 
      elif fid == 4:
8524 
        if ftype == TType.STRING:
8525 
          self.url = iprot.readString();
8526 
        else:
8527 
          iprot.skip(ftype)
8528 
      elif fid == 5:
8529 
        if ftype == TType.STRING:
8530 
          self.data = iprot.readString();
8531 
        else:
8532 
          iprot.skip(ftype)
1859 vikas 8533 
      elif fid == 6:
8534 
        if ftype == TType.I64:
8535 
          self.addedOn = iprot.readI64();
8536 
        else:
8537 
          iprot.skip(ftype)
1845 vikas 8538 
      else:
8539 
        iprot.skip(ftype)
8540 
      iprot.readFieldEnd()
8541 
    iprot.readStructEnd()
8542 
 
8543 
  def write(self, oprot):
8544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8546 
      return
8547 
    oprot.writeStructBegin('addTrackLog_args')
8548 
    if self.trackerId != None:
8549 
      oprot.writeFieldBegin('trackerId', TType.I64, 1)
8550 
      oprot.writeI64(self.trackerId)
8551 
      oprot.writeFieldEnd()
8552 
    if self.userId != None:
8553 
      oprot.writeFieldBegin('userId', TType.I64, 2)
8554 
      oprot.writeI64(self.userId)
8555 
      oprot.writeFieldEnd()
8556 
    if self.event != None:
8557 
      oprot.writeFieldBegin('event', TType.STRING, 3)
8558 
      oprot.writeString(self.event)
8559 
      oprot.writeFieldEnd()
8560 
    if self.url != None:
8561 
      oprot.writeFieldBegin('url', TType.STRING, 4)
8562 
      oprot.writeString(self.url)
8563 
      oprot.writeFieldEnd()
8564 
    if self.data != None:
8565 
      oprot.writeFieldBegin('data', TType.STRING, 5)
8566 
      oprot.writeString(self.data)
8567 
      oprot.writeFieldEnd()
1859 vikas 8568 
    if self.addedOn != None:
8569 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
8570 
      oprot.writeI64(self.addedOn)
8571 
      oprot.writeFieldEnd()
1845 vikas 8572 
    oprot.writeFieldStop()
8573 
    oprot.writeStructEnd()
8574 
 
8575 
  def __repr__(self):
8576 
    L = ['%s=%r' % (key, value)
8577 
      for key, value in self.__dict__.iteritems()]
8578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8579 
 
8580 
  def __eq__(self, other):
8581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8582 
 
8583 
  def __ne__(self, other):
8584 
    return not (self == other)
8585 
 
8586 
class addTrackLog_result:
8587 
  """
8588 
  Attributes:
8589 
   - success
8590 
   - utx
8591 
  """
8592 
 
8593 
  thrift_spec = (
8594 
    (0, TType.I64, 'success', None, None, ), # 0
8595 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8596 
  )
8597 
 
8598 
  def __init__(self, success=None, utx=None,):
8599 
    self.success = success
8600 
    self.utx = utx
8601 
 
8602 
  def read(self, iprot):
8603 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8604 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8605 
      return
8606 
    iprot.readStructBegin()
8607 
    while True:
8608 
      (fname, ftype, fid) = iprot.readFieldBegin()
8609 
      if ftype == TType.STOP:
8610 
        break
8611 
      if fid == 0:
8612 
        if ftype == TType.I64:
8613 
          self.success = iprot.readI64();
8614 
        else:
8615 
          iprot.skip(ftype)
8616 
      elif fid == 1:
8617 
        if ftype == TType.STRUCT:
8618 
          self.utx = UserTrackerException()
8619 
          self.utx.read(iprot)
8620 
        else:
8621 
          iprot.skip(ftype)
8622 
      else:
8623 
        iprot.skip(ftype)
8624 
      iprot.readFieldEnd()
8625 
    iprot.readStructEnd()
8626 
 
8627 
  def write(self, oprot):
8628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8630 
      return
8631 
    oprot.writeStructBegin('addTrackLog_result')
8632 
    if self.success != None:
8633 
      oprot.writeFieldBegin('success', TType.I64, 0)
8634 
      oprot.writeI64(self.success)
8635 
      oprot.writeFieldEnd()
8636 
    if self.utx != None:
8637 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8638 
      self.utx.write(oprot)
8639 
      oprot.writeFieldEnd()
8640 
    oprot.writeFieldStop()
8641 
    oprot.writeStructEnd()
8642 
 
8643 
  def __repr__(self):
8644 
    L = ['%s=%r' % (key, value)
8645 
      for key, value in self.__dict__.iteritems()]
8646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8647 
 
8648 
  def __eq__(self, other):
8649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8650 
 
8651 
  def __ne__(self, other):
8652 
    return not (self == other)
8653 
 
8654 
class getTrackLogById_args:
8655 
  """
8656 
  Attributes:
8657 
   - id
8658 
  """
8659 
 
8660 
  thrift_spec = (
8661 
    None, # 0
8662 
    (1, TType.I64, 'id', None, None, ), # 1
8663 
  )
8664 
 
8665 
  def __init__(self, id=None,):
8666 
    self.id = id
8667 
 
8668 
  def read(self, iprot):
8669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8671 
      return
8672 
    iprot.readStructBegin()
8673 
    while True:
8674 
      (fname, ftype, fid) = iprot.readFieldBegin()
8675 
      if ftype == TType.STOP:
8676 
        break
8677 
      if fid == 1:
8678 
        if ftype == TType.I64:
8679 
          self.id = iprot.readI64();
8680 
        else:
8681 
          iprot.skip(ftype)
8682 
      else:
8683 
        iprot.skip(ftype)
8684 
      iprot.readFieldEnd()
8685 
    iprot.readStructEnd()
8686 
 
8687 
  def write(self, oprot):
8688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8690 
      return
8691 
    oprot.writeStructBegin('getTrackLogById_args')
8692 
    if self.id != None:
8693 
      oprot.writeFieldBegin('id', TType.I64, 1)
8694 
      oprot.writeI64(self.id)
8695 
      oprot.writeFieldEnd()
8696 
    oprot.writeFieldStop()
8697 
    oprot.writeStructEnd()
8698 
 
8699 
  def __repr__(self):
8700 
    L = ['%s=%r' % (key, value)
8701 
      for key, value in self.__dict__.iteritems()]
8702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8703 
 
8704 
  def __eq__(self, other):
8705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8706 
 
8707 
  def __ne__(self, other):
8708 
    return not (self == other)
8709 
 
8710 
class getTrackLogById_result:
8711 
  """
8712 
  Attributes:
8713 
   - success
8714 
   - utx
8715 
  """
8716 
 
8717 
  thrift_spec = (
8718 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
8719 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8720 
  )
8721 
 
8722 
  def __init__(self, success=None, utx=None,):
8723 
    self.success = success
8724 
    self.utx = utx
8725 
 
8726 
  def read(self, iprot):
8727 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8728 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8729 
      return
8730 
    iprot.readStructBegin()
8731 
    while True:
8732 
      (fname, ftype, fid) = iprot.readFieldBegin()
8733 
      if ftype == TType.STOP:
8734 
        break
8735 
      if fid == 0:
8736 
        if ftype == TType.STRUCT:
8737 
          self.success = TrackLog()
8738 
          self.success.read(iprot)
8739 
        else:
8740 
          iprot.skip(ftype)
8741 
      elif fid == 1:
8742 
        if ftype == TType.STRUCT:
8743 
          self.utx = UserTrackerException()
8744 
          self.utx.read(iprot)
8745 
        else:
8746 
          iprot.skip(ftype)
8747 
      else:
8748 
        iprot.skip(ftype)
8749 
      iprot.readFieldEnd()
8750 
    iprot.readStructEnd()
8751 
 
8752 
  def write(self, oprot):
8753 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8754 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8755 
      return
8756 
    oprot.writeStructBegin('getTrackLogById_result')
8757 
    if self.success != None:
8758 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8759 
      self.success.write(oprot)
8760 
      oprot.writeFieldEnd()
8761 
    if self.utx != None:
8762 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8763 
      self.utx.write(oprot)
8764 
      oprot.writeFieldEnd()
8765 
    oprot.writeFieldStop()
8766 
    oprot.writeStructEnd()
8767 
 
8768 
  def __repr__(self):
8769 
    L = ['%s=%r' % (key, value)
8770 
      for key, value in self.__dict__.iteritems()]
8771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8772 
 
8773 
  def __eq__(self, other):
8774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8775 
 
8776 
  def __ne__(self, other):
8777 
    return not (self == other)
8778 
 
8779 
class getTrackLogsByTracker_args:
8780 
  """
8781 
  Attributes:
8782 
   - trackerId
8783 
  """
8784 
 
8785 
  thrift_spec = (
8786 
    None, # 0
8787 
    (1, TType.I64, 'trackerId', None, None, ), # 1
8788 
  )
8789 
 
8790 
  def __init__(self, trackerId=None,):
8791 
    self.trackerId = trackerId
8792 
 
8793 
  def read(self, iprot):
8794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8796 
      return
8797 
    iprot.readStructBegin()
8798 
    while True:
8799 
      (fname, ftype, fid) = iprot.readFieldBegin()
8800 
      if ftype == TType.STOP:
8801 
        break
8802 
      if fid == 1:
8803 
        if ftype == TType.I64:
8804 
          self.trackerId = iprot.readI64();
8805 
        else:
8806 
          iprot.skip(ftype)
8807 
      else:
8808 
        iprot.skip(ftype)
8809 
      iprot.readFieldEnd()
8810 
    iprot.readStructEnd()
8811 
 
8812 
  def write(self, oprot):
8813 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8814 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8815 
      return
8816 
    oprot.writeStructBegin('getTrackLogsByTracker_args')
8817 
    if self.trackerId != None:
8818 
      oprot.writeFieldBegin('trackerId', TType.I64, 1)
8819 
      oprot.writeI64(self.trackerId)
8820 
      oprot.writeFieldEnd()
8821 
    oprot.writeFieldStop()
8822 
    oprot.writeStructEnd()
8823 
 
8824 
  def __repr__(self):
8825 
    L = ['%s=%r' % (key, value)
8826 
      for key, value in self.__dict__.iteritems()]
8827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8828 
 
8829 
  def __eq__(self, other):
8830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8831 
 
8832 
  def __ne__(self, other):
8833 
    return not (self == other)
8834 
 
8835 
class getTrackLogsByTracker_result:
8836 
  """
8837 
  Attributes:
8838 
   - success
8839 
   - utx
8840 
  """
8841 
 
8842 
  thrift_spec = (
8843 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
8844 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8845 
  )
8846 
 
8847 
  def __init__(self, success=None, utx=None,):
8848 
    self.success = success
8849 
    self.utx = utx
8850 
 
8851 
  def read(self, iprot):
8852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8854 
      return
8855 
    iprot.readStructBegin()
8856 
    while True:
8857 
      (fname, ftype, fid) = iprot.readFieldBegin()
8858 
      if ftype == TType.STOP:
8859 
        break
8860 
      if fid == 0:
8861 
        if ftype == TType.LIST:
8862 
          self.success = []
1899 vikas 8863 
          (_etype73, _size70) = iprot.readListBegin()
8864 
          for _i74 in xrange(_size70):
8865 
            _elem75 = TrackLog()
8866 
            _elem75.read(iprot)
8867 
            self.success.append(_elem75)
1845 vikas 8868 
          iprot.readListEnd()
8869 
        else:
8870 
          iprot.skip(ftype)
8871 
      elif fid == 1:
8872 
        if ftype == TType.STRUCT:
8873 
          self.utx = UserTrackerException()
8874 
          self.utx.read(iprot)
8875 
        else:
8876 
          iprot.skip(ftype)
8877 
      else:
8878 
        iprot.skip(ftype)
8879 
      iprot.readFieldEnd()
8880 
    iprot.readStructEnd()
8881 
 
8882 
  def write(self, oprot):
8883 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8884 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8885 
      return
8886 
    oprot.writeStructBegin('getTrackLogsByTracker_result')
8887 
    if self.success != None:
8888 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8889 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1899 vikas 8890 
      for iter76 in self.success:
8891 
        iter76.write(oprot)
1845 vikas 8892 
      oprot.writeListEnd()
8893 
      oprot.writeFieldEnd()
8894 
    if self.utx != None:
8895 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8896 
      self.utx.write(oprot)
8897 
      oprot.writeFieldEnd()
8898 
    oprot.writeFieldStop()
8899 
    oprot.writeStructEnd()
8900 
 
8901 
  def __repr__(self):
8902 
    L = ['%s=%r' % (key, value)
8903 
      for key, value in self.__dict__.iteritems()]
8904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8905 
 
8906 
  def __eq__(self, other):
8907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8908 
 
8909 
  def __ne__(self, other):
8910 
    return not (self == other)
8911 
 
8912 
class getTrackLogsByUser_args:
8913 
  """
8914 
  Attributes:
8915 
   - userId
8916 
  """
8917 
 
8918 
  thrift_spec = (
8919 
    None, # 0
8920 
    (1, TType.I64, 'userId', None, None, ), # 1
8921 
  )
8922 
 
8923 
  def __init__(self, userId=None,):
8924 
    self.userId = userId
8925 
 
8926 
  def read(self, iprot):
8927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8929 
      return
8930 
    iprot.readStructBegin()
8931 
    while True:
8932 
      (fname, ftype, fid) = iprot.readFieldBegin()
8933 
      if ftype == TType.STOP:
8934 
        break
8935 
      if fid == 1:
8936 
        if ftype == TType.I64:
8937 
          self.userId = iprot.readI64();
8938 
        else:
8939 
          iprot.skip(ftype)
8940 
      else:
8941 
        iprot.skip(ftype)
8942 
      iprot.readFieldEnd()
8943 
    iprot.readStructEnd()
8944 
 
8945 
  def write(self, oprot):
8946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8948 
      return
8949 
    oprot.writeStructBegin('getTrackLogsByUser_args')
8950 
    if self.userId != None:
8951 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8952 
      oprot.writeI64(self.userId)
8953 
      oprot.writeFieldEnd()
8954 
    oprot.writeFieldStop()
8955 
    oprot.writeStructEnd()
8956 
 
8957 
  def __repr__(self):
8958 
    L = ['%s=%r' % (key, value)
8959 
      for key, value in self.__dict__.iteritems()]
8960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8961 
 
8962 
  def __eq__(self, other):
8963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8964 
 
8965 
  def __ne__(self, other):
8966 
    return not (self == other)
8967 
 
8968 
class getTrackLogsByUser_result:
8969 
  """
8970 
  Attributes:
8971 
   - success
8972 
   - utx
8973 
  """
8974 
 
8975 
  thrift_spec = (
8976 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
8977 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
8978 
  )
8979 
 
8980 
  def __init__(self, success=None, utx=None,):
8981 
    self.success = success
8982 
    self.utx = utx
8983 
 
8984 
  def read(self, iprot):
8985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8987 
      return
8988 
    iprot.readStructBegin()
8989 
    while True:
8990 
      (fname, ftype, fid) = iprot.readFieldBegin()
8991 
      if ftype == TType.STOP:
8992 
        break
8993 
      if fid == 0:
8994 
        if ftype == TType.LIST:
8995 
          self.success = []
1899 vikas 8996 
          (_etype80, _size77) = iprot.readListBegin()
8997 
          for _i81 in xrange(_size77):
8998 
            _elem82 = TrackLog()
8999 
            _elem82.read(iprot)
9000 
            self.success.append(_elem82)
1845 vikas 9001 
          iprot.readListEnd()
9002 
        else:
9003 
          iprot.skip(ftype)
9004 
      elif fid == 1:
9005 
        if ftype == TType.STRUCT:
9006 
          self.utx = UserTrackerException()
9007 
          self.utx.read(iprot)
9008 
        else:
9009 
          iprot.skip(ftype)
9010 
      else:
9011 
        iprot.skip(ftype)
9012 
      iprot.readFieldEnd()
9013 
    iprot.readStructEnd()
9014 
 
9015 
  def write(self, oprot):
9016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9018 
      return
9019 
    oprot.writeStructBegin('getTrackLogsByUser_result')
9020 
    if self.success != None:
9021 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9022 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1899 vikas 9023 
      for iter83 in self.success:
9024 
        iter83.write(oprot)
1845 vikas 9025 
      oprot.writeListEnd()
9026 
      oprot.writeFieldEnd()
9027 
    if self.utx != None:
9028 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9029 
      self.utx.write(oprot)
9030 
      oprot.writeFieldEnd()
9031 
    oprot.writeFieldStop()
9032 
    oprot.writeStructEnd()
9033 
 
9034 
  def __repr__(self):
9035 
    L = ['%s=%r' % (key, value)
9036 
      for key, value in self.__dict__.iteritems()]
9037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9038 
 
9039 
  def __eq__(self, other):
9040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9041 
 
9042 
  def __ne__(self, other):
9043 
    return not (self == other)
9044 
 
9045 
class getTrackLogs_args:
9046 
  """
9047 
  Attributes:
9048 
   - trackerId
9049 
   - userId
9050 
   - event
9051 
   - url
9052 
  """
9053 
 
9054 
  thrift_spec = (
9055 
    None, # 0
9056 
    (1, TType.I64, 'trackerId', None, None, ), # 1
9057 
    (2, TType.I64, 'userId', None, None, ), # 2
9058 
    (3, TType.STRING, 'event', None, None, ), # 3
9059 
    (4, TType.STRING, 'url', None, None, ), # 4
9060 
  )
9061 
 
9062 
  def __init__(self, trackerId=None, userId=None, event=None, url=None,):
9063 
    self.trackerId = trackerId
9064 
    self.userId = userId
9065 
    self.event = event
9066 
    self.url = url
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:
9079 
          self.trackerId = iprot.readI64();
9080 
        else:
9081 
          iprot.skip(ftype)
9082 
      elif fid == 2:
9083 
        if ftype == TType.I64:
9084 
          self.userId = iprot.readI64();
9085 
        else:
9086 
          iprot.skip(ftype)
9087 
      elif fid == 3:
9088 
        if ftype == TType.STRING:
9089 
          self.event = iprot.readString();
9090 
        else:
9091 
          iprot.skip(ftype)
9092 
      elif fid == 4:
9093 
        if ftype == TType.STRING:
9094 
          self.url = iprot.readString();
9095 
        else:
9096 
          iprot.skip(ftype)
9097 
      else:
9098 
        iprot.skip(ftype)
9099 
      iprot.readFieldEnd()
9100 
    iprot.readStructEnd()
9101 
 
9102 
  def write(self, oprot):
9103 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9104 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9105 
      return
9106 
    oprot.writeStructBegin('getTrackLogs_args')
9107 
    if self.trackerId != None:
9108 
      oprot.writeFieldBegin('trackerId', TType.I64, 1)
9109 
      oprot.writeI64(self.trackerId)
9110 
      oprot.writeFieldEnd()
9111 
    if self.userId != None:
9112 
      oprot.writeFieldBegin('userId', TType.I64, 2)
9113 
      oprot.writeI64(self.userId)
9114 
      oprot.writeFieldEnd()
9115 
    if self.event != None:
9116 
      oprot.writeFieldBegin('event', TType.STRING, 3)
9117 
      oprot.writeString(self.event)
9118 
      oprot.writeFieldEnd()
9119 
    if self.url != None:
9120 
      oprot.writeFieldBegin('url', TType.STRING, 4)
9121 
      oprot.writeString(self.url)
9122 
      oprot.writeFieldEnd()
9123 
    oprot.writeFieldStop()
9124 
    oprot.writeStructEnd()
9125 
 
9126 
  def __repr__(self):
9127 
    L = ['%s=%r' % (key, value)
9128 
      for key, value in self.__dict__.iteritems()]
9129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9130 
 
9131 
  def __eq__(self, other):
9132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9133 
 
9134 
  def __ne__(self, other):
9135 
    return not (self == other)
9136 
 
9137 
class getTrackLogs_result:
9138 
  """
9139 
  Attributes:
9140 
   - success
9141 
   - utx
9142 
  """
9143 
 
9144 
  thrift_spec = (
9145 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
9146 
    (1, TType.STRUCT, 'utx', (UserTrackerException, UserTrackerException.thrift_spec), None, ), # 1
9147 
  )
9148 
 
9149 
  def __init__(self, success=None, utx=None,):
9150 
    self.success = success
9151 
    self.utx = utx
9152 
 
9153 
  def read(self, iprot):
9154 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9155 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9156 
      return
9157 
    iprot.readStructBegin()
9158 
    while True:
9159 
      (fname, ftype, fid) = iprot.readFieldBegin()
9160 
      if ftype == TType.STOP:
9161 
        break
9162 
      if fid == 0:
9163 
        if ftype == TType.LIST:
9164 
          self.success = []
1899 vikas 9165 
          (_etype87, _size84) = iprot.readListBegin()
9166 
          for _i88 in xrange(_size84):
9167 
            _elem89 = TrackLog()
9168 
            _elem89.read(iprot)
9169 
            self.success.append(_elem89)
1845 vikas 9170 
          iprot.readListEnd()
9171 
        else:
9172 
          iprot.skip(ftype)
9173 
      elif fid == 1:
9174 
        if ftype == TType.STRUCT:
9175 
          self.utx = UserTrackerException()
9176 
          self.utx.read(iprot)
9177 
        else:
9178 
          iprot.skip(ftype)
9179 
      else:
9180 
        iprot.skip(ftype)
9181 
      iprot.readFieldEnd()
9182 
    iprot.readStructEnd()
9183 
 
9184 
  def write(self, oprot):
9185 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9186 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9187 
      return
9188 
    oprot.writeStructBegin('getTrackLogs_result')
9189 
    if self.success != None:
9190 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9191 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1899 vikas 9192 
      for iter90 in self.success:
9193 
        iter90.write(oprot)
1845 vikas 9194 
      oprot.writeListEnd()
9195 
      oprot.writeFieldEnd()
9196 
    if self.utx != None:
9197 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9198 
      self.utx.write(oprot)
9199 
      oprot.writeFieldEnd()
9200 
    oprot.writeFieldStop()
9201 
    oprot.writeStructEnd()
9202 
 
9203 
  def __repr__(self):
9204 
    L = ['%s=%r' % (key, value)
9205 
      for key, value in self.__dict__.iteritems()]
9206 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9207 
 
9208 
  def __eq__(self, other):
9209 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9210 
 
9211 
  def __ne__(self, other):
9212 
    return not (self == other)
9213 
 
559 chandransh 9214 
class createCart_args:
94 ashish 9215 
  """
9216 
  Attributes:
559 chandransh 9217 
   - userId
94 ashish 9218 
  """
9219 
 
9220 
  thrift_spec = (
9221 
    None, # 0
559 chandransh 9222 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 9223 
  )
9224 
 
559 chandransh 9225 
  def __init__(self, userId=None,):
9226 
    self.userId = userId
94 ashish 9227 
 
9228 
  def read(self, iprot):
9229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9231 
      return
9232 
    iprot.readStructBegin()
9233 
    while True:
9234 
      (fname, ftype, fid) = iprot.readFieldBegin()
9235 
      if ftype == TType.STOP:
9236 
        break
9237 
      if fid == 1:
9238 
        if ftype == TType.I64:
559 chandransh 9239 
          self.userId = iprot.readI64();
94 ashish 9240 
        else:
9241 
          iprot.skip(ftype)
559 chandransh 9242 
      else:
9243 
        iprot.skip(ftype)
9244 
      iprot.readFieldEnd()
9245 
    iprot.readStructEnd()
9246 
 
9247 
  def write(self, oprot):
9248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9250 
      return
9251 
    oprot.writeStructBegin('createCart_args')
9252 
    if self.userId != None:
9253 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9254 
      oprot.writeI64(self.userId)
9255 
      oprot.writeFieldEnd()
9256 
    oprot.writeFieldStop()
9257 
    oprot.writeStructEnd()
9258 
 
9259 
  def __repr__(self):
9260 
    L = ['%s=%r' % (key, value)
9261 
      for key, value in self.__dict__.iteritems()]
9262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9263 
 
9264 
  def __eq__(self, other):
9265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9266 
 
9267 
  def __ne__(self, other):
9268 
    return not (self == other)
9269 
 
9270 
class createCart_result:
9271 
  """
9272 
  Attributes:
9273 
   - success
9274 
   - scx
9275 
  """
9276 
 
9277 
  thrift_spec = (
9278 
    (0, TType.I64, 'success', None, None, ), # 0
9279 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9280 
  )
9281 
 
9282 
  def __init__(self, success=None, scx=None,):
9283 
    self.success = success
9284 
    self.scx = scx
9285 
 
9286 
  def read(self, iprot):
9287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9289 
      return
9290 
    iprot.readStructBegin()
9291 
    while True:
9292 
      (fname, ftype, fid) = iprot.readFieldBegin()
9293 
      if ftype == TType.STOP:
9294 
        break
9295 
      if fid == 0:
94 ashish 9296 
        if ftype == TType.I64:
559 chandransh 9297 
          self.success = iprot.readI64();
94 ashish 9298 
        else:
9299 
          iprot.skip(ftype)
559 chandransh 9300 
      elif fid == 1:
9301 
        if ftype == TType.STRUCT:
9302 
          self.scx = ShoppingCartException()
9303 
          self.scx.read(iprot)
9304 
        else:
9305 
          iprot.skip(ftype)
94 ashish 9306 
      else:
9307 
        iprot.skip(ftype)
9308 
      iprot.readFieldEnd()
9309 
    iprot.readStructEnd()
9310 
 
9311 
  def write(self, oprot):
9312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9314 
      return
559 chandransh 9315 
    oprot.writeStructBegin('createCart_result')
9316 
    if self.success != None:
9317 
      oprot.writeFieldBegin('success', TType.I64, 0)
9318 
      oprot.writeI64(self.success)
94 ashish 9319 
      oprot.writeFieldEnd()
559 chandransh 9320 
    if self.scx != None:
9321 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9322 
      self.scx.write(oprot)
94 ashish 9323 
      oprot.writeFieldEnd()
9324 
    oprot.writeFieldStop()
9325 
    oprot.writeStructEnd()
9326 
 
9327 
  def __repr__(self):
9328 
    L = ['%s=%r' % (key, value)
9329 
      for key, value in self.__dict__.iteritems()]
9330 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9331 
 
9332 
  def __eq__(self, other):
9333 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9334 
 
9335 
  def __ne__(self, other):
9336 
    return not (self == other)
9337 
 
559 chandransh 9338 
class getCurrentCart_args:
94 ashish 9339 
  """
9340 
  Attributes:
559 chandransh 9341 
   - userId
9342 
  """
9343 
 
9344 
  thrift_spec = (
9345 
    None, # 0
9346 
    (1, TType.I64, 'userId', None, None, ), # 1
9347 
  )
9348 
 
9349 
  def __init__(self, userId=None,):
9350 
    self.userId = userId
9351 
 
9352 
  def read(self, iprot):
9353 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9354 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9355 
      return
9356 
    iprot.readStructBegin()
9357 
    while True:
9358 
      (fname, ftype, fid) = iprot.readFieldBegin()
9359 
      if ftype == TType.STOP:
9360 
        break
9361 
      if fid == 1:
9362 
        if ftype == TType.I64:
9363 
          self.userId = iprot.readI64();
9364 
        else:
9365 
          iprot.skip(ftype)
9366 
      else:
9367 
        iprot.skip(ftype)
9368 
      iprot.readFieldEnd()
9369 
    iprot.readStructEnd()
9370 
 
9371 
  def write(self, oprot):
9372 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9373 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9374 
      return
9375 
    oprot.writeStructBegin('getCurrentCart_args')
9376 
    if self.userId != None:
9377 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9378 
      oprot.writeI64(self.userId)
9379 
      oprot.writeFieldEnd()
9380 
    oprot.writeFieldStop()
9381 
    oprot.writeStructEnd()
9382 
 
9383 
  def __repr__(self):
9384 
    L = ['%s=%r' % (key, value)
9385 
      for key, value in self.__dict__.iteritems()]
9386 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9387 
 
9388 
  def __eq__(self, other):
9389 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9390 
 
9391 
  def __ne__(self, other):
9392 
    return not (self == other)
9393 
 
9394 
class getCurrentCart_result:
9395 
  """
9396 
  Attributes:
94 ashish 9397 
   - success
559 chandransh 9398 
   - scx
94 ashish 9399 
  """
9400 
 
9401 
  thrift_spec = (
559 chandransh 9402 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9403 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9404 
  )
9405 
 
559 chandransh 9406 
  def __init__(self, success=None, scx=None,):
94 ashish 9407 
    self.success = success
559 chandransh 9408 
    self.scx = scx
94 ashish 9409 
 
9410 
  def read(self, iprot):
9411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9413 
      return
9414 
    iprot.readStructBegin()
9415 
    while True:
9416 
      (fname, ftype, fid) = iprot.readFieldBegin()
9417 
      if ftype == TType.STOP:
9418 
        break
9419 
      if fid == 0:
559 chandransh 9420 
        if ftype == TType.STRUCT:
9421 
          self.success = Cart()
9422 
          self.success.read(iprot)
94 ashish 9423 
        else:
9424 
          iprot.skip(ftype)
9425 
      elif fid == 1:
9426 
        if ftype == TType.STRUCT:
559 chandransh 9427 
          self.scx = ShoppingCartException()
9428 
          self.scx.read(iprot)
94 ashish 9429 
        else:
9430 
          iprot.skip(ftype)
9431 
      else:
9432 
        iprot.skip(ftype)
9433 
      iprot.readFieldEnd()
9434 
    iprot.readStructEnd()
9435 
 
9436 
  def write(self, oprot):
9437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9439 
      return
559 chandransh 9440 
    oprot.writeStructBegin('getCurrentCart_result')
94 ashish 9441 
    if self.success != None:
559 chandransh 9442 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9443 
      self.success.write(oprot)
94 ashish 9444 
      oprot.writeFieldEnd()
559 chandransh 9445 
    if self.scx != None:
9446 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9447 
      self.scx.write(oprot)
94 ashish 9448 
      oprot.writeFieldEnd()
9449 
    oprot.writeFieldStop()
9450 
    oprot.writeStructEnd()
9451 
 
9452 
  def __repr__(self):
9453 
    L = ['%s=%r' % (key, value)
9454 
      for key, value in self.__dict__.iteritems()]
9455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9456 
 
9457 
  def __eq__(self, other):
9458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9459 
 
9460 
  def __ne__(self, other):
9461 
    return not (self == other)
9462 
 
559 chandransh 9463 
class getCart_args:
504 rajveer 9464 
  """
9465 
  Attributes:
559 chandransh 9466 
   - cartId
504 rajveer 9467 
  """
9468 
 
9469 
  thrift_spec = (
9470 
    None, # 0
559 chandransh 9471 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 9472 
  )
9473 
 
559 chandransh 9474 
  def __init__(self, cartId=None,):
9475 
    self.cartId = cartId
504 rajveer 9476 
 
9477 
  def read(self, iprot):
9478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9480 
      return
9481 
    iprot.readStructBegin()
9482 
    while True:
9483 
      (fname, ftype, fid) = iprot.readFieldBegin()
9484 
      if ftype == TType.STOP:
9485 
        break
9486 
      if fid == 1:
9487 
        if ftype == TType.I64:
559 chandransh 9488 
          self.cartId = iprot.readI64();
504 rajveer 9489 
        else:
9490 
          iprot.skip(ftype)
9491 
      else:
9492 
        iprot.skip(ftype)
9493 
      iprot.readFieldEnd()
9494 
    iprot.readStructEnd()
9495 
 
9496 
  def write(self, oprot):
9497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9499 
      return
559 chandransh 9500 
    oprot.writeStructBegin('getCart_args')
9501 
    if self.cartId != None:
9502 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9503 
      oprot.writeI64(self.cartId)
504 rajveer 9504 
      oprot.writeFieldEnd()
9505 
    oprot.writeFieldStop()
9506 
    oprot.writeStructEnd()
9507 
 
9508 
  def __repr__(self):
9509 
    L = ['%s=%r' % (key, value)
9510 
      for key, value in self.__dict__.iteritems()]
9511 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9512 
 
9513 
  def __eq__(self, other):
9514 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9515 
 
9516 
  def __ne__(self, other):
9517 
    return not (self == other)
9518 
 
559 chandransh 9519 
class getCart_result:
504 rajveer 9520 
  """
9521 
  Attributes:
9522 
   - success
559 chandransh 9523 
   - scx
504 rajveer 9524 
  """
9525 
 
9526 
  thrift_spec = (
559 chandransh 9527 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9528 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 9529 
  )
9530 
 
559 chandransh 9531 
  def __init__(self, success=None, scx=None,):
504 rajveer 9532 
    self.success = success
559 chandransh 9533 
    self.scx = scx
504 rajveer 9534 
 
9535 
  def read(self, iprot):
9536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9538 
      return
9539 
    iprot.readStructBegin()
9540 
    while True:
9541 
      (fname, ftype, fid) = iprot.readFieldBegin()
9542 
      if ftype == TType.STOP:
9543 
        break
9544 
      if fid == 0:
559 chandransh 9545 
        if ftype == TType.STRUCT:
9546 
          self.success = Cart()
9547 
          self.success.read(iprot)
504 rajveer 9548 
        else:
9549 
          iprot.skip(ftype)
9550 
      elif fid == 1:
9551 
        if ftype == TType.STRUCT:
559 chandransh 9552 
          self.scx = ShoppingCartException()
9553 
          self.scx.read(iprot)
504 rajveer 9554 
        else:
9555 
          iprot.skip(ftype)
9556 
      else:
9557 
        iprot.skip(ftype)
9558 
      iprot.readFieldEnd()
9559 
    iprot.readStructEnd()
9560 
 
9561 
  def write(self, oprot):
9562 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9563 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9564 
      return
559 chandransh 9565 
    oprot.writeStructBegin('getCart_result')
504 rajveer 9566 
    if self.success != None:
559 chandransh 9567 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9568 
      self.success.write(oprot)
504 rajveer 9569 
      oprot.writeFieldEnd()
559 chandransh 9570 
    if self.scx != None:
9571 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9572 
      self.scx.write(oprot)
504 rajveer 9573 
      oprot.writeFieldEnd()
9574 
    oprot.writeFieldStop()
9575 
    oprot.writeStructEnd()
9576 
 
9577 
  def __repr__(self):
9578 
    L = ['%s=%r' % (key, value)
9579 
      for key, value in self.__dict__.iteritems()]
9580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9581 
 
9582 
  def __eq__(self, other):
9583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9584 
 
9585 
  def __ne__(self, other):
9586 
    return not (self == other)
9587 
 
559 chandransh 9588 
class getCartsForUser_args:
94 ashish 9589 
  """
9590 
  Attributes:
559 chandransh 9591 
   - userId
9592 
   - status
94 ashish 9593 
  """
9594 
 
9595 
  thrift_spec = (
9596 
    None, # 0
559 chandransh 9597 
    (1, TType.I64, 'userId', None, None, ), # 1
9598 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 9599 
  )
9600 
 
559 chandransh 9601 
  def __init__(self, userId=None, status=None,):
9602 
    self.userId = userId
9603 
    self.status = status
94 ashish 9604 
 
9605 
  def read(self, iprot):
9606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9608 
      return
9609 
    iprot.readStructBegin()
9610 
    while True:
9611 
      (fname, ftype, fid) = iprot.readFieldBegin()
9612 
      if ftype == TType.STOP:
9613 
        break
9614 
      if fid == 1:
9615 
        if ftype == TType.I64:
559 chandransh 9616 
          self.userId = iprot.readI64();
94 ashish 9617 
        else:
9618 
          iprot.skip(ftype)
9619 
      elif fid == 2:
559 chandransh 9620 
        if ftype == TType.I32:
9621 
          self.status = iprot.readI32();
94 ashish 9622 
        else:
9623 
          iprot.skip(ftype)
9624 
      else:
9625 
        iprot.skip(ftype)
9626 
      iprot.readFieldEnd()
9627 
    iprot.readStructEnd()
9628 
 
9629 
  def write(self, oprot):
9630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9632 
      return
559 chandransh 9633 
    oprot.writeStructBegin('getCartsForUser_args')
9634 
    if self.userId != None:
9635 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9636 
      oprot.writeI64(self.userId)
94 ashish 9637 
      oprot.writeFieldEnd()
559 chandransh 9638 
    if self.status != None:
9639 
      oprot.writeFieldBegin('status', TType.I32, 2)
9640 
      oprot.writeI32(self.status)
94 ashish 9641 
      oprot.writeFieldEnd()
9642 
    oprot.writeFieldStop()
9643 
    oprot.writeStructEnd()
9644 
 
9645 
  def __repr__(self):
9646 
    L = ['%s=%r' % (key, value)
9647 
      for key, value in self.__dict__.iteritems()]
9648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9649 
 
9650 
  def __eq__(self, other):
9651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9652 
 
9653 
  def __ne__(self, other):
9654 
    return not (self == other)
9655 
 
559 chandransh 9656 
class getCartsForUser_result:
94 ashish 9657 
  """
9658 
  Attributes:
9659 
   - success
559 chandransh 9660 
   - scx
94 ashish 9661 
  """
9662 
 
9663 
  thrift_spec = (
559 chandransh 9664 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9665 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9666 
  )
9667 
 
559 chandransh 9668 
  def __init__(self, success=None, scx=None,):
94 ashish 9669 
    self.success = success
559 chandransh 9670 
    self.scx = scx
94 ashish 9671 
 
9672 
  def read(self, iprot):
9673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9675 
      return
9676 
    iprot.readStructBegin()
9677 
    while True:
9678 
      (fname, ftype, fid) = iprot.readFieldBegin()
9679 
      if ftype == TType.STOP:
9680 
        break
9681 
      if fid == 0:
559 chandransh 9682 
        if ftype == TType.LIST:
9683 
          self.success = []
1899 vikas 9684 
          (_etype94, _size91) = iprot.readListBegin()
9685 
          for _i95 in xrange(_size91):
9686 
            _elem96 = Cart()
9687 
            _elem96.read(iprot)
9688 
            self.success.append(_elem96)
559 chandransh 9689 
          iprot.readListEnd()
94 ashish 9690 
        else:
9691 
          iprot.skip(ftype)
9692 
      elif fid == 1:
9693 
        if ftype == TType.STRUCT:
559 chandransh 9694 
          self.scx = ShoppingCartException()
9695 
          self.scx.read(iprot)
94 ashish 9696 
        else:
9697 
          iprot.skip(ftype)
9698 
      else:
9699 
        iprot.skip(ftype)
9700 
      iprot.readFieldEnd()
9701 
    iprot.readStructEnd()
9702 
 
9703 
  def write(self, oprot):
9704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9706 
      return
559 chandransh 9707 
    oprot.writeStructBegin('getCartsForUser_result')
94 ashish 9708 
    if self.success != None:
559 chandransh 9709 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9710 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1899 vikas 9711 
      for iter97 in self.success:
9712 
        iter97.write(oprot)
559 chandransh 9713 
      oprot.writeListEnd()
94 ashish 9714 
      oprot.writeFieldEnd()
559 chandransh 9715 
    if self.scx != None:
9716 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9717 
      self.scx.write(oprot)
94 ashish 9718 
      oprot.writeFieldEnd()
9719 
    oprot.writeFieldStop()
9720 
    oprot.writeStructEnd()
9721 
 
9722 
  def __repr__(self):
9723 
    L = ['%s=%r' % (key, value)
9724 
      for key, value in self.__dict__.iteritems()]
9725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9726 
 
9727 
  def __eq__(self, other):
9728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9729 
 
9730 
  def __ne__(self, other):
9731 
    return not (self == other)
9732 
 
559 chandransh 9733 
class getCartsByStatus_args:
94 ashish 9734 
  """
9735 
  Attributes:
559 chandransh 9736 
   - status
94 ashish 9737 
  """
9738 
 
9739 
  thrift_spec = (
9740 
    None, # 0
559 chandransh 9741 
    (1, TType.I32, 'status', None, None, ), # 1
94 ashish 9742 
  )
9743 
 
559 chandransh 9744 
  def __init__(self, status=None,):
9745 
    self.status = status
94 ashish 9746 
 
9747 
  def read(self, iprot):
9748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9750 
      return
9751 
    iprot.readStructBegin()
9752 
    while True:
9753 
      (fname, ftype, fid) = iprot.readFieldBegin()
9754 
      if ftype == TType.STOP:
9755 
        break
9756 
      if fid == 1:
559 chandransh 9757 
        if ftype == TType.I32:
9758 
          self.status = iprot.readI32();
9759 
        else:
9760 
          iprot.skip(ftype)
9761 
      else:
9762 
        iprot.skip(ftype)
9763 
      iprot.readFieldEnd()
9764 
    iprot.readStructEnd()
9765 
 
9766 
  def write(self, oprot):
9767 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9768 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9769 
      return
9770 
    oprot.writeStructBegin('getCartsByStatus_args')
9771 
    if self.status != None:
9772 
      oprot.writeFieldBegin('status', TType.I32, 1)
9773 
      oprot.writeI32(self.status)
9774 
      oprot.writeFieldEnd()
9775 
    oprot.writeFieldStop()
9776 
    oprot.writeStructEnd()
9777 
 
9778 
  def __repr__(self):
9779 
    L = ['%s=%r' % (key, value)
9780 
      for key, value in self.__dict__.iteritems()]
9781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9782 
 
9783 
  def __eq__(self, other):
9784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9785 
 
9786 
  def __ne__(self, other):
9787 
    return not (self == other)
9788 
 
9789 
class getCartsByStatus_result:
9790 
  """
9791 
  Attributes:
9792 
   - success
9793 
   - scx
9794 
  """
9795 
 
9796 
  thrift_spec = (
9797 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9798 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9799 
  )
9800 
 
9801 
  def __init__(self, success=None, scx=None,):
9802 
    self.success = success
9803 
    self.scx = scx
9804 
 
9805 
  def read(self, iprot):
9806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9808 
      return
9809 
    iprot.readStructBegin()
9810 
    while True:
9811 
      (fname, ftype, fid) = iprot.readFieldBegin()
9812 
      if ftype == TType.STOP:
9813 
        break
9814 
      if fid == 0:
9815 
        if ftype == TType.LIST:
9816 
          self.success = []
1899 vikas 9817 
          (_etype101, _size98) = iprot.readListBegin()
9818 
          for _i102 in xrange(_size98):
9819 
            _elem103 = Cart()
9820 
            _elem103.read(iprot)
9821 
            self.success.append(_elem103)
559 chandransh 9822 
          iprot.readListEnd()
9823 
        else:
9824 
          iprot.skip(ftype)
9825 
      elif fid == 1:
9826 
        if ftype == TType.STRUCT:
9827 
          self.scx = ShoppingCartException()
9828 
          self.scx.read(iprot)
9829 
        else:
9830 
          iprot.skip(ftype)
9831 
      else:
9832 
        iprot.skip(ftype)
9833 
      iprot.readFieldEnd()
9834 
    iprot.readStructEnd()
9835 
 
9836 
  def write(self, oprot):
9837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9839 
      return
9840 
    oprot.writeStructBegin('getCartsByStatus_result')
9841 
    if self.success != None:
9842 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9843 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1899 vikas 9844 
      for iter104 in self.success:
9845 
        iter104.write(oprot)
559 chandransh 9846 
      oprot.writeListEnd()
9847 
      oprot.writeFieldEnd()
9848 
    if self.scx != None:
9849 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9850 
      self.scx.write(oprot)
9851 
      oprot.writeFieldEnd()
9852 
    oprot.writeFieldStop()
9853 
    oprot.writeStructEnd()
9854 
 
9855 
  def __repr__(self):
9856 
    L = ['%s=%r' % (key, value)
9857 
      for key, value in self.__dict__.iteritems()]
9858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9859 
 
9860 
  def __eq__(self, other):
9861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9862 
 
9863 
  def __ne__(self, other):
9864 
    return not (self == other)
9865 
 
9866 
class getCartsByTime_args:
9867 
  """
9868 
  Attributes:
9869 
   - from_time
9870 
   - to_time
9871 
   - status
9872 
  """
9873 
 
9874 
  thrift_spec = (
9875 
    None, # 0
9876 
    (1, TType.I64, 'from_time', None, None, ), # 1
9877 
    (2, TType.I64, 'to_time', None, None, ), # 2
9878 
    (3, TType.I32, 'status', None, None, ), # 3
9879 
  )
9880 
 
9881 
  def __init__(self, from_time=None, to_time=None, status=None,):
9882 
    self.from_time = from_time
9883 
    self.to_time = to_time
9884 
    self.status = status
9885 
 
9886 
  def read(self, iprot):
9887 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9888 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9889 
      return
9890 
    iprot.readStructBegin()
9891 
    while True:
9892 
      (fname, ftype, fid) = iprot.readFieldBegin()
9893 
      if ftype == TType.STOP:
9894 
        break
9895 
      if fid == 1:
94 ashish 9896 
        if ftype == TType.I64:
559 chandransh 9897 
          self.from_time = iprot.readI64();
94 ashish 9898 
        else:
9899 
          iprot.skip(ftype)
122 ashish 9900 
      elif fid == 2:
559 chandransh 9901 
        if ftype == TType.I64:
9902 
          self.to_time = iprot.readI64();
122 ashish 9903 
        else:
9904 
          iprot.skip(ftype)
559 chandransh 9905 
      elif fid == 3:
9906 
        if ftype == TType.I32:
9907 
          self.status = iprot.readI32();
9908 
        else:
9909 
          iprot.skip(ftype)
94 ashish 9910 
      else:
9911 
        iprot.skip(ftype)
9912 
      iprot.readFieldEnd()
9913 
    iprot.readStructEnd()
9914 
 
9915 
  def write(self, oprot):
9916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9918 
      return
559 chandransh 9919 
    oprot.writeStructBegin('getCartsByTime_args')
9920 
    if self.from_time != None:
9921 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
9922 
      oprot.writeI64(self.from_time)
94 ashish 9923 
      oprot.writeFieldEnd()
559 chandransh 9924 
    if self.to_time != None:
9925 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
9926 
      oprot.writeI64(self.to_time)
122 ashish 9927 
      oprot.writeFieldEnd()
559 chandransh 9928 
    if self.status != None:
9929 
      oprot.writeFieldBegin('status', TType.I32, 3)
9930 
      oprot.writeI32(self.status)
9931 
      oprot.writeFieldEnd()
94 ashish 9932 
    oprot.writeFieldStop()
9933 
    oprot.writeStructEnd()
9934 
 
9935 
  def __repr__(self):
9936 
    L = ['%s=%r' % (key, value)
9937 
      for key, value in self.__dict__.iteritems()]
9938 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9939 
 
9940 
  def __eq__(self, other):
9941 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9942 
 
9943 
  def __ne__(self, other):
9944 
    return not (self == other)
9945 
 
559 chandransh 9946 
class getCartsByTime_result:
94 ashish 9947 
  """
9948 
  Attributes:
9949 
   - success
559 chandransh 9950 
   - scx
94 ashish 9951 
  """
9952 
 
9953 
  thrift_spec = (
559 chandransh 9954 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9955 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9956 
  )
9957 
 
559 chandransh 9958 
  def __init__(self, success=None, scx=None,):
94 ashish 9959 
    self.success = success
559 chandransh 9960 
    self.scx = scx
94 ashish 9961 
 
9962 
  def read(self, iprot):
9963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9965 
      return
9966 
    iprot.readStructBegin()
9967 
    while True:
9968 
      (fname, ftype, fid) = iprot.readFieldBegin()
9969 
      if ftype == TType.STOP:
9970 
        break
9971 
      if fid == 0:
559 chandransh 9972 
        if ftype == TType.LIST:
9973 
          self.success = []
1899 vikas 9974 
          (_etype108, _size105) = iprot.readListBegin()
9975 
          for _i109 in xrange(_size105):
9976 
            _elem110 = Cart()
9977 
            _elem110.read(iprot)
9978 
            self.success.append(_elem110)
559 chandransh 9979 
          iprot.readListEnd()
94 ashish 9980 
        else:
9981 
          iprot.skip(ftype)
9982 
      elif fid == 1:
9983 
        if ftype == TType.STRUCT:
559 chandransh 9984 
          self.scx = ShoppingCartException()
9985 
          self.scx.read(iprot)
94 ashish 9986 
        else:
9987 
          iprot.skip(ftype)
9988 
      else:
9989 
        iprot.skip(ftype)
9990 
      iprot.readFieldEnd()
9991 
    iprot.readStructEnd()
9992 
 
9993 
  def write(self, oprot):
9994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9996 
      return
559 chandransh 9997 
    oprot.writeStructBegin('getCartsByTime_result')
94 ashish 9998 
    if self.success != None:
559 chandransh 9999 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10000 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1899 vikas 10001 
      for iter111 in self.success:
10002 
        iter111.write(oprot)
559 chandransh 10003 
      oprot.writeListEnd()
94 ashish 10004 
      oprot.writeFieldEnd()
559 chandransh 10005 
    if self.scx != None:
10006 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10007 
      self.scx.write(oprot)
94 ashish 10008 
      oprot.writeFieldEnd()
10009 
    oprot.writeFieldStop()
10010 
    oprot.writeStructEnd()
10011 
 
10012 
  def __repr__(self):
10013 
    L = ['%s=%r' % (key, value)
10014 
      for key, value in self.__dict__.iteritems()]
10015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10016 
 
10017 
  def __eq__(self, other):
10018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10019 
 
10020 
  def __ne__(self, other):
10021 
    return not (self == other)
10022 
 
559 chandransh 10023 
class changeCartStatus_args:
94 ashish 10024 
  """
10025 
  Attributes:
559 chandransh 10026 
   - cartId
10027 
   - status
94 ashish 10028 
  """
10029 
 
10030 
  thrift_spec = (
10031 
    None, # 0
559 chandransh 10032 
    (1, TType.I64, 'cartId', None, None, ), # 1
10033 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 10034 
  )
10035 
 
559 chandransh 10036 
  def __init__(self, cartId=None, status=None,):
10037 
    self.cartId = cartId
10038 
    self.status = status
94 ashish 10039 
 
10040 
  def read(self, iprot):
10041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10043 
      return
10044 
    iprot.readStructBegin()
10045 
    while True:
10046 
      (fname, ftype, fid) = iprot.readFieldBegin()
10047 
      if ftype == TType.STOP:
10048 
        break
10049 
      if fid == 1:
10050 
        if ftype == TType.I64:
559 chandransh 10051 
          self.cartId = iprot.readI64();
94 ashish 10052 
        else:
10053 
          iprot.skip(ftype)
559 chandransh 10054 
      elif fid == 2:
10055 
        if ftype == TType.I32:
10056 
          self.status = iprot.readI32();
10057 
        else:
10058 
          iprot.skip(ftype)
94 ashish 10059 
      else:
10060 
        iprot.skip(ftype)
10061 
      iprot.readFieldEnd()
10062 
    iprot.readStructEnd()
10063 
 
10064 
  def write(self, oprot):
10065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10067 
      return
559 chandransh 10068 
    oprot.writeStructBegin('changeCartStatus_args')
10069 
    if self.cartId != None:
10070 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10071 
      oprot.writeI64(self.cartId)
94 ashish 10072 
      oprot.writeFieldEnd()
559 chandransh 10073 
    if self.status != None:
10074 
      oprot.writeFieldBegin('status', TType.I32, 2)
10075 
      oprot.writeI32(self.status)
10076 
      oprot.writeFieldEnd()
94 ashish 10077 
    oprot.writeFieldStop()
10078 
    oprot.writeStructEnd()
10079 
 
10080 
  def __repr__(self):
10081 
    L = ['%s=%r' % (key, value)
10082 
      for key, value in self.__dict__.iteritems()]
10083 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10084 
 
10085 
  def __eq__(self, other):
10086 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10087 
 
10088 
  def __ne__(self, other):
10089 
    return not (self == other)
10090 
 
559 chandransh 10091 
class changeCartStatus_result:
94 ashish 10092 
  """
10093 
  Attributes:
559 chandransh 10094 
   - scx
10095 
  """
10096 
 
10097 
  thrift_spec = (
10098 
    None, # 0
10099 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10100 
  )
10101 
 
10102 
  def __init__(self, scx=None,):
10103 
    self.scx = scx
10104 
 
10105 
  def read(self, iprot):
10106 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10107 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10108 
      return
10109 
    iprot.readStructBegin()
10110 
    while True:
10111 
      (fname, ftype, fid) = iprot.readFieldBegin()
10112 
      if ftype == TType.STOP:
10113 
        break
10114 
      if fid == 1:
10115 
        if ftype == TType.STRUCT:
10116 
          self.scx = ShoppingCartException()
10117 
          self.scx.read(iprot)
10118 
        else:
10119 
          iprot.skip(ftype)
10120 
      else:
10121 
        iprot.skip(ftype)
10122 
      iprot.readFieldEnd()
10123 
    iprot.readStructEnd()
10124 
 
10125 
  def write(self, oprot):
10126 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10127 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10128 
      return
10129 
    oprot.writeStructBegin('changeCartStatus_result')
10130 
    if self.scx != None:
10131 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10132 
      self.scx.write(oprot)
10133 
      oprot.writeFieldEnd()
10134 
    oprot.writeFieldStop()
10135 
    oprot.writeStructEnd()
10136 
 
10137 
  def __repr__(self):
10138 
    L = ['%s=%r' % (key, value)
10139 
      for key, value in self.__dict__.iteritems()]
10140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10141 
 
10142 
  def __eq__(self, other):
10143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10144 
 
10145 
  def __ne__(self, other):
10146 
    return not (self == other)
10147 
 
10148 
class addItemToCart_args:
10149 
  """
10150 
  Attributes:
10151 
   - cartId
10152 
   - itemId
10153 
   - quantity
10154 
  """
10155 
 
10156 
  thrift_spec = (
10157 
    None, # 0
10158 
    (1, TType.I64, 'cartId', None, None, ), # 1
10159 
    (2, TType.I64, 'itemId', None, None, ), # 2
10160 
    (3, TType.I64, 'quantity', None, None, ), # 3
10161 
  )
10162 
 
10163 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
10164 
    self.cartId = cartId
10165 
    self.itemId = itemId
10166 
    self.quantity = quantity
10167 
 
10168 
  def read(self, iprot):
10169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10171 
      return
10172 
    iprot.readStructBegin()
10173 
    while True:
10174 
      (fname, ftype, fid) = iprot.readFieldBegin()
10175 
      if ftype == TType.STOP:
10176 
        break
10177 
      if fid == 1:
10178 
        if ftype == TType.I64:
10179 
          self.cartId = iprot.readI64();
10180 
        else:
10181 
          iprot.skip(ftype)
10182 
      elif fid == 2:
10183 
        if ftype == TType.I64:
10184 
          self.itemId = iprot.readI64();
10185 
        else:
10186 
          iprot.skip(ftype)
10187 
      elif fid == 3:
10188 
        if ftype == TType.I64:
10189 
          self.quantity = iprot.readI64();
10190 
        else:
10191 
          iprot.skip(ftype)
10192 
      else:
10193 
        iprot.skip(ftype)
10194 
      iprot.readFieldEnd()
10195 
    iprot.readStructEnd()
10196 
 
10197 
  def write(self, oprot):
10198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10200 
      return
10201 
    oprot.writeStructBegin('addItemToCart_args')
10202 
    if self.cartId != None:
10203 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10204 
      oprot.writeI64(self.cartId)
10205 
      oprot.writeFieldEnd()
10206 
    if self.itemId != None:
10207 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10208 
      oprot.writeI64(self.itemId)
10209 
      oprot.writeFieldEnd()
10210 
    if self.quantity != None:
10211 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10212 
      oprot.writeI64(self.quantity)
10213 
      oprot.writeFieldEnd()
10214 
    oprot.writeFieldStop()
10215 
    oprot.writeStructEnd()
10216 
 
10217 
  def __repr__(self):
10218 
    L = ['%s=%r' % (key, value)
10219 
      for key, value in self.__dict__.iteritems()]
10220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10221 
 
10222 
  def __eq__(self, other):
10223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10224 
 
10225 
  def __ne__(self, other):
10226 
    return not (self == other)
10227 
 
10228 
class addItemToCart_result:
10229 
  """
10230 
  Attributes:
10231 
   - scx
10232 
  """
10233 
 
10234 
  thrift_spec = (
10235 
    None, # 0
10236 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10237 
  )
10238 
 
10239 
  def __init__(self, scx=None,):
10240 
    self.scx = scx
10241 
 
10242 
  def read(self, iprot):
10243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10245 
      return
10246 
    iprot.readStructBegin()
10247 
    while True:
10248 
      (fname, ftype, fid) = iprot.readFieldBegin()
10249 
      if ftype == TType.STOP:
10250 
        break
10251 
      if fid == 1:
10252 
        if ftype == TType.STRUCT:
10253 
          self.scx = ShoppingCartException()
10254 
          self.scx.read(iprot)
10255 
        else:
10256 
          iprot.skip(ftype)
10257 
      else:
10258 
        iprot.skip(ftype)
10259 
      iprot.readFieldEnd()
10260 
    iprot.readStructEnd()
10261 
 
10262 
  def write(self, oprot):
10263 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10264 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10265 
      return
10266 
    oprot.writeStructBegin('addItemToCart_result')
10267 
    if self.scx != None:
10268 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10269 
      self.scx.write(oprot)
10270 
      oprot.writeFieldEnd()
10271 
    oprot.writeFieldStop()
10272 
    oprot.writeStructEnd()
10273 
 
10274 
  def __repr__(self):
10275 
    L = ['%s=%r' % (key, value)
10276 
      for key, value in self.__dict__.iteritems()]
10277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10278 
 
10279 
  def __eq__(self, other):
10280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10281 
 
10282 
  def __ne__(self, other):
10283 
    return not (self == other)
10284 
 
10285 
class deleteItemFromCart_args:
10286 
  """
10287 
  Attributes:
10288 
   - cartId
10289 
   - itemId
10290 
  """
10291 
 
10292 
  thrift_spec = (
10293 
    None, # 0
10294 
    (1, TType.I64, 'cartId', None, None, ), # 1
10295 
    (2, TType.I64, 'itemId', None, None, ), # 2
10296 
  )
10297 
 
10298 
  def __init__(self, cartId=None, itemId=None,):
10299 
    self.cartId = cartId
10300 
    self.itemId = itemId
10301 
 
10302 
  def read(self, iprot):
10303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10305 
      return
10306 
    iprot.readStructBegin()
10307 
    while True:
10308 
      (fname, ftype, fid) = iprot.readFieldBegin()
10309 
      if ftype == TType.STOP:
10310 
        break
10311 
      if fid == 1:
10312 
        if ftype == TType.I64:
10313 
          self.cartId = iprot.readI64();
10314 
        else:
10315 
          iprot.skip(ftype)
10316 
      elif fid == 2:
10317 
        if ftype == TType.I64:
10318 
          self.itemId = iprot.readI64();
10319 
        else:
10320 
          iprot.skip(ftype)
10321 
      else:
10322 
        iprot.skip(ftype)
10323 
      iprot.readFieldEnd()
10324 
    iprot.readStructEnd()
10325 
 
10326 
  def write(self, oprot):
10327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10329 
      return
10330 
    oprot.writeStructBegin('deleteItemFromCart_args')
10331 
    if self.cartId != None:
10332 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10333 
      oprot.writeI64(self.cartId)
10334 
      oprot.writeFieldEnd()
10335 
    if self.itemId != None:
10336 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10337 
      oprot.writeI64(self.itemId)
10338 
      oprot.writeFieldEnd()
10339 
    oprot.writeFieldStop()
10340 
    oprot.writeStructEnd()
10341 
 
10342 
  def __repr__(self):
10343 
    L = ['%s=%r' % (key, value)
10344 
      for key, value in self.__dict__.iteritems()]
10345 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10346 
 
10347 
  def __eq__(self, other):
10348 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10349 
 
10350 
  def __ne__(self, other):
10351 
    return not (self == other)
10352 
 
10353 
class deleteItemFromCart_result:
10354 
  """
10355 
  Attributes:
10356 
   - scx
10357 
  """
10358 
 
10359 
  thrift_spec = (
10360 
    None, # 0
10361 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10362 
  )
10363 
 
10364 
  def __init__(self, scx=None,):
10365 
    self.scx = scx
10366 
 
10367 
  def read(self, iprot):
10368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10370 
      return
10371 
    iprot.readStructBegin()
10372 
    while True:
10373 
      (fname, ftype, fid) = iprot.readFieldBegin()
10374 
      if ftype == TType.STOP:
10375 
        break
10376 
      if fid == 1:
10377 
        if ftype == TType.STRUCT:
10378 
          self.scx = ShoppingCartException()
10379 
          self.scx.read(iprot)
10380 
        else:
10381 
          iprot.skip(ftype)
10382 
      else:
10383 
        iprot.skip(ftype)
10384 
      iprot.readFieldEnd()
10385 
    iprot.readStructEnd()
10386 
 
10387 
  def write(self, oprot):
10388 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10389 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10390 
      return
10391 
    oprot.writeStructBegin('deleteItemFromCart_result')
10392 
    if self.scx != None:
10393 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10394 
      self.scx.write(oprot)
10395 
      oprot.writeFieldEnd()
10396 
    oprot.writeFieldStop()
10397 
    oprot.writeStructEnd()
10398 
 
10399 
  def __repr__(self):
10400 
    L = ['%s=%r' % (key, value)
10401 
      for key, value in self.__dict__.iteritems()]
10402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10403 
 
10404 
  def __eq__(self, other):
10405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10406 
 
10407 
  def __ne__(self, other):
10408 
    return not (self == other)
10409 
 
10410 
class changeQuantity_args:
10411 
  """
10412 
  Attributes:
10413 
   - cartId
10414 
   - itemId
10415 
   - quantity
10416 
  """
10417 
 
10418 
  thrift_spec = (
10419 
    None, # 0
10420 
    (1, TType.I64, 'cartId', None, None, ), # 1
10421 
    (2, TType.I64, 'itemId', None, None, ), # 2
10422 
    (3, TType.I64, 'quantity', None, None, ), # 3
10423 
  )
10424 
 
10425 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
10426 
    self.cartId = cartId
10427 
    self.itemId = itemId
10428 
    self.quantity = quantity
10429 
 
10430 
  def read(self, iprot):
10431 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10432 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10433 
      return
10434 
    iprot.readStructBegin()
10435 
    while True:
10436 
      (fname, ftype, fid) = iprot.readFieldBegin()
10437 
      if ftype == TType.STOP:
10438 
        break
10439 
      if fid == 1:
10440 
        if ftype == TType.I64:
10441 
          self.cartId = iprot.readI64();
10442 
        else:
10443 
          iprot.skip(ftype)
10444 
      elif fid == 2:
10445 
        if ftype == TType.I64:
10446 
          self.itemId = iprot.readI64();
10447 
        else:
10448 
          iprot.skip(ftype)
10449 
      elif fid == 3:
10450 
        if ftype == TType.I64:
10451 
          self.quantity = iprot.readI64();
10452 
        else:
10453 
          iprot.skip(ftype)
10454 
      else:
10455 
        iprot.skip(ftype)
10456 
      iprot.readFieldEnd()
10457 
    iprot.readStructEnd()
10458 
 
10459 
  def write(self, oprot):
10460 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10461 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10462 
      return
10463 
    oprot.writeStructBegin('changeQuantity_args')
10464 
    if self.cartId != None:
10465 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10466 
      oprot.writeI64(self.cartId)
10467 
      oprot.writeFieldEnd()
10468 
    if self.itemId != None:
10469 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10470 
      oprot.writeI64(self.itemId)
10471 
      oprot.writeFieldEnd()
10472 
    if self.quantity != None:
10473 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10474 
      oprot.writeI64(self.quantity)
10475 
      oprot.writeFieldEnd()
10476 
    oprot.writeFieldStop()
10477 
    oprot.writeStructEnd()
10478 
 
10479 
  def __repr__(self):
10480 
    L = ['%s=%r' % (key, value)
10481 
      for key, value in self.__dict__.iteritems()]
10482 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10483 
 
10484 
  def __eq__(self, other):
10485 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10486 
 
10487 
  def __ne__(self, other):
10488 
    return not (self == other)
10489 
 
10490 
class changeQuantity_result:
10491 
  """
10492 
  Attributes:
10493 
   - scx
10494 
  """
10495 
 
10496 
  thrift_spec = (
10497 
    None, # 0
10498 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10499 
  )
10500 
 
10501 
  def __init__(self, scx=None,):
10502 
    self.scx = scx
10503 
 
10504 
  def read(self, iprot):
10505 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10506 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10507 
      return
10508 
    iprot.readStructBegin()
10509 
    while True:
10510 
      (fname, ftype, fid) = iprot.readFieldBegin()
10511 
      if ftype == TType.STOP:
10512 
        break
10513 
      if fid == 1:
10514 
        if ftype == TType.STRUCT:
10515 
          self.scx = ShoppingCartException()
10516 
          self.scx.read(iprot)
10517 
        else:
10518 
          iprot.skip(ftype)
10519 
      else:
10520 
        iprot.skip(ftype)
10521 
      iprot.readFieldEnd()
10522 
    iprot.readStructEnd()
10523 
 
10524 
  def write(self, oprot):
10525 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10526 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10527 
      return
10528 
    oprot.writeStructBegin('changeQuantity_result')
10529 
    if self.scx != None:
10530 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10531 
      self.scx.write(oprot)
10532 
      oprot.writeFieldEnd()
10533 
    oprot.writeFieldStop()
10534 
    oprot.writeStructEnd()
10535 
 
10536 
  def __repr__(self):
10537 
    L = ['%s=%r' % (key, value)
10538 
      for key, value in self.__dict__.iteritems()]
10539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10540 
 
10541 
  def __eq__(self, other):
10542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10543 
 
10544 
  def __ne__(self, other):
10545 
    return not (self == other)
10546 
 
10547 
class changeItemStatus_args:
10548 
  """
10549 
  Attributes:
10550 
   - cartId
10551 
   - itemId
10552 
   - status
10553 
  """
10554 
 
10555 
  thrift_spec = (
10556 
    None, # 0
10557 
    (1, TType.I64, 'cartId', None, None, ), # 1
10558 
    (2, TType.I64, 'itemId', None, None, ), # 2
10559 
    (3, TType.I32, 'status', None, None, ), # 3
10560 
  )
10561 
 
10562 
  def __init__(self, cartId=None, itemId=None, status=None,):
10563 
    self.cartId = cartId
10564 
    self.itemId = itemId
10565 
    self.status = status
10566 
 
10567 
  def read(self, iprot):
10568 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10569 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10570 
      return
10571 
    iprot.readStructBegin()
10572 
    while True:
10573 
      (fname, ftype, fid) = iprot.readFieldBegin()
10574 
      if ftype == TType.STOP:
10575 
        break
10576 
      if fid == 1:
10577 
        if ftype == TType.I64:
10578 
          self.cartId = iprot.readI64();
10579 
        else:
10580 
          iprot.skip(ftype)
10581 
      elif fid == 2:
10582 
        if ftype == TType.I64:
10583 
          self.itemId = iprot.readI64();
10584 
        else:
10585 
          iprot.skip(ftype)
10586 
      elif fid == 3:
10587 
        if ftype == TType.I32:
10588 
          self.status = iprot.readI32();
10589 
        else:
10590 
          iprot.skip(ftype)
10591 
      else:
10592 
        iprot.skip(ftype)
10593 
      iprot.readFieldEnd()
10594 
    iprot.readStructEnd()
10595 
 
10596 
  def write(self, oprot):
10597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10599 
      return
10600 
    oprot.writeStructBegin('changeItemStatus_args')
10601 
    if self.cartId != None:
10602 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10603 
      oprot.writeI64(self.cartId)
10604 
      oprot.writeFieldEnd()
10605 
    if self.itemId != None:
10606 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10607 
      oprot.writeI64(self.itemId)
10608 
      oprot.writeFieldEnd()
10609 
    if self.status != None:
10610 
      oprot.writeFieldBegin('status', TType.I32, 3)
10611 
      oprot.writeI32(self.status)
10612 
      oprot.writeFieldEnd()
10613 
    oprot.writeFieldStop()
10614 
    oprot.writeStructEnd()
10615 
 
10616 
  def __repr__(self):
10617 
    L = ['%s=%r' % (key, value)
10618 
      for key, value in self.__dict__.iteritems()]
10619 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10620 
 
10621 
  def __eq__(self, other):
10622 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10623 
 
10624 
  def __ne__(self, other):
10625 
    return not (self == other)
10626 
 
10627 
class changeItemStatus_result:
10628 
  """
10629 
  Attributes:
10630 
   - scx
10631 
  """
10632 
 
10633 
  thrift_spec = (
10634 
    None, # 0
10635 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10636 
  )
10637 
 
10638 
  def __init__(self, scx=None,):
10639 
    self.scx = scx
10640 
 
10641 
  def read(self, iprot):
10642 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10643 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10644 
      return
10645 
    iprot.readStructBegin()
10646 
    while True:
10647 
      (fname, ftype, fid) = iprot.readFieldBegin()
10648 
      if ftype == TType.STOP:
10649 
        break
10650 
      if fid == 1:
10651 
        if ftype == TType.STRUCT:
10652 
          self.scx = ShoppingCartException()
10653 
          self.scx.read(iprot)
10654 
        else:
10655 
          iprot.skip(ftype)
10656 
      else:
10657 
        iprot.skip(ftype)
10658 
      iprot.readFieldEnd()
10659 
    iprot.readStructEnd()
10660 
 
10661 
  def write(self, oprot):
10662 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10663 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10664 
      return
10665 
    oprot.writeStructBegin('changeItemStatus_result')
10666 
    if self.scx != None:
10667 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10668 
      self.scx.write(oprot)
10669 
      oprot.writeFieldEnd()
10670 
    oprot.writeFieldStop()
10671 
    oprot.writeStructEnd()
10672 
 
10673 
  def __repr__(self):
10674 
    L = ['%s=%r' % (key, value)
10675 
      for key, value in self.__dict__.iteritems()]
10676 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10677 
 
10678 
  def __eq__(self, other):
10679 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10680 
 
10681 
  def __ne__(self, other):
10682 
    return not (self == other)
10683 
 
10684 
class addAddressToCart_args:
10685 
  """
10686 
  Attributes:
10687 
   - cartId
10688 
   - addressId
10689 
  """
10690 
 
10691 
  thrift_spec = (
10692 
    None, # 0
10693 
    (1, TType.I64, 'cartId', None, None, ), # 1
10694 
    (2, TType.I64, 'addressId', None, None, ), # 2
10695 
  )
10696 
 
10697 
  def __init__(self, cartId=None, addressId=None,):
10698 
    self.cartId = cartId
10699 
    self.addressId = addressId
10700 
 
10701 
  def read(self, iprot):
10702 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10703 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10704 
      return
10705 
    iprot.readStructBegin()
10706 
    while True:
10707 
      (fname, ftype, fid) = iprot.readFieldBegin()
10708 
      if ftype == TType.STOP:
10709 
        break
10710 
      if fid == 1:
10711 
        if ftype == TType.I64:
10712 
          self.cartId = iprot.readI64();
10713 
        else:
10714 
          iprot.skip(ftype)
10715 
      elif fid == 2:
10716 
        if ftype == TType.I64:
10717 
          self.addressId = iprot.readI64();
10718 
        else:
10719 
          iprot.skip(ftype)
10720 
      else:
10721 
        iprot.skip(ftype)
10722 
      iprot.readFieldEnd()
10723 
    iprot.readStructEnd()
10724 
 
10725 
  def write(self, oprot):
10726 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10727 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10728 
      return
10729 
    oprot.writeStructBegin('addAddressToCart_args')
10730 
    if self.cartId != None:
10731 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10732 
      oprot.writeI64(self.cartId)
10733 
      oprot.writeFieldEnd()
10734 
    if self.addressId != None:
10735 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
10736 
      oprot.writeI64(self.addressId)
10737 
      oprot.writeFieldEnd()
10738 
    oprot.writeFieldStop()
10739 
    oprot.writeStructEnd()
10740 
 
10741 
  def __repr__(self):
10742 
    L = ['%s=%r' % (key, value)
10743 
      for key, value in self.__dict__.iteritems()]
10744 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10745 
 
10746 
  def __eq__(self, other):
10747 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10748 
 
10749 
  def __ne__(self, other):
10750 
    return not (self == other)
10751 
 
10752 
class addAddressToCart_result:
575 chandransh 10753 
  """
10754 
  Attributes:
10755 
   - scx
10756 
  """
559 chandransh 10757 
 
10758 
  thrift_spec = (
575 chandransh 10759 
    None, # 0
10760 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 10761 
  )
10762 
 
575 chandransh 10763 
  def __init__(self, scx=None,):
10764 
    self.scx = scx
10765 
 
559 chandransh 10766 
  def read(self, iprot):
10767 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10768 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10769 
      return
10770 
    iprot.readStructBegin()
10771 
    while True:
10772 
      (fname, ftype, fid) = iprot.readFieldBegin()
10773 
      if ftype == TType.STOP:
10774 
        break
575 chandransh 10775 
      if fid == 1:
10776 
        if ftype == TType.STRUCT:
10777 
          self.scx = ShoppingCartException()
10778 
          self.scx.read(iprot)
10779 
        else:
10780 
          iprot.skip(ftype)
559 chandransh 10781 
      else:
10782 
        iprot.skip(ftype)
10783 
      iprot.readFieldEnd()
10784 
    iprot.readStructEnd()
10785 
 
10786 
  def write(self, oprot):
10787 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10788 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10789 
      return
10790 
    oprot.writeStructBegin('addAddressToCart_result')
575 chandransh 10791 
    if self.scx != None:
10792 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10793 
      self.scx.write(oprot)
10794 
      oprot.writeFieldEnd()
559 chandransh 10795 
    oprot.writeFieldStop()
10796 
    oprot.writeStructEnd()
10797 
 
10798 
  def __repr__(self):
10799 
    L = ['%s=%r' % (key, value)
10800 
      for key, value in self.__dict__.iteritems()]
10801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10802 
 
10803 
  def __eq__(self, other):
10804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10805 
 
10806 
  def __ne__(self, other):
10807 
    return not (self == other)
10808 
 
690 chandransh 10809 
class createOrders_args:
559 chandransh 10810 
  """
10811 
  Attributes:
10812 
   - cartId
10813 
  """
10814 
 
10815 
  thrift_spec = (
10816 
    None, # 0
10817 
    (1, TType.I64, 'cartId', None, None, ), # 1
10818 
  )
10819 
 
10820 
  def __init__(self, cartId=None,):
10821 
    self.cartId = cartId
10822 
 
10823 
  def read(self, iprot):
10824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10826 
      return
10827 
    iprot.readStructBegin()
10828 
    while True:
10829 
      (fname, ftype, fid) = iprot.readFieldBegin()
10830 
      if ftype == TType.STOP:
10831 
        break
10832 
      if fid == 1:
10833 
        if ftype == TType.I64:
10834 
          self.cartId = iprot.readI64();
10835 
        else:
10836 
          iprot.skip(ftype)
10837 
      else:
10838 
        iprot.skip(ftype)
10839 
      iprot.readFieldEnd()
10840 
    iprot.readStructEnd()
10841 
 
10842 
  def write(self, oprot):
10843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10845 
      return
690 chandransh 10846 
    oprot.writeStructBegin('createOrders_args')
559 chandransh 10847 
    if self.cartId != None:
10848 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10849 
      oprot.writeI64(self.cartId)
10850 
      oprot.writeFieldEnd()
10851 
    oprot.writeFieldStop()
10852 
    oprot.writeStructEnd()
10853 
 
10854 
  def __repr__(self):
10855 
    L = ['%s=%r' % (key, value)
10856 
      for key, value in self.__dict__.iteritems()]
10857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10858 
 
10859 
  def __eq__(self, other):
10860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10861 
 
10862 
  def __ne__(self, other):
10863 
    return not (self == other)
10864 
 
690 chandransh 10865 
class createOrders_result:
559 chandransh 10866 
  """
10867 
  Attributes:
94 ashish 10868 
   - success
559 chandransh 10869 
   - scx
94 ashish 10870 
  """
10871 
 
10872 
  thrift_spec = (
575 chandransh 10873 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 10874 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10875 
  )
10876 
 
559 chandransh 10877 
  def __init__(self, success=None, scx=None,):
94 ashish 10878 
    self.success = success
559 chandransh 10879 
    self.scx = scx
94 ashish 10880 
 
10881 
  def read(self, iprot):
10882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10884 
      return
10885 
    iprot.readStructBegin()
10886 
    while True:
10887 
      (fname, ftype, fid) = iprot.readFieldBegin()
10888 
      if ftype == TType.STOP:
10889 
        break
10890 
      if fid == 0:
575 chandransh 10891 
        if ftype == TType.I64:
10892 
          self.success = iprot.readI64();
94 ashish 10893 
        else:
10894 
          iprot.skip(ftype)
10895 
      elif fid == 1:
10896 
        if ftype == TType.STRUCT:
559 chandransh 10897 
          self.scx = ShoppingCartException()
10898 
          self.scx.read(iprot)
94 ashish 10899 
        else:
10900 
          iprot.skip(ftype)
10901 
      else:
10902 
        iprot.skip(ftype)
10903 
      iprot.readFieldEnd()
10904 
    iprot.readStructEnd()
10905 
 
10906 
  def write(self, oprot):
10907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10909 
      return
690 chandransh 10910 
    oprot.writeStructBegin('createOrders_result')
94 ashish 10911 
    if self.success != None:
575 chandransh 10912 
      oprot.writeFieldBegin('success', TType.I64, 0)
10913 
      oprot.writeI64(self.success)
94 ashish 10914 
      oprot.writeFieldEnd()
559 chandransh 10915 
    if self.scx != None:
10916 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10917 
      self.scx.write(oprot)
94 ashish 10918 
      oprot.writeFieldEnd()
10919 
    oprot.writeFieldStop()
10920 
    oprot.writeStructEnd()
10921 
 
10922 
  def __repr__(self):
10923 
    L = ['%s=%r' % (key, value)
10924 
      for key, value in self.__dict__.iteritems()]
10925 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10926 
 
10927 
  def __eq__(self, other):
10928 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10929 
 
10930 
  def __ne__(self, other):
10931 
    return not (self == other)
10932 
 
559 chandransh 10933 
class validateCart_args:
94 ashish 10934 
  """
10935 
  Attributes:
559 chandransh 10936 
   - cartId
94 ashish 10937 
  """
10938 
 
10939 
  thrift_spec = (
10940 
    None, # 0
559 chandransh 10941 
    (1, TType.I64, 'cartId', None, None, ), # 1
94 ashish 10942 
  )
10943 
 
559 chandransh 10944 
  def __init__(self, cartId=None,):
10945 
    self.cartId = cartId
94 ashish 10946 
 
10947 
  def read(self, iprot):
10948 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10949 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10950 
      return
10951 
    iprot.readStructBegin()
10952 
    while True:
10953 
      (fname, ftype, fid) = iprot.readFieldBegin()
10954 
      if ftype == TType.STOP:
10955 
        break
10956 
      if fid == 1:
10957 
        if ftype == TType.I64:
559 chandransh 10958 
          self.cartId = iprot.readI64();
94 ashish 10959 
        else:
10960 
          iprot.skip(ftype)
10961 
      else:
10962 
        iprot.skip(ftype)
10963 
      iprot.readFieldEnd()
10964 
    iprot.readStructEnd()
10965 
 
10966 
  def write(self, oprot):
10967 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10968 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10969 
      return
559 chandransh 10970 
    oprot.writeStructBegin('validateCart_args')
10971 
    if self.cartId != None:
10972 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10973 
      oprot.writeI64(self.cartId)
94 ashish 10974 
      oprot.writeFieldEnd()
10975 
    oprot.writeFieldStop()
10976 
    oprot.writeStructEnd()
10977 
 
10978 
  def __repr__(self):
10979 
    L = ['%s=%r' % (key, value)
10980 
      for key, value in self.__dict__.iteritems()]
10981 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10982 
 
10983 
  def __eq__(self, other):
10984 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10985 
 
10986 
  def __ne__(self, other):
10987 
    return not (self == other)
10988 
 
559 chandransh 10989 
class validateCart_result:
94 ashish 10990 
  """
10991 
  Attributes:
10992 
   - success
575 chandransh 10993 
   - scex
94 ashish 10994 
  """
10995 
 
10996 
  thrift_spec = (
1466 ankur.sing 10997 
    (0, TType.STRING, 'success', None, None, ), # 0
575 chandransh 10998 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10999 
  )
11000 
 
575 chandransh 11001 
  def __init__(self, success=None, scex=None,):
94 ashish 11002 
    self.success = success
575 chandransh 11003 
    self.scex = scex
94 ashish 11004 
 
11005 
  def read(self, iprot):
11006 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11007 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11008 
      return
11009 
    iprot.readStructBegin()
11010 
    while True:
11011 
      (fname, ftype, fid) = iprot.readFieldBegin()
11012 
      if ftype == TType.STOP:
11013 
        break
11014 
      if fid == 0:
1466 ankur.sing 11015 
        if ftype == TType.STRING:
11016 
          self.success = iprot.readString();
94 ashish 11017 
        else:
11018 
          iprot.skip(ftype)
575 chandransh 11019 
      elif fid == 1:
11020 
        if ftype == TType.STRUCT:
11021 
          self.scex = ShoppingCartException()
11022 
          self.scex.read(iprot)
11023 
        else:
11024 
          iprot.skip(ftype)
94 ashish 11025 
      else:
11026 
        iprot.skip(ftype)
11027 
      iprot.readFieldEnd()
11028 
    iprot.readStructEnd()
11029 
 
11030 
  def write(self, oprot):
11031 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11032 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11033 
      return
559 chandransh 11034 
    oprot.writeStructBegin('validateCart_result')
94 ashish 11035 
    if self.success != None:
1466 ankur.sing 11036 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11037 
      oprot.writeString(self.success)
94 ashish 11038 
      oprot.writeFieldEnd()
575 chandransh 11039 
    if self.scex != None:
11040 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11041 
      self.scex.write(oprot)
11042 
      oprot.writeFieldEnd()
559 chandransh 11043 
    oprot.writeFieldStop()
11044 
    oprot.writeStructEnd()
11045 
 
11046 
  def __repr__(self):
11047 
    L = ['%s=%r' % (key, value)
11048 
      for key, value in self.__dict__.iteritems()]
11049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11050 
 
11051 
  def __eq__(self, other):
11052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11053 
 
11054 
  def __ne__(self, other):
11055 
    return not (self == other)
11056 
 
690 chandransh 11057 
class mergeCart_args:
575 chandransh 11058 
  """
11059 
  Attributes:
690 chandransh 11060 
   - fromCartId
11061 
   - toCartId
11062 
  """
11063 
 
11064 
  thrift_spec = (
11065 
    None, # 0
11066 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
11067 
    (2, TType.I64, 'toCartId', None, None, ), # 2
11068 
  )
11069 
 
11070 
  def __init__(self, fromCartId=None, toCartId=None,):
11071 
    self.fromCartId = fromCartId
11072 
    self.toCartId = toCartId
11073 
 
11074 
  def read(self, iprot):
11075 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11076 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11077 
      return
11078 
    iprot.readStructBegin()
11079 
    while True:
11080 
      (fname, ftype, fid) = iprot.readFieldBegin()
11081 
      if ftype == TType.STOP:
11082 
        break
11083 
      if fid == 1:
11084 
        if ftype == TType.I64:
11085 
          self.fromCartId = iprot.readI64();
11086 
        else:
11087 
          iprot.skip(ftype)
11088 
      elif fid == 2:
11089 
        if ftype == TType.I64:
11090 
          self.toCartId = iprot.readI64();
11091 
        else:
11092 
          iprot.skip(ftype)
11093 
      else:
11094 
        iprot.skip(ftype)
11095 
      iprot.readFieldEnd()
11096 
    iprot.readStructEnd()
11097 
 
11098 
  def write(self, oprot):
11099 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11100 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11101 
      return
11102 
    oprot.writeStructBegin('mergeCart_args')
11103 
    if self.fromCartId != None:
11104 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
11105 
      oprot.writeI64(self.fromCartId)
11106 
      oprot.writeFieldEnd()
11107 
    if self.toCartId != None:
11108 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
11109 
      oprot.writeI64(self.toCartId)
11110 
      oprot.writeFieldEnd()
11111 
    oprot.writeFieldStop()
11112 
    oprot.writeStructEnd()
11113 
 
11114 
  def __repr__(self):
11115 
    L = ['%s=%r' % (key, value)
11116 
      for key, value in self.__dict__.iteritems()]
11117 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11118 
 
11119 
  def __eq__(self, other):
11120 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11121 
 
11122 
  def __ne__(self, other):
11123 
    return not (self == other)
11124 
 
11125 
class mergeCart_result:
11126 
 
11127 
  thrift_spec = (
11128 
  )
11129 
 
11130 
  def read(self, iprot):
11131 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11132 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11133 
      return
11134 
    iprot.readStructBegin()
11135 
    while True:
11136 
      (fname, ftype, fid) = iprot.readFieldBegin()
11137 
      if ftype == TType.STOP:
11138 
        break
11139 
      else:
11140 
        iprot.skip(ftype)
11141 
      iprot.readFieldEnd()
11142 
    iprot.readStructEnd()
11143 
 
11144 
  def write(self, oprot):
11145 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11146 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11147 
      return
11148 
    oprot.writeStructBegin('mergeCart_result')
11149 
    oprot.writeFieldStop()
11150 
    oprot.writeStructEnd()
11151 
 
11152 
  def __repr__(self):
11153 
    L = ['%s=%r' % (key, value)
11154 
      for key, value in self.__dict__.iteritems()]
11155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11156 
 
11157 
  def __eq__(self, other):
11158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11159 
 
11160 
  def __ne__(self, other):
11161 
    return not (self == other)
11162 
 
11163 
class checkOut_args:
11164 
  """
11165 
  Attributes:
575 chandransh 11166 
   - cartId
11167 
  """
11168 
 
11169 
  thrift_spec = (
11170 
    None, # 0
11171 
    (1, TType.I64, 'cartId', None, None, ), # 1
11172 
  )
11173 
 
11174 
  def __init__(self, cartId=None,):
11175 
    self.cartId = cartId
11176 
 
11177 
  def read(self, iprot):
11178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11180 
      return
11181 
    iprot.readStructBegin()
11182 
    while True:
11183 
      (fname, ftype, fid) = iprot.readFieldBegin()
11184 
      if ftype == TType.STOP:
11185 
        break
11186 
      if fid == 1:
11187 
        if ftype == TType.I64:
11188 
          self.cartId = iprot.readI64();
11189 
        else:
11190 
          iprot.skip(ftype)
11191 
      else:
11192 
        iprot.skip(ftype)
11193 
      iprot.readFieldEnd()
11194 
    iprot.readStructEnd()
11195 
 
11196 
  def write(self, oprot):
11197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11199 
      return
690 chandransh 11200 
    oprot.writeStructBegin('checkOut_args')
575 chandransh 11201 
    if self.cartId != None:
11202 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11203 
      oprot.writeI64(self.cartId)
11204 
      oprot.writeFieldEnd()
11205 
    oprot.writeFieldStop()
11206 
    oprot.writeStructEnd()
11207 
 
11208 
  def __repr__(self):
11209 
    L = ['%s=%r' % (key, value)
11210 
      for key, value in self.__dict__.iteritems()]
11211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11212 
 
11213 
  def __eq__(self, other):
11214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11215 
 
11216 
  def __ne__(self, other):
11217 
    return not (self == other)
11218 
 
690 chandransh 11219 
class checkOut_result:
575 chandransh 11220 
  """
11221 
  Attributes:
11222 
   - success
11223 
   - scex
11224 
  """
11225 
 
11226 
  thrift_spec = (
11227 
    (0, TType.BOOL, 'success', None, None, ), # 0
11228 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11229 
  )
11230 
 
11231 
  def __init__(self, success=None, scex=None,):
11232 
    self.success = success
11233 
    self.scex = scex
11234 
 
11235 
  def read(self, iprot):
11236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11238 
      return
11239 
    iprot.readStructBegin()
11240 
    while True:
11241 
      (fname, ftype, fid) = iprot.readFieldBegin()
11242 
      if ftype == TType.STOP:
11243 
        break
11244 
      if fid == 0:
11245 
        if ftype == TType.BOOL:
11246 
          self.success = iprot.readBool();
11247 
        else:
11248 
          iprot.skip(ftype)
11249 
      elif fid == 1:
11250 
        if ftype == TType.STRUCT:
11251 
          self.scex = ShoppingCartException()
11252 
          self.scex.read(iprot)
11253 
        else:
11254 
          iprot.skip(ftype)
11255 
      else:
11256 
        iprot.skip(ftype)
11257 
      iprot.readFieldEnd()
11258 
    iprot.readStructEnd()
11259 
 
11260 
  def write(self, oprot):
11261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11263 
      return
690 chandransh 11264 
    oprot.writeStructBegin('checkOut_result')
575 chandransh 11265 
    if self.success != None:
11266 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11267 
      oprot.writeBool(self.success)
11268 
      oprot.writeFieldEnd()
11269 
    if self.scex != None:
11270 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11271 
      self.scex.write(oprot)
11272 
      oprot.writeFieldEnd()
11273 
    oprot.writeFieldStop()
11274 
    oprot.writeStructEnd()
11275 
 
11276 
  def __repr__(self):
11277 
    L = ['%s=%r' % (key, value)
11278 
      for key, value in self.__dict__.iteritems()]
11279 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11280 
 
11281 
  def __eq__(self, other):
11282 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11283 
 
11284 
  def __ne__(self, other):
11285 
    return not (self == other)
11286 
 
690 chandransh 11287 
class resetCart_args:
559 chandransh 11288 
  """
11289 
  Attributes:
690 chandransh 11290 
   - cartId
11291 
   - items
559 chandransh 11292 
  """
11293 
 
11294 
  thrift_spec = (
11295 
    None, # 0
690 chandransh 11296 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 11297 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 11298 
  )
11299 
 
690 chandransh 11300 
  def __init__(self, cartId=None, items=None,):
11301 
    self.cartId = cartId
11302 
    self.items = items
559 chandransh 11303 
 
11304 
  def read(self, iprot):
11305 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11306 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11307 
      return
11308 
    iprot.readStructBegin()
11309 
    while True:
11310 
      (fname, ftype, fid) = iprot.readFieldBegin()
11311 
      if ftype == TType.STOP:
11312 
        break
11313 
      if fid == 1:
11314 
        if ftype == TType.I64:
690 chandransh 11315 
          self.cartId = iprot.readI64();
559 chandransh 11316 
        else:
11317 
          iprot.skip(ftype)
11318 
      elif fid == 2:
690 chandransh 11319 
        if ftype == TType.MAP:
11320 
          self.items = {}
1899 vikas 11321 
          (_ktype113, _vtype114, _size112 ) = iprot.readMapBegin()
11322 
          for _i116 in xrange(_size112):
11323 
            _key117 = iprot.readI64();
11324 
            _val118 = iprot.readDouble();
11325 
            self.items[_key117] = _val118
690 chandransh 11326 
          iprot.readMapEnd()
559 chandransh 11327 
        else:
11328 
          iprot.skip(ftype)
11329 
      else:
11330 
        iprot.skip(ftype)
11331 
      iprot.readFieldEnd()
11332 
    iprot.readStructEnd()
11333 
 
11334 
  def write(self, oprot):
11335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11337 
      return
690 chandransh 11338 
    oprot.writeStructBegin('resetCart_args')
11339 
    if self.cartId != None:
11340 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11341 
      oprot.writeI64(self.cartId)
94 ashish 11342 
      oprot.writeFieldEnd()
690 chandransh 11343 
    if self.items != None:
11344 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 11345 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
1899 vikas 11346 
      for kiter119,viter120 in self.items.items():
11347 
        oprot.writeI64(kiter119)
11348 
        oprot.writeDouble(viter120)
690 chandransh 11349 
      oprot.writeMapEnd()
559 chandransh 11350 
      oprot.writeFieldEnd()
94 ashish 11351 
    oprot.writeFieldStop()
11352 
    oprot.writeStructEnd()
11353 
 
11354 
  def __repr__(self):
11355 
    L = ['%s=%r' % (key, value)
11356 
      for key, value in self.__dict__.iteritems()]
11357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11358 
 
11359 
  def __eq__(self, other):
11360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11361 
 
11362 
  def __ne__(self, other):
11363 
    return not (self == other)
11364 
 
690 chandransh 11365 
class resetCart_result:
11366 
  """
11367 
  Attributes:
11368 
   - success
11369 
   - scex
11370 
  """
559 chandransh 11371 
 
11372 
  thrift_spec = (
690 chandransh 11373 
    (0, TType.BOOL, 'success', None, None, ), # 0
11374 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11375 
  )
11376 
 
690 chandransh 11377 
  def __init__(self, success=None, scex=None,):
11378 
    self.success = success
11379 
    self.scex = scex
11380 
 
559 chandransh 11381 
  def read(self, iprot):
11382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11384 
      return
11385 
    iprot.readStructBegin()
11386 
    while True:
11387 
      (fname, ftype, fid) = iprot.readFieldBegin()
11388 
      if ftype == TType.STOP:
11389 
        break
690 chandransh 11390 
      if fid == 0:
11391 
        if ftype == TType.BOOL:
11392 
          self.success = iprot.readBool();
11393 
        else:
11394 
          iprot.skip(ftype)
11395 
      elif fid == 1:
11396 
        if ftype == TType.STRUCT:
11397 
          self.scex = ShoppingCartException()
11398 
          self.scex.read(iprot)
11399 
        else:
11400 
          iprot.skip(ftype)
559 chandransh 11401 
      else:
11402 
        iprot.skip(ftype)
11403 
      iprot.readFieldEnd()
11404 
    iprot.readStructEnd()
11405 
 
11406 
  def write(self, oprot):
11407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11409 
      return
690 chandransh 11410 
    oprot.writeStructBegin('resetCart_result')
11411 
    if self.success != None:
11412 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11413 
      oprot.writeBool(self.success)
11414 
      oprot.writeFieldEnd()
11415 
    if self.scex != None:
11416 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11417 
      self.scex.write(oprot)
11418 
      oprot.writeFieldEnd()
559 chandransh 11419 
    oprot.writeFieldStop()
11420 
    oprot.writeStructEnd()
11421 
 
11422 
  def __repr__(self):
11423 
    L = ['%s=%r' % (key, value)
11424 
      for key, value in self.__dict__.iteritems()]
11425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11426 
 
11427 
  def __eq__(self, other):
11428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11429 
 
11430 
  def __ne__(self, other):
11431 
    return not (self == other)
11432 
 
772 rajveer 11433 
class getMyResearch_args:
94 ashish 11434 
  """
11435 
  Attributes:
559 chandransh 11436 
   - userId
11437 
  """
11438 
 
11439 
  thrift_spec = (
11440 
    None, # 0
772 rajveer 11441 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 11442 
  )
11443 
 
772 rajveer 11444 
  def __init__(self, userId=None,):
559 chandransh 11445 
    self.userId = userId
11446 
 
11447 
  def read(self, iprot):
11448 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11449 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11450 
      return
11451 
    iprot.readStructBegin()
11452 
    while True:
11453 
      (fname, ftype, fid) = iprot.readFieldBegin()
11454 
      if ftype == TType.STOP:
11455 
        break
11456 
      if fid == 1:
11457 
        if ftype == TType.I64:
11458 
          self.userId = iprot.readI64();
11459 
        else:
11460 
          iprot.skip(ftype)
11461 
      else:
11462 
        iprot.skip(ftype)
11463 
      iprot.readFieldEnd()
11464 
    iprot.readStructEnd()
11465 
 
11466 
  def write(self, oprot):
11467 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11468 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11469 
      return
772 rajveer 11470 
    oprot.writeStructBegin('getMyResearch_args')
559 chandransh 11471 
    if self.userId != None:
772 rajveer 11472 
      oprot.writeFieldBegin('userId', TType.I64, 1)
559 chandransh 11473 
      oprot.writeI64(self.userId)
11474 
      oprot.writeFieldEnd()
11475 
    oprot.writeFieldStop()
11476 
    oprot.writeStructEnd()
11477 
 
11478 
  def __repr__(self):
11479 
    L = ['%s=%r' % (key, value)
11480 
      for key, value in self.__dict__.iteritems()]
11481 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11482 
 
11483 
  def __eq__(self, other):
11484 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11485 
 
11486 
  def __ne__(self, other):
11487 
    return not (self == other)
11488 
 
11489 
class getMyResearch_result:
94 ashish 11490 
  """
11491 
  Attributes:
11492 
   - success
559 chandransh 11493 
   - scx
94 ashish 11494 
  """
11495 
 
11496 
  thrift_spec = (
559 chandransh 11497 
    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
11498 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
94 ashish 11499 
  )
11500 
 
559 chandransh 11501 
  def __init__(self, success=None, scx=None,):
94 ashish 11502 
    self.success = success
559 chandransh 11503 
    self.scx = scx
94 ashish 11504 
 
11505 
  def read(self, iprot):
11506 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11507 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11508 
      return
11509 
    iprot.readStructBegin()
11510 
    while True:
11511 
      (fname, ftype, fid) = iprot.readFieldBegin()
11512 
      if ftype == TType.STOP:
11513 
        break
11514 
      if fid == 0:
559 chandransh 11515 
        if ftype == TType.STRUCT:
11516 
          self.success = Widget()
11517 
          self.success.read(iprot)
94 ashish 11518 
        else:
11519 
          iprot.skip(ftype)
11520 
      elif fid == 1:
11521 
        if ftype == TType.STRUCT:
559 chandransh 11522 
          self.scx = WidgetException()
11523 
          self.scx.read(iprot)
94 ashish 11524 
        else:
11525 
          iprot.skip(ftype)
11526 
      else:
11527 
        iprot.skip(ftype)
11528 
      iprot.readFieldEnd()
11529 
    iprot.readStructEnd()
11530 
 
11531 
  def write(self, oprot):
11532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11534 
      return
559 chandransh 11535 
    oprot.writeStructBegin('getMyResearch_result')
94 ashish 11536 
    if self.success != None:
559 chandransh 11537 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11538 
      self.success.write(oprot)
94 ashish 11539 
      oprot.writeFieldEnd()
559 chandransh 11540 
    if self.scx != None:
11541 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11542 
      self.scx.write(oprot)
94 ashish 11543 
      oprot.writeFieldEnd()
11544 
    oprot.writeFieldStop()
11545 
    oprot.writeStructEnd()
11546 
 
11547 
  def __repr__(self):
11548 
    L = ['%s=%r' % (key, value)
11549 
      for key, value in self.__dict__.iteritems()]
11550 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11551 
 
11552 
  def __eq__(self, other):
11553 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11554 
 
11555 
  def __ne__(self, other):
11556 
    return not (self == other)
11557 
 
559 chandransh 11558 
class updateMyResearch_args:
94 ashish 11559 
  """
11560 
  Attributes:
772 rajveer 11561 
   - userId
11562 
   - itemId
94 ashish 11563 
  """
11564 
 
11565 
  thrift_spec = (
11566 
    None, # 0
772 rajveer 11567 
    (1, TType.I64, 'userId', None, None, ), # 1
11568 
    (2, TType.I64, 'itemId', None, None, ), # 2
94 ashish 11569 
  )
11570 
 
772 rajveer 11571 
  def __init__(self, userId=None, itemId=None,):
11572 
    self.userId = userId
11573 
    self.itemId = itemId
94 ashish 11574 
 
11575 
  def read(self, iprot):
11576 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11577 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11578 
      return
11579 
    iprot.readStructBegin()
11580 
    while True:
11581 
      (fname, ftype, fid) = iprot.readFieldBegin()
11582 
      if ftype == TType.STOP:
11583 
        break
11584 
      if fid == 1:
11585 
        if ftype == TType.I64:
772 rajveer 11586 
          self.userId = iprot.readI64();
94 ashish 11587 
        else:
11588 
          iprot.skip(ftype)
11589 
      elif fid == 2:
559 chandransh 11590 
        if ftype == TType.I64:
772 rajveer 11591 
          self.itemId = iprot.readI64();
94 ashish 11592 
        else:
11593 
          iprot.skip(ftype)
11594 
      else:
11595 
        iprot.skip(ftype)
11596 
      iprot.readFieldEnd()
11597 
    iprot.readStructEnd()
11598 
 
11599 
  def write(self, oprot):
11600 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11601 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11602 
      return
559 chandransh 11603 
    oprot.writeStructBegin('updateMyResearch_args')
772 rajveer 11604 
    if self.userId != None:
11605 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11606 
      oprot.writeI64(self.userId)
94 ashish 11607 
      oprot.writeFieldEnd()
772 rajveer 11608 
    if self.itemId != None:
11609 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11610 
      oprot.writeI64(self.itemId)
94 ashish 11611 
      oprot.writeFieldEnd()
11612 
    oprot.writeFieldStop()
11613 
    oprot.writeStructEnd()
11614 
 
11615 
  def __repr__(self):
11616 
    L = ['%s=%r' % (key, value)
11617 
      for key, value in self.__dict__.iteritems()]
11618 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11619 
 
11620 
  def __eq__(self, other):
11621 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11622 
 
11623 
  def __ne__(self, other):
11624 
    return not (self == other)
11625 
 
559 chandransh 11626 
class updateMyResearch_result:
94 ashish 11627 
  """
11628 
  Attributes:
11629 
   - success
559 chandransh 11630 
   - scx
94 ashish 11631 
  """
11632 
 
11633 
  thrift_spec = (
11634 
    (0, TType.BOOL, 'success', None, None, ), # 0
559 chandransh 11635 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
94 ashish 11636 
  )
11637 
 
559 chandransh 11638 
  def __init__(self, success=None, scx=None,):
94 ashish 11639 
    self.success = success
559 chandransh 11640 
    self.scx = scx
94 ashish 11641 
 
11642 
  def read(self, iprot):
11643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11645 
      return
11646 
    iprot.readStructBegin()
11647 
    while True:
11648 
      (fname, ftype, fid) = iprot.readFieldBegin()
11649 
      if ftype == TType.STOP:
11650 
        break
11651 
      if fid == 0:
11652 
        if ftype == TType.BOOL:
11653 
          self.success = iprot.readBool();
11654 
        else:
11655 
          iprot.skip(ftype)
11656 
      elif fid == 1:
11657 
        if ftype == TType.STRUCT:
559 chandransh 11658 
          self.scx = WidgetException()
11659 
          self.scx.read(iprot)
94 ashish 11660 
        else:
11661 
          iprot.skip(ftype)
11662 
      else:
11663 
        iprot.skip(ftype)
11664 
      iprot.readFieldEnd()
11665 
    iprot.readStructEnd()
11666 
 
11667 
  def write(self, oprot):
11668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11670 
      return
559 chandransh 11671 
    oprot.writeStructBegin('updateMyResearch_result')
94 ashish 11672 
    if self.success != None:
11673 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11674 
      oprot.writeBool(self.success)
11675 
      oprot.writeFieldEnd()
559 chandransh 11676 
    if self.scx != None:
11677 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11678 
      self.scx.write(oprot)
94 ashish 11679 
      oprot.writeFieldEnd()
11680 
    oprot.writeFieldStop()
11681 
    oprot.writeStructEnd()
11682 
 
11683 
  def __repr__(self):
11684 
    L = ['%s=%r' % (key, value)
11685 
      for key, value in self.__dict__.iteritems()]
11686 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11687 
 
11688 
  def __eq__(self, other):
11689 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11690 
 
11691 
  def __ne__(self, other):
11692 
    return not (self == other)
11693 
 
559 chandransh 11694 
class deleteItemFromMyResearch_args:
130 ashish 11695 
  """
11696 
  Attributes:
772 rajveer 11697 
   - userId
11698 
   - itemId
130 ashish 11699 
  """
94 ashish 11700 
 
130 ashish 11701 
  thrift_spec = (
11702 
    None, # 0
772 rajveer 11703 
    (1, TType.I64, 'userId', None, None, ), # 1
11704 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 11705 
  )
11706 
 
772 rajveer 11707 
  def __init__(self, userId=None, itemId=None,):
11708 
    self.userId = userId
11709 
    self.itemId = itemId
130 ashish 11710 
 
11711 
  def read(self, iprot):
11712 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11713 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11714 
      return
11715 
    iprot.readStructBegin()
11716 
    while True:
11717 
      (fname, ftype, fid) = iprot.readFieldBegin()
11718 
      if ftype == TType.STOP:
11719 
        break
11720 
      if fid == 1:
11721 
        if ftype == TType.I64:
772 rajveer 11722 
          self.userId = iprot.readI64();
130 ashish 11723 
        else:
11724 
          iprot.skip(ftype)
559 chandransh 11725 
      elif fid == 2:
11726 
        if ftype == TType.I64:
772 rajveer 11727 
          self.itemId = iprot.readI64();
559 chandransh 11728 
        else:
11729 
          iprot.skip(ftype)
130 ashish 11730 
      else:
11731 
        iprot.skip(ftype)
11732 
      iprot.readFieldEnd()
11733 
    iprot.readStructEnd()
11734 
 
11735 
  def write(self, oprot):
11736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11738 
      return
559 chandransh 11739 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
772 rajveer 11740 
    if self.userId != None:
11741 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11742 
      oprot.writeI64(self.userId)
130 ashish 11743 
      oprot.writeFieldEnd()
772 rajveer 11744 
    if self.itemId != None:
11745 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11746 
      oprot.writeI64(self.itemId)
559 chandransh 11747 
      oprot.writeFieldEnd()
130 ashish 11748 
    oprot.writeFieldStop()
11749 
    oprot.writeStructEnd()
11750 
 
11751 
  def __repr__(self):
11752 
    L = ['%s=%r' % (key, value)
11753 
      for key, value in self.__dict__.iteritems()]
11754 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11755 
 
11756 
  def __eq__(self, other):
11757 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11758 
 
11759 
  def __ne__(self, other):
11760 
    return not (self == other)
11761 
 
559 chandransh 11762 
class deleteItemFromMyResearch_result:
130 ashish 11763 
  """
11764 
  Attributes:
559 chandransh 11765 
   - scx
11766 
  """
11767 
 
11768 
  thrift_spec = (
11769 
    None, # 0
11770 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
11771 
  )
11772 
 
11773 
  def __init__(self, scx=None,):
11774 
    self.scx = scx
11775 
 
11776 
  def read(self, iprot):
11777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11779 
      return
11780 
    iprot.readStructBegin()
11781 
    while True:
11782 
      (fname, ftype, fid) = iprot.readFieldBegin()
11783 
      if ftype == TType.STOP:
11784 
        break
11785 
      if fid == 1:
11786 
        if ftype == TType.STRUCT:
11787 
          self.scx = WidgetException()
11788 
          self.scx.read(iprot)
11789 
        else:
11790 
          iprot.skip(ftype)
11791 
      else:
11792 
        iprot.skip(ftype)
11793 
      iprot.readFieldEnd()
11794 
    iprot.readStructEnd()
11795 
 
11796 
  def write(self, oprot):
11797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11799 
      return
11800 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
11801 
    if self.scx != None:
11802 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11803 
      self.scx.write(oprot)
11804 
      oprot.writeFieldEnd()
11805 
    oprot.writeFieldStop()
11806 
    oprot.writeStructEnd()
11807 
 
11808 
  def __repr__(self):
11809 
    L = ['%s=%r' % (key, value)
11810 
      for key, value in self.__dict__.iteritems()]
11811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11812 
 
11813 
  def __eq__(self, other):
11814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11815 
 
11816 
  def __ne__(self, other):
11817 
    return not (self == other)
11818 
 
772 rajveer 11819 
class updateBrowseHistory_args:
559 chandransh 11820 
  """
11821 
  Attributes:
772 rajveer 11822 
   - userId
11823 
   - itemId
559 chandransh 11824 
  """
11825 
 
11826 
  thrift_spec = (
11827 
    None, # 0
772 rajveer 11828 
    (1, TType.I64, 'userId', None, None, ), # 1
11829 
    (2, TType.I64, 'itemId', None, None, ), # 2
559 chandransh 11830 
  )
11831 
 
772 rajveer 11832 
  def __init__(self, userId=None, itemId=None,):
11833 
    self.userId = userId
11834 
    self.itemId = itemId
559 chandransh 11835 
 
11836 
  def read(self, iprot):
11837 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11838 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11839 
      return
11840 
    iprot.readStructBegin()
11841 
    while True:
11842 
      (fname, ftype, fid) = iprot.readFieldBegin()
11843 
      if ftype == TType.STOP:
11844 
        break
11845 
      if fid == 1:
11846 
        if ftype == TType.I64:
772 rajveer 11847 
          self.userId = iprot.readI64();
559 chandransh 11848 
        else:
11849 
          iprot.skip(ftype)
11850 
      elif fid == 2:
11851 
        if ftype == TType.I64:
772 rajveer 11852 
          self.itemId = iprot.readI64();
559 chandransh 11853 
        else:
11854 
          iprot.skip(ftype)
11855 
      else:
11856 
        iprot.skip(ftype)
11857 
      iprot.readFieldEnd()
11858 
    iprot.readStructEnd()
11859 
 
11860 
  def write(self, oprot):
11861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11863 
      return
772 rajveer 11864 
    oprot.writeStructBegin('updateBrowseHistory_args')
11865 
    if self.userId != None:
11866 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11867 
      oprot.writeI64(self.userId)
559 chandransh 11868 
      oprot.writeFieldEnd()
772 rajveer 11869 
    if self.itemId != None:
11870 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11871 
      oprot.writeI64(self.itemId)
559 chandransh 11872 
      oprot.writeFieldEnd()
11873 
    oprot.writeFieldStop()
11874 
    oprot.writeStructEnd()
11875 
 
11876 
  def __repr__(self):
11877 
    L = ['%s=%r' % (key, value)
11878 
      for key, value in self.__dict__.iteritems()]
11879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11880 
 
11881 
  def __eq__(self, other):
11882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11883 
 
11884 
  def __ne__(self, other):
11885 
    return not (self == other)
11886 
 
772 rajveer 11887 
class updateBrowseHistory_result:
559 chandransh 11888 
 
11889 
  thrift_spec = (
11890 
  )
11891 
 
11892 
  def read(self, iprot):
11893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11895 
      return
11896 
    iprot.readStructBegin()
11897 
    while True:
11898 
      (fname, ftype, fid) = iprot.readFieldBegin()
11899 
      if ftype == TType.STOP:
11900 
        break
11901 
      else:
11902 
        iprot.skip(ftype)
11903 
      iprot.readFieldEnd()
11904 
    iprot.readStructEnd()
11905 
 
11906 
  def write(self, oprot):
11907 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11908 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11909 
      return
772 rajveer 11910 
    oprot.writeStructBegin('updateBrowseHistory_result')
559 chandransh 11911 
    oprot.writeFieldStop()
11912 
    oprot.writeStructEnd()
11913 
 
11914 
  def __repr__(self):
11915 
    L = ['%s=%r' % (key, value)
11916 
      for key, value in self.__dict__.iteritems()]
11917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11918 
 
11919 
  def __eq__(self, other):
11920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11921 
 
11922 
  def __ne__(self, other):
11923 
    return not (self == other)
11924 
 
772 rajveer 11925 
class getBrowseHistory_args:
559 chandransh 11926 
  """
11927 
  Attributes:
772 rajveer 11928 
   - userId
559 chandransh 11929 
  """
11930 
 
11931 
  thrift_spec = (
11932 
    None, # 0
772 rajveer 11933 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 11934 
  )
11935 
 
772 rajveer 11936 
  def __init__(self, userId=None,):
11937 
    self.userId = userId
559 chandransh 11938 
 
11939 
  def read(self, iprot):
11940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11942 
      return
11943 
    iprot.readStructBegin()
11944 
    while True:
11945 
      (fname, ftype, fid) = iprot.readFieldBegin()
11946 
      if ftype == TType.STOP:
11947 
        break
11948 
      if fid == 1:
11949 
        if ftype == TType.I64:
772 rajveer 11950 
          self.userId = iprot.readI64();
559 chandransh 11951 
        else:
11952 
          iprot.skip(ftype)
11953 
      else:
11954 
        iprot.skip(ftype)
11955 
      iprot.readFieldEnd()
11956 
    iprot.readStructEnd()
11957 
 
11958 
  def write(self, oprot):
11959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11961 
      return
772 rajveer 11962 
    oprot.writeStructBegin('getBrowseHistory_args')
11963 
    if self.userId != None:
11964 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11965 
      oprot.writeI64(self.userId)
559 chandransh 11966 
      oprot.writeFieldEnd()
11967 
    oprot.writeFieldStop()
11968 
    oprot.writeStructEnd()
11969 
 
11970 
  def __repr__(self):
11971 
    L = ['%s=%r' % (key, value)
11972 
      for key, value in self.__dict__.iteritems()]
11973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11974 
 
11975 
  def __eq__(self, other):
11976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11977 
 
11978 
  def __ne__(self, other):
11979 
    return not (self == other)
11980 
 
772 rajveer 11981 
class getBrowseHistory_result:
559 chandransh 11982 
  """
11983 
  Attributes:
130 ashish 11984 
   - success
559 chandransh 11985 
   - scx
130 ashish 11986 
  """
11987 
 
11988 
  thrift_spec = (
772 rajveer 11989 
    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
559 chandransh 11990 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 11991 
  )
11992 
 
559 chandransh 11993 
  def __init__(self, success=None, scx=None,):
130 ashish 11994 
    self.success = success
559 chandransh 11995 
    self.scx = scx
130 ashish 11996 
 
11997 
  def read(self, iprot):
11998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12000 
      return
12001 
    iprot.readStructBegin()
12002 
    while True:
12003 
      (fname, ftype, fid) = iprot.readFieldBegin()
12004 
      if ftype == TType.STOP:
12005 
        break
12006 
      if fid == 0:
559 chandransh 12007 
        if ftype == TType.STRUCT:
772 rajveer 12008 
          self.success = Widget()
559 chandransh 12009 
          self.success.read(iprot)
130 ashish 12010 
        else:
12011 
          iprot.skip(ftype)
12012 
      elif fid == 1:
12013 
        if ftype == TType.STRUCT:
559 chandransh 12014 
          self.scx = WidgetException()
12015 
          self.scx.read(iprot)
130 ashish 12016 
        else:
12017 
          iprot.skip(ftype)
12018 
      else:
12019 
        iprot.skip(ftype)
12020 
      iprot.readFieldEnd()
12021 
    iprot.readStructEnd()
12022 
 
12023 
  def write(self, oprot):
12024 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12025 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12026 
      return
772 rajveer 12027 
    oprot.writeStructBegin('getBrowseHistory_result')
130 ashish 12028 
    if self.success != None:
559 chandransh 12029 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12030 
      self.success.write(oprot)
130 ashish 12031 
      oprot.writeFieldEnd()
559 chandransh 12032 
    if self.scx != None:
12033 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12034 
      self.scx.write(oprot)
130 ashish 12035 
      oprot.writeFieldEnd()
12036 
    oprot.writeFieldStop()
12037 
    oprot.writeStructEnd()
12038 
 
12039 
  def __repr__(self):
12040 
    L = ['%s=%r' % (key, value)
12041 
      for key, value in self.__dict__.iteritems()]
12042 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12043 
 
12044 
  def __eq__(self, other):
12045 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12046 
 
12047 
  def __ne__(self, other):
12048 
    return not (self == other)
12049 
 
772 rajveer 12050 
class mergeBrowseHistory_args:
130 ashish 12051 
  """
12052 
  Attributes:
772 rajveer 12053 
   - fromUserId
12054 
   - toUserId
130 ashish 12055 
  """
12056 
 
12057 
  thrift_spec = (
12058 
    None, # 0
772 rajveer 12059 
    (1, TType.I64, 'fromUserId', None, None, ), # 1
12060 
    (2, TType.I64, 'toUserId', None, None, ), # 2
130 ashish 12061 
  )
12062 
 
772 rajveer 12063 
  def __init__(self, fromUserId=None, toUserId=None,):
12064 
    self.fromUserId = fromUserId
12065 
    self.toUserId = toUserId
130 ashish 12066 
 
12067 
  def read(self, iprot):
12068 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12069 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12070 
      return
12071 
    iprot.readStructBegin()
12072 
    while True:
12073 
      (fname, ftype, fid) = iprot.readFieldBegin()
12074 
      if ftype == TType.STOP:
12075 
        break
12076 
      if fid == 1:
559 chandransh 12077 
        if ftype == TType.I64:
772 rajveer 12078 
          self.fromUserId = iprot.readI64();
130 ashish 12079 
        else:
12080 
          iprot.skip(ftype)
12081 
      elif fid == 2:
559 chandransh 12082 
        if ftype == TType.I64:
772 rajveer 12083 
          self.toUserId = iprot.readI64();
559 chandransh 12084 
        else:
12085 
          iprot.skip(ftype)
130 ashish 12086 
      else:
12087 
        iprot.skip(ftype)
12088 
      iprot.readFieldEnd()
12089 
    iprot.readStructEnd()
12090 
 
12091 
  def write(self, oprot):
12092 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12093 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12094 
      return
772 rajveer 12095 
    oprot.writeStructBegin('mergeBrowseHistory_args')
12096 
    if self.fromUserId != None:
12097 
      oprot.writeFieldBegin('fromUserId', TType.I64, 1)
12098 
      oprot.writeI64(self.fromUserId)
130 ashish 12099 
      oprot.writeFieldEnd()
772 rajveer 12100 
    if self.toUserId != None:
12101 
      oprot.writeFieldBegin('toUserId', TType.I64, 2)
12102 
      oprot.writeI64(self.toUserId)
130 ashish 12103 
      oprot.writeFieldEnd()
12104 
    oprot.writeFieldStop()
12105 
    oprot.writeStructEnd()
12106 
 
12107 
  def __repr__(self):
12108 
    L = ['%s=%r' % (key, value)
12109 
      for key, value in self.__dict__.iteritems()]
12110 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12111 
 
12112 
  def __eq__(self, other):
12113 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12114 
 
12115 
  def __ne__(self, other):
12116 
    return not (self == other)
12117 
 
772 rajveer 12118 
class mergeBrowseHistory_result:
559 chandransh 12119 
 
12120 
  thrift_spec = (
12121 
  )
12122 
 
12123 
  def read(self, iprot):
12124 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12125 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12126 
      return
12127 
    iprot.readStructBegin()
12128 
    while True:
12129 
      (fname, ftype, fid) = iprot.readFieldBegin()
12130 
      if ftype == TType.STOP:
12131 
        break
12132 
      else:
12133 
        iprot.skip(ftype)
12134 
      iprot.readFieldEnd()
12135 
    iprot.readStructEnd()
12136 
 
12137 
  def write(self, oprot):
12138 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12139 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12140 
      return
772 rajveer 12141 
    oprot.writeStructBegin('mergeBrowseHistory_result')
559 chandransh 12142 
    oprot.writeFieldStop()
12143 
    oprot.writeStructEnd()
12144 
 
12145 
  def __repr__(self):
12146 
    L = ['%s=%r' % (key, value)
12147 
      for key, value in self.__dict__.iteritems()]
12148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12149 
 
12150 
  def __eq__(self, other):
12151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12152 
 
12153 
  def __ne__(self, other):
12154 
    return not (self == other)
12155 
 
1596 ankur.sing 12156 
class getUserCount_args:
12157 
  """
12158 
  Attributes:
12159 
   - userType
12160 
  """
559 chandransh 12161 
 
1596 ankur.sing 12162 
  thrift_spec = (
12163 
    None, # 0
12164 
    (1, TType.I32, 'userType', None, None, ), # 1
12165 
  )
12166 
 
12167 
  def __init__(self, userType=None,):
12168 
    self.userType = userType
12169 
 
12170 
  def read(self, iprot):
12171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12173 
      return
12174 
    iprot.readStructBegin()
12175 
    while True:
12176 
      (fname, ftype, fid) = iprot.readFieldBegin()
12177 
      if ftype == TType.STOP:
12178 
        break
12179 
      if fid == 1:
12180 
        if ftype == TType.I32:
12181 
          self.userType = iprot.readI32();
12182 
        else:
12183 
          iprot.skip(ftype)
12184 
      else:
12185 
        iprot.skip(ftype)
12186 
      iprot.readFieldEnd()
12187 
    iprot.readStructEnd()
12188 
 
12189 
  def write(self, oprot):
12190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12192 
      return
12193 
    oprot.writeStructBegin('getUserCount_args')
12194 
    if self.userType != None:
12195 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12196 
      oprot.writeI32(self.userType)
12197 
      oprot.writeFieldEnd()
12198 
    oprot.writeFieldStop()
12199 
    oprot.writeStructEnd()
12200 
 
12201 
  def __repr__(self):
12202 
    L = ['%s=%r' % (key, value)
12203 
      for key, value in self.__dict__.iteritems()]
12204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12205 
 
12206 
  def __eq__(self, other):
12207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12208 
 
12209 
  def __ne__(self, other):
12210 
    return not (self == other)
12211 
 
12212 
class getUserCount_result:
12213 
  """
12214 
  Attributes:
12215 
   - success
12216 
  """
12217 
 
12218 
  thrift_spec = (
12219 
    (0, TType.I64, 'success', None, None, ), # 0
12220 
  )
12221 
 
12222 
  def __init__(self, success=None,):
12223 
    self.success = success
12224 
 
12225 
  def read(self, iprot):
12226 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12227 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12228 
      return
12229 
    iprot.readStructBegin()
12230 
    while True:
12231 
      (fname, ftype, fid) = iprot.readFieldBegin()
12232 
      if ftype == TType.STOP:
12233 
        break
12234 
      if fid == 0:
12235 
        if ftype == TType.I64:
12236 
          self.success = iprot.readI64();
12237 
        else:
12238 
          iprot.skip(ftype)
12239 
      else:
12240 
        iprot.skip(ftype)
12241 
      iprot.readFieldEnd()
12242 
    iprot.readStructEnd()
12243 
 
12244 
  def write(self, oprot):
12245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12247 
      return
12248 
    oprot.writeStructBegin('getUserCount_result')
12249 
    if self.success != None:
12250 
      oprot.writeFieldBegin('success', TType.I64, 0)
12251 
      oprot.writeI64(self.success)
12252 
      oprot.writeFieldEnd()
12253 
    oprot.writeFieldStop()
12254 
    oprot.writeStructEnd()
12255 
 
12256 
  def __repr__(self):
12257 
    L = ['%s=%r' % (key, value)
12258 
      for key, value in self.__dict__.iteritems()]
12259 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12260 
 
12261 
  def __eq__(self, other):
12262 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12263 
 
12264 
  def __ne__(self, other):
12265 
    return not (self == other)
12266 
 
1673 ankur.sing 12267 
class getAllUsers_args:
12268 
  """
12269 
  Attributes:
12270 
   - userType
1891 ankur.sing 12271 
   - startDate
12272 
   - endDate
1673 ankur.sing 12273 
  """
1596 ankur.sing 12274 
 
1673 ankur.sing 12275 
  thrift_spec = (
12276 
    None, # 0
12277 
    (1, TType.I32, 'userType', None, None, ), # 1
1891 ankur.sing 12278 
    (2, TType.I64, 'startDate', None, None, ), # 2
12279 
    (3, TType.I64, 'endDate', None, None, ), # 3
1673 ankur.sing 12280 
  )
12281 
 
1891 ankur.sing 12282 
  def __init__(self, userType=None, startDate=None, endDate=None,):
1673 ankur.sing 12283 
    self.userType = userType
1891 ankur.sing 12284 
    self.startDate = startDate
12285 
    self.endDate = endDate
1673 ankur.sing 12286 
 
12287 
  def read(self, iprot):
12288 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12289 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12290 
      return
12291 
    iprot.readStructBegin()
12292 
    while True:
12293 
      (fname, ftype, fid) = iprot.readFieldBegin()
12294 
      if ftype == TType.STOP:
12295 
        break
12296 
      if fid == 1:
12297 
        if ftype == TType.I32:
12298 
          self.userType = iprot.readI32();
12299 
        else:
12300 
          iprot.skip(ftype)
1891 ankur.sing 12301 
      elif fid == 2:
12302 
        if ftype == TType.I64:
12303 
          self.startDate = iprot.readI64();
12304 
        else:
12305 
          iprot.skip(ftype)
12306 
      elif fid == 3:
12307 
        if ftype == TType.I64:
12308 
          self.endDate = iprot.readI64();
12309 
        else:
12310 
          iprot.skip(ftype)
1673 ankur.sing 12311 
      else:
12312 
        iprot.skip(ftype)
12313 
      iprot.readFieldEnd()
12314 
    iprot.readStructEnd()
12315 
 
12316 
  def write(self, oprot):
12317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12319 
      return
12320 
    oprot.writeStructBegin('getAllUsers_args')
12321 
    if self.userType != None:
12322 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12323 
      oprot.writeI32(self.userType)
12324 
      oprot.writeFieldEnd()
1891 ankur.sing 12325 
    if self.startDate != None:
12326 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
12327 
      oprot.writeI64(self.startDate)
12328 
      oprot.writeFieldEnd()
12329 
    if self.endDate != None:
12330 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
12331 
      oprot.writeI64(self.endDate)
12332 
      oprot.writeFieldEnd()
1673 ankur.sing 12333 
    oprot.writeFieldStop()
12334 
    oprot.writeStructEnd()
12335 
 
12336 
  def __repr__(self):
12337 
    L = ['%s=%r' % (key, value)
12338 
      for key, value in self.__dict__.iteritems()]
12339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12340 
 
12341 
  def __eq__(self, other):
12342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12343 
 
12344 
  def __ne__(self, other):
12345 
    return not (self == other)
12346 
 
12347 
class getAllUsers_result:
12348 
  """
12349 
  Attributes:
12350 
   - success
12351 
  """
12352 
 
12353 
  thrift_spec = (
12354 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
12355 
  )
12356 
 
12357 
  def __init__(self, success=None,):
12358 
    self.success = success
12359 
 
12360 
  def read(self, iprot):
12361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12363 
      return
12364 
    iprot.readStructBegin()
12365 
    while True:
12366 
      (fname, ftype, fid) = iprot.readFieldBegin()
12367 
      if ftype == TType.STOP:
12368 
        break
12369 
      if fid == 0:
12370 
        if ftype == TType.LIST:
12371 
          self.success = []
1899 vikas 12372 
          (_etype124, _size121) = iprot.readListBegin()
12373 
          for _i125 in xrange(_size121):
12374 
            _elem126 = User()
12375 
            _elem126.read(iprot)
12376 
            self.success.append(_elem126)
1673 ankur.sing 12377 
          iprot.readListEnd()
12378 
        else:
12379 
          iprot.skip(ftype)
12380 
      else:
12381 
        iprot.skip(ftype)
12382 
      iprot.readFieldEnd()
12383 
    iprot.readStructEnd()
12384 
 
12385 
  def write(self, oprot):
12386 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12387 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12388 
      return
12389 
    oprot.writeStructBegin('getAllUsers_result')
12390 
    if self.success != None:
12391 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12392 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1899 vikas 12393 
      for iter127 in self.success:
12394 
        iter127.write(oprot)
1673 ankur.sing 12395 
      oprot.writeListEnd()
12396 
      oprot.writeFieldEnd()
12397 
    oprot.writeFieldStop()
12398 
    oprot.writeStructEnd()
12399 
 
12400 
  def __repr__(self):
12401 
    L = ['%s=%r' % (key, value)
12402 
      for key, value in self.__dict__.iteritems()]
12403 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12404 
 
12405 
  def __eq__(self, other):
12406 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12407 
 
12408 
  def __ne__(self, other):
12409 
    return not (self == other)
12410 
 
12411