Subversion Repositories SmartDukaan

Rev

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

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