Subversion Repositories SmartDukaan

Rev

Rev 3378 | Rev 3431 | 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 *
3376 rajveer 8 
import shop2020.thriftpy.generic.GenericService
94 ashish 9 
from ttypes import *
10 
from thrift.Thrift import TProcessor
11 
from thrift.transport import TTransport
12 
from thrift.protocol import TBinaryProtocol
13 
try:
14 
  from thrift.protocol import fastbinary
15 
except:
16 
  fastbinary = None
17 
 
18 
 
3376 rajveer 19 
class Iface(shop2020.thriftpy.generic.GenericService.Iface):
94 ashish 20 
  """
21 
  service
22 
  """
559 chandransh 23 
  def createAnonymousUser(self, jsessionId):
94 ashish 24 
    """
25 
    Parameters:
559 chandransh 26 
     - jsessionId
94 ashish 27 
    """
28 
    pass
29 
 
559 chandransh 30 
  def getUserById(self, userId):
94 ashish 31 
    """
32 
    Parameters:
33 
     - userId
34 
    """
35 
    pass
36 
 
1491 vikas 37 
  def getUserByEmail(self, email):
38 
    """
39 
    Parameters:
40 
     - email
41 
    """
42 
    pass
43 
 
3032 mandeep.dh 44 
  def getUserByMobileNumber(self, mobileNumber):
45 
    """
46 
    Parameters:
47 
     - mobileNumber
48 
    """
49 
    pass
50 
 
559 chandransh 51 
  def createUser(self, user):
94 ashish 52 
    """
53 
    Parameters:
559 chandransh 54 
     - user
94 ashish 55 
    """
56 
    pass
57 
 
559 chandransh 58 
  def updateUser(self, user):
94 ashish 59 
    """
60 
    Parameters:
559 chandransh 61 
     - user
94 ashish 62 
    """
63 
    pass
64 
 
559 chandransh 65 
  def deleteUser(self, userId):
94 ashish 66 
    """
67 
    Parameters:
68 
     - userId
69 
    """
70 
    pass
71 
 
559 chandransh 72 
  def getUserState(self, userId):
94 ashish 73 
    """
74 
    Parameters:
75 
     - userId
76 
    """
77 
    pass
78 
 
559 chandransh 79 
  def authenticateUser(self, email, password):
94 ashish 80 
    """
81 
    Parameters:
82 
     - email
83 
     - password
84 
    """
85 
    pass
86 
 
87 
  def userExists(self, email):
88 
    """
89 
    Parameters:
90 
     - email
91 
    """
92 
    pass
93 
 
567 rajveer 94 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 95 
    """
96 
    Parameters:
97 
     - userId
98 
     - address
513 rajveer 99 
     - setDefault
94 ashish 100 
    """
101 
    pass
102 
 
103 
  def removeAddressForUser(self, userid, addressId):
104 
    """
105 
    Parameters:
106 
     - userid
107 
     - addressId
108 
    """
109 
    pass
110 
 
111 
  def setUserAsLoggedIn(self, userId, timestamp):
112 
    """
113 
    Parameters:
114 
     - userId
115 
     - timestamp
116 
    """
117 
    pass
118 
 
119 
  def setUserAsLoggedOut(self, userid, timestamp):
120 
    """
121 
    Parameters:
122 
     - userid
123 
     - timestamp
124 
    """
125 
    pass
126 
 
504 rajveer 127 
  def setDefaultAddress(self, userid, addressId):
128 
    """
129 
    Parameters:
130 
     - userid
131 
     - addressId
132 
    """
133 
    pass
134 
 
594 rajveer 135 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 136 
    """
137 
    Parameters:
138 
     - userid
594 rajveer 139 
     - oldPassword
140 
     - newPassword
94 ashish 141 
    """
142 
    pass
143 
 
884 rajveer 144 
  def forgotPassword(self, email, newPassword):
581 rajveer 145 
    """
146 
    Parameters:
147 
     - email
884 rajveer 148 
     - newPassword
581 rajveer 149 
    """
150 
    pass
151 
 
594 rajveer 152 
  def getAllAddressesForUser(self, userId):
153 
    """
154 
    Parameters:
155 
     - userId
156 
    """
157 
    pass
158 
 
1894 vikas 159 
  def getAddressById(self, addressId):
160 
    """
161 
    Parameters:
162 
     - addressId
163 
    """
164 
    pass
165 
 
594 rajveer 166 
  def getDefaultAddressId(self, userId):
167 
    """
168 
    Parameters:
169 
     - userId
170 
    """
171 
    pass
172 
 
785 rajveer 173 
  def getDefaultPincode(self, userId):
174 
    """
175 
    Parameters:
176 
     - userId
177 
    """
178 
    pass
179 
 
1274 varun.gupt 180 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
181 
    """
182 
    Parameters:
183 
     - userId
184 
     - replyTo
185 
     - communicationType
186 
     - orderId
187 
     - airwaybillNo
188 
     - productName
189 
     - subject
190 
     - message
191 
    """
192 
    pass
193 
 
1590 varun.gupt 194 
  def getUserCommunicationById(self, id):
195 
    """
196 
    Parameters:
197 
     - id
198 
    """
199 
    pass
200 
 
201 
  def getUserCommunicationByUser(self, userId):
202 
    """
203 
    Parameters:
204 
     - userId
205 
    """
206 
    pass
207 
 
208 
  def getAllUserCommunications(self, ):
209 
    pass
210 
 
1859 vikas 211 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 212 
    """
213 
    Parameters:
214 
     - name
1859 vikas 215 
     - addedOn
1845 vikas 216 
    """
217 
    pass
218 
 
1899 vikas 219 
  def getAllMasterAffiliates(self, ):
220 
    pass
221 
 
1845 vikas 222 
  def getMasterAffiliateById(self, id):
223 
    """
224 
    Parameters:
225 
     - id
226 
    """
227 
    pass
228 
 
229 
  def getMasterAffiliateByName(self, name):
230 
    """
231 
    Parameters:
232 
     - name
233 
    """
234 
    pass
235 
 
1859 vikas 236 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 237 
    """
238 
    Parameters:
239 
     - name
240 
     - url
241 
     - masterAffiliateId
1859 vikas 242 
     - addedOn
1845 vikas 243 
    """
244 
    pass
245 
 
246 
  def getAffiliateById(self, id):
247 
    """
248 
    Parameters:
249 
     - id
250 
    """
251 
    pass
252 
 
253 
  def getAffiliateByName(self, name):
254 
    """
255 
    Parameters:
256 
     - name
257 
    """
258 
    pass
259 
 
1996 vikas 260 
  def getTrackerById(self, id):
1845 vikas 261 
    """
262 
    Parameters:
263 
     - id
264 
    """
265 
    pass
266 
 
1996 vikas 267 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 268 
    """
269 
    Parameters:
1996 vikas 270 
     - id
1845 vikas 271 
    """
272 
    pass
273 
 
1996 vikas 274 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 275 
    """
276 
    Parameters:
277 
     - affiliateId
278 
     - userId
279 
     - event
280 
     - url
281 
     - data
1859 vikas 282 
     - addedOn
1845 vikas 283 
    """
284 
    pass
285 
 
286 
  def getTrackLogById(self, id):
287 
    """
288 
    Parameters:
289 
     - id
290 
    """
291 
    pass
292 
 
3293 vikas 293 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 294 
    """
295 
    Parameters:
1996 vikas 296 
     - affiliateId
3293 vikas 297 
     - startDate
298 
     - endDate
1845 vikas 299 
    """
300 
    pass
301 
 
302 
  def getTrackLogsByUser(self, userId):
303 
    """
304 
    Parameters:
305 
     - userId
306 
    """
307 
    pass
308 
 
1996 vikas 309 
  def getTrackLogs(self, userId, event, url):
1845 vikas 310 
    """
311 
    Parameters:
312 
     - userId
313 
     - event
314 
     - url
315 
    """
316 
    pass
317 
 
559 chandransh 318 
  def createCart(self, userId):
94 ashish 319 
    """
320 
    Parameters:
559 chandransh 321 
     - userId
94 ashish 322 
    """
323 
    pass
324 
 
559 chandransh 325 
  def getCurrentCart(self, userId):
94 ashish 326 
    """
327 
    Parameters:
559 chandransh 328 
     - userId
94 ashish 329 
    """
330 
    pass
331 
 
559 chandransh 332 
  def getCart(self, cartId):
94 ashish 333 
    """
334 
    Parameters:
559 chandransh 335 
     - cartId
94 ashish 336 
    """
337 
    pass
338 
 
559 chandransh 339 
  def getCartsForUser(self, userId, status):
94 ashish 340 
    """
341 
    Parameters:
559 chandransh 342 
     - userId
343 
     - status
94 ashish 344 
    """
345 
    pass
346 
 
559 chandransh 347 
  def getCartsByStatus(self, status):
94 ashish 348 
    """
349 
    Parameters:
559 chandransh 350 
     - status
94 ashish 351 
    """
352 
    pass
353 
 
559 chandransh 354 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 355 
    """
356 
    Parameters:
559 chandransh 357 
     - from_time
358 
     - to_time
359 
     - status
94 ashish 360 
    """
361 
    pass
362 
 
559 chandransh 363 
  def changeCartStatus(self, cartId, status):
130 ashish 364 
    """
365 
    Parameters:
559 chandransh 366 
     - cartId
367 
     - status
130 ashish 368 
    """
369 
    pass
94 ashish 370 
 
559 chandransh 371 
  def addItemToCart(self, cartId, itemId, quantity):
130 ashish 372 
    """
373 
    Parameters:
559 chandransh 374 
     - cartId
375 
     - itemId
376 
     - quantity
130 ashish 377 
    """
378 
    pass
379 
 
559 chandransh 380 
  def deleteItemFromCart(self, cartId, itemId):
381 
    """
382 
    Parameters:
383 
     - cartId
384 
     - itemId
385 
    """
386 
    pass
130 ashish 387 
 
559 chandransh 388 
  def changeQuantity(self, cartId, itemId, quantity):
389 
    """
390 
    Parameters:
391 
     - cartId
392 
     - itemId
393 
     - quantity
394 
    """
395 
    pass
396 
 
397 
  def changeItemStatus(self, cartId, itemId, status):
398 
    """
399 
    Parameters:
400 
     - cartId
401 
     - itemId
402 
     - status
403 
    """
404 
    pass
405 
 
406 
  def addAddressToCart(self, cartId, addressId):
407 
    """
408 
    Parameters:
409 
     - cartId
410 
     - addressId
411 
    """
412 
    pass
413 
 
1976 varun.gupt 414 
  def applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
415 
    """
416 
    Parameters:
417 
     - cartId
418 
     - couponCode
419 
     - totalPrice
420 
     - discountedPrice
421 
    """
422 
    pass
423 
 
424 
  def removeCoupon(self, cartId):
425 
    """
426 
    Parameters:
427 
     - cartId
428 
    """
429 
    pass
430 
 
2815 vikas 431 
  def createOrders(self, cartId, sessionSource, sessionStartTime):
559 chandransh 432 
    """
690 chandransh 433 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
434 
 
559 chandransh 435 
    Parameters:
436 
     - cartId
2815 vikas 437 
     - sessionSource
438 
     - sessionStartTime
559 chandransh 439 
    """
440 
    pass
441 
 
442 
  def validateCart(self, cartId):
443 
    """
690 chandransh 444 
    Validates that:
445 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 446 
    2. All of the lines in the cart are active items.
690 chandransh 447 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 448 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 449 
 
559 chandransh 450 
    Parameters:
451 
     - cartId
452 
    """
453 
    pass
454 
 
690 chandransh 455 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 456 
    """
690 chandransh 457 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
458 
 
575 chandransh 459 
    Parameters:
690 chandransh 460 
     - fromCartId
461 
     - toCartId
462 
    """
463 
    pass
464 
 
465 
  def checkOut(self, cartId):
466 
    """
467 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
468 
 
469 
    Parameters:
575 chandransh 470 
     - cartId
471 
    """
472 
    pass
473 
 
690 chandransh 474 
  def resetCart(self, cartId, items):
559 chandransh 475 
    """
690 chandransh 476 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
477 
    This methods removes the specified quantiry of the specified item from the cart.
478 
 
559 chandransh 479 
    Parameters:
690 chandransh 480 
     - cartId
481 
     - items
559 chandransh 482 
    """
483 
    pass
484 
 
2981 rajveer 485 
  def getUserCount(self, userType):
559 chandransh 486 
    """
2981 rajveer 487 
    Returns number of registered users.
488 
    If userType = null, then it returns count of all users, including anonymous
489 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
490 
    If userType = UserType.USER, then it returns count of non-anonymous users only
772 rajveer 491 
 
559 chandransh 492 
    Parameters:
2981 rajveer 493 
     - userType
559 chandransh 494 
    """
495 
    pass
496 
 
2981 rajveer 497 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 498 
    """
2981 rajveer 499 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
500 
    If any of startDate or endDate is -1, then that filter is ignored.
501 
    If userType is null, then returns all the users, irrespective of anonymous flag
502 
 
503 
 
559 chandransh 504 
    Parameters:
2981 rajveer 505 
     - userType
506 
     - startDate
507 
     - endDate
559 chandransh 508 
    """
509 
    pass
510 
 
2981 rajveer 511 
  def putUserNote(self, user_id, entity_id, slide, note):
559 chandransh 512 
    """
513 
    Parameters:
2981 rajveer 514 
     - user_id
515 
     - entity_id
516 
     - slide
517 
     - note
559 chandransh 518 
    """
519 
    pass
520 
 
2981 rajveer 521 
  def getUserNotes(self, user_id, entity_id):
559 chandransh 522 
    """
523 
    Parameters:
2981 rajveer 524 
     - user_id
525 
     - entity_id
559 chandransh 526 
    """
527 
    pass
528 
 
2981 rajveer 529 
  def getMyResearchItems(self, userId):
559 chandransh 530 
    """
2981 rajveer 531 
    Returns list of item ids in myresearch for the user
532 
 
559 chandransh 533 
    Parameters:
534 
     - userId
535 
    """
536 
    pass
537 
 
2981 rajveer 538 
  def updateMyResearch(self, userId, itemId):
559 chandransh 539 
    """
2981 rajveer 540 
    add item to my research for a user
541 
 
559 chandransh 542 
    Parameters:
2981 rajveer 543 
     - userId
544 
     - itemId
559 chandransh 545 
    """
546 
    pass
547 
 
2981 rajveer 548 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 549 
    """
2981 rajveer 550 
    delete item from my research for a user
1596 ankur.sing 551 
 
552 
    Parameters:
2981 rajveer 553 
     - userId
554 
     - itemId
1596 ankur.sing 555 
    """
556 
    pass
559 chandransh 557 
 
2981 rajveer 558 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 559 
    """
2981 rajveer 560 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
1673 ankur.sing 561 
 
562 
    Parameters:
2981 rajveer 563 
     - userId
1673 ankur.sing 564 
    """
565 
    pass
1596 ankur.sing 566 
 
2981 rajveer 567 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 568 
    """
2981 rajveer 569 
    add item to browse history for a user
2642 varun.gupt 570 
 
571 
    Parameters:
2981 rajveer 572 
     - userId
573 
     - itemId
2642 varun.gupt 574 
    """
575 
    pass
1673 ankur.sing 576 
 
3385 varun.gupt 577 
  def getCartsWithCouponCount(self, couponCode):
578 
    """
579 
    Returns count of Carts with given coupon applied
580 
 
581 
    Parameters:
582 
     - couponCode
583 
    """
584 
    pass
2642 varun.gupt 585 
 
3385 varun.gupt 586 
 
3376 rajveer 587 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 588 
  """
589 
  service
590 
  """
591 
  def __init__(self, iprot, oprot=None):
3376 rajveer 592 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 593 
 
559 chandransh 594 
  def createAnonymousUser(self, jsessionId):
94 ashish 595 
    """
596 
    Parameters:
559 chandransh 597 
     - jsessionId
94 ashish 598 
    """
559 chandransh 599 
    self.send_createAnonymousUser(jsessionId)
600 
    return self.recv_createAnonymousUser()
94 ashish 601 
 
559 chandransh 602 
  def send_createAnonymousUser(self, jsessionId):
603 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
604 
    args = createAnonymousUser_args()
605 
    args.jsessionId = jsessionId
94 ashish 606 
    args.write(self._oprot)
607 
    self._oprot.writeMessageEnd()
608 
    self._oprot.trans.flush()
609 
 
559 chandransh 610 
  def recv_createAnonymousUser(self, ):
94 ashish 611 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
612 
    if mtype == TMessageType.EXCEPTION:
613 
      x = TApplicationException()
614 
      x.read(self._iprot)
615 
      self._iprot.readMessageEnd()
616 
      raise x
559 chandransh 617 
    result = createAnonymousUser_result()
94 ashish 618 
    result.read(self._iprot)
619 
    self._iprot.readMessageEnd()
620 
    if result.success != None:
621 
      return result.success
559 chandransh 622 
    if result.ucex != None:
623 
      raise result.ucex
624 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 625 
 
559 chandransh 626 
  def getUserById(self, userId):
94 ashish 627 
    """
628 
    Parameters:
629 
     - userId
630 
    """
559 chandransh 631 
    self.send_getUserById(userId)
632 
    return self.recv_getUserById()
94 ashish 633 
 
559 chandransh 634 
  def send_getUserById(self, userId):
635 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
636 
    args = getUserById_args()
94 ashish 637 
    args.userId = userId
638 
    args.write(self._oprot)
639 
    self._oprot.writeMessageEnd()
640 
    self._oprot.trans.flush()
641 
 
559 chandransh 642 
  def recv_getUserById(self, ):
94 ashish 643 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
644 
    if mtype == TMessageType.EXCEPTION:
645 
      x = TApplicationException()
646 
      x.read(self._iprot)
647 
      self._iprot.readMessageEnd()
648 
      raise x
559 chandransh 649 
    result = getUserById_result()
94 ashish 650 
    result.read(self._iprot)
651 
    self._iprot.readMessageEnd()
652 
    if result.success != None:
653 
      return result.success
559 chandransh 654 
    if result.ucex != None:
655 
      raise result.ucex
656 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 657 
 
1491 vikas 658 
  def getUserByEmail(self, email):
659 
    """
660 
    Parameters:
661 
     - email
662 
    """
663 
    self.send_getUserByEmail(email)
664 
    return self.recv_getUserByEmail()
665 
 
666 
  def send_getUserByEmail(self, email):
667 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
668 
    args = getUserByEmail_args()
669 
    args.email = email
670 
    args.write(self._oprot)
671 
    self._oprot.writeMessageEnd()
672 
    self._oprot.trans.flush()
673 
 
674 
  def recv_getUserByEmail(self, ):
675 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
676 
    if mtype == TMessageType.EXCEPTION:
677 
      x = TApplicationException()
678 
      x.read(self._iprot)
679 
      self._iprot.readMessageEnd()
680 
      raise x
681 
    result = getUserByEmail_result()
682 
    result.read(self._iprot)
683 
    self._iprot.readMessageEnd()
684 
    if result.success != None:
685 
      return result.success
686 
    if result.ucex != None:
687 
      raise result.ucex
688 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
689 
 
3032 mandeep.dh 690 
  def getUserByMobileNumber(self, mobileNumber):
691 
    """
692 
    Parameters:
693 
     - mobileNumber
694 
    """
695 
    self.send_getUserByMobileNumber(mobileNumber)
696 
    return self.recv_getUserByMobileNumber()
697 
 
698 
  def send_getUserByMobileNumber(self, mobileNumber):
699 
    self._oprot.writeMessageBegin('getUserByMobileNumber', TMessageType.CALL, self._seqid)
700 
    args = getUserByMobileNumber_args()
701 
    args.mobileNumber = mobileNumber
702 
    args.write(self._oprot)
703 
    self._oprot.writeMessageEnd()
704 
    self._oprot.trans.flush()
705 
 
706 
  def recv_getUserByMobileNumber(self, ):
707 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
708 
    if mtype == TMessageType.EXCEPTION:
709 
      x = TApplicationException()
710 
      x.read(self._iprot)
711 
      self._iprot.readMessageEnd()
712 
      raise x
713 
    result = getUserByMobileNumber_result()
714 
    result.read(self._iprot)
715 
    self._iprot.readMessageEnd()
716 
    if result.success != None:
717 
      return result.success
718 
    if result.ucex != None:
719 
      raise result.ucex
720 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByMobileNumber failed: unknown result");
721 
 
559 chandransh 722 
  def createUser(self, user):
94 ashish 723 
    """
724 
    Parameters:
559 chandransh 725 
     - user
94 ashish 726 
    """
559 chandransh 727 
    self.send_createUser(user)
728 
    return self.recv_createUser()
94 ashish 729 
 
559 chandransh 730 
  def send_createUser(self, user):
731 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
732 
    args = createUser_args()
733 
    args.user = user
94 ashish 734 
    args.write(self._oprot)
735 
    self._oprot.writeMessageEnd()
736 
    self._oprot.trans.flush()
737 
 
559 chandransh 738 
  def recv_createUser(self, ):
94 ashish 739 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
740 
    if mtype == TMessageType.EXCEPTION:
741 
      x = TApplicationException()
742 
      x.read(self._iprot)
743 
      self._iprot.readMessageEnd()
744 
      raise x
559 chandransh 745 
    result = createUser_result()
94 ashish 746 
    result.read(self._iprot)
747 
    self._iprot.readMessageEnd()
748 
    if result.success != None:
749 
      return result.success
559 chandransh 750 
    if result.ucex != None:
751 
      raise result.ucex
752 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 753 
 
559 chandransh 754 
  def updateUser(self, user):
94 ashish 755 
    """
756 
    Parameters:
559 chandransh 757 
     - user
94 ashish 758 
    """
559 chandransh 759 
    self.send_updateUser(user)
760 
    return self.recv_updateUser()
94 ashish 761 
 
559 chandransh 762 
  def send_updateUser(self, user):
763 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
764 
    args = updateUser_args()
765 
    args.user = user
94 ashish 766 
    args.write(self._oprot)
767 
    self._oprot.writeMessageEnd()
768 
    self._oprot.trans.flush()
769 
 
559 chandransh 770 
  def recv_updateUser(self, ):
94 ashish 771 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
772 
    if mtype == TMessageType.EXCEPTION:
773 
      x = TApplicationException()
774 
      x.read(self._iprot)
775 
      self._iprot.readMessageEnd()
776 
      raise x
559 chandransh 777 
    result = updateUser_result()
94 ashish 778 
    result.read(self._iprot)
779 
    self._iprot.readMessageEnd()
780 
    if result.success != None:
781 
      return result.success
559 chandransh 782 
    if result.ucex != None:
783 
      raise result.ucex
784 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 785 
 
559 chandransh 786 
  def deleteUser(self, userId):
94 ashish 787 
    """
788 
    Parameters:
789 
     - userId
790 
    """
559 chandransh 791 
    self.send_deleteUser(userId)
792 
    return self.recv_deleteUser()
94 ashish 793 
 
559 chandransh 794 
  def send_deleteUser(self, userId):
795 
    self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
796 
    args = deleteUser_args()
94 ashish 797 
    args.userId = userId
798 
    args.write(self._oprot)
799 
    self._oprot.writeMessageEnd()
800 
    self._oprot.trans.flush()
801 
 
559 chandransh 802 
  def recv_deleteUser(self, ):
94 ashish 803 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
804 
    if mtype == TMessageType.EXCEPTION:
805 
      x = TApplicationException()
806 
      x.read(self._iprot)
807 
      self._iprot.readMessageEnd()
808 
      raise x
559 chandransh 809 
    result = deleteUser_result()
94 ashish 810 
    result.read(self._iprot)
811 
    self._iprot.readMessageEnd()
812 
    if result.success != None:
813 
      return result.success
559 chandransh 814 
    if result.ucex != None:
815 
      raise result.ucex
816 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
94 ashish 817 
 
559 chandransh 818 
  def getUserState(self, userId):
94 ashish 819 
    """
820 
    Parameters:
821 
     - userId
822 
    """
559 chandransh 823 
    self.send_getUserState(userId)
824 
    return self.recv_getUserState()
94 ashish 825 
 
559 chandransh 826 
  def send_getUserState(self, userId):
827 
    self._oprot.writeMessageBegin('getUserState', TMessageType.CALL, self._seqid)
828 
    args = getUserState_args()
94 ashish 829 
    args.userId = userId
830 
    args.write(self._oprot)
831 
    self._oprot.writeMessageEnd()
832 
    self._oprot.trans.flush()
833 
 
559 chandransh 834 
  def recv_getUserState(self, ):
94 ashish 835 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
836 
    if mtype == TMessageType.EXCEPTION:
837 
      x = TApplicationException()
838 
      x.read(self._iprot)
839 
      self._iprot.readMessageEnd()
840 
      raise x
559 chandransh 841 
    result = getUserState_result()
94 ashish 842 
    result.read(self._iprot)
843 
    self._iprot.readMessageEnd()
844 
    if result.success != None:
845 
      return result.success
559 chandransh 846 
    if result.ucex != None:
847 
      raise result.ucex
848 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserState failed: unknown result");
94 ashish 849 
 
559 chandransh 850 
  def authenticateUser(self, email, password):
94 ashish 851 
    """
852 
    Parameters:
853 
     - email
854 
     - password
855 
    """
559 chandransh 856 
    self.send_authenticateUser(email, password)
122 ashish 857 
    return self.recv_authenticateUser()
858 
 
559 chandransh 859 
  def send_authenticateUser(self, email, password):
122 ashish 860 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
861 
    args = authenticateUser_args()
559 chandransh 862 
    args.email = email
122 ashish 863 
    args.password = password
864 
    args.write(self._oprot)
865 
    self._oprot.writeMessageEnd()
866 
    self._oprot.trans.flush()
867 
 
868 
  def recv_authenticateUser(self, ):
869 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
870 
    if mtype == TMessageType.EXCEPTION:
871 
      x = TApplicationException()
872 
      x.read(self._iprot)
873 
      self._iprot.readMessageEnd()
874 
      raise x
875 
    result = authenticateUser_result()
876 
    result.read(self._iprot)
877 
    self._iprot.readMessageEnd()
878 
    if result.success != None:
879 
      return result.success
559 chandransh 880 
    if result.auex != None:
881 
      raise result.auex
122 ashish 882 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
883 
 
94 ashish 884 
  def userExists(self, email):
885 
    """
886 
    Parameters:
887 
     - email
888 
    """
889 
    self.send_userExists(email)
890 
    return self.recv_userExists()
891 
 
892 
  def send_userExists(self, email):
893 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
894 
    args = userExists_args()
895 
    args.email = email
896 
    args.write(self._oprot)
897 
    self._oprot.writeMessageEnd()
898 
    self._oprot.trans.flush()
899 
 
900 
  def recv_userExists(self, ):
901 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
902 
    if mtype == TMessageType.EXCEPTION:
903 
      x = TApplicationException()
904 
      x.read(self._iprot)
905 
      self._iprot.readMessageEnd()
906 
      raise x
907 
    result = userExists_result()
908 
    result.read(self._iprot)
909 
    self._iprot.readMessageEnd()
910 
    if result.success != None:
911 
      return result.success
912 
    if result.ucx != None:
913 
      raise result.ucx
914 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
915 
 
567 rajveer 916 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 917 
    """
918 
    Parameters:
919 
     - userId
920 
     - address
513 rajveer 921 
     - setDefault
94 ashish 922 
    """
567 rajveer 923 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 924 
    return self.recv_addAddressForUser()
925 
 
567 rajveer 926 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 927 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
928 
    args = addAddressForUser_args()
559 chandransh 929 
    args.userId = userId
94 ashish 930 
    args.address = address
513 rajveer 931 
    args.setDefault = setDefault
94 ashish 932 
    args.write(self._oprot)
933 
    self._oprot.writeMessageEnd()
934 
    self._oprot.trans.flush()
935 
 
936 
  def recv_addAddressForUser(self, ):
937 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
938 
    if mtype == TMessageType.EXCEPTION:
939 
      x = TApplicationException()
940 
      x.read(self._iprot)
941 
      self._iprot.readMessageEnd()
942 
      raise x
943 
    result = addAddressForUser_result()
944 
    result.read(self._iprot)
945 
    self._iprot.readMessageEnd()
946 
    if result.success != None:
947 
      return result.success
948 
    if result.ucx != None:
949 
      raise result.ucx
950 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
951 
 
952 
  def removeAddressForUser(self, userid, addressId):
953 
    """
954 
    Parameters:
955 
     - userid
956 
     - addressId
957 
    """
958 
    self.send_removeAddressForUser(userid, addressId)
959 
    return self.recv_removeAddressForUser()
960 
 
961 
  def send_removeAddressForUser(self, userid, addressId):
962 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
963 
    args = removeAddressForUser_args()
964 
    args.userid = userid
965 
    args.addressId = addressId
966 
    args.write(self._oprot)
967 
    self._oprot.writeMessageEnd()
968 
    self._oprot.trans.flush()
969 
 
970 
  def recv_removeAddressForUser(self, ):
971 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
972 
    if mtype == TMessageType.EXCEPTION:
973 
      x = TApplicationException()
974 
      x.read(self._iprot)
975 
      self._iprot.readMessageEnd()
976 
      raise x
977 
    result = removeAddressForUser_result()
978 
    result.read(self._iprot)
979 
    self._iprot.readMessageEnd()
980 
    if result.success != None:
981 
      return result.success
982 
    if result.ucx != None:
983 
      raise result.ucx
984 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
985 
 
986 
  def setUserAsLoggedIn(self, userId, timestamp):
987 
    """
988 
    Parameters:
989 
     - userId
990 
     - timestamp
991 
    """
992 
    self.send_setUserAsLoggedIn(userId, timestamp)
993 
    return self.recv_setUserAsLoggedIn()
994 
 
995 
  def send_setUserAsLoggedIn(self, userId, timestamp):
996 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
997 
    args = setUserAsLoggedIn_args()
998 
    args.userId = userId
999 
    args.timestamp = timestamp
1000 
    args.write(self._oprot)
1001 
    self._oprot.writeMessageEnd()
1002 
    self._oprot.trans.flush()
1003 
 
1004 
  def recv_setUserAsLoggedIn(self, ):
1005 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1006 
    if mtype == TMessageType.EXCEPTION:
1007 
      x = TApplicationException()
1008 
      x.read(self._iprot)
1009 
      self._iprot.readMessageEnd()
1010 
      raise x
1011 
    result = setUserAsLoggedIn_result()
1012 
    result.read(self._iprot)
1013 
    self._iprot.readMessageEnd()
1014 
    if result.success != None:
1015 
      return result.success
1016 
    if result.ucx != None:
1017 
      raise result.ucx
1018 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1019 
 
1020 
  def setUserAsLoggedOut(self, userid, timestamp):
1021 
    """
1022 
    Parameters:
1023 
     - userid
1024 
     - timestamp
1025 
    """
1026 
    self.send_setUserAsLoggedOut(userid, timestamp)
1027 
    return self.recv_setUserAsLoggedOut()
1028 
 
1029 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1030 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1031 
    args = setUserAsLoggedOut_args()
1032 
    args.userid = userid
1033 
    args.timestamp = timestamp
1034 
    args.write(self._oprot)
1035 
    self._oprot.writeMessageEnd()
1036 
    self._oprot.trans.flush()
1037 
 
1038 
  def recv_setUserAsLoggedOut(self, ):
1039 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1040 
    if mtype == TMessageType.EXCEPTION:
1041 
      x = TApplicationException()
1042 
      x.read(self._iprot)
1043 
      self._iprot.readMessageEnd()
1044 
      raise x
1045 
    result = setUserAsLoggedOut_result()
1046 
    result.read(self._iprot)
1047 
    self._iprot.readMessageEnd()
1048 
    if result.success != None:
1049 
      return result.success
1050 
    if result.ucx != None:
1051 
      raise result.ucx
1052 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1053 
 
504 rajveer 1054 
  def setDefaultAddress(self, userid, addressId):
1055 
    """
1056 
    Parameters:
1057 
     - userid
1058 
     - addressId
1059 
    """
1060 
    self.send_setDefaultAddress(userid, addressId)
1061 
    return self.recv_setDefaultAddress()
1062 
 
1063 
  def send_setDefaultAddress(self, userid, addressId):
1064 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1065 
    args = setDefaultAddress_args()
1066 
    args.userid = userid
1067 
    args.addressId = addressId
1068 
    args.write(self._oprot)
1069 
    self._oprot.writeMessageEnd()
1070 
    self._oprot.trans.flush()
1071 
 
1072 
  def recv_setDefaultAddress(self, ):
1073 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1074 
    if mtype == TMessageType.EXCEPTION:
1075 
      x = TApplicationException()
1076 
      x.read(self._iprot)
1077 
      self._iprot.readMessageEnd()
1078 
      raise x
1079 
    result = setDefaultAddress_result()
1080 
    result.read(self._iprot)
1081 
    self._iprot.readMessageEnd()
1082 
    if result.success != None:
1083 
      return result.success
1084 
    if result.ucx != None:
1085 
      raise result.ucx
1086 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1087 
 
594 rajveer 1088 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1089 
    """
1090 
    Parameters:
1091 
     - userid
594 rajveer 1092 
     - oldPassword
1093 
     - newPassword
94 ashish 1094 
    """
594 rajveer 1095 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1096 
    return self.recv_updatePassword()
1097 
 
594 rajveer 1098 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1099 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1100 
    args = updatePassword_args()
1101 
    args.userid = userid
594 rajveer 1102 
    args.oldPassword = oldPassword
1103 
    args.newPassword = newPassword
94 ashish 1104 
    args.write(self._oprot)
1105 
    self._oprot.writeMessageEnd()
1106 
    self._oprot.trans.flush()
1107 
 
1108 
  def recv_updatePassword(self, ):
1109 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1110 
    if mtype == TMessageType.EXCEPTION:
1111 
      x = TApplicationException()
1112 
      x.read(self._iprot)
1113 
      self._iprot.readMessageEnd()
1114 
      raise x
1115 
    result = updatePassword_result()
1116 
    result.read(self._iprot)
1117 
    self._iprot.readMessageEnd()
1118 
    if result.success != None:
1119 
      return result.success
1120 
    if result.ucx != None:
1121 
      raise result.ucx
1122 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1123 
 
884 rajveer 1124 
  def forgotPassword(self, email, newPassword):
581 rajveer 1125 
    """
1126 
    Parameters:
1127 
     - email
884 rajveer 1128 
     - newPassword
581 rajveer 1129 
    """
884 rajveer 1130 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1131 
    return self.recv_forgotPassword()
1132 
 
884 rajveer 1133 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1134 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1135 
    args = forgotPassword_args()
1136 
    args.email = email
884 rajveer 1137 
    args.newPassword = newPassword
581 rajveer 1138 
    args.write(self._oprot)
1139 
    self._oprot.writeMessageEnd()
1140 
    self._oprot.trans.flush()
1141 
 
1142 
  def recv_forgotPassword(self, ):
1143 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1144 
    if mtype == TMessageType.EXCEPTION:
1145 
      x = TApplicationException()
1146 
      x.read(self._iprot)
1147 
      self._iprot.readMessageEnd()
1148 
      raise x
1149 
    result = forgotPassword_result()
1150 
    result.read(self._iprot)
1151 
    self._iprot.readMessageEnd()
1152 
    if result.success != None:
1153 
      return result.success
1154 
    if result.ucx != None:
1155 
      raise result.ucx
1156 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1157 
 
594 rajveer 1158 
  def getAllAddressesForUser(self, userId):
1159 
    """
1160 
    Parameters:
1161 
     - userId
1162 
    """
1163 
    self.send_getAllAddressesForUser(userId)
1164 
    return self.recv_getAllAddressesForUser()
1165 
 
1166 
  def send_getAllAddressesForUser(self, userId):
1167 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1168 
    args = getAllAddressesForUser_args()
1169 
    args.userId = userId
1170 
    args.write(self._oprot)
1171 
    self._oprot.writeMessageEnd()
1172 
    self._oprot.trans.flush()
1173 
 
1174 
  def recv_getAllAddressesForUser(self, ):
1175 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1176 
    if mtype == TMessageType.EXCEPTION:
1177 
      x = TApplicationException()
1178 
      x.read(self._iprot)
1179 
      self._iprot.readMessageEnd()
1180 
      raise x
1181 
    result = getAllAddressesForUser_result()
1182 
    result.read(self._iprot)
1183 
    self._iprot.readMessageEnd()
1184 
    if result.success != None:
1185 
      return result.success
1186 
    if result.ucx != None:
1187 
      raise result.ucx
1188 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1189 
 
1894 vikas 1190 
  def getAddressById(self, addressId):
1191 
    """
1192 
    Parameters:
1193 
     - addressId
1194 
    """
1195 
    self.send_getAddressById(addressId)
1196 
    return self.recv_getAddressById()
1197 
 
1198 
  def send_getAddressById(self, addressId):
1199 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1200 
    args = getAddressById_args()
1201 
    args.addressId = addressId
1202 
    args.write(self._oprot)
1203 
    self._oprot.writeMessageEnd()
1204 
    self._oprot.trans.flush()
1205 
 
1206 
  def recv_getAddressById(self, ):
1207 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1208 
    if mtype == TMessageType.EXCEPTION:
1209 
      x = TApplicationException()
1210 
      x.read(self._iprot)
1211 
      self._iprot.readMessageEnd()
1212 
      raise x
1213 
    result = getAddressById_result()
1214 
    result.read(self._iprot)
1215 
    self._iprot.readMessageEnd()
1216 
    if result.success != None:
1217 
      return result.success
1218 
    if result.ucx != None:
1219 
      raise result.ucx
1220 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1221 
 
594 rajveer 1222 
  def getDefaultAddressId(self, userId):
1223 
    """
1224 
    Parameters:
1225 
     - userId
1226 
    """
1227 
    self.send_getDefaultAddressId(userId)
1228 
    return self.recv_getDefaultAddressId()
1229 
 
1230 
  def send_getDefaultAddressId(self, userId):
1231 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1232 
    args = getDefaultAddressId_args()
1233 
    args.userId = userId
1234 
    args.write(self._oprot)
1235 
    self._oprot.writeMessageEnd()
1236 
    self._oprot.trans.flush()
1237 
 
1238 
  def recv_getDefaultAddressId(self, ):
1239 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1240 
    if mtype == TMessageType.EXCEPTION:
1241 
      x = TApplicationException()
1242 
      x.read(self._iprot)
1243 
      self._iprot.readMessageEnd()
1244 
      raise x
1245 
    result = getDefaultAddressId_result()
1246 
    result.read(self._iprot)
1247 
    self._iprot.readMessageEnd()
1248 
    if result.success != None:
1249 
      return result.success
1250 
    if result.ucx != None:
1251 
      raise result.ucx
1252 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1253 
 
785 rajveer 1254 
  def getDefaultPincode(self, userId):
1255 
    """
1256 
    Parameters:
1257 
     - userId
1258 
    """
1259 
    self.send_getDefaultPincode(userId)
1260 
    return self.recv_getDefaultPincode()
1261 
 
1262 
  def send_getDefaultPincode(self, userId):
1263 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1264 
    args = getDefaultPincode_args()
1265 
    args.userId = userId
1266 
    args.write(self._oprot)
1267 
    self._oprot.writeMessageEnd()
1268 
    self._oprot.trans.flush()
1269 
 
1270 
  def recv_getDefaultPincode(self, ):
1271 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1272 
    if mtype == TMessageType.EXCEPTION:
1273 
      x = TApplicationException()
1274 
      x.read(self._iprot)
1275 
      self._iprot.readMessageEnd()
1276 
      raise x
1277 
    result = getDefaultPincode_result()
1278 
    result.read(self._iprot)
1279 
    self._iprot.readMessageEnd()
1280 
    if result.success != None:
1281 
      return result.success
1282 
    if result.ucx != None:
1283 
      raise result.ucx
1284 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1285 
 
1274 varun.gupt 1286 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1287 
    """
1288 
    Parameters:
1289 
     - userId
1290 
     - replyTo
1291 
     - communicationType
1292 
     - orderId
1293 
     - airwaybillNo
1294 
     - productName
1295 
     - subject
1296 
     - message
1297 
    """
1298 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1299 
    return self.recv_saveUserCommunication()
1300 
 
1301 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1302 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1303 
    args = saveUserCommunication_args()
1304 
    args.userId = userId
1305 
    args.replyTo = replyTo
1306 
    args.communicationType = communicationType
1307 
    args.orderId = orderId
1308 
    args.airwaybillNo = airwaybillNo
1309 
    args.productName = productName
1310 
    args.subject = subject
1311 
    args.message = message
1312 
    args.write(self._oprot)
1313 
    self._oprot.writeMessageEnd()
1314 
    self._oprot.trans.flush()
1315 
 
1316 
  def recv_saveUserCommunication(self, ):
1317 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1318 
    if mtype == TMessageType.EXCEPTION:
1319 
      x = TApplicationException()
1320 
      x.read(self._iprot)
1321 
      self._iprot.readMessageEnd()
1322 
      raise x
1323 
    result = saveUserCommunication_result()
1324 
    result.read(self._iprot)
1325 
    self._iprot.readMessageEnd()
1326 
    if result.success != None:
1327 
      return result.success
1328 
    if result.ucx != None:
1329 
      raise result.ucx
1330 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1331 
 
1590 varun.gupt 1332 
  def getUserCommunicationById(self, id):
1333 
    """
1334 
    Parameters:
1335 
     - id
1336 
    """
1337 
    self.send_getUserCommunicationById(id)
1338 
    return self.recv_getUserCommunicationById()
1339 
 
1340 
  def send_getUserCommunicationById(self, id):
1341 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1342 
    args = getUserCommunicationById_args()
1343 
    args.id = id
1344 
    args.write(self._oprot)
1345 
    self._oprot.writeMessageEnd()
1346 
    self._oprot.trans.flush()
1347 
 
1348 
  def recv_getUserCommunicationById(self, ):
1349 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1350 
    if mtype == TMessageType.EXCEPTION:
1351 
      x = TApplicationException()
1352 
      x.read(self._iprot)
1353 
      self._iprot.readMessageEnd()
1354 
      raise x
1355 
    result = getUserCommunicationById_result()
1356 
    result.read(self._iprot)
1357 
    self._iprot.readMessageEnd()
1358 
    if result.success != None:
1359 
      return result.success
1360 
    if result.ucx != None:
1361 
      raise result.ucx
1362 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1363 
 
1364 
  def getUserCommunicationByUser(self, userId):
1365 
    """
1366 
    Parameters:
1367 
     - userId
1368 
    """
1369 
    self.send_getUserCommunicationByUser(userId)
1370 
    return self.recv_getUserCommunicationByUser()
1371 
 
1372 
  def send_getUserCommunicationByUser(self, userId):
1373 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1374 
    args = getUserCommunicationByUser_args()
1375 
    args.userId = userId
1376 
    args.write(self._oprot)
1377 
    self._oprot.writeMessageEnd()
1378 
    self._oprot.trans.flush()
1379 
 
1380 
  def recv_getUserCommunicationByUser(self, ):
1381 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1382 
    if mtype == TMessageType.EXCEPTION:
1383 
      x = TApplicationException()
1384 
      x.read(self._iprot)
1385 
      self._iprot.readMessageEnd()
1386 
      raise x
1387 
    result = getUserCommunicationByUser_result()
1388 
    result.read(self._iprot)
1389 
    self._iprot.readMessageEnd()
1390 
    if result.success != None:
1391 
      return result.success
1392 
    if result.ucx != None:
1393 
      raise result.ucx
1394 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1395 
 
1396 
  def getAllUserCommunications(self, ):
1397 
    self.send_getAllUserCommunications()
1398 
    return self.recv_getAllUserCommunications()
1399 
 
1400 
  def send_getAllUserCommunications(self, ):
1401 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1402 
    args = getAllUserCommunications_args()
1403 
    args.write(self._oprot)
1404 
    self._oprot.writeMessageEnd()
1405 
    self._oprot.trans.flush()
1406 
 
1407 
  def recv_getAllUserCommunications(self, ):
1408 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1409 
    if mtype == TMessageType.EXCEPTION:
1410 
      x = TApplicationException()
1411 
      x.read(self._iprot)
1412 
      self._iprot.readMessageEnd()
1413 
      raise x
1414 
    result = getAllUserCommunications_result()
1415 
    result.read(self._iprot)
1416 
    self._iprot.readMessageEnd()
1417 
    if result.success != None:
1418 
      return result.success
1419 
    if result.ucx != None:
1420 
      raise result.ucx
1421 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1422 
 
1859 vikas 1423 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1424 
    """
1425 
    Parameters:
1426 
     - name
1859 vikas 1427 
     - addedOn
1845 vikas 1428 
    """
1859 vikas 1429 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1430 
    return self.recv_createMasterAffiliate()
1431 
 
1859 vikas 1432 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1433 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1434 
    args = createMasterAffiliate_args()
1435 
    args.name = name
1859 vikas 1436 
    args.addedOn = addedOn
1845 vikas 1437 
    args.write(self._oprot)
1438 
    self._oprot.writeMessageEnd()
1439 
    self._oprot.trans.flush()
1440 
 
1441 
  def recv_createMasterAffiliate(self, ):
1442 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1443 
    if mtype == TMessageType.EXCEPTION:
1444 
      x = TApplicationException()
1445 
      x.read(self._iprot)
1446 
      self._iprot.readMessageEnd()
1447 
      raise x
1448 
    result = createMasterAffiliate_result()
1449 
    result.read(self._iprot)
1450 
    self._iprot.readMessageEnd()
1451 
    if result.success != None:
1452 
      return result.success
1453 
    if result.utx != None:
1454 
      raise result.utx
1455 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1456 
 
1899 vikas 1457 
  def getAllMasterAffiliates(self, ):
1458 
    self.send_getAllMasterAffiliates()
1459 
    return self.recv_getAllMasterAffiliates()
1460 
 
1461 
  def send_getAllMasterAffiliates(self, ):
1462 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1463 
    args = getAllMasterAffiliates_args()
1464 
    args.write(self._oprot)
1465 
    self._oprot.writeMessageEnd()
1466 
    self._oprot.trans.flush()
1467 
 
1468 
  def recv_getAllMasterAffiliates(self, ):
1469 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1470 
    if mtype == TMessageType.EXCEPTION:
1471 
      x = TApplicationException()
1472 
      x.read(self._iprot)
1473 
      self._iprot.readMessageEnd()
1474 
      raise x
1475 
    result = getAllMasterAffiliates_result()
1476 
    result.read(self._iprot)
1477 
    self._iprot.readMessageEnd()
1478 
    if result.success != None:
1479 
      return result.success
1480 
    if result.utx != None:
1481 
      raise result.utx
1482 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1483 
 
1845 vikas 1484 
  def getMasterAffiliateById(self, id):
1485 
    """
1486 
    Parameters:
1487 
     - id
1488 
    """
1489 
    self.send_getMasterAffiliateById(id)
1490 
    return self.recv_getMasterAffiliateById()
1491 
 
1492 
  def send_getMasterAffiliateById(self, id):
1493 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1494 
    args = getMasterAffiliateById_args()
1495 
    args.id = id
1496 
    args.write(self._oprot)
1497 
    self._oprot.writeMessageEnd()
1498 
    self._oprot.trans.flush()
1499 
 
1500 
  def recv_getMasterAffiliateById(self, ):
1501 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1502 
    if mtype == TMessageType.EXCEPTION:
1503 
      x = TApplicationException()
1504 
      x.read(self._iprot)
1505 
      self._iprot.readMessageEnd()
1506 
      raise x
1507 
    result = getMasterAffiliateById_result()
1508 
    result.read(self._iprot)
1509 
    self._iprot.readMessageEnd()
1510 
    if result.success != None:
1511 
      return result.success
1512 
    if result.utx != None:
1513 
      raise result.utx
1514 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1515 
 
1516 
  def getMasterAffiliateByName(self, name):
1517 
    """
1518 
    Parameters:
1519 
     - name
1520 
    """
1521 
    self.send_getMasterAffiliateByName(name)
1522 
    return self.recv_getMasterAffiliateByName()
1523 
 
1524 
  def send_getMasterAffiliateByName(self, name):
1525 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1526 
    args = getMasterAffiliateByName_args()
1527 
    args.name = name
1528 
    args.write(self._oprot)
1529 
    self._oprot.writeMessageEnd()
1530 
    self._oprot.trans.flush()
1531 
 
1532 
  def recv_getMasterAffiliateByName(self, ):
1533 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1534 
    if mtype == TMessageType.EXCEPTION:
1535 
      x = TApplicationException()
1536 
      x.read(self._iprot)
1537 
      self._iprot.readMessageEnd()
1538 
      raise x
1539 
    result = getMasterAffiliateByName_result()
1540 
    result.read(self._iprot)
1541 
    self._iprot.readMessageEnd()
1542 
    if result.success != None:
1543 
      return result.success
1544 
    if result.utx != None:
1545 
      raise result.utx
1546 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1547 
 
1859 vikas 1548 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1549 
    """
1550 
    Parameters:
1551 
     - name
1552 
     - url
1553 
     - masterAffiliateId
1859 vikas 1554 
     - addedOn
1845 vikas 1555 
    """
1859 vikas 1556 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1557 
    return self.recv_createAffiliate()
1558 
 
1859 vikas 1559 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1560 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1561 
    args = createAffiliate_args()
1562 
    args.name = name
1563 
    args.url = url
1564 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1565 
    args.addedOn = addedOn
1845 vikas 1566 
    args.write(self._oprot)
1567 
    self._oprot.writeMessageEnd()
1568 
    self._oprot.trans.flush()
1569 
 
1570 
  def recv_createAffiliate(self, ):
1571 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1572 
    if mtype == TMessageType.EXCEPTION:
1573 
      x = TApplicationException()
1574 
      x.read(self._iprot)
1575 
      self._iprot.readMessageEnd()
1576 
      raise x
1577 
    result = createAffiliate_result()
1578 
    result.read(self._iprot)
1579 
    self._iprot.readMessageEnd()
1580 
    if result.success != None:
1581 
      return result.success
1582 
    if result.utx != None:
1583 
      raise result.utx
1584 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1585 
 
1586 
  def getAffiliateById(self, id):
1587 
    """
1588 
    Parameters:
1589 
     - id
1590 
    """
1591 
    self.send_getAffiliateById(id)
1592 
    return self.recv_getAffiliateById()
1593 
 
1594 
  def send_getAffiliateById(self, id):
1595 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1596 
    args = getAffiliateById_args()
1597 
    args.id = id
1598 
    args.write(self._oprot)
1599 
    self._oprot.writeMessageEnd()
1600 
    self._oprot.trans.flush()
1601 
 
1602 
  def recv_getAffiliateById(self, ):
1603 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1604 
    if mtype == TMessageType.EXCEPTION:
1605 
      x = TApplicationException()
1606 
      x.read(self._iprot)
1607 
      self._iprot.readMessageEnd()
1608 
      raise x
1609 
    result = getAffiliateById_result()
1610 
    result.read(self._iprot)
1611 
    self._iprot.readMessageEnd()
1612 
    if result.success != None:
1613 
      return result.success
1614 
    if result.utx != None:
1615 
      raise result.utx
1616 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1617 
 
1618 
  def getAffiliateByName(self, name):
1619 
    """
1620 
    Parameters:
1621 
     - name
1622 
    """
1623 
    self.send_getAffiliateByName(name)
1624 
    return self.recv_getAffiliateByName()
1625 
 
1626 
  def send_getAffiliateByName(self, name):
1627 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1628 
    args = getAffiliateByName_args()
1629 
    args.name = name
1630 
    args.write(self._oprot)
1631 
    self._oprot.writeMessageEnd()
1632 
    self._oprot.trans.flush()
1633 
 
1634 
  def recv_getAffiliateByName(self, ):
1635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1636 
    if mtype == TMessageType.EXCEPTION:
1637 
      x = TApplicationException()
1638 
      x.read(self._iprot)
1639 
      self._iprot.readMessageEnd()
1640 
      raise x
1641 
    result = getAffiliateByName_result()
1642 
    result.read(self._iprot)
1643 
    self._iprot.readMessageEnd()
1644 
    if result.success != None:
1645 
      return result.success
1646 
    if result.utx != None:
1647 
      raise result.utx
1648 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1649 
 
1996 vikas 1650 
  def getTrackerById(self, id):
1845 vikas 1651 
    """
1652 
    Parameters:
1653 
     - id
1654 
    """
1996 vikas 1655 
    self.send_getTrackerById(id)
1845 vikas 1656 
    return self.recv_getTrackerById()
1657 
 
1996 vikas 1658 
  def send_getTrackerById(self, id):
1845 vikas 1659 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1660 
    args = getTrackerById_args()
1996 vikas 1661 
    args.id = id
1845 vikas 1662 
    args.write(self._oprot)
1663 
    self._oprot.writeMessageEnd()
1664 
    self._oprot.trans.flush()
1665 
 
1666 
  def recv_getTrackerById(self, ):
1667 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1668 
    if mtype == TMessageType.EXCEPTION:
1669 
      x = TApplicationException()
1670 
      x.read(self._iprot)
1671 
      self._iprot.readMessageEnd()
1672 
      raise x
1673 
    result = getTrackerById_result()
1674 
    result.read(self._iprot)
1675 
    self._iprot.readMessageEnd()
1676 
    if result.success != None:
1677 
      return result.success
1678 
    if result.utx != None:
1679 
      raise result.utx
1680 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1681 
 
1996 vikas 1682 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1683 
    """
1684 
    Parameters:
1996 vikas 1685 
     - id
1845 vikas 1686 
    """
1996 vikas 1687 
    self.send_getAffiliatesByMasterAffiliate(id)
1688 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1689 
 
1996 vikas 1690 
  def send_getAffiliatesByMasterAffiliate(self, id):
1691 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1692 
    args = getAffiliatesByMasterAffiliate_args()
1693 
    args.id = id
1845 vikas 1694 
    args.write(self._oprot)
1695 
    self._oprot.writeMessageEnd()
1696 
    self._oprot.trans.flush()
1697 
 
1996 vikas 1698 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1699 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1700 
    if mtype == TMessageType.EXCEPTION:
1701 
      x = TApplicationException()
1702 
      x.read(self._iprot)
1703 
      self._iprot.readMessageEnd()
1704 
      raise x
1996 vikas 1705 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1706 
    result.read(self._iprot)
1707 
    self._iprot.readMessageEnd()
1708 
    if result.success != None:
1709 
      return result.success
1710 
    if result.utx != None:
1711 
      raise result.utx
1996 vikas 1712 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1713 
 
1996 vikas 1714 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1715 
    """
1716 
    Parameters:
1996 vikas 1717 
     - affiliateId
1845 vikas 1718 
     - userId
1719 
     - event
1720 
     - url
1721 
     - data
1859 vikas 1722 
     - addedOn
1845 vikas 1723 
    """
1996 vikas 1724 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1725 
    return self.recv_addTrackLog()
1726 
 
1996 vikas 1727 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1728 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1729 
    args = addTrackLog_args()
1996 vikas 1730 
    args.affiliateId = affiliateId
1845 vikas 1731 
    args.userId = userId
1732 
    args.event = event
1733 
    args.url = url
1734 
    args.data = data
1859 vikas 1735 
    args.addedOn = addedOn
1845 vikas 1736 
    args.write(self._oprot)
1737 
    self._oprot.writeMessageEnd()
1738 
    self._oprot.trans.flush()
1739 
 
1740 
  def recv_addTrackLog(self, ):
1741 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1742 
    if mtype == TMessageType.EXCEPTION:
1743 
      x = TApplicationException()
1744 
      x.read(self._iprot)
1745 
      self._iprot.readMessageEnd()
1746 
      raise x
1747 
    result = addTrackLog_result()
1748 
    result.read(self._iprot)
1749 
    self._iprot.readMessageEnd()
1750 
    if result.success != None:
1751 
      return result.success
1752 
    if result.utx != None:
1753 
      raise result.utx
1754 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1755 
 
1756 
  def getTrackLogById(self, id):
1757 
    """
1758 
    Parameters:
1759 
     - id
1760 
    """
1761 
    self.send_getTrackLogById(id)
1762 
    return self.recv_getTrackLogById()
1763 
 
1764 
  def send_getTrackLogById(self, id):
1765 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1766 
    args = getTrackLogById_args()
1767 
    args.id = id
1768 
    args.write(self._oprot)
1769 
    self._oprot.writeMessageEnd()
1770 
    self._oprot.trans.flush()
1771 
 
1772 
  def recv_getTrackLogById(self, ):
1773 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1774 
    if mtype == TMessageType.EXCEPTION:
1775 
      x = TApplicationException()
1776 
      x.read(self._iprot)
1777 
      self._iprot.readMessageEnd()
1778 
      raise x
1779 
    result = getTrackLogById_result()
1780 
    result.read(self._iprot)
1781 
    self._iprot.readMessageEnd()
1782 
    if result.success != None:
1783 
      return result.success
1784 
    if result.utx != None:
1785 
      raise result.utx
1786 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1787 
 
3293 vikas 1788 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 1789 
    """
1790 
    Parameters:
1996 vikas 1791 
     - affiliateId
3293 vikas 1792 
     - startDate
1793 
     - endDate
1845 vikas 1794 
    """
3293 vikas 1795 
    self.send_getTrackLogsByAffiliate(affiliateId, startDate, endDate)
1996 vikas 1796 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 1797 
 
3293 vikas 1798 
  def send_getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1996 vikas 1799 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
1800 
    args = getTrackLogsByAffiliate_args()
1801 
    args.affiliateId = affiliateId
3293 vikas 1802 
    args.startDate = startDate
1803 
    args.endDate = endDate
1845 vikas 1804 
    args.write(self._oprot)
1805 
    self._oprot.writeMessageEnd()
1806 
    self._oprot.trans.flush()
1807 
 
1996 vikas 1808 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 1809 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1810 
    if mtype == TMessageType.EXCEPTION:
1811 
      x = TApplicationException()
1812 
      x.read(self._iprot)
1813 
      self._iprot.readMessageEnd()
1814 
      raise x
1996 vikas 1815 
    result = getTrackLogsByAffiliate_result()
1845 vikas 1816 
    result.read(self._iprot)
1817 
    self._iprot.readMessageEnd()
1818 
    if result.success != None:
1819 
      return result.success
1820 
    if result.utx != None:
1821 
      raise result.utx
1996 vikas 1822 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 1823 
 
1824 
  def getTrackLogsByUser(self, userId):
1825 
    """
1826 
    Parameters:
1827 
     - userId
1828 
    """
1829 
    self.send_getTrackLogsByUser(userId)
1830 
    return self.recv_getTrackLogsByUser()
1831 
 
1832 
  def send_getTrackLogsByUser(self, userId):
1833 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
1834 
    args = getTrackLogsByUser_args()
1835 
    args.userId = userId
1836 
    args.write(self._oprot)
1837 
    self._oprot.writeMessageEnd()
1838 
    self._oprot.trans.flush()
1839 
 
1840 
  def recv_getTrackLogsByUser(self, ):
1841 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1842 
    if mtype == TMessageType.EXCEPTION:
1843 
      x = TApplicationException()
1844 
      x.read(self._iprot)
1845 
      self._iprot.readMessageEnd()
1846 
      raise x
1847 
    result = getTrackLogsByUser_result()
1848 
    result.read(self._iprot)
1849 
    self._iprot.readMessageEnd()
1850 
    if result.success != None:
1851 
      return result.success
1852 
    if result.utx != None:
1853 
      raise result.utx
1854 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
1855 
 
1996 vikas 1856 
  def getTrackLogs(self, userId, event, url):
1845 vikas 1857 
    """
1858 
    Parameters:
1859 
     - userId
1860 
     - event
1861 
     - url
1862 
    """
1996 vikas 1863 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 1864 
    return self.recv_getTrackLogs()
1865 
 
1996 vikas 1866 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 1867 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
1868 
    args = getTrackLogs_args()
1869 
    args.userId = userId
1870 
    args.event = event
1871 
    args.url = url
1872 
    args.write(self._oprot)
1873 
    self._oprot.writeMessageEnd()
1874 
    self._oprot.trans.flush()
1875 
 
1876 
  def recv_getTrackLogs(self, ):
1877 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1878 
    if mtype == TMessageType.EXCEPTION:
1879 
      x = TApplicationException()
1880 
      x.read(self._iprot)
1881 
      self._iprot.readMessageEnd()
1882 
      raise x
1883 
    result = getTrackLogs_result()
1884 
    result.read(self._iprot)
1885 
    self._iprot.readMessageEnd()
1886 
    if result.success != None:
1887 
      return result.success
1888 
    if result.utx != None:
1889 
      raise result.utx
1890 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
1891 
 
559 chandransh 1892 
  def createCart(self, userId):
94 ashish 1893 
    """
1894 
    Parameters:
559 chandransh 1895 
     - userId
94 ashish 1896 
    """
559 chandransh 1897 
    self.send_createCart(userId)
1898 
    return self.recv_createCart()
94 ashish 1899 
 
559 chandransh 1900 
  def send_createCart(self, userId):
1901 
    self._oprot.writeMessageBegin('createCart', TMessageType.CALL, self._seqid)
1902 
    args = createCart_args()
1903 
    args.userId = userId
94 ashish 1904 
    args.write(self._oprot)
1905 
    self._oprot.writeMessageEnd()
1906 
    self._oprot.trans.flush()
1907 
 
559 chandransh 1908 
  def recv_createCart(self, ):
94 ashish 1909 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1910 
    if mtype == TMessageType.EXCEPTION:
1911 
      x = TApplicationException()
1912 
      x.read(self._iprot)
1913 
      self._iprot.readMessageEnd()
1914 
      raise x
559 chandransh 1915 
    result = createCart_result()
94 ashish 1916 
    result.read(self._iprot)
1917 
    self._iprot.readMessageEnd()
1918 
    if result.success != None:
1919 
      return result.success
559 chandransh 1920 
    if result.scx != None:
1921 
      raise result.scx
1922 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createCart failed: unknown result");
94 ashish 1923 
 
559 chandransh 1924 
  def getCurrentCart(self, userId):
94 ashish 1925 
    """
1926 
    Parameters:
559 chandransh 1927 
     - userId
94 ashish 1928 
    """
559 chandransh 1929 
    self.send_getCurrentCart(userId)
1930 
    return self.recv_getCurrentCart()
94 ashish 1931 
 
559 chandransh 1932 
  def send_getCurrentCart(self, userId):
1933 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
1934 
    args = getCurrentCart_args()
1935 
    args.userId = userId
94 ashish 1936 
    args.write(self._oprot)
1937 
    self._oprot.writeMessageEnd()
1938 
    self._oprot.trans.flush()
1939 
 
559 chandransh 1940 
  def recv_getCurrentCart(self, ):
94 ashish 1941 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1942 
    if mtype == TMessageType.EXCEPTION:
1943 
      x = TApplicationException()
1944 
      x.read(self._iprot)
1945 
      self._iprot.readMessageEnd()
1946 
      raise x
559 chandransh 1947 
    result = getCurrentCart_result()
94 ashish 1948 
    result.read(self._iprot)
1949 
    self._iprot.readMessageEnd()
1950 
    if result.success != None:
1951 
      return result.success
559 chandransh 1952 
    if result.scx != None:
1953 
      raise result.scx
1954 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 1955 
 
559 chandransh 1956 
  def getCart(self, cartId):
94 ashish 1957 
    """
1958 
    Parameters:
559 chandransh 1959 
     - cartId
94 ashish 1960 
    """
559 chandransh 1961 
    self.send_getCart(cartId)
1962 
    return self.recv_getCart()
94 ashish 1963 
 
559 chandransh 1964 
  def send_getCart(self, cartId):
1965 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
1966 
    args = getCart_args()
1967 
    args.cartId = cartId
94 ashish 1968 
    args.write(self._oprot)
1969 
    self._oprot.writeMessageEnd()
1970 
    self._oprot.trans.flush()
1971 
 
559 chandransh 1972 
  def recv_getCart(self, ):
94 ashish 1973 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1974 
    if mtype == TMessageType.EXCEPTION:
1975 
      x = TApplicationException()
1976 
      x.read(self._iprot)
1977 
      self._iprot.readMessageEnd()
1978 
      raise x
559 chandransh 1979 
    result = getCart_result()
94 ashish 1980 
    result.read(self._iprot)
1981 
    self._iprot.readMessageEnd()
1982 
    if result.success != None:
1983 
      return result.success
559 chandransh 1984 
    if result.scx != None:
1985 
      raise result.scx
1986 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 1987 
 
559 chandransh 1988 
  def getCartsForUser(self, userId, status):
94 ashish 1989 
    """
1990 
    Parameters:
559 chandransh 1991 
     - userId
1992 
     - status
94 ashish 1993 
    """
559 chandransh 1994 
    self.send_getCartsForUser(userId, status)
1995 
    return self.recv_getCartsForUser()
94 ashish 1996 
 
559 chandransh 1997 
  def send_getCartsForUser(self, userId, status):
1998 
    self._oprot.writeMessageBegin('getCartsForUser', TMessageType.CALL, self._seqid)
1999 
    args = getCartsForUser_args()
2000 
    args.userId = userId
2001 
    args.status = status
94 ashish 2002 
    args.write(self._oprot)
2003 
    self._oprot.writeMessageEnd()
2004 
    self._oprot.trans.flush()
2005 
 
559 chandransh 2006 
  def recv_getCartsForUser(self, ):
94 ashish 2007 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2008 
    if mtype == TMessageType.EXCEPTION:
2009 
      x = TApplicationException()
2010 
      x.read(self._iprot)
2011 
      self._iprot.readMessageEnd()
2012 
      raise x
559 chandransh 2013 
    result = getCartsForUser_result()
94 ashish 2014 
    result.read(self._iprot)
2015 
    self._iprot.readMessageEnd()
2016 
    if result.success != None:
2017 
      return result.success
559 chandransh 2018 
    if result.scx != None:
2019 
      raise result.scx
2020 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsForUser failed: unknown result");
94 ashish 2021 
 
559 chandransh 2022 
  def getCartsByStatus(self, status):
94 ashish 2023 
    """
2024 
    Parameters:
559 chandransh 2025 
     - status
94 ashish 2026 
    """
559 chandransh 2027 
    self.send_getCartsByStatus(status)
2028 
    return self.recv_getCartsByStatus()
94 ashish 2029 
 
559 chandransh 2030 
  def send_getCartsByStatus(self, status):
2031 
    self._oprot.writeMessageBegin('getCartsByStatus', TMessageType.CALL, self._seqid)
2032 
    args = getCartsByStatus_args()
2033 
    args.status = status
94 ashish 2034 
    args.write(self._oprot)
2035 
    self._oprot.writeMessageEnd()
2036 
    self._oprot.trans.flush()
2037 
 
559 chandransh 2038 
  def recv_getCartsByStatus(self, ):
94 ashish 2039 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2040 
    if mtype == TMessageType.EXCEPTION:
2041 
      x = TApplicationException()
2042 
      x.read(self._iprot)
2043 
      self._iprot.readMessageEnd()
2044 
      raise x
559 chandransh 2045 
    result = getCartsByStatus_result()
94 ashish 2046 
    result.read(self._iprot)
2047 
    self._iprot.readMessageEnd()
2048 
    if result.success != None:
2049 
      return result.success
559 chandransh 2050 
    if result.scx != None:
2051 
      raise result.scx
2052 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByStatus failed: unknown result");
94 ashish 2053 
 
559 chandransh 2054 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2055 
    """
2056 
    Parameters:
559 chandransh 2057 
     - from_time
2058 
     - to_time
2059 
     - status
94 ashish 2060 
    """
559 chandransh 2061 
    self.send_getCartsByTime(from_time, to_time, status)
2062 
    return self.recv_getCartsByTime()
94 ashish 2063 
 
559 chandransh 2064 
  def send_getCartsByTime(self, from_time, to_time, status):
2065 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2066 
    args = getCartsByTime_args()
2067 
    args.from_time = from_time
2068 
    args.to_time = to_time
2069 
    args.status = status
94 ashish 2070 
    args.write(self._oprot)
2071 
    self._oprot.writeMessageEnd()
2072 
    self._oprot.trans.flush()
2073 
 
559 chandransh 2074 
  def recv_getCartsByTime(self, ):
94 ashish 2075 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2076 
    if mtype == TMessageType.EXCEPTION:
2077 
      x = TApplicationException()
2078 
      x.read(self._iprot)
2079 
      self._iprot.readMessageEnd()
2080 
      raise x
559 chandransh 2081 
    result = getCartsByTime_result()
94 ashish 2082 
    result.read(self._iprot)
2083 
    self._iprot.readMessageEnd()
2084 
    if result.success != None:
2085 
      return result.success
559 chandransh 2086 
    if result.scx != None:
2087 
      raise result.scx
2088 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2089 
 
559 chandransh 2090 
  def changeCartStatus(self, cartId, status):
130 ashish 2091 
    """
2092 
    Parameters:
559 chandransh 2093 
     - cartId
2094 
     - status
130 ashish 2095 
    """
559 chandransh 2096 
    self.send_changeCartStatus(cartId, status)
2097 
    self.recv_changeCartStatus()
94 ashish 2098 
 
559 chandransh 2099 
  def send_changeCartStatus(self, cartId, status):
2100 
    self._oprot.writeMessageBegin('changeCartStatus', TMessageType.CALL, self._seqid)
2101 
    args = changeCartStatus_args()
2102 
    args.cartId = cartId
2103 
    args.status = status
130 ashish 2104 
    args.write(self._oprot)
2105 
    self._oprot.writeMessageEnd()
2106 
    self._oprot.trans.flush()
2107 
 
559 chandransh 2108 
  def recv_changeCartStatus(self, ):
130 ashish 2109 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2110 
    if mtype == TMessageType.EXCEPTION:
2111 
      x = TApplicationException()
2112 
      x.read(self._iprot)
2113 
      self._iprot.readMessageEnd()
2114 
      raise x
559 chandransh 2115 
    result = changeCartStatus_result()
130 ashish 2116 
    result.read(self._iprot)
2117 
    self._iprot.readMessageEnd()
559 chandransh 2118 
    if result.scx != None:
2119 
      raise result.scx
2120 
    return
2121 
 
2122 
  def addItemToCart(self, cartId, itemId, quantity):
2123 
    """
2124 
    Parameters:
2125 
     - cartId
2126 
     - itemId
2127 
     - quantity
2128 
    """
2129 
    self.send_addItemToCart(cartId, itemId, quantity)
2035 rajveer 2130 
    return self.recv_addItemToCart()
559 chandransh 2131 
 
2132 
  def send_addItemToCart(self, cartId, itemId, quantity):
2133 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2134 
    args = addItemToCart_args()
2135 
    args.cartId = cartId
2136 
    args.itemId = itemId
2137 
    args.quantity = quantity
2138 
    args.write(self._oprot)
2139 
    self._oprot.writeMessageEnd()
2140 
    self._oprot.trans.flush()
2141 
 
2142 
  def recv_addItemToCart(self, ):
2143 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2144 
    if mtype == TMessageType.EXCEPTION:
2145 
      x = TApplicationException()
2146 
      x.read(self._iprot)
2147 
      self._iprot.readMessageEnd()
2148 
      raise x
2149 
    result = addItemToCart_result()
2150 
    result.read(self._iprot)
2151 
    self._iprot.readMessageEnd()
2035 rajveer 2152 
    if result.success != None:
2153 
      return result.success
559 chandransh 2154 
    if result.scx != None:
2155 
      raise result.scx
2035 rajveer 2156 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2157 
 
2158 
  def deleteItemFromCart(self, cartId, itemId):
2159 
    """
2160 
    Parameters:
2161 
     - cartId
2162 
     - itemId
2163 
    """
2164 
    self.send_deleteItemFromCart(cartId, itemId)
2165 
    self.recv_deleteItemFromCart()
2166 
 
2167 
  def send_deleteItemFromCart(self, cartId, itemId):
2168 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2169 
    args = deleteItemFromCart_args()
2170 
    args.cartId = cartId
2171 
    args.itemId = itemId
2172 
    args.write(self._oprot)
2173 
    self._oprot.writeMessageEnd()
2174 
    self._oprot.trans.flush()
2175 
 
2176 
  def recv_deleteItemFromCart(self, ):
2177 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2178 
    if mtype == TMessageType.EXCEPTION:
2179 
      x = TApplicationException()
2180 
      x.read(self._iprot)
2181 
      self._iprot.readMessageEnd()
2182 
      raise x
2183 
    result = deleteItemFromCart_result()
2184 
    result.read(self._iprot)
2185 
    self._iprot.readMessageEnd()
2186 
    if result.scx != None:
2187 
      raise result.scx
2188 
    return
2189 
 
2190 
  def changeQuantity(self, cartId, itemId, quantity):
2191 
    """
2192 
    Parameters:
2193 
     - cartId
2194 
     - itemId
2195 
     - quantity
2196 
    """
2197 
    self.send_changeQuantity(cartId, itemId, quantity)
2198 
    self.recv_changeQuantity()
2199 
 
2200 
  def send_changeQuantity(self, cartId, itemId, quantity):
2201 
    self._oprot.writeMessageBegin('changeQuantity', TMessageType.CALL, self._seqid)
2202 
    args = changeQuantity_args()
2203 
    args.cartId = cartId
2204 
    args.itemId = itemId
2205 
    args.quantity = quantity
2206 
    args.write(self._oprot)
2207 
    self._oprot.writeMessageEnd()
2208 
    self._oprot.trans.flush()
2209 
 
2210 
  def recv_changeQuantity(self, ):
2211 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2212 
    if mtype == TMessageType.EXCEPTION:
2213 
      x = TApplicationException()
2214 
      x.read(self._iprot)
2215 
      self._iprot.readMessageEnd()
2216 
      raise x
2217 
    result = changeQuantity_result()
2218 
    result.read(self._iprot)
2219 
    self._iprot.readMessageEnd()
2220 
    if result.scx != None:
2221 
      raise result.scx
2222 
    return
2223 
 
2224 
  def changeItemStatus(self, cartId, itemId, status):
2225 
    """
2226 
    Parameters:
2227 
     - cartId
2228 
     - itemId
2229 
     - status
2230 
    """
2231 
    self.send_changeItemStatus(cartId, itemId, status)
2232 
    self.recv_changeItemStatus()
2233 
 
2234 
  def send_changeItemStatus(self, cartId, itemId, status):
2235 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
2236 
    args = changeItemStatus_args()
2237 
    args.cartId = cartId
2238 
    args.itemId = itemId
2239 
    args.status = status
2240 
    args.write(self._oprot)
2241 
    self._oprot.writeMessageEnd()
2242 
    self._oprot.trans.flush()
2243 
 
2244 
  def recv_changeItemStatus(self, ):
2245 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2246 
    if mtype == TMessageType.EXCEPTION:
2247 
      x = TApplicationException()
2248 
      x.read(self._iprot)
2249 
      self._iprot.readMessageEnd()
2250 
      raise x
2251 
    result = changeItemStatus_result()
2252 
    result.read(self._iprot)
2253 
    self._iprot.readMessageEnd()
2254 
    if result.scx != None:
2255 
      raise result.scx
2256 
    return
2257 
 
2258 
  def addAddressToCart(self, cartId, addressId):
2259 
    """
2260 
    Parameters:
2261 
     - cartId
2262 
     - addressId
2263 
    """
2264 
    self.send_addAddressToCart(cartId, addressId)
2265 
    self.recv_addAddressToCart()
2266 
 
2267 
  def send_addAddressToCart(self, cartId, addressId):
2268 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2269 
    args = addAddressToCart_args()
2270 
    args.cartId = cartId
2271 
    args.addressId = addressId
2272 
    args.write(self._oprot)
2273 
    self._oprot.writeMessageEnd()
2274 
    self._oprot.trans.flush()
2275 
 
2276 
  def recv_addAddressToCart(self, ):
2277 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2278 
    if mtype == TMessageType.EXCEPTION:
2279 
      x = TApplicationException()
2280 
      x.read(self._iprot)
2281 
      self._iprot.readMessageEnd()
2282 
      raise x
2283 
    result = addAddressToCart_result()
2284 
    result.read(self._iprot)
2285 
    self._iprot.readMessageEnd()
575 chandransh 2286 
    if result.scx != None:
2287 
      raise result.scx
559 chandransh 2288 
    return
2289 
 
1976 varun.gupt 2290 
  def applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
2291 
    """
2292 
    Parameters:
2293 
     - cartId
2294 
     - couponCode
2295 
     - totalPrice
2296 
     - discountedPrice
2297 
    """
2298 
    self.send_applyCouponToCart(cartId, couponCode, totalPrice, discountedPrice)
2299 
    self.recv_applyCouponToCart()
2300 
 
2301 
  def send_applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
2302 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2303 
    args = applyCouponToCart_args()
2304 
    args.cartId = cartId
2305 
    args.couponCode = couponCode
2306 
    args.totalPrice = totalPrice
2307 
    args.discountedPrice = discountedPrice
2308 
    args.write(self._oprot)
2309 
    self._oprot.writeMessageEnd()
2310 
    self._oprot.trans.flush()
2311 
 
2312 
  def recv_applyCouponToCart(self, ):
2313 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2314 
    if mtype == TMessageType.EXCEPTION:
2315 
      x = TApplicationException()
2316 
      x.read(self._iprot)
2317 
      self._iprot.readMessageEnd()
2318 
      raise x
2319 
    result = applyCouponToCart_result()
2320 
    result.read(self._iprot)
2321 
    self._iprot.readMessageEnd()
2322 
    if result.scx != None:
2323 
      raise result.scx
2324 
    return
2325 
 
2326 
  def removeCoupon(self, cartId):
2327 
    """
2328 
    Parameters:
2329 
     - cartId
2330 
    """
2331 
    self.send_removeCoupon(cartId)
2332 
    self.recv_removeCoupon()
2333 
 
2334 
  def send_removeCoupon(self, cartId):
2335 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2336 
    args = removeCoupon_args()
2337 
    args.cartId = cartId
2338 
    args.write(self._oprot)
2339 
    self._oprot.writeMessageEnd()
2340 
    self._oprot.trans.flush()
2341 
 
2342 
  def recv_removeCoupon(self, ):
2343 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2344 
    if mtype == TMessageType.EXCEPTION:
2345 
      x = TApplicationException()
2346 
      x.read(self._iprot)
2347 
      self._iprot.readMessageEnd()
2348 
      raise x
2349 
    result = removeCoupon_result()
2350 
    result.read(self._iprot)
2351 
    self._iprot.readMessageEnd()
2352 
    if result.scx != None:
2353 
      raise result.scx
2354 
    return
2355 
 
2815 vikas 2356 
  def createOrders(self, cartId, sessionSource, sessionStartTime):
559 chandransh 2357 
    """
690 chandransh 2358 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
2359 
 
559 chandransh 2360 
    Parameters:
2361 
     - cartId
2815 vikas 2362 
     - sessionSource
2363 
     - sessionStartTime
559 chandransh 2364 
    """
2815 vikas 2365 
    self.send_createOrders(cartId, sessionSource, sessionStartTime)
690 chandransh 2366 
    return self.recv_createOrders()
559 chandransh 2367 
 
2815 vikas 2368 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime):
690 chandransh 2369 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2370 
    args = createOrders_args()
559 chandransh 2371 
    args.cartId = cartId
2815 vikas 2372 
    args.sessionSource = sessionSource
2373 
    args.sessionStartTime = sessionStartTime
559 chandransh 2374 
    args.write(self._oprot)
2375 
    self._oprot.writeMessageEnd()
2376 
    self._oprot.trans.flush()
2377 
 
690 chandransh 2378 
  def recv_createOrders(self, ):
559 chandransh 2379 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2380 
    if mtype == TMessageType.EXCEPTION:
2381 
      x = TApplicationException()
2382 
      x.read(self._iprot)
2383 
      self._iprot.readMessageEnd()
2384 
      raise x
690 chandransh 2385 
    result = createOrders_result()
559 chandransh 2386 
    result.read(self._iprot)
2387 
    self._iprot.readMessageEnd()
130 ashish 2388 
    if result.success != None:
2389 
      return result.success
559 chandransh 2390 
    if result.scx != None:
2391 
      raise result.scx
690 chandransh 2392 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2393 
 
559 chandransh 2394 
  def validateCart(self, cartId):
130 ashish 2395 
    """
690 chandransh 2396 
    Validates that:
2397 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2398 
    2. All of the lines in the cart are active items.
690 chandransh 2399 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2400 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 2401 
 
130 ashish 2402 
    Parameters:
559 chandransh 2403 
     - cartId
130 ashish 2404 
    """
559 chandransh 2405 
    self.send_validateCart(cartId)
2406 
    return self.recv_validateCart()
130 ashish 2407 
 
559 chandransh 2408 
  def send_validateCart(self, cartId):
2409 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2410 
    args = validateCart_args()
2411 
    args.cartId = cartId
130 ashish 2412 
    args.write(self._oprot)
2413 
    self._oprot.writeMessageEnd()
2414 
    self._oprot.trans.flush()
2415 
 
559 chandransh 2416 
  def recv_validateCart(self, ):
130 ashish 2417 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2418 
    if mtype == TMessageType.EXCEPTION:
2419 
      x = TApplicationException()
2420 
      x.read(self._iprot)
2421 
      self._iprot.readMessageEnd()
2422 
      raise x
559 chandransh 2423 
    result = validateCart_result()
130 ashish 2424 
    result.read(self._iprot)
2425 
    self._iprot.readMessageEnd()
2426 
    if result.success != None:
2427 
      return result.success
575 chandransh 2428 
    if result.scex != None:
2429 
      raise result.scex
559 chandransh 2430 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2431 
 
690 chandransh 2432 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2433 
    """
690 chandransh 2434 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
2435 
 
575 chandransh 2436 
    Parameters:
690 chandransh 2437 
     - fromCartId
2438 
     - toCartId
2439 
    """
2440 
    self.send_mergeCart(fromCartId, toCartId)
2441 
    self.recv_mergeCart()
2442 
 
2443 
  def send_mergeCart(self, fromCartId, toCartId):
2444 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2445 
    args = mergeCart_args()
2446 
    args.fromCartId = fromCartId
2447 
    args.toCartId = toCartId
2448 
    args.write(self._oprot)
2449 
    self._oprot.writeMessageEnd()
2450 
    self._oprot.trans.flush()
2451 
 
2452 
  def recv_mergeCart(self, ):
2453 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2454 
    if mtype == TMessageType.EXCEPTION:
2455 
      x = TApplicationException()
2456 
      x.read(self._iprot)
2457 
      self._iprot.readMessageEnd()
2458 
      raise x
2459 
    result = mergeCart_result()
2460 
    result.read(self._iprot)
2461 
    self._iprot.readMessageEnd()
2462 
    return
2463 
 
2464 
  def checkOut(self, cartId):
2465 
    """
2466 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
2467 
 
2468 
    Parameters:
575 chandransh 2469 
     - cartId
2470 
    """
690 chandransh 2471 
    self.send_checkOut(cartId)
2472 
    return self.recv_checkOut()
575 chandransh 2473 
 
690 chandransh 2474 
  def send_checkOut(self, cartId):
2475 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2476 
    args = checkOut_args()
575 chandransh 2477 
    args.cartId = cartId
2478 
    args.write(self._oprot)
2479 
    self._oprot.writeMessageEnd()
2480 
    self._oprot.trans.flush()
2481 
 
690 chandransh 2482 
  def recv_checkOut(self, ):
575 chandransh 2483 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2484 
    if mtype == TMessageType.EXCEPTION:
2485 
      x = TApplicationException()
2486 
      x.read(self._iprot)
2487 
      self._iprot.readMessageEnd()
2488 
      raise x
690 chandransh 2489 
    result = checkOut_result()
575 chandransh 2490 
    result.read(self._iprot)
2491 
    self._iprot.readMessageEnd()
2492 
    if result.success != None:
2493 
      return result.success
2494 
    if result.scex != None:
2495 
      raise result.scex
690 chandransh 2496 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2497 
 
690 chandransh 2498 
  def resetCart(self, cartId, items):
559 chandransh 2499 
    """
690 chandransh 2500 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2501 
    This methods removes the specified quantiry of the specified item from the cart.
2502 
 
559 chandransh 2503 
    Parameters:
690 chandransh 2504 
     - cartId
2505 
     - items
559 chandransh 2506 
    """
690 chandransh 2507 
    self.send_resetCart(cartId, items)
2508 
    return self.recv_resetCart()
130 ashish 2509 
 
690 chandransh 2510 
  def send_resetCart(self, cartId, items):
2511 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2512 
    args = resetCart_args()
2513 
    args.cartId = cartId
2514 
    args.items = items
559 chandransh 2515 
    args.write(self._oprot)
2516 
    self._oprot.writeMessageEnd()
2517 
    self._oprot.trans.flush()
2518 
 
690 chandransh 2519 
  def recv_resetCart(self, ):
559 chandransh 2520 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2521 
    if mtype == TMessageType.EXCEPTION:
2522 
      x = TApplicationException()
2523 
      x.read(self._iprot)
2524 
      self._iprot.readMessageEnd()
2525 
      raise x
690 chandransh 2526 
    result = resetCart_result()
559 chandransh 2527 
    result.read(self._iprot)
2528 
    self._iprot.readMessageEnd()
690 chandransh 2529 
    if result.success != None:
2530 
      return result.success
2531 
    if result.scex != None:
2532 
      raise result.scex
2533 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2534 
 
2981 rajveer 2535 
  def getUserCount(self, userType):
559 chandransh 2536 
    """
2981 rajveer 2537 
    Returns number of registered users.
2538 
    If userType = null, then it returns count of all users, including anonymous
2539 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2540 
    If userType = UserType.USER, then it returns count of non-anonymous users only
772 rajveer 2541 
 
559 chandransh 2542 
    Parameters:
2981 rajveer 2543 
     - userType
559 chandransh 2544 
    """
2981 rajveer 2545 
    self.send_getUserCount(userType)
2546 
    return self.recv_getUserCount()
559 chandransh 2547 
 
2981 rajveer 2548 
  def send_getUserCount(self, userType):
2549 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2550 
    args = getUserCount_args()
2551 
    args.userType = userType
559 chandransh 2552 
    args.write(self._oprot)
2553 
    self._oprot.writeMessageEnd()
2554 
    self._oprot.trans.flush()
2555 
 
2981 rajveer 2556 
  def recv_getUserCount(self, ):
559 chandransh 2557 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2558 
    if mtype == TMessageType.EXCEPTION:
2559 
      x = TApplicationException()
2560 
      x.read(self._iprot)
2561 
      self._iprot.readMessageEnd()
2562 
      raise x
2981 rajveer 2563 
    result = getUserCount_result()
559 chandransh 2564 
    result.read(self._iprot)
2565 
    self._iprot.readMessageEnd()
2566 
    if result.success != None:
2567 
      return result.success
2981 rajveer 2568 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2569 
 
2981 rajveer 2570 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2571 
    """
2981 rajveer 2572 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2573 
    If any of startDate or endDate is -1, then that filter is ignored.
2574 
    If userType is null, then returns all the users, irrespective of anonymous flag
2575 
 
2576 
 
559 chandransh 2577 
    Parameters:
2981 rajveer 2578 
     - userType
2579 
     - startDate
2580 
     - endDate
559 chandransh 2581 
    """
2981 rajveer 2582 
    self.send_getAllUsers(userType, startDate, endDate)
2583 
    return self.recv_getAllUsers()
559 chandransh 2584 
 
2981 rajveer 2585 
  def send_getAllUsers(self, userType, startDate, endDate):
2586 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2587 
    args = getAllUsers_args()
2588 
    args.userType = userType
2589 
    args.startDate = startDate
2590 
    args.endDate = endDate
559 chandransh 2591 
    args.write(self._oprot)
2592 
    self._oprot.writeMessageEnd()
2593 
    self._oprot.trans.flush()
2594 
 
2981 rajveer 2595 
  def recv_getAllUsers(self, ):
559 chandransh 2596 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2597 
    if mtype == TMessageType.EXCEPTION:
2598 
      x = TApplicationException()
2599 
      x.read(self._iprot)
2600 
      self._iprot.readMessageEnd()
2601 
      raise x
2981 rajveer 2602 
    result = getAllUsers_result()
559 chandransh 2603 
    result.read(self._iprot)
2604 
    self._iprot.readMessageEnd()
2605 
    if result.success != None:
2606 
      return result.success
2981 rajveer 2607 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2608 
 
2981 rajveer 2609 
  def putUserNote(self, user_id, entity_id, slide, note):
559 chandransh 2610 
    """
2611 
    Parameters:
2981 rajveer 2612 
     - user_id
2613 
     - entity_id
2614 
     - slide
2615 
     - note
559 chandransh 2616 
    """
2981 rajveer 2617 
    self.send_putUserNote(user_id, entity_id, slide, note)
2618 
    self.recv_putUserNote()
559 chandransh 2619 
 
2981 rajveer 2620 
  def send_putUserNote(self, user_id, entity_id, slide, note):
2621 
    self._oprot.writeMessageBegin('putUserNote', TMessageType.CALL, self._seqid)
2622 
    args = putUserNote_args()
2623 
    args.user_id = user_id
2624 
    args.entity_id = entity_id
2625 
    args.slide = slide
2626 
    args.note = note
559 chandransh 2627 
    args.write(self._oprot)
2628 
    self._oprot.writeMessageEnd()
2629 
    self._oprot.trans.flush()
2630 
 
2981 rajveer 2631 
  def recv_putUserNote(self, ):
559 chandransh 2632 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2633 
    if mtype == TMessageType.EXCEPTION:
2634 
      x = TApplicationException()
2635 
      x.read(self._iprot)
2636 
      self._iprot.readMessageEnd()
2637 
      raise x
2981 rajveer 2638 
    result = putUserNote_result()
559 chandransh 2639 
    result.read(self._iprot)
2640 
    self._iprot.readMessageEnd()
2641 
    return
2642 
 
2981 rajveer 2643 
  def getUserNotes(self, user_id, entity_id):
559 chandransh 2644 
    """
2645 
    Parameters:
2981 rajveer 2646 
     - user_id
2647 
     - entity_id
559 chandransh 2648 
    """
2981 rajveer 2649 
    self.send_getUserNotes(user_id, entity_id)
2650 
    return self.recv_getUserNotes()
559 chandransh 2651 
 
2981 rajveer 2652 
  def send_getUserNotes(self, user_id, entity_id):
2653 
    self._oprot.writeMessageBegin('getUserNotes', TMessageType.CALL, self._seqid)
2654 
    args = getUserNotes_args()
2655 
    args.user_id = user_id
2656 
    args.entity_id = entity_id
559 chandransh 2657 
    args.write(self._oprot)
2658 
    self._oprot.writeMessageEnd()
2659 
    self._oprot.trans.flush()
2660 
 
2981 rajveer 2661 
  def recv_getUserNotes(self, ):
559 chandransh 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
2981 rajveer 2668 
    result = getUserNotes_result()
559 chandransh 2669 
    result.read(self._iprot)
2670 
    self._iprot.readMessageEnd()
2981 rajveer 2671 
    if result.success != None:
2672 
      return result.success
2673 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserNotes failed: unknown result");
559 chandransh 2674 
 
2981 rajveer 2675 
  def getMyResearchItems(self, userId):
559 chandransh 2676 
    """
2981 rajveer 2677 
    Returns list of item ids in myresearch for the user
2678 
 
559 chandransh 2679 
    Parameters:
772 rajveer 2680 
     - userId
559 chandransh 2681 
    """
2981 rajveer 2682 
    self.send_getMyResearchItems(userId)
2683 
    return self.recv_getMyResearchItems()
559 chandransh 2684 
 
2981 rajveer 2685 
  def send_getMyResearchItems(self, userId):
2686 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2687 
    args = getMyResearchItems_args()
772 rajveer 2688 
    args.userId = userId
559 chandransh 2689 
    args.write(self._oprot)
2690 
    self._oprot.writeMessageEnd()
2691 
    self._oprot.trans.flush()
2692 
 
2981 rajveer 2693 
  def recv_getMyResearchItems(self, ):
559 chandransh 2694 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2695 
    if mtype == TMessageType.EXCEPTION:
2696 
      x = TApplicationException()
2697 
      x.read(self._iprot)
2698 
      self._iprot.readMessageEnd()
2699 
      raise x
2981 rajveer 2700 
    result = getMyResearchItems_result()
559 chandransh 2701 
    result.read(self._iprot)
2702 
    self._iprot.readMessageEnd()
2703 
    if result.success != None:
2704 
      return result.success
2705 
    if result.scx != None:
2706 
      raise result.scx
2981 rajveer 2707 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2708 
 
2981 rajveer 2709 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2710 
    """
2981 rajveer 2711 
    add item to my research for a user
2712 
 
559 chandransh 2713 
    Parameters:
2981 rajveer 2714 
     - userId
2715 
     - itemId
559 chandransh 2716 
    """
2981 rajveer 2717 
    self.send_updateMyResearch(userId, itemId)
2718 
    return self.recv_updateMyResearch()
559 chandransh 2719 
 
2981 rajveer 2720 
  def send_updateMyResearch(self, userId, itemId):
2721 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2722 
    args = updateMyResearch_args()
2723 
    args.userId = userId
2724 
    args.itemId = itemId
559 chandransh 2725 
    args.write(self._oprot)
2726 
    self._oprot.writeMessageEnd()
2727 
    self._oprot.trans.flush()
2728 
 
2981 rajveer 2729 
  def recv_updateMyResearch(self, ):
559 chandransh 2730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2731 
    if mtype == TMessageType.EXCEPTION:
2732 
      x = TApplicationException()
2733 
      x.read(self._iprot)
2734 
      self._iprot.readMessageEnd()
2735 
      raise x
2981 rajveer 2736 
    result = updateMyResearch_result()
559 chandransh 2737 
    result.read(self._iprot)
2738 
    self._iprot.readMessageEnd()
2981 rajveer 2739 
    if result.success != None:
2740 
      return result.success
2741 
    if result.scx != None:
2742 
      raise result.scx
2743 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
559 chandransh 2744 
 
2981 rajveer 2745 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2746 
    """
2981 rajveer 2747 
    delete item from my research for a user
1596 ankur.sing 2748 
 
2749 
    Parameters:
2981 rajveer 2750 
     - userId
2751 
     - itemId
1596 ankur.sing 2752 
    """
2981 rajveer 2753 
    self.send_deleteItemFromMyResearch(userId, itemId)
2754 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2755 
 
2981 rajveer 2756 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2757 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2758 
    args = deleteItemFromMyResearch_args()
2759 
    args.userId = userId
2760 
    args.itemId = itemId
1596 ankur.sing 2761 
    args.write(self._oprot)
2762 
    self._oprot.writeMessageEnd()
2763 
    self._oprot.trans.flush()
2764 
 
2981 rajveer 2765 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 2766 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2767 
    if mtype == TMessageType.EXCEPTION:
2768 
      x = TApplicationException()
2769 
      x.read(self._iprot)
2770 
      self._iprot.readMessageEnd()
2771 
      raise x
2981 rajveer 2772 
    result = deleteItemFromMyResearch_result()
1596 ankur.sing 2773 
    result.read(self._iprot)
2774 
    self._iprot.readMessageEnd()
2981 rajveer 2775 
    if result.scx != None:
2776 
      raise result.scx
2777 
    return
1596 ankur.sing 2778 
 
2981 rajveer 2779 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2780 
    """
2981 rajveer 2781 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
1673 ankur.sing 2782 
 
2783 
    Parameters:
2981 rajveer 2784 
     - userId
1673 ankur.sing 2785 
    """
2981 rajveer 2786 
    self.send_getBrowseHistoryItems(userId)
2787 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2788 
 
2981 rajveer 2789 
  def send_getBrowseHistoryItems(self, userId):
2790 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2791 
    args = getBrowseHistoryItems_args()
2792 
    args.userId = userId
1673 ankur.sing 2793 
    args.write(self._oprot)
2794 
    self._oprot.writeMessageEnd()
2795 
    self._oprot.trans.flush()
2796 
 
2981 rajveer 2797 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 2798 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2799 
    if mtype == TMessageType.EXCEPTION:
2800 
      x = TApplicationException()
2801 
      x.read(self._iprot)
2802 
      self._iprot.readMessageEnd()
2803 
      raise x
2981 rajveer 2804 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 2805 
    result.read(self._iprot)
2806 
    self._iprot.readMessageEnd()
2807 
    if result.success != None:
2808 
      return result.success
2981 rajveer 2809 
    if result.scx != None:
2810 
      raise result.scx
2811 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 2812 
 
2981 rajveer 2813 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 2814 
    """
2981 rajveer 2815 
    add item to browse history for a user
2642 varun.gupt 2816 
 
2817 
    Parameters:
2981 rajveer 2818 
     - userId
2819 
     - itemId
2642 varun.gupt 2820 
    """
2981 rajveer 2821 
    self.send_updateBrowseHistory(userId, itemId)
2822 
    self.recv_updateBrowseHistory()
1673 ankur.sing 2823 
 
2981 rajveer 2824 
  def send_updateBrowseHistory(self, userId, itemId):
2825 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2826 
    args = updateBrowseHistory_args()
2827 
    args.userId = userId
2828 
    args.itemId = itemId
2642 varun.gupt 2829 
    args.write(self._oprot)
2830 
    self._oprot.writeMessageEnd()
2831 
    self._oprot.trans.flush()
2832 
 
2981 rajveer 2833 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 2834 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2835 
    if mtype == TMessageType.EXCEPTION:
2836 
      x = TApplicationException()
2837 
      x.read(self._iprot)
2838 
      self._iprot.readMessageEnd()
2839 
      raise x
2981 rajveer 2840 
    result = updateBrowseHistory_result()
2642 varun.gupt 2841 
    result.read(self._iprot)
2842 
    self._iprot.readMessageEnd()
2843 
    return
2844 
 
3385 varun.gupt 2845 
  def getCartsWithCouponCount(self, couponCode):
2846 
    """
2847 
    Returns count of Carts with given coupon applied
2848 
 
2849 
    Parameters:
2850 
     - couponCode
2851 
    """
2852 
    self.send_getCartsWithCouponCount(couponCode)
2853 
    return self.recv_getCartsWithCouponCount()
2642 varun.gupt 2854 
 
3385 varun.gupt 2855 
  def send_getCartsWithCouponCount(self, couponCode):
2856 
    self._oprot.writeMessageBegin('getCartsWithCouponCount', TMessageType.CALL, self._seqid)
2857 
    args = getCartsWithCouponCount_args()
2858 
    args.couponCode = couponCode
2859 
    args.write(self._oprot)
2860 
    self._oprot.writeMessageEnd()
2861 
    self._oprot.trans.flush()
2862 
 
2863 
  def recv_getCartsWithCouponCount(self, ):
2864 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2865 
    if mtype == TMessageType.EXCEPTION:
2866 
      x = TApplicationException()
2867 
      x.read(self._iprot)
2868 
      self._iprot.readMessageEnd()
2869 
      raise x
2870 
    result = getCartsWithCouponCount_result()
2871 
    result.read(self._iprot)
2872 
    self._iprot.readMessageEnd()
2873 
    if result.success != None:
2874 
      return result.success
2875 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsWithCouponCount failed: unknown result");
2876 
 
2877 
 
3376 rajveer 2878 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 2879 
  def __init__(self, handler):
3376 rajveer 2880 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
559 chandransh 2881 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
2882 
    self._processMap["getUserById"] = Processor.process_getUserById
1491 vikas 2883 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
3032 mandeep.dh 2884 
    self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
559 chandransh 2885 
    self._processMap["createUser"] = Processor.process_createUser
2886 
    self._processMap["updateUser"] = Processor.process_updateUser
2887 
    self._processMap["deleteUser"] = Processor.process_deleteUser
2888 
    self._processMap["getUserState"] = Processor.process_getUserState
122 ashish 2889 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 2890 
    self._processMap["userExists"] = Processor.process_userExists
2891 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
2892 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
2893 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
2894 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 2895 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 2896 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 2897 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 2898 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 2899 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 2900 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 2901 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 2902 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 2903 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
2904 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
2905 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
1845 vikas 2906 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 2907 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 2908 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
2909 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
2910 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
2911 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
2912 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 2913 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 2914 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
2915 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
2916 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 2917 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 2918 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
2919 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 2920 
    self._processMap["createCart"] = Processor.process_createCart
2921 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
2922 
    self._processMap["getCart"] = Processor.process_getCart
2923 
    self._processMap["getCartsForUser"] = Processor.process_getCartsForUser
2924 
    self._processMap["getCartsByStatus"] = Processor.process_getCartsByStatus
2925 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
2926 
    self._processMap["changeCartStatus"] = Processor.process_changeCartStatus
2927 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
2928 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
2929 
    self._processMap["changeQuantity"] = Processor.process_changeQuantity
2930 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
2931 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
1976 varun.gupt 2932 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
2933 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
690 chandransh 2934 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 2935 
    self._processMap["validateCart"] = Processor.process_validateCart
2936 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 2937 
    self._processMap["checkOut"] = Processor.process_checkOut
2938 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 2939 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 2940 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2642 varun.gupt 2941 
    self._processMap["putUserNote"] = Processor.process_putUserNote
2942 
    self._processMap["getUserNotes"] = Processor.process_getUserNotes
2981 rajveer 2943 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
2944 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
2945 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
2946 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
2947 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
3385 varun.gupt 2948 
    self._processMap["getCartsWithCouponCount"] = Processor.process_getCartsWithCouponCount
94 ashish 2949 
 
2950 
  def process(self, iprot, oprot):
2951 
    (name, type, seqid) = iprot.readMessageBegin()
2952 
    if name not in self._processMap:
2953 
      iprot.skip(TType.STRUCT)
2954 
      iprot.readMessageEnd()
2955 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
2956 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
2957 
      x.write(oprot)
2958 
      oprot.writeMessageEnd()
2959 
      oprot.trans.flush()
2960 
      return
2961 
    else:
2962 
      self._processMap[name](self, seqid, iprot, oprot)
2963 
    return True
2964 
 
559 chandransh 2965 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
2966 
    args = createAnonymousUser_args()
94 ashish 2967 
    args.read(iprot)
2968 
    iprot.readMessageEnd()
559 chandransh 2969 
    result = createAnonymousUser_result()
94 ashish 2970 
    try:
559 chandransh 2971 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
2972 
    except UserContextException, ucex:
2973 
      result.ucex = ucex
2974 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 2975 
    result.write(oprot)
2976 
    oprot.writeMessageEnd()
2977 
    oprot.trans.flush()
2978 
 
559 chandransh 2979 
  def process_getUserById(self, seqid, iprot, oprot):
2980 
    args = getUserById_args()
94 ashish 2981 
    args.read(iprot)
2982 
    iprot.readMessageEnd()
559 chandransh 2983 
    result = getUserById_result()
94 ashish 2984 
    try:
559 chandransh 2985 
      result.success = self._handler.getUserById(args.userId)
2986 
    except UserContextException, ucex:
2987 
      result.ucex = ucex
2988 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 2989 
    result.write(oprot)
2990 
    oprot.writeMessageEnd()
2991 
    oprot.trans.flush()
2992 
 
1491 vikas 2993 
  def process_getUserByEmail(self, seqid, iprot, oprot):
2994 
    args = getUserByEmail_args()
2995 
    args.read(iprot)
2996 
    iprot.readMessageEnd()
2997 
    result = getUserByEmail_result()
2998 
    try:
2999 
      result.success = self._handler.getUserByEmail(args.email)
3000 
    except UserContextException, ucex:
3001 
      result.ucex = ucex
3002 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
3003 
    result.write(oprot)
3004 
    oprot.writeMessageEnd()
3005 
    oprot.trans.flush()
3006 
 
3032 mandeep.dh 3007 
  def process_getUserByMobileNumber(self, seqid, iprot, oprot):
3008 
    args = getUserByMobileNumber_args()
3009 
    args.read(iprot)
3010 
    iprot.readMessageEnd()
3011 
    result = getUserByMobileNumber_result()
3012 
    try:
3013 
      result.success = self._handler.getUserByMobileNumber(args.mobileNumber)
3014 
    except UserContextException, ucex:
3015 
      result.ucex = ucex
3016 
    oprot.writeMessageBegin("getUserByMobileNumber", TMessageType.REPLY, seqid)
3017 
    result.write(oprot)
3018 
    oprot.writeMessageEnd()
3019 
    oprot.trans.flush()
3020 
 
559 chandransh 3021 
  def process_createUser(self, seqid, iprot, oprot):
3022 
    args = createUser_args()
94 ashish 3023 
    args.read(iprot)
3024 
    iprot.readMessageEnd()
559 chandransh 3025 
    result = createUser_result()
94 ashish 3026 
    try:
559 chandransh 3027 
      result.success = self._handler.createUser(args.user)
3028 
    except UserContextException, ucex:
3029 
      result.ucex = ucex
3030 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 3031 
    result.write(oprot)
3032 
    oprot.writeMessageEnd()
3033 
    oprot.trans.flush()
3034 
 
559 chandransh 3035 
  def process_updateUser(self, seqid, iprot, oprot):
3036 
    args = updateUser_args()
94 ashish 3037 
    args.read(iprot)
3038 
    iprot.readMessageEnd()
559 chandransh 3039 
    result = updateUser_result()
94 ashish 3040 
    try:
559 chandransh 3041 
      result.success = self._handler.updateUser(args.user)
3042 
    except UserContextException, ucex:
3043 
      result.ucex = ucex
3044 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 3045 
    result.write(oprot)
3046 
    oprot.writeMessageEnd()
3047 
    oprot.trans.flush()
3048 
 
559 chandransh 3049 
  def process_deleteUser(self, seqid, iprot, oprot):
3050 
    args = deleteUser_args()
94 ashish 3051 
    args.read(iprot)
3052 
    iprot.readMessageEnd()
559 chandransh 3053 
    result = deleteUser_result()
94 ashish 3054 
    try:
559 chandransh 3055 
      result.success = self._handler.deleteUser(args.userId)
3056 
    except UserContextException, ucex:
3057 
      result.ucex = ucex
3058 
    oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
94 ashish 3059 
    result.write(oprot)
3060 
    oprot.writeMessageEnd()
3061 
    oprot.trans.flush()
3062 
 
559 chandransh 3063 
  def process_getUserState(self, seqid, iprot, oprot):
3064 
    args = getUserState_args()
94 ashish 3065 
    args.read(iprot)
3066 
    iprot.readMessageEnd()
559 chandransh 3067 
    result = getUserState_result()
94 ashish 3068 
    try:
559 chandransh 3069 
      result.success = self._handler.getUserState(args.userId)
3070 
    except UserContextException, ucex:
3071 
      result.ucex = ucex
3072 
    oprot.writeMessageBegin("getUserState", TMessageType.REPLY, seqid)
94 ashish 3073 
    result.write(oprot)
3074 
    oprot.writeMessageEnd()
3075 
    oprot.trans.flush()
3076 
 
122 ashish 3077 
  def process_authenticateUser(self, seqid, iprot, oprot):
3078 
    args = authenticateUser_args()
3079 
    args.read(iprot)
3080 
    iprot.readMessageEnd()
3081 
    result = authenticateUser_result()
3082 
    try:
559 chandransh 3083 
      result.success = self._handler.authenticateUser(args.email, args.password)
3084 
    except AuthenticationException, auex:
3085 
      result.auex = auex
122 ashish 3086 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
3087 
    result.write(oprot)
3088 
    oprot.writeMessageEnd()
3089 
    oprot.trans.flush()
3090 
 
94 ashish 3091 
  def process_userExists(self, seqid, iprot, oprot):
3092 
    args = userExists_args()
3093 
    args.read(iprot)
3094 
    iprot.readMessageEnd()
3095 
    result = userExists_result()
3096 
    try:
3097 
      result.success = self._handler.userExists(args.email)
3098 
    except UserContextException, ucx:
3099 
      result.ucx = ucx
3100 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
3101 
    result.write(oprot)
3102 
    oprot.writeMessageEnd()
3103 
    oprot.trans.flush()
3104 
 
3105 
  def process_addAddressForUser(self, seqid, iprot, oprot):
3106 
    args = addAddressForUser_args()
3107 
    args.read(iprot)
3108 
    iprot.readMessageEnd()
3109 
    result = addAddressForUser_result()
3110 
    try:
567 rajveer 3111 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 3112 
    except UserContextException, ucx:
3113 
      result.ucx = ucx
3114 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
3115 
    result.write(oprot)
3116 
    oprot.writeMessageEnd()
3117 
    oprot.trans.flush()
3118 
 
3119 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
3120 
    args = removeAddressForUser_args()
3121 
    args.read(iprot)
3122 
    iprot.readMessageEnd()
3123 
    result = removeAddressForUser_result()
3124 
    try:
3125 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
3126 
    except UserContextException, ucx:
3127 
      result.ucx = ucx
3128 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
3129 
    result.write(oprot)
3130 
    oprot.writeMessageEnd()
3131 
    oprot.trans.flush()
3132 
 
3133 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
3134 
    args = setUserAsLoggedIn_args()
3135 
    args.read(iprot)
3136 
    iprot.readMessageEnd()
3137 
    result = setUserAsLoggedIn_result()
3138 
    try:
3139 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
3140 
    except UserContextException, ucx:
3141 
      result.ucx = ucx
3142 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
3143 
    result.write(oprot)
3144 
    oprot.writeMessageEnd()
3145 
    oprot.trans.flush()
3146 
 
3147 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
3148 
    args = setUserAsLoggedOut_args()
3149 
    args.read(iprot)
3150 
    iprot.readMessageEnd()
3151 
    result = setUserAsLoggedOut_result()
3152 
    try:
3153 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
3154 
    except UserContextException, ucx:
3155 
      result.ucx = ucx
3156 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
3157 
    result.write(oprot)
3158 
    oprot.writeMessageEnd()
3159 
    oprot.trans.flush()
3160 
 
504 rajveer 3161 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
3162 
    args = setDefaultAddress_args()
3163 
    args.read(iprot)
3164 
    iprot.readMessageEnd()
3165 
    result = setDefaultAddress_result()
3166 
    try:
3167 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
3168 
    except UserContextException, ucx:
3169 
      result.ucx = ucx
3170 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
3171 
    result.write(oprot)
3172 
    oprot.writeMessageEnd()
3173 
    oprot.trans.flush()
3174 
 
94 ashish 3175 
  def process_updatePassword(self, seqid, iprot, oprot):
3176 
    args = updatePassword_args()
3177 
    args.read(iprot)
3178 
    iprot.readMessageEnd()
3179 
    result = updatePassword_result()
3180 
    try:
594 rajveer 3181 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 3182 
    except UserContextException, ucx:
3183 
      result.ucx = ucx
3184 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
3185 
    result.write(oprot)
3186 
    oprot.writeMessageEnd()
3187 
    oprot.trans.flush()
3188 
 
581 rajveer 3189 
  def process_forgotPassword(self, seqid, iprot, oprot):
3190 
    args = forgotPassword_args()
3191 
    args.read(iprot)
3192 
    iprot.readMessageEnd()
3193 
    result = forgotPassword_result()
3194 
    try:
884 rajveer 3195 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 3196 
    except UserContextException, ucx:
3197 
      result.ucx = ucx
3198 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
3199 
    result.write(oprot)
3200 
    oprot.writeMessageEnd()
3201 
    oprot.trans.flush()
3202 
 
594 rajveer 3203 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
3204 
    args = getAllAddressesForUser_args()
3205 
    args.read(iprot)
3206 
    iprot.readMessageEnd()
3207 
    result = getAllAddressesForUser_result()
3208 
    try:
3209 
      result.success = self._handler.getAllAddressesForUser(args.userId)
3210 
    except UserContextException, ucx:
3211 
      result.ucx = ucx
3212 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
3213 
    result.write(oprot)
3214 
    oprot.writeMessageEnd()
3215 
    oprot.trans.flush()
3216 
 
1894 vikas 3217 
  def process_getAddressById(self, seqid, iprot, oprot):
3218 
    args = getAddressById_args()
3219 
    args.read(iprot)
3220 
    iprot.readMessageEnd()
3221 
    result = getAddressById_result()
3222 
    try:
3223 
      result.success = self._handler.getAddressById(args.addressId)
3224 
    except UserContextException, ucx:
3225 
      result.ucx = ucx
3226 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
3227 
    result.write(oprot)
3228 
    oprot.writeMessageEnd()
3229 
    oprot.trans.flush()
3230 
 
594 rajveer 3231 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
3232 
    args = getDefaultAddressId_args()
3233 
    args.read(iprot)
3234 
    iprot.readMessageEnd()
3235 
    result = getDefaultAddressId_result()
3236 
    try:
3237 
      result.success = self._handler.getDefaultAddressId(args.userId)
3238 
    except UserContextException, ucx:
3239 
      result.ucx = ucx
3240 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
3241 
    result.write(oprot)
3242 
    oprot.writeMessageEnd()
3243 
    oprot.trans.flush()
3244 
 
785 rajveer 3245 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
3246 
    args = getDefaultPincode_args()
3247 
    args.read(iprot)
3248 
    iprot.readMessageEnd()
3249 
    result = getDefaultPincode_result()
3250 
    try:
3251 
      result.success = self._handler.getDefaultPincode(args.userId)
3252 
    except UserContextException, ucx:
3253 
      result.ucx = ucx
3254 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
3255 
    result.write(oprot)
3256 
    oprot.writeMessageEnd()
3257 
    oprot.trans.flush()
3258 
 
1274 varun.gupt 3259 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
3260 
    args = saveUserCommunication_args()
3261 
    args.read(iprot)
3262 
    iprot.readMessageEnd()
3263 
    result = saveUserCommunication_result()
3264 
    try:
3265 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
3266 
    except UserCommunicationException, ucx:
3267 
      result.ucx = ucx
3268 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
3269 
    result.write(oprot)
3270 
    oprot.writeMessageEnd()
3271 
    oprot.trans.flush()
3272 
 
1590 varun.gupt 3273 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
3274 
    args = getUserCommunicationById_args()
3275 
    args.read(iprot)
3276 
    iprot.readMessageEnd()
3277 
    result = getUserCommunicationById_result()
3278 
    try:
3279 
      result.success = self._handler.getUserCommunicationById(args.id)
3280 
    except UserCommunicationException, ucx:
3281 
      result.ucx = ucx
3282 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
3283 
    result.write(oprot)
3284 
    oprot.writeMessageEnd()
3285 
    oprot.trans.flush()
3286 
 
3287 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
3288 
    args = getUserCommunicationByUser_args()
3289 
    args.read(iprot)
3290 
    iprot.readMessageEnd()
3291 
    result = getUserCommunicationByUser_result()
3292 
    try:
3293 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
3294 
    except UserCommunicationException, ucx:
3295 
      result.ucx = ucx
3296 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
3297 
    result.write(oprot)
3298 
    oprot.writeMessageEnd()
3299 
    oprot.trans.flush()
3300 
 
3301 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
3302 
    args = getAllUserCommunications_args()
3303 
    args.read(iprot)
3304 
    iprot.readMessageEnd()
3305 
    result = getAllUserCommunications_result()
3306 
    try:
3307 
      result.success = self._handler.getAllUserCommunications()
3308 
    except UserCommunicationException, ucx:
3309 
      result.ucx = ucx
3310 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
3311 
    result.write(oprot)
3312 
    oprot.writeMessageEnd()
3313 
    oprot.trans.flush()
3314 
 
1845 vikas 3315 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
3316 
    args = createMasterAffiliate_args()
3317 
    args.read(iprot)
3318 
    iprot.readMessageEnd()
3319 
    result = createMasterAffiliate_result()
3320 
    try:
1859 vikas 3321 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 3322 
    except UserAffiliateException, utx:
1845 vikas 3323 
      result.utx = utx
3324 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
3325 
    result.write(oprot)
3326 
    oprot.writeMessageEnd()
3327 
    oprot.trans.flush()
3328 
 
1899 vikas 3329 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
3330 
    args = getAllMasterAffiliates_args()
3331 
    args.read(iprot)
3332 
    iprot.readMessageEnd()
3333 
    result = getAllMasterAffiliates_result()
3334 
    try:
3335 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 3336 
    except UserAffiliateException, utx:
1899 vikas 3337 
      result.utx = utx
3338 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
3339 
    result.write(oprot)
3340 
    oprot.writeMessageEnd()
3341 
    oprot.trans.flush()
3342 
 
1845 vikas 3343 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
3344 
    args = getMasterAffiliateById_args()
3345 
    args.read(iprot)
3346 
    iprot.readMessageEnd()
3347 
    result = getMasterAffiliateById_result()
3348 
    try:
3349 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 3350 
    except UserAffiliateException, utx:
1845 vikas 3351 
      result.utx = utx
3352 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
3353 
    result.write(oprot)
3354 
    oprot.writeMessageEnd()
3355 
    oprot.trans.flush()
3356 
 
3357 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
3358 
    args = getMasterAffiliateByName_args()
3359 
    args.read(iprot)
3360 
    iprot.readMessageEnd()
3361 
    result = getMasterAffiliateByName_result()
3362 
    try:
3363 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 3364 
    except UserAffiliateException, utx:
1845 vikas 3365 
      result.utx = utx
3366 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
3367 
    result.write(oprot)
3368 
    oprot.writeMessageEnd()
3369 
    oprot.trans.flush()
3370 
 
3371 
  def process_createAffiliate(self, seqid, iprot, oprot):
3372 
    args = createAffiliate_args()
3373 
    args.read(iprot)
3374 
    iprot.readMessageEnd()
3375 
    result = createAffiliate_result()
3376 
    try:
1859 vikas 3377 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 3378 
    except UserAffiliateException, utx:
1845 vikas 3379 
      result.utx = utx
3380 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
3381 
    result.write(oprot)
3382 
    oprot.writeMessageEnd()
3383 
    oprot.trans.flush()
3384 
 
3385 
  def process_getAffiliateById(self, seqid, iprot, oprot):
3386 
    args = getAffiliateById_args()
3387 
    args.read(iprot)
3388 
    iprot.readMessageEnd()
3389 
    result = getAffiliateById_result()
3390 
    try:
3391 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 3392 
    except UserAffiliateException, utx:
1845 vikas 3393 
      result.utx = utx
3394 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
3395 
    result.write(oprot)
3396 
    oprot.writeMessageEnd()
3397 
    oprot.trans.flush()
3398 
 
3399 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
3400 
    args = getAffiliateByName_args()
3401 
    args.read(iprot)
3402 
    iprot.readMessageEnd()
3403 
    result = getAffiliateByName_result()
3404 
    try:
3405 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 3406 
    except UserAffiliateException, utx:
1845 vikas 3407 
      result.utx = utx
3408 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
3409 
    result.write(oprot)
3410 
    oprot.writeMessageEnd()
3411 
    oprot.trans.flush()
3412 
 
3413 
  def process_getTrackerById(self, seqid, iprot, oprot):
3414 
    args = getTrackerById_args()
3415 
    args.read(iprot)
3416 
    iprot.readMessageEnd()
3417 
    result = getTrackerById_result()
3418 
    try:
1996 vikas 3419 
      result.success = self._handler.getTrackerById(args.id)
3420 
    except UserAffiliateException, utx:
1845 vikas 3421 
      result.utx = utx
3422 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
3423 
    result.write(oprot)
3424 
    oprot.writeMessageEnd()
3425 
    oprot.trans.flush()
3426 
 
1996 vikas 3427 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
3428 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 3429 
    args.read(iprot)
3430 
    iprot.readMessageEnd()
1996 vikas 3431 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 3432 
    try:
1996 vikas 3433 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
3434 
    except UserAffiliateException, utx:
1845 vikas 3435 
      result.utx = utx
1996 vikas 3436 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3437 
    result.write(oprot)
3438 
    oprot.writeMessageEnd()
3439 
    oprot.trans.flush()
3440 
 
3441 
  def process_addTrackLog(self, seqid, iprot, oprot):
3442 
    args = addTrackLog_args()
3443 
    args.read(iprot)
3444 
    iprot.readMessageEnd()
3445 
    result = addTrackLog_result()
3446 
    try:
1996 vikas 3447 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
3448 
    except UserAffiliateException, utx:
1845 vikas 3449 
      result.utx = utx
3450 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
3451 
    result.write(oprot)
3452 
    oprot.writeMessageEnd()
3453 
    oprot.trans.flush()
3454 
 
3455 
  def process_getTrackLogById(self, seqid, iprot, oprot):
3456 
    args = getTrackLogById_args()
3457 
    args.read(iprot)
3458 
    iprot.readMessageEnd()
3459 
    result = getTrackLogById_result()
3460 
    try:
3461 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 3462 
    except UserAffiliateException, utx:
1845 vikas 3463 
      result.utx = utx
3464 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
3465 
    result.write(oprot)
3466 
    oprot.writeMessageEnd()
3467 
    oprot.trans.flush()
3468 
 
1996 vikas 3469 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
3470 
    args = getTrackLogsByAffiliate_args()
1845 vikas 3471 
    args.read(iprot)
3472 
    iprot.readMessageEnd()
1996 vikas 3473 
    result = getTrackLogsByAffiliate_result()
1845 vikas 3474 
    try:
3293 vikas 3475 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId, args.startDate, args.endDate)
1996 vikas 3476 
    except UserAffiliateException, utx:
1845 vikas 3477 
      result.utx = utx
1996 vikas 3478 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3479 
    result.write(oprot)
3480 
    oprot.writeMessageEnd()
3481 
    oprot.trans.flush()
3482 
 
3483 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
3484 
    args = getTrackLogsByUser_args()
3485 
    args.read(iprot)
3486 
    iprot.readMessageEnd()
3487 
    result = getTrackLogsByUser_result()
3488 
    try:
3489 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 3490 
    except UserAffiliateException, utx:
1845 vikas 3491 
      result.utx = utx
3492 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
3493 
    result.write(oprot)
3494 
    oprot.writeMessageEnd()
3495 
    oprot.trans.flush()
3496 
 
3497 
  def process_getTrackLogs(self, seqid, iprot, oprot):
3498 
    args = getTrackLogs_args()
3499 
    args.read(iprot)
3500 
    iprot.readMessageEnd()
3501 
    result = getTrackLogs_result()
3502 
    try:
1996 vikas 3503 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
3504 
    except UserAffiliateException, utx:
1845 vikas 3505 
      result.utx = utx
3506 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
3507 
    result.write(oprot)
3508 
    oprot.writeMessageEnd()
3509 
    oprot.trans.flush()
3510 
 
559 chandransh 3511 
  def process_createCart(self, seqid, iprot, oprot):
3512 
    args = createCart_args()
94 ashish 3513 
    args.read(iprot)
3514 
    iprot.readMessageEnd()
559 chandransh 3515 
    result = createCart_result()
94 ashish 3516 
    try:
559 chandransh 3517 
      result.success = self._handler.createCart(args.userId)
3518 
    except ShoppingCartException, scx:
3519 
      result.scx = scx
3520 
    oprot.writeMessageBegin("createCart", TMessageType.REPLY, seqid)
94 ashish 3521 
    result.write(oprot)
3522 
    oprot.writeMessageEnd()
3523 
    oprot.trans.flush()
3524 
 
559 chandransh 3525 
  def process_getCurrentCart(self, seqid, iprot, oprot):
3526 
    args = getCurrentCart_args()
94 ashish 3527 
    args.read(iprot)
3528 
    iprot.readMessageEnd()
559 chandransh 3529 
    result = getCurrentCart_result()
94 ashish 3530 
    try:
559 chandransh 3531 
      result.success = self._handler.getCurrentCart(args.userId)
3532 
    except ShoppingCartException, scx:
3533 
      result.scx = scx
3534 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 3535 
    result.write(oprot)
3536 
    oprot.writeMessageEnd()
3537 
    oprot.trans.flush()
3538 
 
559 chandransh 3539 
  def process_getCart(self, seqid, iprot, oprot):
3540 
    args = getCart_args()
94 ashish 3541 
    args.read(iprot)
3542 
    iprot.readMessageEnd()
559 chandransh 3543 
    result = getCart_result()
94 ashish 3544 
    try:
559 chandransh 3545 
      result.success = self._handler.getCart(args.cartId)
3546 
    except ShoppingCartException, scx:
3547 
      result.scx = scx
3548 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 3549 
    result.write(oprot)
3550 
    oprot.writeMessageEnd()
3551 
    oprot.trans.flush()
3552 
 
559 chandransh 3553 
  def process_getCartsForUser(self, seqid, iprot, oprot):
3554 
    args = getCartsForUser_args()
94 ashish 3555 
    args.read(iprot)
3556 
    iprot.readMessageEnd()
559 chandransh 3557 
    result = getCartsForUser_result()
94 ashish 3558 
    try:
559 chandransh 3559 
      result.success = self._handler.getCartsForUser(args.userId, args.status)
3560 
    except ShoppingCartException, scx:
3561 
      result.scx = scx
3562 
    oprot.writeMessageBegin("getCartsForUser", TMessageType.REPLY, seqid)
94 ashish 3563 
    result.write(oprot)
3564 
    oprot.writeMessageEnd()
3565 
    oprot.trans.flush()
3566 
 
559 chandransh 3567 
  def process_getCartsByStatus(self, seqid, iprot, oprot):
3568 
    args = getCartsByStatus_args()
94 ashish 3569 
    args.read(iprot)
3570 
    iprot.readMessageEnd()
559 chandransh 3571 
    result = getCartsByStatus_result()
94 ashish 3572 
    try:
559 chandransh 3573 
      result.success = self._handler.getCartsByStatus(args.status)
3574 
    except ShoppingCartException, scx:
3575 
      result.scx = scx
3576 
    oprot.writeMessageBegin("getCartsByStatus", TMessageType.REPLY, seqid)
94 ashish 3577 
    result.write(oprot)
3578 
    oprot.writeMessageEnd()
3579 
    oprot.trans.flush()
3580 
 
559 chandransh 3581 
  def process_getCartsByTime(self, seqid, iprot, oprot):
3582 
    args = getCartsByTime_args()
94 ashish 3583 
    args.read(iprot)
3584 
    iprot.readMessageEnd()
559 chandransh 3585 
    result = getCartsByTime_result()
94 ashish 3586 
    try:
559 chandransh 3587 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
3588 
    except ShoppingCartException, scx:
3589 
      result.scx = scx
3590 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 3591 
    result.write(oprot)
3592 
    oprot.writeMessageEnd()
3593 
    oprot.trans.flush()
3594 
 
559 chandransh 3595 
  def process_changeCartStatus(self, seqid, iprot, oprot):
3596 
    args = changeCartStatus_args()
130 ashish 3597 
    args.read(iprot)
3598 
    iprot.readMessageEnd()
559 chandransh 3599 
    result = changeCartStatus_result()
130 ashish 3600 
    try:
559 chandransh 3601 
      self._handler.changeCartStatus(args.cartId, args.status)
3602 
    except ShoppingCartException, scx:
3603 
      result.scx = scx
3604 
    oprot.writeMessageBegin("changeCartStatus", TMessageType.REPLY, seqid)
130 ashish 3605 
    result.write(oprot)
3606 
    oprot.writeMessageEnd()
3607 
    oprot.trans.flush()
94 ashish 3608 
 
559 chandransh 3609 
  def process_addItemToCart(self, seqid, iprot, oprot):
3610 
    args = addItemToCart_args()
130 ashish 3611 
    args.read(iprot)
3612 
    iprot.readMessageEnd()
559 chandransh 3613 
    result = addItemToCart_result()
130 ashish 3614 
    try:
2035 rajveer 3615 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity)
559 chandransh 3616 
    except ShoppingCartException, scx:
3617 
      result.scx = scx
3618 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 3619 
    result.write(oprot)
3620 
    oprot.writeMessageEnd()
3621 
    oprot.trans.flush()
3622 
 
559 chandransh 3623 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
3624 
    args = deleteItemFromCart_args()
3625 
    args.read(iprot)
3626 
    iprot.readMessageEnd()
3627 
    result = deleteItemFromCart_result()
3628 
    try:
3629 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
3630 
    except ShoppingCartException, scx:
3631 
      result.scx = scx
3632 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
3633 
    result.write(oprot)
3634 
    oprot.writeMessageEnd()
3635 
    oprot.trans.flush()
130 ashish 3636 
 
559 chandransh 3637 
  def process_changeQuantity(self, seqid, iprot, oprot):
3638 
    args = changeQuantity_args()
3639 
    args.read(iprot)
3640 
    iprot.readMessageEnd()
3641 
    result = changeQuantity_result()
3642 
    try:
3643 
      self._handler.changeQuantity(args.cartId, args.itemId, args.quantity)
3644 
    except ShoppingCartException, scx:
3645 
      result.scx = scx
3646 
    oprot.writeMessageBegin("changeQuantity", TMessageType.REPLY, seqid)
3647 
    result.write(oprot)
3648 
    oprot.writeMessageEnd()
3649 
    oprot.trans.flush()
3650 
 
3651 
  def process_changeItemStatus(self, seqid, iprot, oprot):
3652 
    args = changeItemStatus_args()
3653 
    args.read(iprot)
3654 
    iprot.readMessageEnd()
3655 
    result = changeItemStatus_result()
3656 
    try:
3657 
      self._handler.changeItemStatus(args.cartId, args.itemId, args.status)
3658 
    except ShoppingCartException, scx:
3659 
      result.scx = scx
3660 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
3661 
    result.write(oprot)
3662 
    oprot.writeMessageEnd()
3663 
    oprot.trans.flush()
3664 
 
3665 
  def process_addAddressToCart(self, seqid, iprot, oprot):
3666 
    args = addAddressToCart_args()
3667 
    args.read(iprot)
3668 
    iprot.readMessageEnd()
3669 
    result = addAddressToCart_result()
575 chandransh 3670 
    try:
3671 
      self._handler.addAddressToCart(args.cartId, args.addressId)
3672 
    except ShoppingCartException, scx:
3673 
      result.scx = scx
559 chandransh 3674 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
3675 
    result.write(oprot)
3676 
    oprot.writeMessageEnd()
3677 
    oprot.trans.flush()
3678 
 
1976 varun.gupt 3679 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
3680 
    args = applyCouponToCart_args()
3681 
    args.read(iprot)
3682 
    iprot.readMessageEnd()
3683 
    result = applyCouponToCart_result()
3684 
    try:
3685 
      self._handler.applyCouponToCart(args.cartId, args.couponCode, args.totalPrice, args.discountedPrice)
3686 
    except ShoppingCartException, scx:
3687 
      result.scx = scx
3688 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
3689 
    result.write(oprot)
3690 
    oprot.writeMessageEnd()
3691 
    oprot.trans.flush()
3692 
 
3693 
  def process_removeCoupon(self, seqid, iprot, oprot):
3694 
    args = removeCoupon_args()
3695 
    args.read(iprot)
3696 
    iprot.readMessageEnd()
3697 
    result = removeCoupon_result()
3698 
    try:
3699 
      self._handler.removeCoupon(args.cartId)
3700 
    except ShoppingCartException, scx:
3701 
      result.scx = scx
3702 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
3703 
    result.write(oprot)
3704 
    oprot.writeMessageEnd()
3705 
    oprot.trans.flush()
3706 
 
690 chandransh 3707 
  def process_createOrders(self, seqid, iprot, oprot):
3708 
    args = createOrders_args()
559 chandransh 3709 
    args.read(iprot)
3710 
    iprot.readMessageEnd()
690 chandransh 3711 
    result = createOrders_result()
559 chandransh 3712 
    try:
2815 vikas 3713 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime)
559 chandransh 3714 
    except ShoppingCartException, scx:
3715 
      result.scx = scx
690 chandransh 3716 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 3717 
    result.write(oprot)
3718 
    oprot.writeMessageEnd()
3719 
    oprot.trans.flush()
3720 
 
3721 
  def process_validateCart(self, seqid, iprot, oprot):
3722 
    args = validateCart_args()
3723 
    args.read(iprot)
3724 
    iprot.readMessageEnd()
3725 
    result = validateCart_result()
575 chandransh 3726 
    try:
3727 
      result.success = self._handler.validateCart(args.cartId)
3728 
    except ShoppingCartException, scex:
3729 
      result.scex = scex
559 chandransh 3730 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
3731 
    result.write(oprot)
3732 
    oprot.writeMessageEnd()
3733 
    oprot.trans.flush()
3734 
 
690 chandransh 3735 
  def process_mergeCart(self, seqid, iprot, oprot):
3736 
    args = mergeCart_args()
575 chandransh 3737 
    args.read(iprot)
3738 
    iprot.readMessageEnd()
690 chandransh 3739 
    result = mergeCart_result()
3740 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
3741 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
3742 
    result.write(oprot)
3743 
    oprot.writeMessageEnd()
3744 
    oprot.trans.flush()
3745 
 
3746 
  def process_checkOut(self, seqid, iprot, oprot):
3747 
    args = checkOut_args()
3748 
    args.read(iprot)
3749 
    iprot.readMessageEnd()
3750 
    result = checkOut_result()
575 chandransh 3751 
    try:
690 chandransh 3752 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 3753 
    except ShoppingCartException, scex:
3754 
      result.scex = scex
690 chandransh 3755 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 3756 
    result.write(oprot)
3757 
    oprot.writeMessageEnd()
3758 
    oprot.trans.flush()
3759 
 
690 chandransh 3760 
  def process_resetCart(self, seqid, iprot, oprot):
3761 
    args = resetCart_args()
559 chandransh 3762 
    args.read(iprot)
3763 
    iprot.readMessageEnd()
690 chandransh 3764 
    result = resetCart_result()
3765 
    try:
3766 
      result.success = self._handler.resetCart(args.cartId, args.items)
3767 
    except ShoppingCartException, scex:
3768 
      result.scex = scex
3769 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 3770 
    result.write(oprot)
3771 
    oprot.writeMessageEnd()
3772 
    oprot.trans.flush()
3773 
 
2981 rajveer 3774 
  def process_getUserCount(self, seqid, iprot, oprot):
3775 
    args = getUserCount_args()
559 chandransh 3776 
    args.read(iprot)
3777 
    iprot.readMessageEnd()
2981 rajveer 3778 
    result = getUserCount_result()
3779 
    result.success = self._handler.getUserCount(args.userType)
3780 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 3781 
    result.write(oprot)
3782 
    oprot.writeMessageEnd()
3783 
    oprot.trans.flush()
3784 
 
2981 rajveer 3785 
  def process_getAllUsers(self, seqid, iprot, oprot):
3786 
    args = getAllUsers_args()
559 chandransh 3787 
    args.read(iprot)
3788 
    iprot.readMessageEnd()
2981 rajveer 3789 
    result = getAllUsers_result()
3790 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
3791 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 3792 
    result.write(oprot)
3793 
    oprot.writeMessageEnd()
3794 
    oprot.trans.flush()
3795 
 
2981 rajveer 3796 
  def process_putUserNote(self, seqid, iprot, oprot):
3797 
    args = putUserNote_args()
559 chandransh 3798 
    args.read(iprot)
3799 
    iprot.readMessageEnd()
2981 rajveer 3800 
    result = putUserNote_result()
3801 
    self._handler.putUserNote(args.user_id, args.entity_id, args.slide, args.note)
3802 
    oprot.writeMessageBegin("putUserNote", TMessageType.REPLY, seqid)
559 chandransh 3803 
    result.write(oprot)
3804 
    oprot.writeMessageEnd()
3805 
    oprot.trans.flush()
3806 
 
2981 rajveer 3807 
  def process_getUserNotes(self, seqid, iprot, oprot):
3808 
    args = getUserNotes_args()
559 chandransh 3809 
    args.read(iprot)
3810 
    iprot.readMessageEnd()
2981 rajveer 3811 
    result = getUserNotes_result()
3812 
    result.success = self._handler.getUserNotes(args.user_id, args.entity_id)
3813 
    oprot.writeMessageBegin("getUserNotes", TMessageType.REPLY, seqid)
559 chandransh 3814 
    result.write(oprot)
3815 
    oprot.writeMessageEnd()
3816 
    oprot.trans.flush()
3817 
 
2981 rajveer 3818 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
3819 
    args = getMyResearchItems_args()
559 chandransh 3820 
    args.read(iprot)
3821 
    iprot.readMessageEnd()
2981 rajveer 3822 
    result = getMyResearchItems_result()
559 chandransh 3823 
    try:
2981 rajveer 3824 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 3825 
    except WidgetException, scx:
3826 
      result.scx = scx
2981 rajveer 3827 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 3828 
    result.write(oprot)
3829 
    oprot.writeMessageEnd()
3830 
    oprot.trans.flush()
3831 
 
2981 rajveer 3832 
  def process_updateMyResearch(self, seqid, iprot, oprot):
3833 
    args = updateMyResearch_args()
772 rajveer 3834 
    args.read(iprot)
3835 
    iprot.readMessageEnd()
2981 rajveer 3836 
    result = updateMyResearch_result()
3837 
    try:
3838 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
3839 
    except WidgetException, scx:
3840 
      result.scx = scx
3841 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 3842 
    result.write(oprot)
3843 
    oprot.writeMessageEnd()
3844 
    oprot.trans.flush()
559 chandransh 3845 
 
2981 rajveer 3846 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
3847 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 3848 
    args.read(iprot)
3849 
    iprot.readMessageEnd()
2981 rajveer 3850 
    result = deleteItemFromMyResearch_result()
3851 
    try:
3852 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
3853 
    except WidgetException, scx:
3854 
      result.scx = scx
3855 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 3856 
    result.write(oprot)
3857 
    oprot.writeMessageEnd()
3858 
    oprot.trans.flush()
772 rajveer 3859 
 
2981 rajveer 3860 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
3861 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 3862 
    args.read(iprot)
3863 
    iprot.readMessageEnd()
2981 rajveer 3864 
    result = getBrowseHistoryItems_result()
3865 
    try:
3866 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
3867 
    except WidgetException, scx:
3868 
      result.scx = scx
3869 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 3870 
    result.write(oprot)
3871 
    oprot.writeMessageEnd()
3872 
    oprot.trans.flush()
1596 ankur.sing 3873 
 
2981 rajveer 3874 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
3875 
    args = updateBrowseHistory_args()
2642 varun.gupt 3876 
    args.read(iprot)
3877 
    iprot.readMessageEnd()
2981 rajveer 3878 
    result = updateBrowseHistory_result()
3879 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
3880 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 3881 
    result.write(oprot)
3882 
    oprot.writeMessageEnd()
3883 
    oprot.trans.flush()
1673 ankur.sing 3884 
 
3385 varun.gupt 3885 
  def process_getCartsWithCouponCount(self, seqid, iprot, oprot):
3886 
    args = getCartsWithCouponCount_args()
3887 
    args.read(iprot)
3888 
    iprot.readMessageEnd()
3889 
    result = getCartsWithCouponCount_result()
3890 
    result.success = self._handler.getCartsWithCouponCount(args.couponCode)
3891 
    oprot.writeMessageBegin("getCartsWithCouponCount", TMessageType.REPLY, seqid)
3892 
    result.write(oprot)
3893 
    oprot.writeMessageEnd()
3894 
    oprot.trans.flush()
2642 varun.gupt 3895 
 
3385 varun.gupt 3896 
 
94 ashish 3897 
# HELPER FUNCTIONS AND STRUCTURES
3898 
 
559 chandransh 3899 
class createAnonymousUser_args:
94 ashish 3900 
  """
3901 
  Attributes:
559 chandransh 3902 
   - jsessionId
94 ashish 3903 
  """
3904 
 
3905 
  thrift_spec = (
3906 
    None, # 0
559 chandransh 3907 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 3908 
  )
3909 
 
559 chandransh 3910 
  def __init__(self, jsessionId=None,):
3911 
    self.jsessionId = jsessionId
94 ashish 3912 
 
3913 
  def read(self, iprot):
3914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3916 
      return
3917 
    iprot.readStructBegin()
3918 
    while True:
3919 
      (fname, ftype, fid) = iprot.readFieldBegin()
3920 
      if ftype == TType.STOP:
3921 
        break
3922 
      if fid == 1:
559 chandransh 3923 
        if ftype == TType.STRING:
3924 
          self.jsessionId = iprot.readString();
94 ashish 3925 
        else:
3926 
          iprot.skip(ftype)
3927 
      else:
3928 
        iprot.skip(ftype)
3929 
      iprot.readFieldEnd()
3930 
    iprot.readStructEnd()
3931 
 
3932 
  def write(self, oprot):
3933 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3934 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3935 
      return
559 chandransh 3936 
    oprot.writeStructBegin('createAnonymousUser_args')
3937 
    if self.jsessionId != None:
3938 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
3939 
      oprot.writeString(self.jsessionId)
94 ashish 3940 
      oprot.writeFieldEnd()
3941 
    oprot.writeFieldStop()
3942 
    oprot.writeStructEnd()
3943 
 
3944 
  def __repr__(self):
3945 
    L = ['%s=%r' % (key, value)
3946 
      for key, value in self.__dict__.iteritems()]
3947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3948 
 
3949 
  def __eq__(self, other):
3950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3951 
 
3952 
  def __ne__(self, other):
3953 
    return not (self == other)
3954 
 
559 chandransh 3955 
class createAnonymousUser_result:
94 ashish 3956 
  """
3957 
  Attributes:
3958 
   - success
559 chandransh 3959 
   - ucex
94 ashish 3960 
  """
3961 
 
3962 
  thrift_spec = (
559 chandransh 3963 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
3964 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 3965 
  )
3966 
 
559 chandransh 3967 
  def __init__(self, success=None, ucex=None,):
94 ashish 3968 
    self.success = success
559 chandransh 3969 
    self.ucex = ucex
94 ashish 3970 
 
3971 
  def read(self, iprot):
3972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3974 
      return
3975 
    iprot.readStructBegin()
3976 
    while True:
3977 
      (fname, ftype, fid) = iprot.readFieldBegin()
3978 
      if ftype == TType.STOP:
3979 
        break
3980 
      if fid == 0:
3981 
        if ftype == TType.STRUCT:
559 chandransh 3982 
          self.success = User()
94 ashish 3983 
          self.success.read(iprot)
3984 
        else:
3985 
          iprot.skip(ftype)
3986 
      elif fid == 1:
3987 
        if ftype == TType.STRUCT:
559 chandransh 3988 
          self.ucex = UserContextException()
3989 
          self.ucex.read(iprot)
94 ashish 3990 
        else:
3991 
          iprot.skip(ftype)
3992 
      else:
3993 
        iprot.skip(ftype)
3994 
      iprot.readFieldEnd()
3995 
    iprot.readStructEnd()
3996 
 
3997 
  def write(self, oprot):
3998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4000 
      return
559 chandransh 4001 
    oprot.writeStructBegin('createAnonymousUser_result')
94 ashish 4002 
    if self.success != None:
4003 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4004 
      self.success.write(oprot)
4005 
      oprot.writeFieldEnd()
559 chandransh 4006 
    if self.ucex != None:
4007 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4008 
      self.ucex.write(oprot)
94 ashish 4009 
      oprot.writeFieldEnd()
4010 
    oprot.writeFieldStop()
4011 
    oprot.writeStructEnd()
4012 
 
4013 
  def __repr__(self):
4014 
    L = ['%s=%r' % (key, value)
4015 
      for key, value in self.__dict__.iteritems()]
4016 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4017 
 
4018 
  def __eq__(self, other):
4019 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4020 
 
4021 
  def __ne__(self, other):
4022 
    return not (self == other)
4023 
 
559 chandransh 4024 
class getUserById_args:
94 ashish 4025 
  """
4026 
  Attributes:
4027 
   - userId
4028 
  """
4029 
 
4030 
  thrift_spec = (
4031 
    None, # 0
4032 
    (1, TType.I64, 'userId', None, None, ), # 1
4033 
  )
4034 
 
559 chandransh 4035 
  def __init__(self, userId=None,):
94 ashish 4036 
    self.userId = userId
4037 
 
4038 
  def read(self, iprot):
4039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4041 
      return
4042 
    iprot.readStructBegin()
4043 
    while True:
4044 
      (fname, ftype, fid) = iprot.readFieldBegin()
4045 
      if ftype == TType.STOP:
4046 
        break
4047 
      if fid == 1:
4048 
        if ftype == TType.I64:
4049 
          self.userId = iprot.readI64();
4050 
        else:
4051 
          iprot.skip(ftype)
4052 
      else:
4053 
        iprot.skip(ftype)
4054 
      iprot.readFieldEnd()
4055 
    iprot.readStructEnd()
4056 
 
4057 
  def write(self, oprot):
4058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4060 
      return
559 chandransh 4061 
    oprot.writeStructBegin('getUserById_args')
94 ashish 4062 
    if self.userId != None:
4063 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4064 
      oprot.writeI64(self.userId)
4065 
      oprot.writeFieldEnd()
4066 
    oprot.writeFieldStop()
4067 
    oprot.writeStructEnd()
4068 
 
4069 
  def __repr__(self):
4070 
    L = ['%s=%r' % (key, value)
4071 
      for key, value in self.__dict__.iteritems()]
4072 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4073 
 
4074 
  def __eq__(self, other):
4075 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4076 
 
4077 
  def __ne__(self, other):
4078 
    return not (self == other)
4079 
 
559 chandransh 4080 
class getUserById_result:
94 ashish 4081 
  """
4082 
  Attributes:
4083 
   - success
559 chandransh 4084 
   - ucex
94 ashish 4085 
  """
4086 
 
4087 
  thrift_spec = (
559 chandransh 4088 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4089 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4090 
  )
4091 
 
559 chandransh 4092 
  def __init__(self, success=None, ucex=None,):
94 ashish 4093 
    self.success = success
559 chandransh 4094 
    self.ucex = ucex
94 ashish 4095 
 
4096 
  def read(self, iprot):
4097 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4098 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4099 
      return
4100 
    iprot.readStructBegin()
4101 
    while True:
4102 
      (fname, ftype, fid) = iprot.readFieldBegin()
4103 
      if ftype == TType.STOP:
4104 
        break
4105 
      if fid == 0:
4106 
        if ftype == TType.STRUCT:
559 chandransh 4107 
          self.success = User()
94 ashish 4108 
          self.success.read(iprot)
4109 
        else:
4110 
          iprot.skip(ftype)
4111 
      elif fid == 1:
4112 
        if ftype == TType.STRUCT:
559 chandransh 4113 
          self.ucex = UserContextException()
4114 
          self.ucex.read(iprot)
94 ashish 4115 
        else:
4116 
          iprot.skip(ftype)
4117 
      else:
4118 
        iprot.skip(ftype)
4119 
      iprot.readFieldEnd()
4120 
    iprot.readStructEnd()
4121 
 
4122 
  def write(self, oprot):
4123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4125 
      return
559 chandransh 4126 
    oprot.writeStructBegin('getUserById_result')
94 ashish 4127 
    if self.success != None:
4128 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4129 
      self.success.write(oprot)
4130 
      oprot.writeFieldEnd()
559 chandransh 4131 
    if self.ucex != None:
4132 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4133 
      self.ucex.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 
 
1491 vikas 4149 
class getUserByEmail_args:
4150 
  """
4151 
  Attributes:
4152 
   - email
4153 
  """
4154 
 
4155 
  thrift_spec = (
4156 
    None, # 0
4157 
    (1, TType.STRING, 'email', None, None, ), # 1
4158 
  )
4159 
 
4160 
  def __init__(self, email=None,):
4161 
    self.email = email
4162 
 
4163 
  def read(self, iprot):
4164 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4165 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4166 
      return
4167 
    iprot.readStructBegin()
4168 
    while True:
4169 
      (fname, ftype, fid) = iprot.readFieldBegin()
4170 
      if ftype == TType.STOP:
4171 
        break
4172 
      if fid == 1:
4173 
        if ftype == TType.STRING:
4174 
          self.email = iprot.readString();
4175 
        else:
4176 
          iprot.skip(ftype)
4177 
      else:
4178 
        iprot.skip(ftype)
4179 
      iprot.readFieldEnd()
4180 
    iprot.readStructEnd()
4181 
 
4182 
  def write(self, oprot):
4183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4185 
      return
4186 
    oprot.writeStructBegin('getUserByEmail_args')
4187 
    if self.email != None:
4188 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4189 
      oprot.writeString(self.email)
4190 
      oprot.writeFieldEnd()
4191 
    oprot.writeFieldStop()
4192 
    oprot.writeStructEnd()
4193 
 
4194 
  def __repr__(self):
4195 
    L = ['%s=%r' % (key, value)
4196 
      for key, value in self.__dict__.iteritems()]
4197 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4198 
 
4199 
  def __eq__(self, other):
4200 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4201 
 
4202 
  def __ne__(self, other):
4203 
    return not (self == other)
4204 
 
4205 
class getUserByEmail_result:
4206 
  """
4207 
  Attributes:
4208 
   - success
4209 
   - ucex
4210 
  """
4211 
 
4212 
  thrift_spec = (
4213 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4214 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4215 
  )
4216 
 
4217 
  def __init__(self, success=None, ucex=None,):
4218 
    self.success = success
4219 
    self.ucex = ucex
4220 
 
4221 
  def read(self, iprot):
4222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4224 
      return
4225 
    iprot.readStructBegin()
4226 
    while True:
4227 
      (fname, ftype, fid) = iprot.readFieldBegin()
4228 
      if ftype == TType.STOP:
4229 
        break
4230 
      if fid == 0:
4231 
        if ftype == TType.STRUCT:
4232 
          self.success = User()
4233 
          self.success.read(iprot)
4234 
        else:
4235 
          iprot.skip(ftype)
4236 
      elif fid == 1:
4237 
        if ftype == TType.STRUCT:
4238 
          self.ucex = UserContextException()
4239 
          self.ucex.read(iprot)
4240 
        else:
4241 
          iprot.skip(ftype)
4242 
      else:
4243 
        iprot.skip(ftype)
4244 
      iprot.readFieldEnd()
4245 
    iprot.readStructEnd()
4246 
 
4247 
  def write(self, oprot):
4248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4250 
      return
4251 
    oprot.writeStructBegin('getUserByEmail_result')
4252 
    if self.success != None:
4253 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4254 
      self.success.write(oprot)
4255 
      oprot.writeFieldEnd()
4256 
    if self.ucex != None:
4257 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4258 
      self.ucex.write(oprot)
4259 
      oprot.writeFieldEnd()
4260 
    oprot.writeFieldStop()
4261 
    oprot.writeStructEnd()
4262 
 
4263 
  def __repr__(self):
4264 
    L = ['%s=%r' % (key, value)
4265 
      for key, value in self.__dict__.iteritems()]
4266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4267 
 
4268 
  def __eq__(self, other):
4269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4270 
 
4271 
  def __ne__(self, other):
4272 
    return not (self == other)
4273 
 
3032 mandeep.dh 4274 
class getUserByMobileNumber_args:
4275 
  """
4276 
  Attributes:
4277 
   - mobileNumber
4278 
  """
4279 
 
4280 
  thrift_spec = (
4281 
    None, # 0
4282 
    (1, TType.I64, 'mobileNumber', None, None, ), # 1
4283 
  )
4284 
 
4285 
  def __init__(self, mobileNumber=None,):
4286 
    self.mobileNumber = mobileNumber
4287 
 
4288 
  def read(self, iprot):
4289 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4290 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4291 
      return
4292 
    iprot.readStructBegin()
4293 
    while True:
4294 
      (fname, ftype, fid) = iprot.readFieldBegin()
4295 
      if ftype == TType.STOP:
4296 
        break
4297 
      if fid == 1:
4298 
        if ftype == TType.I64:
4299 
          self.mobileNumber = iprot.readI64();
4300 
        else:
4301 
          iprot.skip(ftype)
4302 
      else:
4303 
        iprot.skip(ftype)
4304 
      iprot.readFieldEnd()
4305 
    iprot.readStructEnd()
4306 
 
4307 
  def write(self, oprot):
4308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4310 
      return
4311 
    oprot.writeStructBegin('getUserByMobileNumber_args')
4312 
    if self.mobileNumber != None:
4313 
      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
4314 
      oprot.writeI64(self.mobileNumber)
4315 
      oprot.writeFieldEnd()
4316 
    oprot.writeFieldStop()
4317 
    oprot.writeStructEnd()
4318 
 
4319 
  def __repr__(self):
4320 
    L = ['%s=%r' % (key, value)
4321 
      for key, value in self.__dict__.iteritems()]
4322 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4323 
 
4324 
  def __eq__(self, other):
4325 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4326 
 
4327 
  def __ne__(self, other):
4328 
    return not (self == other)
4329 
 
4330 
class getUserByMobileNumber_result:
4331 
  """
4332 
  Attributes:
4333 
   - success
4334 
   - ucex
4335 
  """
4336 
 
4337 
  thrift_spec = (
4338 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4339 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4340 
  )
4341 
 
4342 
  def __init__(self, success=None, ucex=None,):
4343 
    self.success = success
4344 
    self.ucex = ucex
4345 
 
4346 
  def read(self, iprot):
4347 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4348 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4349 
      return
4350 
    iprot.readStructBegin()
4351 
    while True:
4352 
      (fname, ftype, fid) = iprot.readFieldBegin()
4353 
      if ftype == TType.STOP:
4354 
        break
4355 
      if fid == 0:
4356 
        if ftype == TType.STRUCT:
4357 
          self.success = User()
4358 
          self.success.read(iprot)
4359 
        else:
4360 
          iprot.skip(ftype)
4361 
      elif fid == 1:
4362 
        if ftype == TType.STRUCT:
4363 
          self.ucex = UserContextException()
4364 
          self.ucex.read(iprot)
4365 
        else:
4366 
          iprot.skip(ftype)
4367 
      else:
4368 
        iprot.skip(ftype)
4369 
      iprot.readFieldEnd()
4370 
    iprot.readStructEnd()
4371 
 
4372 
  def write(self, oprot):
4373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4375 
      return
4376 
    oprot.writeStructBegin('getUserByMobileNumber_result')
4377 
    if self.success != None:
4378 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4379 
      self.success.write(oprot)
4380 
      oprot.writeFieldEnd()
4381 
    if self.ucex != None:
4382 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4383 
      self.ucex.write(oprot)
4384 
      oprot.writeFieldEnd()
4385 
    oprot.writeFieldStop()
4386 
    oprot.writeStructEnd()
4387 
 
4388 
  def __repr__(self):
4389 
    L = ['%s=%r' % (key, value)
4390 
      for key, value in self.__dict__.iteritems()]
4391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4392 
 
4393 
  def __eq__(self, other):
4394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4395 
 
4396 
  def __ne__(self, other):
4397 
    return not (self == other)
4398 
 
559 chandransh 4399 
class createUser_args:
94 ashish 4400 
  """
4401 
  Attributes:
559 chandransh 4402 
   - user
94 ashish 4403 
  """
4404 
 
4405 
  thrift_spec = (
4406 
    None, # 0
559 chandransh 4407 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4408 
  )
4409 
 
559 chandransh 4410 
  def __init__(self, user=None,):
4411 
    self.user = user
94 ashish 4412 
 
4413 
  def read(self, iprot):
4414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4416 
      return
4417 
    iprot.readStructBegin()
4418 
    while True:
4419 
      (fname, ftype, fid) = iprot.readFieldBegin()
4420 
      if ftype == TType.STOP:
4421 
        break
4422 
      if fid == 1:
559 chandransh 4423 
        if ftype == TType.STRUCT:
4424 
          self.user = User()
4425 
          self.user.read(iprot)
94 ashish 4426 
        else:
4427 
          iprot.skip(ftype)
4428 
      else:
4429 
        iprot.skip(ftype)
4430 
      iprot.readFieldEnd()
4431 
    iprot.readStructEnd()
4432 
 
4433 
  def write(self, oprot):
4434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4436 
      return
559 chandransh 4437 
    oprot.writeStructBegin('createUser_args')
4438 
    if self.user != None:
4439 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4440 
      self.user.write(oprot)
94 ashish 4441 
      oprot.writeFieldEnd()
4442 
    oprot.writeFieldStop()
4443 
    oprot.writeStructEnd()
4444 
 
4445 
  def __repr__(self):
4446 
    L = ['%s=%r' % (key, value)
4447 
      for key, value in self.__dict__.iteritems()]
4448 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4449 
 
4450 
  def __eq__(self, other):
4451 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4452 
 
4453 
  def __ne__(self, other):
4454 
    return not (self == other)
4455 
 
559 chandransh 4456 
class createUser_result:
94 ashish 4457 
  """
4458 
  Attributes:
4459 
   - success
559 chandransh 4460 
   - ucex
94 ashish 4461 
  """
4462 
 
4463 
  thrift_spec = (
559 chandransh 4464 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4465 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4466 
  )
4467 
 
559 chandransh 4468 
  def __init__(self, success=None, ucex=None,):
94 ashish 4469 
    self.success = success
559 chandransh 4470 
    self.ucex = ucex
94 ashish 4471 
 
4472 
  def read(self, iprot):
4473 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4474 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4475 
      return
4476 
    iprot.readStructBegin()
4477 
    while True:
4478 
      (fname, ftype, fid) = iprot.readFieldBegin()
4479 
      if ftype == TType.STOP:
4480 
        break
4481 
      if fid == 0:
4482 
        if ftype == TType.STRUCT:
559 chandransh 4483 
          self.success = User()
94 ashish 4484 
          self.success.read(iprot)
4485 
        else:
4486 
          iprot.skip(ftype)
4487 
      elif fid == 1:
4488 
        if ftype == TType.STRUCT:
559 chandransh 4489 
          self.ucex = UserContextException()
4490 
          self.ucex.read(iprot)
94 ashish 4491 
        else:
4492 
          iprot.skip(ftype)
4493 
      else:
4494 
        iprot.skip(ftype)
4495 
      iprot.readFieldEnd()
4496 
    iprot.readStructEnd()
4497 
 
4498 
  def write(self, oprot):
4499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4501 
      return
559 chandransh 4502 
    oprot.writeStructBegin('createUser_result')
94 ashish 4503 
    if self.success != None:
4504 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4505 
      self.success.write(oprot)
4506 
      oprot.writeFieldEnd()
559 chandransh 4507 
    if self.ucex != None:
4508 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4509 
      self.ucex.write(oprot)
94 ashish 4510 
      oprot.writeFieldEnd()
4511 
    oprot.writeFieldStop()
4512 
    oprot.writeStructEnd()
4513 
 
4514 
  def __repr__(self):
4515 
    L = ['%s=%r' % (key, value)
4516 
      for key, value in self.__dict__.iteritems()]
4517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4518 
 
4519 
  def __eq__(self, other):
4520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4521 
 
4522 
  def __ne__(self, other):
4523 
    return not (self == other)
4524 
 
559 chandransh 4525 
class updateUser_args:
94 ashish 4526 
  """
4527 
  Attributes:
559 chandransh 4528 
   - user
94 ashish 4529 
  """
4530 
 
4531 
  thrift_spec = (
4532 
    None, # 0
559 chandransh 4533 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4534 
  )
4535 
 
559 chandransh 4536 
  def __init__(self, user=None,):
4537 
    self.user = user
94 ashish 4538 
 
4539 
  def read(self, iprot):
4540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4542 
      return
4543 
    iprot.readStructBegin()
4544 
    while True:
4545 
      (fname, ftype, fid) = iprot.readFieldBegin()
4546 
      if ftype == TType.STOP:
4547 
        break
4548 
      if fid == 1:
559 chandransh 4549 
        if ftype == TType.STRUCT:
4550 
          self.user = User()
4551 
          self.user.read(iprot)
94 ashish 4552 
        else:
4553 
          iprot.skip(ftype)
4554 
      else:
4555 
        iprot.skip(ftype)
4556 
      iprot.readFieldEnd()
4557 
    iprot.readStructEnd()
4558 
 
4559 
  def write(self, oprot):
4560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4562 
      return
559 chandransh 4563 
    oprot.writeStructBegin('updateUser_args')
4564 
    if self.user != None:
4565 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4566 
      self.user.write(oprot)
94 ashish 4567 
      oprot.writeFieldEnd()
4568 
    oprot.writeFieldStop()
4569 
    oprot.writeStructEnd()
4570 
 
4571 
  def __repr__(self):
4572 
    L = ['%s=%r' % (key, value)
4573 
      for key, value in self.__dict__.iteritems()]
4574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4575 
 
4576 
  def __eq__(self, other):
4577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4578 
 
4579 
  def __ne__(self, other):
4580 
    return not (self == other)
4581 
 
559 chandransh 4582 
class updateUser_result:
94 ashish 4583 
  """
4584 
  Attributes:
4585 
   - success
559 chandransh 4586 
   - ucex
94 ashish 4587 
  """
4588 
 
4589 
  thrift_spec = (
559 chandransh 4590 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4591 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4592 
  )
4593 
 
559 chandransh 4594 
  def __init__(self, success=None, ucex=None,):
94 ashish 4595 
    self.success = success
559 chandransh 4596 
    self.ucex = ucex
94 ashish 4597 
 
4598 
  def read(self, iprot):
4599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4601 
      return
4602 
    iprot.readStructBegin()
4603 
    while True:
4604 
      (fname, ftype, fid) = iprot.readFieldBegin()
4605 
      if ftype == TType.STOP:
4606 
        break
4607 
      if fid == 0:
4608 
        if ftype == TType.STRUCT:
559 chandransh 4609 
          self.success = User()
94 ashish 4610 
          self.success.read(iprot)
4611 
        else:
4612 
          iprot.skip(ftype)
4613 
      elif fid == 1:
4614 
        if ftype == TType.STRUCT:
559 chandransh 4615 
          self.ucex = UserContextException()
4616 
          self.ucex.read(iprot)
94 ashish 4617 
        else:
4618 
          iprot.skip(ftype)
4619 
      else:
4620 
        iprot.skip(ftype)
4621 
      iprot.readFieldEnd()
4622 
    iprot.readStructEnd()
4623 
 
4624 
  def write(self, oprot):
4625 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4626 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4627 
      return
559 chandransh 4628 
    oprot.writeStructBegin('updateUser_result')
94 ashish 4629 
    if self.success != None:
4630 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4631 
      self.success.write(oprot)
4632 
      oprot.writeFieldEnd()
559 chandransh 4633 
    if self.ucex != None:
4634 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4635 
      self.ucex.write(oprot)
94 ashish 4636 
      oprot.writeFieldEnd()
4637 
    oprot.writeFieldStop()
4638 
    oprot.writeStructEnd()
4639 
 
4640 
  def __repr__(self):
4641 
    L = ['%s=%r' % (key, value)
4642 
      for key, value in self.__dict__.iteritems()]
4643 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4644 
 
4645 
  def __eq__(self, other):
4646 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4647 
 
4648 
  def __ne__(self, other):
4649 
    return not (self == other)
4650 
 
559 chandransh 4651 
class deleteUser_args:
94 ashish 4652 
  """
4653 
  Attributes:
4654 
   - userId
4655 
  """
4656 
 
4657 
  thrift_spec = (
4658 
    None, # 0
4659 
    (1, TType.I64, 'userId', None, None, ), # 1
4660 
  )
4661 
 
559 chandransh 4662 
  def __init__(self, userId=None,):
94 ashish 4663 
    self.userId = userId
4664 
 
4665 
  def read(self, iprot):
4666 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4667 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4668 
      return
4669 
    iprot.readStructBegin()
4670 
    while True:
4671 
      (fname, ftype, fid) = iprot.readFieldBegin()
4672 
      if ftype == TType.STOP:
4673 
        break
4674 
      if fid == 1:
4675 
        if ftype == TType.I64:
4676 
          self.userId = iprot.readI64();
4677 
        else:
4678 
          iprot.skip(ftype)
4679 
      else:
4680 
        iprot.skip(ftype)
4681 
      iprot.readFieldEnd()
4682 
    iprot.readStructEnd()
4683 
 
4684 
  def write(self, oprot):
4685 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4686 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4687 
      return
559 chandransh 4688 
    oprot.writeStructBegin('deleteUser_args')
94 ashish 4689 
    if self.userId != None:
4690 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4691 
      oprot.writeI64(self.userId)
4692 
      oprot.writeFieldEnd()
4693 
    oprot.writeFieldStop()
4694 
    oprot.writeStructEnd()
4695 
 
4696 
  def __repr__(self):
4697 
    L = ['%s=%r' % (key, value)
4698 
      for key, value in self.__dict__.iteritems()]
4699 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4700 
 
4701 
  def __eq__(self, other):
4702 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4703 
 
4704 
  def __ne__(self, other):
4705 
    return not (self == other)
4706 
 
559 chandransh 4707 
class deleteUser_result:
94 ashish 4708 
  """
4709 
  Attributes:
4710 
   - success
559 chandransh 4711 
   - ucex
94 ashish 4712 
  """
4713 
 
4714 
  thrift_spec = (
559 chandransh 4715 
    (0, TType.BOOL, 'success', None, None, ), # 0
4716 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4717 
  )
4718 
 
559 chandransh 4719 
  def __init__(self, success=None, ucex=None,):
94 ashish 4720 
    self.success = success
559 chandransh 4721 
    self.ucex = ucex
94 ashish 4722 
 
4723 
  def read(self, iprot):
4724 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4725 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4726 
      return
4727 
    iprot.readStructBegin()
4728 
    while True:
4729 
      (fname, ftype, fid) = iprot.readFieldBegin()
4730 
      if ftype == TType.STOP:
4731 
        break
4732 
      if fid == 0:
559 chandransh 4733 
        if ftype == TType.BOOL:
4734 
          self.success = iprot.readBool();
94 ashish 4735 
        else:
4736 
          iprot.skip(ftype)
4737 
      elif fid == 1:
4738 
        if ftype == TType.STRUCT:
559 chandransh 4739 
          self.ucex = UserContextException()
4740 
          self.ucex.read(iprot)
94 ashish 4741 
        else:
4742 
          iprot.skip(ftype)
4743 
      else:
4744 
        iprot.skip(ftype)
4745 
      iprot.readFieldEnd()
4746 
    iprot.readStructEnd()
4747 
 
4748 
  def write(self, oprot):
4749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4751 
      return
559 chandransh 4752 
    oprot.writeStructBegin('deleteUser_result')
94 ashish 4753 
    if self.success != None:
559 chandransh 4754 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4755 
      oprot.writeBool(self.success)
94 ashish 4756 
      oprot.writeFieldEnd()
559 chandransh 4757 
    if self.ucex != None:
4758 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4759 
      self.ucex.write(oprot)
94 ashish 4760 
      oprot.writeFieldEnd()
4761 
    oprot.writeFieldStop()
4762 
    oprot.writeStructEnd()
4763 
 
4764 
  def __repr__(self):
4765 
    L = ['%s=%r' % (key, value)
4766 
      for key, value in self.__dict__.iteritems()]
4767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4768 
 
4769 
  def __eq__(self, other):
4770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4771 
 
4772 
  def __ne__(self, other):
4773 
    return not (self == other)
4774 
 
559 chandransh 4775 
class getUserState_args:
94 ashish 4776 
  """
4777 
  Attributes:
4778 
   - userId
4779 
  """
4780 
 
4781 
  thrift_spec = (
4782 
    None, # 0
4783 
    (1, TType.I64, 'userId', None, None, ), # 1
4784 
  )
4785 
 
559 chandransh 4786 
  def __init__(self, userId=None,):
94 ashish 4787 
    self.userId = userId
4788 
 
4789 
  def read(self, iprot):
4790 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4791 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4792 
      return
4793 
    iprot.readStructBegin()
4794 
    while True:
4795 
      (fname, ftype, fid) = iprot.readFieldBegin()
4796 
      if ftype == TType.STOP:
4797 
        break
4798 
      if fid == 1:
4799 
        if ftype == TType.I64:
4800 
          self.userId = iprot.readI64();
4801 
        else:
4802 
          iprot.skip(ftype)
4803 
      else:
4804 
        iprot.skip(ftype)
4805 
      iprot.readFieldEnd()
4806 
    iprot.readStructEnd()
4807 
 
4808 
  def write(self, oprot):
4809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4811 
      return
559 chandransh 4812 
    oprot.writeStructBegin('getUserState_args')
94 ashish 4813 
    if self.userId != None:
4814 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4815 
      oprot.writeI64(self.userId)
4816 
      oprot.writeFieldEnd()
4817 
    oprot.writeFieldStop()
4818 
    oprot.writeStructEnd()
4819 
 
4820 
  def __repr__(self):
4821 
    L = ['%s=%r' % (key, value)
4822 
      for key, value in self.__dict__.iteritems()]
4823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4824 
 
4825 
  def __eq__(self, other):
4826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4827 
 
4828 
  def __ne__(self, other):
4829 
    return not (self == other)
4830 
 
559 chandransh 4831 
class getUserState_result:
94 ashish 4832 
  """
4833 
  Attributes:
4834 
   - success
559 chandransh 4835 
   - ucex
94 ashish 4836 
  """
4837 
 
4838 
  thrift_spec = (
559 chandransh 4839 
    (0, TType.STRUCT, 'success', (UserState, UserState.thrift_spec), None, ), # 0
4840 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4841 
  )
4842 
 
559 chandransh 4843 
  def __init__(self, success=None, ucex=None,):
94 ashish 4844 
    self.success = success
559 chandransh 4845 
    self.ucex = ucex
94 ashish 4846 
 
4847 
  def read(self, iprot):
4848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4850 
      return
4851 
    iprot.readStructBegin()
4852 
    while True:
4853 
      (fname, ftype, fid) = iprot.readFieldBegin()
4854 
      if ftype == TType.STOP:
4855 
        break
4856 
      if fid == 0:
4857 
        if ftype == TType.STRUCT:
559 chandransh 4858 
          self.success = UserState()
94 ashish 4859 
          self.success.read(iprot)
4860 
        else:
4861 
          iprot.skip(ftype)
4862 
      elif fid == 1:
4863 
        if ftype == TType.STRUCT:
559 chandransh 4864 
          self.ucex = UserContextException()
4865 
          self.ucex.read(iprot)
94 ashish 4866 
        else:
4867 
          iprot.skip(ftype)
4868 
      else:
4869 
        iprot.skip(ftype)
4870 
      iprot.readFieldEnd()
4871 
    iprot.readStructEnd()
4872 
 
4873 
  def write(self, oprot):
4874 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4875 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4876 
      return
559 chandransh 4877 
    oprot.writeStructBegin('getUserState_result')
94 ashish 4878 
    if self.success != None:
4879 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4880 
      self.success.write(oprot)
4881 
      oprot.writeFieldEnd()
559 chandransh 4882 
    if self.ucex != None:
4883 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4884 
      self.ucex.write(oprot)
94 ashish 4885 
      oprot.writeFieldEnd()
4886 
    oprot.writeFieldStop()
4887 
    oprot.writeStructEnd()
4888 
 
4889 
  def __repr__(self):
4890 
    L = ['%s=%r' % (key, value)
4891 
      for key, value in self.__dict__.iteritems()]
4892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4893 
 
4894 
  def __eq__(self, other):
4895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4896 
 
4897 
  def __ne__(self, other):
4898 
    return not (self == other)
4899 
 
559 chandransh 4900 
class authenticateUser_args:
94 ashish 4901 
  """
4902 
  Attributes:
4903 
   - email
4904 
   - password
4905 
  """
4906 
 
4907 
  thrift_spec = (
4908 
    None, # 0
4909 
    (1, TType.STRING, 'email', None, None, ), # 1
4910 
    (2, TType.STRING, 'password', None, None, ), # 2
4911 
  )
4912 
 
4913 
  def __init__(self, email=None, password=None,):
4914 
    self.email = email
4915 
    self.password = password
4916 
 
4917 
  def read(self, iprot):
4918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4920 
      return
4921 
    iprot.readStructBegin()
4922 
    while True:
4923 
      (fname, ftype, fid) = iprot.readFieldBegin()
4924 
      if ftype == TType.STOP:
4925 
        break
4926 
      if fid == 1:
4927 
        if ftype == TType.STRING:
4928 
          self.email = iprot.readString();
4929 
        else:
4930 
          iprot.skip(ftype)
4931 
      elif fid == 2:
4932 
        if ftype == TType.STRING:
4933 
          self.password = iprot.readString();
4934 
        else:
4935 
          iprot.skip(ftype)
4936 
      else:
4937 
        iprot.skip(ftype)
4938 
      iprot.readFieldEnd()
4939 
    iprot.readStructEnd()
4940 
 
4941 
  def write(self, oprot):
4942 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4943 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4944 
      return
559 chandransh 4945 
    oprot.writeStructBegin('authenticateUser_args')
94 ashish 4946 
    if self.email != None:
4947 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4948 
      oprot.writeString(self.email)
4949 
      oprot.writeFieldEnd()
4950 
    if self.password != None:
4951 
      oprot.writeFieldBegin('password', TType.STRING, 2)
4952 
      oprot.writeString(self.password)
4953 
      oprot.writeFieldEnd()
4954 
    oprot.writeFieldStop()
4955 
    oprot.writeStructEnd()
4956 
 
4957 
  def __repr__(self):
4958 
    L = ['%s=%r' % (key, value)
4959 
      for key, value in self.__dict__.iteritems()]
4960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4961 
 
4962 
  def __eq__(self, other):
4963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4964 
 
4965 
  def __ne__(self, other):
4966 
    return not (self == other)
4967 
 
559 chandransh 4968 
class authenticateUser_result:
94 ashish 4969 
  """
4970 
  Attributes:
4971 
   - success
559 chandransh 4972 
   - auex
94 ashish 4973 
  """
4974 
 
4975 
  thrift_spec = (
559 chandransh 4976 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4977 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 4978 
  )
4979 
 
559 chandransh 4980 
  def __init__(self, success=None, auex=None,):
94 ashish 4981 
    self.success = success
559 chandransh 4982 
    self.auex = auex
94 ashish 4983 
 
4984 
  def read(self, iprot):
4985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4987 
      return
4988 
    iprot.readStructBegin()
4989 
    while True:
4990 
      (fname, ftype, fid) = iprot.readFieldBegin()
4991 
      if ftype == TType.STOP:
4992 
        break
4993 
      if fid == 0:
4994 
        if ftype == TType.STRUCT:
559 chandransh 4995 
          self.success = User()
94 ashish 4996 
          self.success.read(iprot)
4997 
        else:
4998 
          iprot.skip(ftype)
4999 
      elif fid == 1:
5000 
        if ftype == TType.STRUCT:
559 chandransh 5001 
          self.auex = AuthenticationException()
5002 
          self.auex.read(iprot)
94 ashish 5003 
        else:
5004 
          iprot.skip(ftype)
5005 
      else:
5006 
        iprot.skip(ftype)
5007 
      iprot.readFieldEnd()
5008 
    iprot.readStructEnd()
5009 
 
5010 
  def write(self, oprot):
5011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5013 
      return
559 chandransh 5014 
    oprot.writeStructBegin('authenticateUser_result')
94 ashish 5015 
    if self.success != None:
5016 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5017 
      self.success.write(oprot)
5018 
      oprot.writeFieldEnd()
559 chandransh 5019 
    if self.auex != None:
5020 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
5021 
      self.auex.write(oprot)
94 ashish 5022 
      oprot.writeFieldEnd()
5023 
    oprot.writeFieldStop()
5024 
    oprot.writeStructEnd()
5025 
 
5026 
  def __repr__(self):
5027 
    L = ['%s=%r' % (key, value)
5028 
      for key, value in self.__dict__.iteritems()]
5029 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5030 
 
5031 
  def __eq__(self, other):
5032 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5033 
 
5034 
  def __ne__(self, other):
5035 
    return not (self == other)
5036 
 
559 chandransh 5037 
class userExists_args:
122 ashish 5038 
  """
5039 
  Attributes:
559 chandransh 5040 
   - email
122 ashish 5041 
  """
5042 
 
5043 
  thrift_spec = (
5044 
    None, # 0
559 chandransh 5045 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 5046 
  )
5047 
 
559 chandransh 5048 
  def __init__(self, email=None,):
5049 
    self.email = email
122 ashish 5050 
 
5051 
  def read(self, iprot):
5052 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5053 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5054 
      return
5055 
    iprot.readStructBegin()
5056 
    while True:
5057 
      (fname, ftype, fid) = iprot.readFieldBegin()
5058 
      if ftype == TType.STOP:
5059 
        break
5060 
      if fid == 1:
5061 
        if ftype == TType.STRING:
559 chandransh 5062 
          self.email = iprot.readString();
122 ashish 5063 
        else:
5064 
          iprot.skip(ftype)
559 chandransh 5065 
      else:
5066 
        iprot.skip(ftype)
5067 
      iprot.readFieldEnd()
5068 
    iprot.readStructEnd()
5069 
 
5070 
  def write(self, oprot):
5071 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5072 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5073 
      return
5074 
    oprot.writeStructBegin('userExists_args')
5075 
    if self.email != None:
5076 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5077 
      oprot.writeString(self.email)
5078 
      oprot.writeFieldEnd()
5079 
    oprot.writeFieldStop()
5080 
    oprot.writeStructEnd()
5081 
 
5082 
  def __repr__(self):
5083 
    L = ['%s=%r' % (key, value)
5084 
      for key, value in self.__dict__.iteritems()]
5085 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5086 
 
5087 
  def __eq__(self, other):
5088 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5089 
 
5090 
  def __ne__(self, other):
5091 
    return not (self == other)
5092 
 
5093 
class userExists_result:
5094 
  """
5095 
  Attributes:
5096 
   - success
5097 
   - ucx
5098 
  """
5099 
 
5100 
  thrift_spec = (
5101 
    (0, TType.BOOL, 'success', None, None, ), # 0
5102 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5103 
  )
5104 
 
5105 
  def __init__(self, success=None, ucx=None,):
5106 
    self.success = success
5107 
    self.ucx = ucx
5108 
 
5109 
  def read(self, iprot):
5110 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5111 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5112 
      return
5113 
    iprot.readStructBegin()
5114 
    while True:
5115 
      (fname, ftype, fid) = iprot.readFieldBegin()
5116 
      if ftype == TType.STOP:
5117 
        break
5118 
      if fid == 0:
5119 
        if ftype == TType.BOOL:
5120 
          self.success = iprot.readBool();
5121 
        else:
5122 
          iprot.skip(ftype)
5123 
      elif fid == 1:
5124 
        if ftype == TType.STRUCT:
5125 
          self.ucx = UserContextException()
5126 
          self.ucx.read(iprot)
5127 
        else:
5128 
          iprot.skip(ftype)
5129 
      else:
5130 
        iprot.skip(ftype)
5131 
      iprot.readFieldEnd()
5132 
    iprot.readStructEnd()
5133 
 
5134 
  def write(self, oprot):
5135 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5136 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5137 
      return
5138 
    oprot.writeStructBegin('userExists_result')
5139 
    if self.success != None:
5140 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5141 
      oprot.writeBool(self.success)
5142 
      oprot.writeFieldEnd()
5143 
    if self.ucx != None:
5144 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5145 
      self.ucx.write(oprot)
5146 
      oprot.writeFieldEnd()
5147 
    oprot.writeFieldStop()
5148 
    oprot.writeStructEnd()
5149 
 
5150 
  def __repr__(self):
5151 
    L = ['%s=%r' % (key, value)
5152 
      for key, value in self.__dict__.iteritems()]
5153 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5154 
 
5155 
  def __eq__(self, other):
5156 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5157 
 
5158 
  def __ne__(self, other):
5159 
    return not (self == other)
5160 
 
5161 
class addAddressForUser_args:
5162 
  """
5163 
  Attributes:
5164 
   - userId
5165 
   - address
5166 
   - setDefault
5167 
  """
5168 
 
5169 
  thrift_spec = (
5170 
    None, # 0
5171 
    (1, TType.I64, 'userId', None, None, ), # 1
5172 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 5173 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 5174 
  )
5175 
 
567 rajveer 5176 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 5177 
    self.userId = userId
5178 
    self.address = address
5179 
    self.setDefault = setDefault
5180 
 
5181 
  def read(self, iprot):
5182 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5183 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5184 
      return
5185 
    iprot.readStructBegin()
5186 
    while True:
5187 
      (fname, ftype, fid) = iprot.readFieldBegin()
5188 
      if ftype == TType.STOP:
5189 
        break
5190 
      if fid == 1:
5191 
        if ftype == TType.I64:
5192 
          self.userId = iprot.readI64();
5193 
        else:
5194 
          iprot.skip(ftype)
122 ashish 5195 
      elif fid == 2:
559 chandransh 5196 
        if ftype == TType.STRUCT:
5197 
          self.address = Address()
5198 
          self.address.read(iprot)
122 ashish 5199 
        else:
5200 
          iprot.skip(ftype)
5201 
      elif fid == 3:
5202 
        if ftype == TType.BOOL:
559 chandransh 5203 
          self.setDefault = iprot.readBool();
122 ashish 5204 
        else:
5205 
          iprot.skip(ftype)
5206 
      else:
5207 
        iprot.skip(ftype)
5208 
      iprot.readFieldEnd()
5209 
    iprot.readStructEnd()
5210 
 
5211 
  def write(self, oprot):
5212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5214 
      return
559 chandransh 5215 
    oprot.writeStructBegin('addAddressForUser_args')
5216 
    if self.userId != None:
5217 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5218 
      oprot.writeI64(self.userId)
122 ashish 5219 
      oprot.writeFieldEnd()
559 chandransh 5220 
    if self.address != None:
5221 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
5222 
      self.address.write(oprot)
122 ashish 5223 
      oprot.writeFieldEnd()
559 chandransh 5224 
    if self.setDefault != None:
567 rajveer 5225 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 5226 
      oprot.writeBool(self.setDefault)
5227 
      oprot.writeFieldEnd()
122 ashish 5228 
    oprot.writeFieldStop()
5229 
    oprot.writeStructEnd()
5230 
 
5231 
  def __repr__(self):
5232 
    L = ['%s=%r' % (key, value)
5233 
      for key, value in self.__dict__.iteritems()]
5234 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5235 
 
5236 
  def __eq__(self, other):
5237 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5238 
 
5239 
  def __ne__(self, other):
5240 
    return not (self == other)
5241 
 
559 chandransh 5242 
class addAddressForUser_result:
122 ashish 5243 
  """
5244 
  Attributes:
5245 
   - success
559 chandransh 5246 
   - ucx
122 ashish 5247 
  """
5248 
 
5249 
  thrift_spec = (
567 rajveer 5250 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 5251 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 5252 
  )
5253 
 
559 chandransh 5254 
  def __init__(self, success=None, ucx=None,):
122 ashish 5255 
    self.success = success
559 chandransh 5256 
    self.ucx = ucx
122 ashish 5257 
 
5258 
  def read(self, iprot):
5259 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5260 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5261 
      return
5262 
    iprot.readStructBegin()
5263 
    while True:
5264 
      (fname, ftype, fid) = iprot.readFieldBegin()
5265 
      if ftype == TType.STOP:
5266 
        break
5267 
      if fid == 0:
567 rajveer 5268 
        if ftype == TType.I64:
5269 
          self.success = iprot.readI64();
122 ashish 5270 
        else:
5271 
          iprot.skip(ftype)
5272 
      elif fid == 1:
5273 
        if ftype == TType.STRUCT:
559 chandransh 5274 
          self.ucx = UserContextException()
5275 
          self.ucx.read(iprot)
122 ashish 5276 
        else:
5277 
          iprot.skip(ftype)
5278 
      else:
5279 
        iprot.skip(ftype)
5280 
      iprot.readFieldEnd()
5281 
    iprot.readStructEnd()
5282 
 
5283 
  def write(self, oprot):
5284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5286 
      return
559 chandransh 5287 
    oprot.writeStructBegin('addAddressForUser_result')
122 ashish 5288 
    if self.success != None:
567 rajveer 5289 
      oprot.writeFieldBegin('success', TType.I64, 0)
5290 
      oprot.writeI64(self.success)
122 ashish 5291 
      oprot.writeFieldEnd()
559 chandransh 5292 
    if self.ucx != None:
5293 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5294 
      self.ucx.write(oprot)
122 ashish 5295 
      oprot.writeFieldEnd()
5296 
    oprot.writeFieldStop()
5297 
    oprot.writeStructEnd()
5298 
 
5299 
  def __repr__(self):
5300 
    L = ['%s=%r' % (key, value)
5301 
      for key, value in self.__dict__.iteritems()]
5302 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5303 
 
5304 
  def __eq__(self, other):
5305 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5306 
 
5307 
  def __ne__(self, other):
5308 
    return not (self == other)
5309 
 
559 chandransh 5310 
class removeAddressForUser_args:
94 ashish 5311 
  """
5312 
  Attributes:
559 chandransh 5313 
   - userid
5314 
   - addressId
94 ashish 5315 
  """
5316 
 
5317 
  thrift_spec = (
5318 
    None, # 0
559 chandransh 5319 
    (1, TType.I64, 'userid', None, None, ), # 1
5320 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 5321 
  )
5322 
 
559 chandransh 5323 
  def __init__(self, userid=None, addressId=None,):
5324 
    self.userid = userid
5325 
    self.addressId = addressId
94 ashish 5326 
 
5327 
  def read(self, iprot):
5328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5330 
      return
5331 
    iprot.readStructBegin()
5332 
    while True:
5333 
      (fname, ftype, fid) = iprot.readFieldBegin()
5334 
      if ftype == TType.STOP:
5335 
        break
5336 
      if fid == 1:
559 chandransh 5337 
        if ftype == TType.I64:
5338 
          self.userid = iprot.readI64();
94 ashish 5339 
        else:
5340 
          iprot.skip(ftype)
559 chandransh 5341 
      elif fid == 2:
5342 
        if ftype == TType.I64:
5343 
          self.addressId = iprot.readI64();
5344 
        else:
5345 
          iprot.skip(ftype)
94 ashish 5346 
      else:
5347 
        iprot.skip(ftype)
5348 
      iprot.readFieldEnd()
5349 
    iprot.readStructEnd()
5350 
 
5351 
  def write(self, oprot):
5352 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5353 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5354 
      return
559 chandransh 5355 
    oprot.writeStructBegin('removeAddressForUser_args')
5356 
    if self.userid != None:
5357 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5358 
      oprot.writeI64(self.userid)
94 ashish 5359 
      oprot.writeFieldEnd()
559 chandransh 5360 
    if self.addressId != None:
5361 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5362 
      oprot.writeI64(self.addressId)
5363 
      oprot.writeFieldEnd()
94 ashish 5364 
    oprot.writeFieldStop()
5365 
    oprot.writeStructEnd()
5366 
 
5367 
  def __repr__(self):
5368 
    L = ['%s=%r' % (key, value)
5369 
      for key, value in self.__dict__.iteritems()]
5370 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5371 
 
5372 
  def __eq__(self, other):
5373 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5374 
 
5375 
  def __ne__(self, other):
5376 
    return not (self == other)
5377 
 
559 chandransh 5378 
class removeAddressForUser_result:
94 ashish 5379 
  """
5380 
  Attributes:
5381 
   - success
5382 
   - ucx
5383 
  """
5384 
 
5385 
  thrift_spec = (
5386 
    (0, TType.BOOL, 'success', None, None, ), # 0
5387 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5388 
  )
5389 
 
5390 
  def __init__(self, success=None, ucx=None,):
5391 
    self.success = success
5392 
    self.ucx = ucx
5393 
 
5394 
  def read(self, iprot):
5395 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5396 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5397 
      return
5398 
    iprot.readStructBegin()
5399 
    while True:
5400 
      (fname, ftype, fid) = iprot.readFieldBegin()
5401 
      if ftype == TType.STOP:
5402 
        break
5403 
      if fid == 0:
5404 
        if ftype == TType.BOOL:
5405 
          self.success = iprot.readBool();
5406 
        else:
5407 
          iprot.skip(ftype)
5408 
      elif fid == 1:
5409 
        if ftype == TType.STRUCT:
5410 
          self.ucx = UserContextException()
5411 
          self.ucx.read(iprot)
5412 
        else:
5413 
          iprot.skip(ftype)
5414 
      else:
5415 
        iprot.skip(ftype)
5416 
      iprot.readFieldEnd()
5417 
    iprot.readStructEnd()
5418 
 
5419 
  def write(self, oprot):
5420 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5421 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5422 
      return
559 chandransh 5423 
    oprot.writeStructBegin('removeAddressForUser_result')
94 ashish 5424 
    if self.success != None:
5425 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5426 
      oprot.writeBool(self.success)
5427 
      oprot.writeFieldEnd()
5428 
    if self.ucx != None:
5429 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5430 
      self.ucx.write(oprot)
5431 
      oprot.writeFieldEnd()
5432 
    oprot.writeFieldStop()
5433 
    oprot.writeStructEnd()
5434 
 
5435 
  def __repr__(self):
5436 
    L = ['%s=%r' % (key, value)
5437 
      for key, value in self.__dict__.iteritems()]
5438 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5439 
 
5440 
  def __eq__(self, other):
5441 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5442 
 
5443 
  def __ne__(self, other):
5444 
    return not (self == other)
5445 
 
559 chandransh 5446 
class setUserAsLoggedIn_args:
94 ashish 5447 
  """
5448 
  Attributes:
559 chandransh 5449 
   - userId
94 ashish 5450 
   - timestamp
5451 
  """
5452 
 
5453 
  thrift_spec = (
5454 
    None, # 0
559 chandransh 5455 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 5456 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5457 
  )
5458 
 
559 chandransh 5459 
  def __init__(self, userId=None, timestamp=None,):
5460 
    self.userId = userId
94 ashish 5461 
    self.timestamp = timestamp
5462 
 
5463 
  def read(self, iprot):
5464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5466 
      return
5467 
    iprot.readStructBegin()
5468 
    while True:
5469 
      (fname, ftype, fid) = iprot.readFieldBegin()
5470 
      if ftype == TType.STOP:
5471 
        break
5472 
      if fid == 1:
559 chandransh 5473 
        if ftype == TType.I64:
5474 
          self.userId = iprot.readI64();
94 ashish 5475 
        else:
5476 
          iprot.skip(ftype)
5477 
      elif fid == 2:
5478 
        if ftype == TType.I64:
5479 
          self.timestamp = iprot.readI64();
5480 
        else:
5481 
          iprot.skip(ftype)
5482 
      else:
5483 
        iprot.skip(ftype)
5484 
      iprot.readFieldEnd()
5485 
    iprot.readStructEnd()
5486 
 
5487 
  def write(self, oprot):
5488 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5489 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5490 
      return
559 chandransh 5491 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
5492 
    if self.userId != None:
5493 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5494 
      oprot.writeI64(self.userId)
94 ashish 5495 
      oprot.writeFieldEnd()
5496 
    if self.timestamp != None:
5497 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5498 
      oprot.writeI64(self.timestamp)
5499 
      oprot.writeFieldEnd()
5500 
    oprot.writeFieldStop()
5501 
    oprot.writeStructEnd()
5502 
 
5503 
  def __repr__(self):
5504 
    L = ['%s=%r' % (key, value)
5505 
      for key, value in self.__dict__.iteritems()]
5506 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5507 
 
5508 
  def __eq__(self, other):
5509 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5510 
 
5511 
  def __ne__(self, other):
5512 
    return not (self == other)
5513 
 
559 chandransh 5514 
class setUserAsLoggedIn_result:
94 ashish 5515 
  """
5516 
  Attributes:
5517 
   - success
5518 
   - ucx
5519 
  """
5520 
 
5521 
  thrift_spec = (
5522 
    (0, TType.BOOL, 'success', None, None, ), # 0
5523 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5524 
  )
5525 
 
5526 
  def __init__(self, success=None, ucx=None,):
5527 
    self.success = success
5528 
    self.ucx = ucx
5529 
 
5530 
  def read(self, iprot):
5531 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5532 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5533 
      return
5534 
    iprot.readStructBegin()
5535 
    while True:
5536 
      (fname, ftype, fid) = iprot.readFieldBegin()
5537 
      if ftype == TType.STOP:
5538 
        break
5539 
      if fid == 0:
5540 
        if ftype == TType.BOOL:
5541 
          self.success = iprot.readBool();
5542 
        else:
5543 
          iprot.skip(ftype)
5544 
      elif fid == 1:
5545 
        if ftype == TType.STRUCT:
5546 
          self.ucx = UserContextException()
5547 
          self.ucx.read(iprot)
5548 
        else:
5549 
          iprot.skip(ftype)
5550 
      else:
5551 
        iprot.skip(ftype)
5552 
      iprot.readFieldEnd()
5553 
    iprot.readStructEnd()
5554 
 
5555 
  def write(self, oprot):
5556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5558 
      return
559 chandransh 5559 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
94 ashish 5560 
    if self.success != None:
5561 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5562 
      oprot.writeBool(self.success)
5563 
      oprot.writeFieldEnd()
5564 
    if self.ucx != None:
5565 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5566 
      self.ucx.write(oprot)
5567 
      oprot.writeFieldEnd()
5568 
    oprot.writeFieldStop()
5569 
    oprot.writeStructEnd()
5570 
 
5571 
  def __repr__(self):
5572 
    L = ['%s=%r' % (key, value)
5573 
      for key, value in self.__dict__.iteritems()]
5574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5575 
 
5576 
  def __eq__(self, other):
5577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5578 
 
5579 
  def __ne__(self, other):
5580 
    return not (self == other)
5581 
 
559 chandransh 5582 
class setUserAsLoggedOut_args:
94 ashish 5583 
  """
5584 
  Attributes:
5585 
   - userid
5586 
   - timestamp
5587 
  """
5588 
 
5589 
  thrift_spec = (
5590 
    None, # 0
559 chandransh 5591 
    (1, TType.I64, 'userid', None, None, ), # 1
5592 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 5593 
  )
5594 
 
559 chandransh 5595 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 5596 
    self.userid = userid
5597 
    self.timestamp = timestamp
5598 
 
5599 
  def read(self, iprot):
5600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5602 
      return
5603 
    iprot.readStructBegin()
5604 
    while True:
5605 
      (fname, ftype, fid) = iprot.readFieldBegin()
5606 
      if ftype == TType.STOP:
5607 
        break
5608 
      if fid == 1:
5609 
        if ftype == TType.I64:
5610 
          self.userid = iprot.readI64();
5611 
        else:
5612 
          iprot.skip(ftype)
559 chandransh 5613 
      elif fid == 2:
94 ashish 5614 
        if ftype == TType.I64:
5615 
          self.timestamp = iprot.readI64();
5616 
        else:
5617 
          iprot.skip(ftype)
5618 
      else:
5619 
        iprot.skip(ftype)
5620 
      iprot.readFieldEnd()
5621 
    iprot.readStructEnd()
5622 
 
5623 
  def write(self, oprot):
5624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5626 
      return
559 chandransh 5627 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
94 ashish 5628 
    if self.userid != None:
559 chandransh 5629 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 5630 
      oprot.writeI64(self.userid)
5631 
      oprot.writeFieldEnd()
5632 
    if self.timestamp != None:
559 chandransh 5633 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 5634 
      oprot.writeI64(self.timestamp)
5635 
      oprot.writeFieldEnd()
5636 
    oprot.writeFieldStop()
5637 
    oprot.writeStructEnd()
5638 
 
5639 
  def __repr__(self):
5640 
    L = ['%s=%r' % (key, value)
5641 
      for key, value in self.__dict__.iteritems()]
5642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5643 
 
5644 
  def __eq__(self, other):
5645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5646 
 
5647 
  def __ne__(self, other):
5648 
    return not (self == other)
5649 
 
559 chandransh 5650 
class setUserAsLoggedOut_result:
94 ashish 5651 
  """
5652 
  Attributes:
5653 
   - success
5654 
   - ucx
5655 
  """
5656 
 
5657 
  thrift_spec = (
5658 
    (0, TType.BOOL, 'success', None, None, ), # 0
5659 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5660 
  )
5661 
 
5662 
  def __init__(self, success=None, ucx=None,):
5663 
    self.success = success
5664 
    self.ucx = ucx
5665 
 
5666 
  def read(self, iprot):
5667 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5668 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5669 
      return
5670 
    iprot.readStructBegin()
5671 
    while True:
5672 
      (fname, ftype, fid) = iprot.readFieldBegin()
5673 
      if ftype == TType.STOP:
5674 
        break
5675 
      if fid == 0:
5676 
        if ftype == TType.BOOL:
5677 
          self.success = iprot.readBool();
5678 
        else:
5679 
          iprot.skip(ftype)
5680 
      elif fid == 1:
5681 
        if ftype == TType.STRUCT:
5682 
          self.ucx = UserContextException()
5683 
          self.ucx.read(iprot)
5684 
        else:
5685 
          iprot.skip(ftype)
5686 
      else:
5687 
        iprot.skip(ftype)
5688 
      iprot.readFieldEnd()
5689 
    iprot.readStructEnd()
5690 
 
5691 
  def write(self, oprot):
5692 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5693 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5694 
      return
559 chandransh 5695 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
94 ashish 5696 
    if self.success != None:
5697 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5698 
      oprot.writeBool(self.success)
5699 
      oprot.writeFieldEnd()
5700 
    if self.ucx != None:
5701 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5702 
      self.ucx.write(oprot)
5703 
      oprot.writeFieldEnd()
5704 
    oprot.writeFieldStop()
5705 
    oprot.writeStructEnd()
5706 
 
5707 
  def __repr__(self):
5708 
    L = ['%s=%r' % (key, value)
5709 
      for key, value in self.__dict__.iteritems()]
5710 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5711 
 
5712 
  def __eq__(self, other):
5713 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5714 
 
5715 
  def __ne__(self, other):
5716 
    return not (self == other)
5717 
 
559 chandransh 5718 
class setDefaultAddress_args:
94 ashish 5719 
  """
5720 
  Attributes:
5721 
   - userid
5722 
   - addressId
5723 
  """
5724 
 
5725 
  thrift_spec = (
5726 
    None, # 0
5727 
    (1, TType.I64, 'userid', None, None, ), # 1
5728 
    (2, TType.I64, 'addressId', None, None, ), # 2
5729 
  )
5730 
 
5731 
  def __init__(self, userid=None, addressId=None,):
5732 
    self.userid = userid
5733 
    self.addressId = addressId
5734 
 
5735 
  def read(self, iprot):
5736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5738 
      return
5739 
    iprot.readStructBegin()
5740 
    while True:
5741 
      (fname, ftype, fid) = iprot.readFieldBegin()
5742 
      if ftype == TType.STOP:
5743 
        break
5744 
      if fid == 1:
5745 
        if ftype == TType.I64:
5746 
          self.userid = iprot.readI64();
5747 
        else:
5748 
          iprot.skip(ftype)
5749 
      elif fid == 2:
5750 
        if ftype == TType.I64:
5751 
          self.addressId = iprot.readI64();
5752 
        else:
5753 
          iprot.skip(ftype)
5754 
      else:
5755 
        iprot.skip(ftype)
5756 
      iprot.readFieldEnd()
5757 
    iprot.readStructEnd()
5758 
 
5759 
  def write(self, oprot):
5760 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5761 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5762 
      return
559 chandransh 5763 
    oprot.writeStructBegin('setDefaultAddress_args')
94 ashish 5764 
    if self.userid != None:
5765 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5766 
      oprot.writeI64(self.userid)
5767 
      oprot.writeFieldEnd()
5768 
    if self.addressId != None:
5769 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5770 
      oprot.writeI64(self.addressId)
5771 
      oprot.writeFieldEnd()
5772 
    oprot.writeFieldStop()
5773 
    oprot.writeStructEnd()
5774 
 
5775 
  def __repr__(self):
5776 
    L = ['%s=%r' % (key, value)
5777 
      for key, value in self.__dict__.iteritems()]
5778 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5779 
 
5780 
  def __eq__(self, other):
5781 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5782 
 
5783 
  def __ne__(self, other):
5784 
    return not (self == other)
5785 
 
559 chandransh 5786 
class setDefaultAddress_result:
94 ashish 5787 
  """
5788 
  Attributes:
5789 
   - success
5790 
   - ucx
5791 
  """
5792 
 
5793 
  thrift_spec = (
5794 
    (0, TType.BOOL, 'success', None, None, ), # 0
5795 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5796 
  )
5797 
 
5798 
  def __init__(self, success=None, ucx=None,):
5799 
    self.success = success
5800 
    self.ucx = ucx
5801 
 
5802 
  def read(self, iprot):
5803 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5804 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5805 
      return
5806 
    iprot.readStructBegin()
5807 
    while True:
5808 
      (fname, ftype, fid) = iprot.readFieldBegin()
5809 
      if ftype == TType.STOP:
5810 
        break
5811 
      if fid == 0:
5812 
        if ftype == TType.BOOL:
5813 
          self.success = iprot.readBool();
5814 
        else:
5815 
          iprot.skip(ftype)
5816 
      elif fid == 1:
5817 
        if ftype == TType.STRUCT:
5818 
          self.ucx = UserContextException()
5819 
          self.ucx.read(iprot)
5820 
        else:
5821 
          iprot.skip(ftype)
5822 
      else:
5823 
        iprot.skip(ftype)
5824 
      iprot.readFieldEnd()
5825 
    iprot.readStructEnd()
5826 
 
5827 
  def write(self, oprot):
5828 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5829 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5830 
      return
559 chandransh 5831 
    oprot.writeStructBegin('setDefaultAddress_result')
94 ashish 5832 
    if self.success != None:
5833 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5834 
      oprot.writeBool(self.success)
5835 
      oprot.writeFieldEnd()
5836 
    if self.ucx != None:
5837 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5838 
      self.ucx.write(oprot)
5839 
      oprot.writeFieldEnd()
5840 
    oprot.writeFieldStop()
5841 
    oprot.writeStructEnd()
5842 
 
5843 
  def __repr__(self):
5844 
    L = ['%s=%r' % (key, value)
5845 
      for key, value in self.__dict__.iteritems()]
5846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5847 
 
5848 
  def __eq__(self, other):
5849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5850 
 
5851 
  def __ne__(self, other):
5852 
    return not (self == other)
5853 
 
559 chandransh 5854 
class updatePassword_args:
94 ashish 5855 
  """
5856 
  Attributes:
559 chandransh 5857 
   - userid
594 rajveer 5858 
   - oldPassword
5859 
   - newPassword
94 ashish 5860 
  """
5861 
 
5862 
  thrift_spec = (
5863 
    None, # 0
559 chandransh 5864 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 5865 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
5866 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 5867 
  )
5868 
 
594 rajveer 5869 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 5870 
    self.userid = userid
594 rajveer 5871 
    self.oldPassword = oldPassword
5872 
    self.newPassword = newPassword
94 ashish 5873 
 
5874 
  def read(self, iprot):
5875 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5876 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5877 
      return
5878 
    iprot.readStructBegin()
5879 
    while True:
5880 
      (fname, ftype, fid) = iprot.readFieldBegin()
5881 
      if ftype == TType.STOP:
5882 
        break
5883 
      if fid == 1:
5884 
        if ftype == TType.I64:
559 chandransh 5885 
          self.userid = iprot.readI64();
94 ashish 5886 
        else:
5887 
          iprot.skip(ftype)
5888 
      elif fid == 2:
559 chandransh 5889 
        if ftype == TType.STRING:
594 rajveer 5890 
          self.oldPassword = iprot.readString();
94 ashish 5891 
        else:
5892 
          iprot.skip(ftype)
594 rajveer 5893 
      elif fid == 3:
5894 
        if ftype == TType.STRING:
5895 
          self.newPassword = iprot.readString();
5896 
        else:
5897 
          iprot.skip(ftype)
94 ashish 5898 
      else:
5899 
        iprot.skip(ftype)
5900 
      iprot.readFieldEnd()
5901 
    iprot.readStructEnd()
5902 
 
5903 
  def write(self, oprot):
5904 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5905 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5906 
      return
559 chandransh 5907 
    oprot.writeStructBegin('updatePassword_args')
5908 
    if self.userid != None:
5909 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5910 
      oprot.writeI64(self.userid)
94 ashish 5911 
      oprot.writeFieldEnd()
594 rajveer 5912 
    if self.oldPassword != None:
5913 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
5914 
      oprot.writeString(self.oldPassword)
94 ashish 5915 
      oprot.writeFieldEnd()
594 rajveer 5916 
    if self.newPassword != None:
5917 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
5918 
      oprot.writeString(self.newPassword)
5919 
      oprot.writeFieldEnd()
94 ashish 5920 
    oprot.writeFieldStop()
5921 
    oprot.writeStructEnd()
5922 
 
5923 
  def __repr__(self):
5924 
    L = ['%s=%r' % (key, value)
5925 
      for key, value in self.__dict__.iteritems()]
5926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5927 
 
5928 
  def __eq__(self, other):
5929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5930 
 
5931 
  def __ne__(self, other):
5932 
    return not (self == other)
5933 
 
559 chandransh 5934 
class updatePassword_result:
94 ashish 5935 
  """
5936 
  Attributes:
5937 
   - success
5938 
   - ucx
5939 
  """
5940 
 
5941 
  thrift_spec = (
5942 
    (0, TType.BOOL, 'success', None, None, ), # 0
5943 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5944 
  )
5945 
 
5946 
  def __init__(self, success=None, ucx=None,):
5947 
    self.success = success
5948 
    self.ucx = ucx
5949 
 
5950 
  def read(self, iprot):
5951 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5952 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5953 
      return
5954 
    iprot.readStructBegin()
5955 
    while True:
5956 
      (fname, ftype, fid) = iprot.readFieldBegin()
5957 
      if ftype == TType.STOP:
5958 
        break
5959 
      if fid == 0:
5960 
        if ftype == TType.BOOL:
5961 
          self.success = iprot.readBool();
5962 
        else:
5963 
          iprot.skip(ftype)
5964 
      elif fid == 1:
5965 
        if ftype == TType.STRUCT:
5966 
          self.ucx = UserContextException()
5967 
          self.ucx.read(iprot)
5968 
        else:
5969 
          iprot.skip(ftype)
5970 
      else:
5971 
        iprot.skip(ftype)
5972 
      iprot.readFieldEnd()
5973 
    iprot.readStructEnd()
5974 
 
5975 
  def write(self, oprot):
5976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5978 
      return
559 chandransh 5979 
    oprot.writeStructBegin('updatePassword_result')
94 ashish 5980 
    if self.success != None:
5981 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5982 
      oprot.writeBool(self.success)
5983 
      oprot.writeFieldEnd()
5984 
    if self.ucx != None:
5985 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5986 
      self.ucx.write(oprot)
5987 
      oprot.writeFieldEnd()
5988 
    oprot.writeFieldStop()
5989 
    oprot.writeStructEnd()
5990 
 
5991 
  def __repr__(self):
5992 
    L = ['%s=%r' % (key, value)
5993 
      for key, value in self.__dict__.iteritems()]
5994 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5995 
 
5996 
  def __eq__(self, other):
5997 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5998 
 
5999 
  def __ne__(self, other):
6000 
    return not (self == other)
6001 
 
581 rajveer 6002 
class forgotPassword_args:
6003 
  """
6004 
  Attributes:
6005 
   - email
884 rajveer 6006 
   - newPassword
581 rajveer 6007 
  """
6008 
 
6009 
  thrift_spec = (
6010 
    None, # 0
6011 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 6012 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 6013 
  )
6014 
 
884 rajveer 6015 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 6016 
    self.email = email
884 rajveer 6017 
    self.newPassword = newPassword
581 rajveer 6018 
 
6019 
  def read(self, iprot):
6020 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6021 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6022 
      return
6023 
    iprot.readStructBegin()
6024 
    while True:
6025 
      (fname, ftype, fid) = iprot.readFieldBegin()
6026 
      if ftype == TType.STOP:
6027 
        break
6028 
      if fid == 1:
6029 
        if ftype == TType.STRING:
6030 
          self.email = iprot.readString();
6031 
        else:
6032 
          iprot.skip(ftype)
884 rajveer 6033 
      elif fid == 2:
6034 
        if ftype == TType.STRING:
6035 
          self.newPassword = iprot.readString();
6036 
        else:
6037 
          iprot.skip(ftype)
581 rajveer 6038 
      else:
6039 
        iprot.skip(ftype)
6040 
      iprot.readFieldEnd()
6041 
    iprot.readStructEnd()
6042 
 
6043 
  def write(self, oprot):
6044 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6045 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6046 
      return
6047 
    oprot.writeStructBegin('forgotPassword_args')
6048 
    if self.email != None:
6049 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6050 
      oprot.writeString(self.email)
6051 
      oprot.writeFieldEnd()
884 rajveer 6052 
    if self.newPassword != None:
6053 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
6054 
      oprot.writeString(self.newPassword)
6055 
      oprot.writeFieldEnd()
581 rajveer 6056 
    oprot.writeFieldStop()
6057 
    oprot.writeStructEnd()
6058 
 
6059 
  def __repr__(self):
6060 
    L = ['%s=%r' % (key, value)
6061 
      for key, value in self.__dict__.iteritems()]
6062 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6063 
 
6064 
  def __eq__(self, other):
6065 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6066 
 
6067 
  def __ne__(self, other):
6068 
    return not (self == other)
6069 
 
6070 
class forgotPassword_result:
6071 
  """
6072 
  Attributes:
6073 
   - success
6074 
   - ucx
6075 
  """
6076 
 
6077 
  thrift_spec = (
6078 
    (0, TType.BOOL, 'success', None, None, ), # 0
6079 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6080 
  )
6081 
 
6082 
  def __init__(self, success=None, ucx=None,):
6083 
    self.success = success
6084 
    self.ucx = ucx
6085 
 
6086 
  def read(self, iprot):
6087 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6088 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6089 
      return
6090 
    iprot.readStructBegin()
6091 
    while True:
6092 
      (fname, ftype, fid) = iprot.readFieldBegin()
6093 
      if ftype == TType.STOP:
6094 
        break
6095 
      if fid == 0:
6096 
        if ftype == TType.BOOL:
6097 
          self.success = iprot.readBool();
6098 
        else:
6099 
          iprot.skip(ftype)
6100 
      elif fid == 1:
6101 
        if ftype == TType.STRUCT:
6102 
          self.ucx = UserContextException()
6103 
          self.ucx.read(iprot)
6104 
        else:
6105 
          iprot.skip(ftype)
6106 
      else:
6107 
        iprot.skip(ftype)
6108 
      iprot.readFieldEnd()
6109 
    iprot.readStructEnd()
6110 
 
6111 
  def write(self, oprot):
6112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6114 
      return
6115 
    oprot.writeStructBegin('forgotPassword_result')
6116 
    if self.success != None:
6117 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6118 
      oprot.writeBool(self.success)
6119 
      oprot.writeFieldEnd()
6120 
    if self.ucx != None:
6121 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6122 
      self.ucx.write(oprot)
6123 
      oprot.writeFieldEnd()
6124 
    oprot.writeFieldStop()
6125 
    oprot.writeStructEnd()
6126 
 
6127 
  def __repr__(self):
6128 
    L = ['%s=%r' % (key, value)
6129 
      for key, value in self.__dict__.iteritems()]
6130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6131 
 
6132 
  def __eq__(self, other):
6133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6134 
 
6135 
  def __ne__(self, other):
6136 
    return not (self == other)
6137 
 
594 rajveer 6138 
class getAllAddressesForUser_args:
6139 
  """
6140 
  Attributes:
6141 
   - userId
6142 
  """
6143 
 
6144 
  thrift_spec = (
6145 
    None, # 0
6146 
    (1, TType.I64, 'userId', None, None, ), # 1
6147 
  )
6148 
 
6149 
  def __init__(self, userId=None,):
6150 
    self.userId = userId
6151 
 
6152 
  def read(self, iprot):
6153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6155 
      return
6156 
    iprot.readStructBegin()
6157 
    while True:
6158 
      (fname, ftype, fid) = iprot.readFieldBegin()
6159 
      if ftype == TType.STOP:
6160 
        break
6161 
      if fid == 1:
6162 
        if ftype == TType.I64:
6163 
          self.userId = iprot.readI64();
6164 
        else:
6165 
          iprot.skip(ftype)
6166 
      else:
6167 
        iprot.skip(ftype)
6168 
      iprot.readFieldEnd()
6169 
    iprot.readStructEnd()
6170 
 
6171 
  def write(self, oprot):
6172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6174 
      return
6175 
    oprot.writeStructBegin('getAllAddressesForUser_args')
6176 
    if self.userId != None:
6177 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6178 
      oprot.writeI64(self.userId)
6179 
      oprot.writeFieldEnd()
6180 
    oprot.writeFieldStop()
6181 
    oprot.writeStructEnd()
6182 
 
6183 
  def __repr__(self):
6184 
    L = ['%s=%r' % (key, value)
6185 
      for key, value in self.__dict__.iteritems()]
6186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6187 
 
6188 
  def __eq__(self, other):
6189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6190 
 
6191 
  def __ne__(self, other):
6192 
    return not (self == other)
6193 
 
6194 
class getAllAddressesForUser_result:
6195 
  """
6196 
  Attributes:
6197 
   - success
6198 
   - ucx
6199 
  """
6200 
 
6201 
  thrift_spec = (
6202 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
6203 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6204 
  )
6205 
 
6206 
  def __init__(self, success=None, ucx=None,):
6207 
    self.success = success
6208 
    self.ucx = ucx
6209 
 
6210 
  def read(self, iprot):
6211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6213 
      return
6214 
    iprot.readStructBegin()
6215 
    while True:
6216 
      (fname, ftype, fid) = iprot.readFieldBegin()
6217 
      if ftype == TType.STOP:
6218 
        break
6219 
      if fid == 0:
6220 
        if ftype == TType.LIST:
6221 
          self.success = []
3385 varun.gupt 6222 
          (_etype38, _size35) = iprot.readListBegin()
6223 
          for _i39 in xrange(_size35):
6224 
            _elem40 = Address()
6225 
            _elem40.read(iprot)
6226 
            self.success.append(_elem40)
594 rajveer 6227 
          iprot.readListEnd()
6228 
        else:
6229 
          iprot.skip(ftype)
6230 
      elif fid == 1:
6231 
        if ftype == TType.STRUCT:
6232 
          self.ucx = UserContextException()
6233 
          self.ucx.read(iprot)
6234 
        else:
6235 
          iprot.skip(ftype)
6236 
      else:
6237 
        iprot.skip(ftype)
6238 
      iprot.readFieldEnd()
6239 
    iprot.readStructEnd()
6240 
 
6241 
  def write(self, oprot):
6242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6244 
      return
6245 
    oprot.writeStructBegin('getAllAddressesForUser_result')
6246 
    if self.success != None:
6247 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6248 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3385 varun.gupt 6249 
      for iter41 in self.success:
6250 
        iter41.write(oprot)
594 rajveer 6251 
      oprot.writeListEnd()
6252 
      oprot.writeFieldEnd()
6253 
    if self.ucx != None:
6254 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6255 
      self.ucx.write(oprot)
6256 
      oprot.writeFieldEnd()
6257 
    oprot.writeFieldStop()
6258 
    oprot.writeStructEnd()
6259 
 
6260 
  def __repr__(self):
6261 
    L = ['%s=%r' % (key, value)
6262 
      for key, value in self.__dict__.iteritems()]
6263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6264 
 
6265 
  def __eq__(self, other):
6266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6267 
 
6268 
  def __ne__(self, other):
6269 
    return not (self == other)
6270 
 
1894 vikas 6271 
class getAddressById_args:
6272 
  """
6273 
  Attributes:
6274 
   - addressId
6275 
  """
6276 
 
6277 
  thrift_spec = (
6278 
    None, # 0
6279 
    (1, TType.I64, 'addressId', None, None, ), # 1
6280 
  )
6281 
 
6282 
  def __init__(self, addressId=None,):
6283 
    self.addressId = addressId
6284 
 
6285 
  def read(self, iprot):
6286 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6287 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6288 
      return
6289 
    iprot.readStructBegin()
6290 
    while True:
6291 
      (fname, ftype, fid) = iprot.readFieldBegin()
6292 
      if ftype == TType.STOP:
6293 
        break
6294 
      if fid == 1:
6295 
        if ftype == TType.I64:
6296 
          self.addressId = iprot.readI64();
6297 
        else:
6298 
          iprot.skip(ftype)
6299 
      else:
6300 
        iprot.skip(ftype)
6301 
      iprot.readFieldEnd()
6302 
    iprot.readStructEnd()
6303 
 
6304 
  def write(self, oprot):
6305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6307 
      return
6308 
    oprot.writeStructBegin('getAddressById_args')
6309 
    if self.addressId != None:
6310 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
6311 
      oprot.writeI64(self.addressId)
6312 
      oprot.writeFieldEnd()
6313 
    oprot.writeFieldStop()
6314 
    oprot.writeStructEnd()
6315 
 
6316 
  def __repr__(self):
6317 
    L = ['%s=%r' % (key, value)
6318 
      for key, value in self.__dict__.iteritems()]
6319 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6320 
 
6321 
  def __eq__(self, other):
6322 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6323 
 
6324 
  def __ne__(self, other):
6325 
    return not (self == other)
6326 
 
6327 
class getAddressById_result:
6328 
  """
6329 
  Attributes:
6330 
   - success
6331 
   - ucx
6332 
  """
6333 
 
6334 
  thrift_spec = (
6335 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
6336 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6337 
  )
6338 
 
6339 
  def __init__(self, success=None, ucx=None,):
6340 
    self.success = success
6341 
    self.ucx = ucx
6342 
 
6343 
  def read(self, iprot):
6344 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6345 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6346 
      return
6347 
    iprot.readStructBegin()
6348 
    while True:
6349 
      (fname, ftype, fid) = iprot.readFieldBegin()
6350 
      if ftype == TType.STOP:
6351 
        break
6352 
      if fid == 0:
6353 
        if ftype == TType.STRUCT:
6354 
          self.success = Address()
6355 
          self.success.read(iprot)
6356 
        else:
6357 
          iprot.skip(ftype)
6358 
      elif fid == 1:
6359 
        if ftype == TType.STRUCT:
6360 
          self.ucx = UserContextException()
6361 
          self.ucx.read(iprot)
6362 
        else:
6363 
          iprot.skip(ftype)
6364 
      else:
6365 
        iprot.skip(ftype)
6366 
      iprot.readFieldEnd()
6367 
    iprot.readStructEnd()
6368 
 
6369 
  def write(self, oprot):
6370 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6371 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6372 
      return
6373 
    oprot.writeStructBegin('getAddressById_result')
6374 
    if self.success != None:
6375 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6376 
      self.success.write(oprot)
6377 
      oprot.writeFieldEnd()
6378 
    if self.ucx != None:
6379 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6380 
      self.ucx.write(oprot)
6381 
      oprot.writeFieldEnd()
6382 
    oprot.writeFieldStop()
6383 
    oprot.writeStructEnd()
6384 
 
6385 
  def __repr__(self):
6386 
    L = ['%s=%r' % (key, value)
6387 
      for key, value in self.__dict__.iteritems()]
6388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6389 
 
6390 
  def __eq__(self, other):
6391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6392 
 
6393 
  def __ne__(self, other):
6394 
    return not (self == other)
6395 
 
594 rajveer 6396 
class getDefaultAddressId_args:
6397 
  """
6398 
  Attributes:
6399 
   - userId
6400 
  """
6401 
 
6402 
  thrift_spec = (
6403 
    None, # 0
6404 
    (1, TType.I64, 'userId', None, None, ), # 1
6405 
  )
6406 
 
6407 
  def __init__(self, userId=None,):
6408 
    self.userId = userId
6409 
 
6410 
  def read(self, iprot):
6411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6413 
      return
6414 
    iprot.readStructBegin()
6415 
    while True:
6416 
      (fname, ftype, fid) = iprot.readFieldBegin()
6417 
      if ftype == TType.STOP:
6418 
        break
6419 
      if fid == 1:
6420 
        if ftype == TType.I64:
6421 
          self.userId = iprot.readI64();
6422 
        else:
6423 
          iprot.skip(ftype)
6424 
      else:
6425 
        iprot.skip(ftype)
6426 
      iprot.readFieldEnd()
6427 
    iprot.readStructEnd()
6428 
 
6429 
  def write(self, oprot):
6430 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6431 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6432 
      return
6433 
    oprot.writeStructBegin('getDefaultAddressId_args')
6434 
    if self.userId != None:
6435 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6436 
      oprot.writeI64(self.userId)
6437 
      oprot.writeFieldEnd()
6438 
    oprot.writeFieldStop()
6439 
    oprot.writeStructEnd()
6440 
 
6441 
  def __repr__(self):
6442 
    L = ['%s=%r' % (key, value)
6443 
      for key, value in self.__dict__.iteritems()]
6444 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6445 
 
6446 
  def __eq__(self, other):
6447 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6448 
 
6449 
  def __ne__(self, other):
6450 
    return not (self == other)
6451 
 
6452 
class getDefaultAddressId_result:
6453 
  """
6454 
  Attributes:
6455 
   - success
6456 
   - ucx
6457 
  """
6458 
 
6459 
  thrift_spec = (
6460 
    (0, TType.I64, 'success', None, None, ), # 0
6461 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6462 
  )
6463 
 
6464 
  def __init__(self, success=None, ucx=None,):
6465 
    self.success = success
6466 
    self.ucx = ucx
6467 
 
6468 
  def read(self, iprot):
6469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6471 
      return
6472 
    iprot.readStructBegin()
6473 
    while True:
6474 
      (fname, ftype, fid) = iprot.readFieldBegin()
6475 
      if ftype == TType.STOP:
6476 
        break
6477 
      if fid == 0:
6478 
        if ftype == TType.I64:
6479 
          self.success = iprot.readI64();
6480 
        else:
6481 
          iprot.skip(ftype)
6482 
      elif fid == 1:
6483 
        if ftype == TType.STRUCT:
6484 
          self.ucx = UserContextException()
6485 
          self.ucx.read(iprot)
6486 
        else:
6487 
          iprot.skip(ftype)
6488 
      else:
6489 
        iprot.skip(ftype)
6490 
      iprot.readFieldEnd()
6491 
    iprot.readStructEnd()
6492 
 
6493 
  def write(self, oprot):
6494 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6495 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6496 
      return
6497 
    oprot.writeStructBegin('getDefaultAddressId_result')
6498 
    if self.success != None:
6499 
      oprot.writeFieldBegin('success', TType.I64, 0)
6500 
      oprot.writeI64(self.success)
6501 
      oprot.writeFieldEnd()
6502 
    if self.ucx != None:
6503 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6504 
      self.ucx.write(oprot)
6505 
      oprot.writeFieldEnd()
6506 
    oprot.writeFieldStop()
6507 
    oprot.writeStructEnd()
6508 
 
6509 
  def __repr__(self):
6510 
    L = ['%s=%r' % (key, value)
6511 
      for key, value in self.__dict__.iteritems()]
6512 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6513 
 
6514 
  def __eq__(self, other):
6515 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6516 
 
6517 
  def __ne__(self, other):
6518 
    return not (self == other)
6519 
 
785 rajveer 6520 
class getDefaultPincode_args:
6521 
  """
6522 
  Attributes:
6523 
   - userId
6524 
  """
6525 
 
6526 
  thrift_spec = (
6527 
    None, # 0
6528 
    (1, TType.I64, 'userId', None, None, ), # 1
6529 
  )
6530 
 
6531 
  def __init__(self, userId=None,):
6532 
    self.userId = userId
6533 
 
6534 
  def read(self, iprot):
6535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6537 
      return
6538 
    iprot.readStructBegin()
6539 
    while True:
6540 
      (fname, ftype, fid) = iprot.readFieldBegin()
6541 
      if ftype == TType.STOP:
6542 
        break
6543 
      if fid == 1:
6544 
        if ftype == TType.I64:
6545 
          self.userId = iprot.readI64();
6546 
        else:
6547 
          iprot.skip(ftype)
6548 
      else:
6549 
        iprot.skip(ftype)
6550 
      iprot.readFieldEnd()
6551 
    iprot.readStructEnd()
6552 
 
6553 
  def write(self, oprot):
6554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6556 
      return
6557 
    oprot.writeStructBegin('getDefaultPincode_args')
6558 
    if self.userId != None:
6559 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6560 
      oprot.writeI64(self.userId)
6561 
      oprot.writeFieldEnd()
6562 
    oprot.writeFieldStop()
6563 
    oprot.writeStructEnd()
6564 
 
6565 
  def __repr__(self):
6566 
    L = ['%s=%r' % (key, value)
6567 
      for key, value in self.__dict__.iteritems()]
6568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6569 
 
6570 
  def __eq__(self, other):
6571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6572 
 
6573 
  def __ne__(self, other):
6574 
    return not (self == other)
6575 
 
6576 
class getDefaultPincode_result:
6577 
  """
6578 
  Attributes:
6579 
   - success
6580 
   - ucx
6581 
  """
6582 
 
6583 
  thrift_spec = (
6584 
    (0, TType.STRING, 'success', None, None, ), # 0
6585 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6586 
  )
6587 
 
6588 
  def __init__(self, success=None, ucx=None,):
6589 
    self.success = success
6590 
    self.ucx = ucx
6591 
 
6592 
  def read(self, iprot):
6593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6595 
      return
6596 
    iprot.readStructBegin()
6597 
    while True:
6598 
      (fname, ftype, fid) = iprot.readFieldBegin()
6599 
      if ftype == TType.STOP:
6600 
        break
6601 
      if fid == 0:
6602 
        if ftype == TType.STRING:
6603 
          self.success = iprot.readString();
6604 
        else:
6605 
          iprot.skip(ftype)
6606 
      elif fid == 1:
6607 
        if ftype == TType.STRUCT:
6608 
          self.ucx = UserContextException()
6609 
          self.ucx.read(iprot)
6610 
        else:
6611 
          iprot.skip(ftype)
6612 
      else:
6613 
        iprot.skip(ftype)
6614 
      iprot.readFieldEnd()
6615 
    iprot.readStructEnd()
6616 
 
6617 
  def write(self, oprot):
6618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6620 
      return
6621 
    oprot.writeStructBegin('getDefaultPincode_result')
6622 
    if self.success != None:
6623 
      oprot.writeFieldBegin('success', TType.STRING, 0)
6624 
      oprot.writeString(self.success)
6625 
      oprot.writeFieldEnd()
6626 
    if self.ucx != None:
6627 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6628 
      self.ucx.write(oprot)
6629 
      oprot.writeFieldEnd()
6630 
    oprot.writeFieldStop()
6631 
    oprot.writeStructEnd()
6632 
 
6633 
  def __repr__(self):
6634 
    L = ['%s=%r' % (key, value)
6635 
      for key, value in self.__dict__.iteritems()]
6636 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6637 
 
6638 
  def __eq__(self, other):
6639 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6640 
 
6641 
  def __ne__(self, other):
6642 
    return not (self == other)
6643 
 
1274 varun.gupt 6644 
class saveUserCommunication_args:
6645 
  """
6646 
  Attributes:
6647 
   - userId
6648 
   - replyTo
6649 
   - communicationType
6650 
   - orderId
6651 
   - airwaybillNo
6652 
   - productName
6653 
   - subject
6654 
   - message
6655 
  """
6656 
 
6657 
  thrift_spec = (
6658 
    None, # 0
6659 
    (1, TType.I64, 'userId', None, None, ), # 1
6660 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
6661 
    (3, TType.I64, 'communicationType', None, None, ), # 3
6662 
    (4, TType.I64, 'orderId', None, None, ), # 4
6663 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
6664 
    (6, TType.STRING, 'productName', None, None, ), # 6
6665 
    (7, TType.STRING, 'subject', None, None, ), # 7
6666 
    (8, TType.STRING, 'message', None, None, ), # 8
6667 
  )
6668 
 
6669 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
6670 
    self.userId = userId
6671 
    self.replyTo = replyTo
6672 
    self.communicationType = communicationType
6673 
    self.orderId = orderId
6674 
    self.airwaybillNo = airwaybillNo
6675 
    self.productName = productName
6676 
    self.subject = subject
6677 
    self.message = message
6678 
 
6679 
  def read(self, iprot):
6680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6682 
      return
6683 
    iprot.readStructBegin()
6684 
    while True:
6685 
      (fname, ftype, fid) = iprot.readFieldBegin()
6686 
      if ftype == TType.STOP:
6687 
        break
6688 
      if fid == 1:
6689 
        if ftype == TType.I64:
6690 
          self.userId = iprot.readI64();
6691 
        else:
6692 
          iprot.skip(ftype)
6693 
      elif fid == 2:
6694 
        if ftype == TType.STRING:
6695 
          self.replyTo = iprot.readString();
6696 
        else:
6697 
          iprot.skip(ftype)
6698 
      elif fid == 3:
6699 
        if ftype == TType.I64:
6700 
          self.communicationType = iprot.readI64();
6701 
        else:
6702 
          iprot.skip(ftype)
6703 
      elif fid == 4:
6704 
        if ftype == TType.I64:
6705 
          self.orderId = iprot.readI64();
6706 
        else:
6707 
          iprot.skip(ftype)
6708 
      elif fid == 5:
6709 
        if ftype == TType.STRING:
6710 
          self.airwaybillNo = iprot.readString();
6711 
        else:
6712 
          iprot.skip(ftype)
6713 
      elif fid == 6:
6714 
        if ftype == TType.STRING:
6715 
          self.productName = iprot.readString();
6716 
        else:
6717 
          iprot.skip(ftype)
6718 
      elif fid == 7:
6719 
        if ftype == TType.STRING:
6720 
          self.subject = iprot.readString();
6721 
        else:
6722 
          iprot.skip(ftype)
6723 
      elif fid == 8:
6724 
        if ftype == TType.STRING:
6725 
          self.message = iprot.readString();
6726 
        else:
6727 
          iprot.skip(ftype)
6728 
      else:
6729 
        iprot.skip(ftype)
6730 
      iprot.readFieldEnd()
6731 
    iprot.readStructEnd()
6732 
 
6733 
  def write(self, oprot):
6734 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6735 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6736 
      return
6737 
    oprot.writeStructBegin('saveUserCommunication_args')
6738 
    if self.userId != None:
6739 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6740 
      oprot.writeI64(self.userId)
6741 
      oprot.writeFieldEnd()
6742 
    if self.replyTo != None:
6743 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
6744 
      oprot.writeString(self.replyTo)
6745 
      oprot.writeFieldEnd()
6746 
    if self.communicationType != None:
6747 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
6748 
      oprot.writeI64(self.communicationType)
6749 
      oprot.writeFieldEnd()
6750 
    if self.orderId != None:
6751 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
6752 
      oprot.writeI64(self.orderId)
6753 
      oprot.writeFieldEnd()
6754 
    if self.airwaybillNo != None:
6755 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
6756 
      oprot.writeString(self.airwaybillNo)
6757 
      oprot.writeFieldEnd()
6758 
    if self.productName != None:
6759 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
6760 
      oprot.writeString(self.productName)
6761 
      oprot.writeFieldEnd()
6762 
    if self.subject != None:
6763 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
6764 
      oprot.writeString(self.subject)
6765 
      oprot.writeFieldEnd()
6766 
    if self.message != None:
6767 
      oprot.writeFieldBegin('message', TType.STRING, 8)
6768 
      oprot.writeString(self.message)
6769 
      oprot.writeFieldEnd()
6770 
    oprot.writeFieldStop()
6771 
    oprot.writeStructEnd()
6772 
 
6773 
  def __repr__(self):
6774 
    L = ['%s=%r' % (key, value)
6775 
      for key, value in self.__dict__.iteritems()]
6776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6777 
 
6778 
  def __eq__(self, other):
6779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6780 
 
6781 
  def __ne__(self, other):
6782 
    return not (self == other)
6783 
 
6784 
class saveUserCommunication_result:
6785 
  """
6786 
  Attributes:
6787 
   - success
6788 
   - ucx
6789 
  """
6790 
 
6791 
  thrift_spec = (
6792 
    (0, TType.BOOL, 'success', None, None, ), # 0
6793 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6794 
  )
6795 
 
6796 
  def __init__(self, success=None, ucx=None,):
6797 
    self.success = success
6798 
    self.ucx = ucx
6799 
 
6800 
  def read(self, iprot):
6801 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6802 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6803 
      return
6804 
    iprot.readStructBegin()
6805 
    while True:
6806 
      (fname, ftype, fid) = iprot.readFieldBegin()
6807 
      if ftype == TType.STOP:
6808 
        break
6809 
      if fid == 0:
6810 
        if ftype == TType.BOOL:
6811 
          self.success = iprot.readBool();
6812 
        else:
6813 
          iprot.skip(ftype)
6814 
      elif fid == 1:
6815 
        if ftype == TType.STRUCT:
6816 
          self.ucx = UserCommunicationException()
6817 
          self.ucx.read(iprot)
6818 
        else:
6819 
          iprot.skip(ftype)
6820 
      else:
6821 
        iprot.skip(ftype)
6822 
      iprot.readFieldEnd()
6823 
    iprot.readStructEnd()
6824 
 
6825 
  def write(self, oprot):
6826 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6827 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6828 
      return
6829 
    oprot.writeStructBegin('saveUserCommunication_result')
6830 
    if self.success != None:
6831 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6832 
      oprot.writeBool(self.success)
6833 
      oprot.writeFieldEnd()
6834 
    if self.ucx != None:
6835 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6836 
      self.ucx.write(oprot)
6837 
      oprot.writeFieldEnd()
6838 
    oprot.writeFieldStop()
6839 
    oprot.writeStructEnd()
6840 
 
6841 
  def __repr__(self):
6842 
    L = ['%s=%r' % (key, value)
6843 
      for key, value in self.__dict__.iteritems()]
6844 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6845 
 
6846 
  def __eq__(self, other):
6847 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6848 
 
6849 
  def __ne__(self, other):
6850 
    return not (self == other)
6851 
 
1590 varun.gupt 6852 
class getUserCommunicationById_args:
6853 
  """
6854 
  Attributes:
6855 
   - id
6856 
  """
6857 
 
6858 
  thrift_spec = (
6859 
    None, # 0
6860 
    (1, TType.I64, 'id', None, None, ), # 1
6861 
  )
6862 
 
6863 
  def __init__(self, id=None,):
6864 
    self.id = id
6865 
 
6866 
  def read(self, iprot):
6867 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6868 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6869 
      return
6870 
    iprot.readStructBegin()
6871 
    while True:
6872 
      (fname, ftype, fid) = iprot.readFieldBegin()
6873 
      if ftype == TType.STOP:
6874 
        break
6875 
      if fid == 1:
6876 
        if ftype == TType.I64:
6877 
          self.id = iprot.readI64();
6878 
        else:
6879 
          iprot.skip(ftype)
6880 
      else:
6881 
        iprot.skip(ftype)
6882 
      iprot.readFieldEnd()
6883 
    iprot.readStructEnd()
6884 
 
6885 
  def write(self, oprot):
6886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6888 
      return
6889 
    oprot.writeStructBegin('getUserCommunicationById_args')
6890 
    if self.id != None:
6891 
      oprot.writeFieldBegin('id', TType.I64, 1)
6892 
      oprot.writeI64(self.id)
6893 
      oprot.writeFieldEnd()
6894 
    oprot.writeFieldStop()
6895 
    oprot.writeStructEnd()
6896 
 
6897 
  def __repr__(self):
6898 
    L = ['%s=%r' % (key, value)
6899 
      for key, value in self.__dict__.iteritems()]
6900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6901 
 
6902 
  def __eq__(self, other):
6903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6904 
 
6905 
  def __ne__(self, other):
6906 
    return not (self == other)
6907 
 
6908 
class getUserCommunicationById_result:
6909 
  """
6910 
  Attributes:
6911 
   - success
6912 
   - ucx
6913 
  """
6914 
 
6915 
  thrift_spec = (
6916 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
6917 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6918 
  )
6919 
 
6920 
  def __init__(self, success=None, ucx=None,):
6921 
    self.success = success
6922 
    self.ucx = ucx
6923 
 
6924 
  def read(self, iprot):
6925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6927 
      return
6928 
    iprot.readStructBegin()
6929 
    while True:
6930 
      (fname, ftype, fid) = iprot.readFieldBegin()
6931 
      if ftype == TType.STOP:
6932 
        break
6933 
      if fid == 0:
6934 
        if ftype == TType.STRUCT:
6935 
          self.success = UserCommunication()
6936 
          self.success.read(iprot)
6937 
        else:
6938 
          iprot.skip(ftype)
6939 
      elif fid == 1:
6940 
        if ftype == TType.STRUCT:
6941 
          self.ucx = UserCommunicationException()
6942 
          self.ucx.read(iprot)
6943 
        else:
6944 
          iprot.skip(ftype)
6945 
      else:
6946 
        iprot.skip(ftype)
6947 
      iprot.readFieldEnd()
6948 
    iprot.readStructEnd()
6949 
 
6950 
  def write(self, oprot):
6951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6953 
      return
6954 
    oprot.writeStructBegin('getUserCommunicationById_result')
6955 
    if self.success != None:
6956 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6957 
      self.success.write(oprot)
6958 
      oprot.writeFieldEnd()
6959 
    if self.ucx != None:
6960 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6961 
      self.ucx.write(oprot)
6962 
      oprot.writeFieldEnd()
6963 
    oprot.writeFieldStop()
6964 
    oprot.writeStructEnd()
6965 
 
6966 
  def __repr__(self):
6967 
    L = ['%s=%r' % (key, value)
6968 
      for key, value in self.__dict__.iteritems()]
6969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6970 
 
6971 
  def __eq__(self, other):
6972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6973 
 
6974 
  def __ne__(self, other):
6975 
    return not (self == other)
6976 
 
6977 
class getUserCommunicationByUser_args:
6978 
  """
6979 
  Attributes:
6980 
   - userId
6981 
  """
6982 
 
6983 
  thrift_spec = (
6984 
    None, # 0
6985 
    (1, TType.I64, 'userId', None, None, ), # 1
6986 
  )
6987 
 
6988 
  def __init__(self, userId=None,):
6989 
    self.userId = userId
6990 
 
6991 
  def read(self, iprot):
6992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6994 
      return
6995 
    iprot.readStructBegin()
6996 
    while True:
6997 
      (fname, ftype, fid) = iprot.readFieldBegin()
6998 
      if ftype == TType.STOP:
6999 
        break
7000 
      if fid == 1:
7001 
        if ftype == TType.I64:
7002 
          self.userId = iprot.readI64();
7003 
        else:
7004 
          iprot.skip(ftype)
7005 
      else:
7006 
        iprot.skip(ftype)
7007 
      iprot.readFieldEnd()
7008 
    iprot.readStructEnd()
7009 
 
7010 
  def write(self, oprot):
7011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7013 
      return
7014 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
7015 
    if self.userId != None:
7016 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7017 
      oprot.writeI64(self.userId)
7018 
      oprot.writeFieldEnd()
7019 
    oprot.writeFieldStop()
7020 
    oprot.writeStructEnd()
7021 
 
7022 
  def __repr__(self):
7023 
    L = ['%s=%r' % (key, value)
7024 
      for key, value in self.__dict__.iteritems()]
7025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7026 
 
7027 
  def __eq__(self, other):
7028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7029 
 
7030 
  def __ne__(self, other):
7031 
    return not (self == other)
7032 
 
7033 
class getUserCommunicationByUser_result:
7034 
  """
7035 
  Attributes:
7036 
   - success
7037 
   - ucx
7038 
  """
7039 
 
7040 
  thrift_spec = (
7041 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
7042 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7043 
  )
7044 
 
7045 
  def __init__(self, success=None, ucx=None,):
7046 
    self.success = success
7047 
    self.ucx = ucx
7048 
 
7049 
  def read(self, iprot):
7050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7052 
      return
7053 
    iprot.readStructBegin()
7054 
    while True:
7055 
      (fname, ftype, fid) = iprot.readFieldBegin()
7056 
      if ftype == TType.STOP:
7057 
        break
7058 
      if fid == 0:
7059 
        if ftype == TType.LIST:
7060 
          self.success = []
3385 varun.gupt 7061 
          (_etype45, _size42) = iprot.readListBegin()
7062 
          for _i46 in xrange(_size42):
7063 
            _elem47 = UserCommunication()
7064 
            _elem47.read(iprot)
7065 
            self.success.append(_elem47)
1590 varun.gupt 7066 
          iprot.readListEnd()
7067 
        else:
7068 
          iprot.skip(ftype)
7069 
      elif fid == 1:
7070 
        if ftype == TType.STRUCT:
7071 
          self.ucx = UserCommunicationException()
7072 
          self.ucx.read(iprot)
7073 
        else:
7074 
          iprot.skip(ftype)
7075 
      else:
7076 
        iprot.skip(ftype)
7077 
      iprot.readFieldEnd()
7078 
    iprot.readStructEnd()
7079 
 
7080 
  def write(self, oprot):
7081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7083 
      return
7084 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
7085 
    if self.success != None:
7086 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7087 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3385 varun.gupt 7088 
      for iter48 in self.success:
7089 
        iter48.write(oprot)
1590 varun.gupt 7090 
      oprot.writeListEnd()
7091 
      oprot.writeFieldEnd()
7092 
    if self.ucx != None:
7093 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7094 
      self.ucx.write(oprot)
7095 
      oprot.writeFieldEnd()
7096 
    oprot.writeFieldStop()
7097 
    oprot.writeStructEnd()
7098 
 
7099 
  def __repr__(self):
7100 
    L = ['%s=%r' % (key, value)
7101 
      for key, value in self.__dict__.iteritems()]
7102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7103 
 
7104 
  def __eq__(self, other):
7105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7106 
 
7107 
  def __ne__(self, other):
7108 
    return not (self == other)
7109 
 
7110 
class getAllUserCommunications_args:
7111 
 
7112 
  thrift_spec = (
7113 
  )
7114 
 
7115 
  def read(self, iprot):
7116 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7117 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7118 
      return
7119 
    iprot.readStructBegin()
7120 
    while True:
7121 
      (fname, ftype, fid) = iprot.readFieldBegin()
7122 
      if ftype == TType.STOP:
7123 
        break
7124 
      else:
7125 
        iprot.skip(ftype)
7126 
      iprot.readFieldEnd()
7127 
    iprot.readStructEnd()
7128 
 
7129 
  def write(self, oprot):
7130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7132 
      return
7133 
    oprot.writeStructBegin('getAllUserCommunications_args')
7134 
    oprot.writeFieldStop()
7135 
    oprot.writeStructEnd()
7136 
 
7137 
  def __repr__(self):
7138 
    L = ['%s=%r' % (key, value)
7139 
      for key, value in self.__dict__.iteritems()]
7140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7141 
 
7142 
  def __eq__(self, other):
7143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7144 
 
7145 
  def __ne__(self, other):
7146 
    return not (self == other)
7147 
 
7148 
class getAllUserCommunications_result:
7149 
  """
7150 
  Attributes:
7151 
   - success
7152 
   - ucx
7153 
  """
7154 
 
7155 
  thrift_spec = (
7156 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
7157 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7158 
  )
7159 
 
7160 
  def __init__(self, success=None, ucx=None,):
7161 
    self.success = success
7162 
    self.ucx = ucx
7163 
 
7164 
  def read(self, iprot):
7165 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7166 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7167 
      return
7168 
    iprot.readStructBegin()
7169 
    while True:
7170 
      (fname, ftype, fid) = iprot.readFieldBegin()
7171 
      if ftype == TType.STOP:
7172 
        break
7173 
      if fid == 0:
7174 
        if ftype == TType.LIST:
7175 
          self.success = []
3385 varun.gupt 7176 
          (_etype52, _size49) = iprot.readListBegin()
7177 
          for _i53 in xrange(_size49):
7178 
            _elem54 = UserCommunication()
7179 
            _elem54.read(iprot)
7180 
            self.success.append(_elem54)
1590 varun.gupt 7181 
          iprot.readListEnd()
7182 
        else:
7183 
          iprot.skip(ftype)
7184 
      elif fid == 1:
7185 
        if ftype == TType.STRUCT:
7186 
          self.ucx = UserCommunicationException()
7187 
          self.ucx.read(iprot)
7188 
        else:
7189 
          iprot.skip(ftype)
7190 
      else:
7191 
        iprot.skip(ftype)
7192 
      iprot.readFieldEnd()
7193 
    iprot.readStructEnd()
7194 
 
7195 
  def write(self, oprot):
7196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7198 
      return
7199 
    oprot.writeStructBegin('getAllUserCommunications_result')
7200 
    if self.success != None:
7201 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7202 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3385 varun.gupt 7203 
      for iter55 in self.success:
7204 
        iter55.write(oprot)
1590 varun.gupt 7205 
      oprot.writeListEnd()
7206 
      oprot.writeFieldEnd()
7207 
    if self.ucx != None:
7208 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7209 
      self.ucx.write(oprot)
7210 
      oprot.writeFieldEnd()
7211 
    oprot.writeFieldStop()
7212 
    oprot.writeStructEnd()
7213 
 
7214 
  def __repr__(self):
7215 
    L = ['%s=%r' % (key, value)
7216 
      for key, value in self.__dict__.iteritems()]
7217 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7218 
 
7219 
  def __eq__(self, other):
7220 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7221 
 
7222 
  def __ne__(self, other):
7223 
    return not (self == other)
7224 
 
1845 vikas 7225 
class createMasterAffiliate_args:
7226 
  """
7227 
  Attributes:
7228 
   - name
1859 vikas 7229 
   - addedOn
1845 vikas 7230 
  """
7231 
 
7232 
  thrift_spec = (
7233 
    None, # 0
7234 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 7235 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 7236 
  )
7237 
 
1859 vikas 7238 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 7239 
    self.name = name
1859 vikas 7240 
    self.addedOn = addedOn
1845 vikas 7241 
 
7242 
  def read(self, iprot):
7243 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7244 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7245 
      return
7246 
    iprot.readStructBegin()
7247 
    while True:
7248 
      (fname, ftype, fid) = iprot.readFieldBegin()
7249 
      if ftype == TType.STOP:
7250 
        break
7251 
      if fid == 1:
7252 
        if ftype == TType.STRING:
7253 
          self.name = iprot.readString();
7254 
        else:
7255 
          iprot.skip(ftype)
1859 vikas 7256 
      elif fid == 2:
7257 
        if ftype == TType.I64:
7258 
          self.addedOn = iprot.readI64();
7259 
        else:
7260 
          iprot.skip(ftype)
1845 vikas 7261 
      else:
7262 
        iprot.skip(ftype)
7263 
      iprot.readFieldEnd()
7264 
    iprot.readStructEnd()
7265 
 
7266 
  def write(self, oprot):
7267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7269 
      return
7270 
    oprot.writeStructBegin('createMasterAffiliate_args')
7271 
    if self.name != None:
7272 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7273 
      oprot.writeString(self.name)
7274 
      oprot.writeFieldEnd()
1859 vikas 7275 
    if self.addedOn != None:
7276 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
7277 
      oprot.writeI64(self.addedOn)
7278 
      oprot.writeFieldEnd()
1845 vikas 7279 
    oprot.writeFieldStop()
7280 
    oprot.writeStructEnd()
7281 
 
7282 
  def __repr__(self):
7283 
    L = ['%s=%r' % (key, value)
7284 
      for key, value in self.__dict__.iteritems()]
7285 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7286 
 
7287 
  def __eq__(self, other):
7288 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7289 
 
7290 
  def __ne__(self, other):
7291 
    return not (self == other)
7292 
 
7293 
class createMasterAffiliate_result:
7294 
  """
7295 
  Attributes:
7296 
   - success
7297 
   - utx
7298 
  """
7299 
 
7300 
  thrift_spec = (
7301 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7302 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7303 
  )
7304 
 
7305 
  def __init__(self, success=None, utx=None,):
7306 
    self.success = success
7307 
    self.utx = utx
7308 
 
7309 
  def read(self, iprot):
7310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7312 
      return
7313 
    iprot.readStructBegin()
7314 
    while True:
7315 
      (fname, ftype, fid) = iprot.readFieldBegin()
7316 
      if ftype == TType.STOP:
7317 
        break
7318 
      if fid == 0:
7319 
        if ftype == TType.STRUCT:
7320 
          self.success = MasterAffiliate()
7321 
          self.success.read(iprot)
7322 
        else:
7323 
          iprot.skip(ftype)
7324 
      elif fid == 1:
7325 
        if ftype == TType.STRUCT:
1996 vikas 7326 
          self.utx = UserAffiliateException()
1845 vikas 7327 
          self.utx.read(iprot)
7328 
        else:
7329 
          iprot.skip(ftype)
7330 
      else:
7331 
        iprot.skip(ftype)
7332 
      iprot.readFieldEnd()
7333 
    iprot.readStructEnd()
7334 
 
7335 
  def write(self, oprot):
7336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7338 
      return
7339 
    oprot.writeStructBegin('createMasterAffiliate_result')
7340 
    if self.success != None:
7341 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7342 
      self.success.write(oprot)
7343 
      oprot.writeFieldEnd()
7344 
    if self.utx != None:
7345 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7346 
      self.utx.write(oprot)
7347 
      oprot.writeFieldEnd()
7348 
    oprot.writeFieldStop()
7349 
    oprot.writeStructEnd()
7350 
 
7351 
  def __repr__(self):
7352 
    L = ['%s=%r' % (key, value)
7353 
      for key, value in self.__dict__.iteritems()]
7354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7355 
 
7356 
  def __eq__(self, other):
7357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7358 
 
7359 
  def __ne__(self, other):
7360 
    return not (self == other)
7361 
 
1899 vikas 7362 
class getAllMasterAffiliates_args:
7363 
 
7364 
  thrift_spec = (
7365 
  )
7366 
 
7367 
  def read(self, iprot):
7368 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7369 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7370 
      return
7371 
    iprot.readStructBegin()
7372 
    while True:
7373 
      (fname, ftype, fid) = iprot.readFieldBegin()
7374 
      if ftype == TType.STOP:
7375 
        break
7376 
      else:
7377 
        iprot.skip(ftype)
7378 
      iprot.readFieldEnd()
7379 
    iprot.readStructEnd()
7380 
 
7381 
  def write(self, oprot):
7382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7384 
      return
7385 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
7386 
    oprot.writeFieldStop()
7387 
    oprot.writeStructEnd()
7388 
 
7389 
  def __repr__(self):
7390 
    L = ['%s=%r' % (key, value)
7391 
      for key, value in self.__dict__.iteritems()]
7392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7393 
 
7394 
  def __eq__(self, other):
7395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7396 
 
7397 
  def __ne__(self, other):
7398 
    return not (self == other)
7399 
 
7400 
class getAllMasterAffiliates_result:
7401 
  """
7402 
  Attributes:
7403 
   - success
7404 
   - utx
7405 
  """
7406 
 
7407 
  thrift_spec = (
7408 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 7409 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 7410 
  )
7411 
 
7412 
  def __init__(self, success=None, utx=None,):
7413 
    self.success = success
7414 
    self.utx = utx
7415 
 
7416 
  def read(self, iprot):
7417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7419 
      return
7420 
    iprot.readStructBegin()
7421 
    while True:
7422 
      (fname, ftype, fid) = iprot.readFieldBegin()
7423 
      if ftype == TType.STOP:
7424 
        break
7425 
      if fid == 0:
7426 
        if ftype == TType.LIST:
7427 
          self.success = []
3385 varun.gupt 7428 
          (_etype59, _size56) = iprot.readListBegin()
7429 
          for _i60 in xrange(_size56):
7430 
            _elem61 = MasterAffiliate()
7431 
            _elem61.read(iprot)
7432 
            self.success.append(_elem61)
1899 vikas 7433 
          iprot.readListEnd()
7434 
        else:
7435 
          iprot.skip(ftype)
7436 
      elif fid == 1:
7437 
        if ftype == TType.STRUCT:
1996 vikas 7438 
          self.utx = UserAffiliateException()
1899 vikas 7439 
          self.utx.read(iprot)
7440 
        else:
7441 
          iprot.skip(ftype)
7442 
      else:
7443 
        iprot.skip(ftype)
7444 
      iprot.readFieldEnd()
7445 
    iprot.readStructEnd()
7446 
 
7447 
  def write(self, oprot):
7448 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7449 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7450 
      return
7451 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
7452 
    if self.success != None:
7453 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7454 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3385 varun.gupt 7455 
      for iter62 in self.success:
7456 
        iter62.write(oprot)
1899 vikas 7457 
      oprot.writeListEnd()
7458 
      oprot.writeFieldEnd()
7459 
    if self.utx != None:
7460 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7461 
      self.utx.write(oprot)
7462 
      oprot.writeFieldEnd()
7463 
    oprot.writeFieldStop()
7464 
    oprot.writeStructEnd()
7465 
 
7466 
  def __repr__(self):
7467 
    L = ['%s=%r' % (key, value)
7468 
      for key, value in self.__dict__.iteritems()]
7469 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7470 
 
7471 
  def __eq__(self, other):
7472 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7473 
 
7474 
  def __ne__(self, other):
7475 
    return not (self == other)
7476 
 
1845 vikas 7477 
class getMasterAffiliateById_args:
7478 
  """
7479 
  Attributes:
7480 
   - id
7481 
  """
7482 
 
7483 
  thrift_spec = (
7484 
    None, # 0
7485 
    (1, TType.I64, 'id', None, None, ), # 1
7486 
  )
7487 
 
7488 
  def __init__(self, id=None,):
7489 
    self.id = id
7490 
 
7491 
  def read(self, iprot):
7492 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7493 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7494 
      return
7495 
    iprot.readStructBegin()
7496 
    while True:
7497 
      (fname, ftype, fid) = iprot.readFieldBegin()
7498 
      if ftype == TType.STOP:
7499 
        break
7500 
      if fid == 1:
7501 
        if ftype == TType.I64:
7502 
          self.id = iprot.readI64();
7503 
        else:
7504 
          iprot.skip(ftype)
7505 
      else:
7506 
        iprot.skip(ftype)
7507 
      iprot.readFieldEnd()
7508 
    iprot.readStructEnd()
7509 
 
7510 
  def write(self, oprot):
7511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7513 
      return
7514 
    oprot.writeStructBegin('getMasterAffiliateById_args')
7515 
    if self.id != None:
7516 
      oprot.writeFieldBegin('id', TType.I64, 1)
7517 
      oprot.writeI64(self.id)
7518 
      oprot.writeFieldEnd()
7519 
    oprot.writeFieldStop()
7520 
    oprot.writeStructEnd()
7521 
 
7522 
  def __repr__(self):
7523 
    L = ['%s=%r' % (key, value)
7524 
      for key, value in self.__dict__.iteritems()]
7525 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7526 
 
7527 
  def __eq__(self, other):
7528 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7529 
 
7530 
  def __ne__(self, other):
7531 
    return not (self == other)
7532 
 
7533 
class getMasterAffiliateById_result:
7534 
  """
7535 
  Attributes:
7536 
   - success
7537 
   - utx
7538 
  """
7539 
 
7540 
  thrift_spec = (
7541 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7542 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7543 
  )
7544 
 
7545 
  def __init__(self, success=None, utx=None,):
7546 
    self.success = success
7547 
    self.utx = utx
7548 
 
7549 
  def read(self, iprot):
7550 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7551 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7552 
      return
7553 
    iprot.readStructBegin()
7554 
    while True:
7555 
      (fname, ftype, fid) = iprot.readFieldBegin()
7556 
      if ftype == TType.STOP:
7557 
        break
7558 
      if fid == 0:
7559 
        if ftype == TType.STRUCT:
7560 
          self.success = MasterAffiliate()
7561 
          self.success.read(iprot)
7562 
        else:
7563 
          iprot.skip(ftype)
7564 
      elif fid == 1:
7565 
        if ftype == TType.STRUCT:
1996 vikas 7566 
          self.utx = UserAffiliateException()
1845 vikas 7567 
          self.utx.read(iprot)
7568 
        else:
7569 
          iprot.skip(ftype)
7570 
      else:
7571 
        iprot.skip(ftype)
7572 
      iprot.readFieldEnd()
7573 
    iprot.readStructEnd()
7574 
 
7575 
  def write(self, oprot):
7576 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7577 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7578 
      return
7579 
    oprot.writeStructBegin('getMasterAffiliateById_result')
7580 
    if self.success != None:
7581 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7582 
      self.success.write(oprot)
7583 
      oprot.writeFieldEnd()
7584 
    if self.utx != None:
7585 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7586 
      self.utx.write(oprot)
7587 
      oprot.writeFieldEnd()
7588 
    oprot.writeFieldStop()
7589 
    oprot.writeStructEnd()
7590 
 
7591 
  def __repr__(self):
7592 
    L = ['%s=%r' % (key, value)
7593 
      for key, value in self.__dict__.iteritems()]
7594 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7595 
 
7596 
  def __eq__(self, other):
7597 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7598 
 
7599 
  def __ne__(self, other):
7600 
    return not (self == other)
7601 
 
7602 
class getMasterAffiliateByName_args:
7603 
  """
7604 
  Attributes:
7605 
   - name
7606 
  """
7607 
 
7608 
  thrift_spec = (
7609 
    None, # 0
7610 
    (1, TType.STRING, 'name', None, None, ), # 1
7611 
  )
7612 
 
7613 
  def __init__(self, name=None,):
7614 
    self.name = name
7615 
 
7616 
  def read(self, iprot):
7617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7619 
      return
7620 
    iprot.readStructBegin()
7621 
    while True:
7622 
      (fname, ftype, fid) = iprot.readFieldBegin()
7623 
      if ftype == TType.STOP:
7624 
        break
7625 
      if fid == 1:
7626 
        if ftype == TType.STRING:
7627 
          self.name = iprot.readString();
7628 
        else:
7629 
          iprot.skip(ftype)
7630 
      else:
7631 
        iprot.skip(ftype)
7632 
      iprot.readFieldEnd()
7633 
    iprot.readStructEnd()
7634 
 
7635 
  def write(self, oprot):
7636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7638 
      return
7639 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
7640 
    if self.name != None:
7641 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7642 
      oprot.writeString(self.name)
7643 
      oprot.writeFieldEnd()
7644 
    oprot.writeFieldStop()
7645 
    oprot.writeStructEnd()
7646 
 
7647 
  def __repr__(self):
7648 
    L = ['%s=%r' % (key, value)
7649 
      for key, value in self.__dict__.iteritems()]
7650 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7651 
 
7652 
  def __eq__(self, other):
7653 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7654 
 
7655 
  def __ne__(self, other):
7656 
    return not (self == other)
7657 
 
7658 
class getMasterAffiliateByName_result:
7659 
  """
7660 
  Attributes:
7661 
   - success
7662 
   - utx
7663 
  """
7664 
 
7665 
  thrift_spec = (
7666 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7667 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7668 
  )
7669 
 
7670 
  def __init__(self, success=None, utx=None,):
7671 
    self.success = success
7672 
    self.utx = utx
7673 
 
7674 
  def read(self, iprot):
7675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7677 
      return
7678 
    iprot.readStructBegin()
7679 
    while True:
7680 
      (fname, ftype, fid) = iprot.readFieldBegin()
7681 
      if ftype == TType.STOP:
7682 
        break
7683 
      if fid == 0:
7684 
        if ftype == TType.STRUCT:
7685 
          self.success = MasterAffiliate()
7686 
          self.success.read(iprot)
7687 
        else:
7688 
          iprot.skip(ftype)
7689 
      elif fid == 1:
7690 
        if ftype == TType.STRUCT:
1996 vikas 7691 
          self.utx = UserAffiliateException()
1845 vikas 7692 
          self.utx.read(iprot)
7693 
        else:
7694 
          iprot.skip(ftype)
7695 
      else:
7696 
        iprot.skip(ftype)
7697 
      iprot.readFieldEnd()
7698 
    iprot.readStructEnd()
7699 
 
7700 
  def write(self, oprot):
7701 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7702 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7703 
      return
7704 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
7705 
    if self.success != None:
7706 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7707 
      self.success.write(oprot)
7708 
      oprot.writeFieldEnd()
7709 
    if self.utx != None:
7710 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7711 
      self.utx.write(oprot)
7712 
      oprot.writeFieldEnd()
7713 
    oprot.writeFieldStop()
7714 
    oprot.writeStructEnd()
7715 
 
7716 
  def __repr__(self):
7717 
    L = ['%s=%r' % (key, value)
7718 
      for key, value in self.__dict__.iteritems()]
7719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7720 
 
7721 
  def __eq__(self, other):
7722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7723 
 
7724 
  def __ne__(self, other):
7725 
    return not (self == other)
7726 
 
7727 
class createAffiliate_args:
7728 
  """
7729 
  Attributes:
7730 
   - name
7731 
   - url
7732 
   - masterAffiliateId
1859 vikas 7733 
   - addedOn
1845 vikas 7734 
  """
7735 
 
7736 
  thrift_spec = (
7737 
    None, # 0
7738 
    (1, TType.STRING, 'name', None, None, ), # 1
7739 
    (2, TType.STRING, 'url', None, None, ), # 2
7740 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 7741 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 7742 
  )
7743 
 
1859 vikas 7744 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 7745 
    self.name = name
7746 
    self.url = url
7747 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 7748 
    self.addedOn = addedOn
1845 vikas 7749 
 
7750 
  def read(self, iprot):
7751 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7752 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7753 
      return
7754 
    iprot.readStructBegin()
7755 
    while True:
7756 
      (fname, ftype, fid) = iprot.readFieldBegin()
7757 
      if ftype == TType.STOP:
7758 
        break
7759 
      if fid == 1:
7760 
        if ftype == TType.STRING:
7761 
          self.name = iprot.readString();
7762 
        else:
7763 
          iprot.skip(ftype)
7764 
      elif fid == 2:
7765 
        if ftype == TType.STRING:
7766 
          self.url = iprot.readString();
7767 
        else:
7768 
          iprot.skip(ftype)
7769 
      elif fid == 3:
7770 
        if ftype == TType.I64:
7771 
          self.masterAffiliateId = iprot.readI64();
7772 
        else:
7773 
          iprot.skip(ftype)
1859 vikas 7774 
      elif fid == 4:
7775 
        if ftype == TType.I64:
7776 
          self.addedOn = iprot.readI64();
7777 
        else:
7778 
          iprot.skip(ftype)
1845 vikas 7779 
      else:
7780 
        iprot.skip(ftype)
7781 
      iprot.readFieldEnd()
7782 
    iprot.readStructEnd()
7783 
 
7784 
  def write(self, oprot):
7785 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7786 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7787 
      return
7788 
    oprot.writeStructBegin('createAffiliate_args')
7789 
    if self.name != None:
7790 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7791 
      oprot.writeString(self.name)
7792 
      oprot.writeFieldEnd()
7793 
    if self.url != None:
7794 
      oprot.writeFieldBegin('url', TType.STRING, 2)
7795 
      oprot.writeString(self.url)
7796 
      oprot.writeFieldEnd()
7797 
    if self.masterAffiliateId != None:
7798 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
7799 
      oprot.writeI64(self.masterAffiliateId)
7800 
      oprot.writeFieldEnd()
1859 vikas 7801 
    if self.addedOn != None:
7802 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
7803 
      oprot.writeI64(self.addedOn)
7804 
      oprot.writeFieldEnd()
1845 vikas 7805 
    oprot.writeFieldStop()
7806 
    oprot.writeStructEnd()
7807 
 
7808 
  def __repr__(self):
7809 
    L = ['%s=%r' % (key, value)
7810 
      for key, value in self.__dict__.iteritems()]
7811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7812 
 
7813 
  def __eq__(self, other):
7814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7815 
 
7816 
  def __ne__(self, other):
7817 
    return not (self == other)
7818 
 
7819 
class createAffiliate_result:
7820 
  """
7821 
  Attributes:
7822 
   - success
7823 
   - utx
7824 
  """
7825 
 
7826 
  thrift_spec = (
7827 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 7828 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7829 
  )
7830 
 
7831 
  def __init__(self, success=None, utx=None,):
7832 
    self.success = success
7833 
    self.utx = utx
7834 
 
7835 
  def read(self, iprot):
7836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7838 
      return
7839 
    iprot.readStructBegin()
7840 
    while True:
7841 
      (fname, ftype, fid) = iprot.readFieldBegin()
7842 
      if ftype == TType.STOP:
7843 
        break
7844 
      if fid == 0:
7845 
        if ftype == TType.STRUCT:
7846 
          self.success = Affiliate()
7847 
          self.success.read(iprot)
7848 
        else:
7849 
          iprot.skip(ftype)
7850 
      elif fid == 1:
7851 
        if ftype == TType.STRUCT:
1996 vikas 7852 
          self.utx = UserAffiliateException()
1845 vikas 7853 
          self.utx.read(iprot)
7854 
        else:
7855 
          iprot.skip(ftype)
7856 
      else:
7857 
        iprot.skip(ftype)
7858 
      iprot.readFieldEnd()
7859 
    iprot.readStructEnd()
7860 
 
7861 
  def write(self, oprot):
7862 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7863 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7864 
      return
7865 
    oprot.writeStructBegin('createAffiliate_result')
7866 
    if self.success != None:
7867 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7868 
      self.success.write(oprot)
7869 
      oprot.writeFieldEnd()
7870 
    if self.utx != None:
7871 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7872 
      self.utx.write(oprot)
7873 
      oprot.writeFieldEnd()
7874 
    oprot.writeFieldStop()
7875 
    oprot.writeStructEnd()
7876 
 
7877 
  def __repr__(self):
7878 
    L = ['%s=%r' % (key, value)
7879 
      for key, value in self.__dict__.iteritems()]
7880 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7881 
 
7882 
  def __eq__(self, other):
7883 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7884 
 
7885 
  def __ne__(self, other):
7886 
    return not (self == other)
7887 
 
7888 
class getAffiliateById_args:
7889 
  """
7890 
  Attributes:
7891 
   - id
7892 
  """
7893 
 
7894 
  thrift_spec = (
7895 
    None, # 0
7896 
    (1, TType.I64, 'id', None, None, ), # 1
7897 
  )
7898 
 
7899 
  def __init__(self, id=None,):
7900 
    self.id = id
7901 
 
7902 
  def read(self, iprot):
7903 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7904 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7905 
      return
7906 
    iprot.readStructBegin()
7907 
    while True:
7908 
      (fname, ftype, fid) = iprot.readFieldBegin()
7909 
      if ftype == TType.STOP:
7910 
        break
7911 
      if fid == 1:
7912 
        if ftype == TType.I64:
7913 
          self.id = iprot.readI64();
7914 
        else:
7915 
          iprot.skip(ftype)
7916 
      else:
7917 
        iprot.skip(ftype)
7918 
      iprot.readFieldEnd()
7919 
    iprot.readStructEnd()
7920 
 
7921 
  def write(self, oprot):
7922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7924 
      return
7925 
    oprot.writeStructBegin('getAffiliateById_args')
7926 
    if self.id != None:
7927 
      oprot.writeFieldBegin('id', TType.I64, 1)
7928 
      oprot.writeI64(self.id)
7929 
      oprot.writeFieldEnd()
7930 
    oprot.writeFieldStop()
7931 
    oprot.writeStructEnd()
7932 
 
7933 
  def __repr__(self):
7934 
    L = ['%s=%r' % (key, value)
7935 
      for key, value in self.__dict__.iteritems()]
7936 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7937 
 
7938 
  def __eq__(self, other):
7939 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7940 
 
7941 
  def __ne__(self, other):
7942 
    return not (self == other)
7943 
 
7944 
class getAffiliateById_result:
7945 
  """
7946 
  Attributes:
7947 
   - success
7948 
   - utx
7949 
  """
7950 
 
7951 
  thrift_spec = (
7952 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 7953 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7954 
  )
7955 
 
7956 
  def __init__(self, success=None, utx=None,):
7957 
    self.success = success
7958 
    self.utx = utx
7959 
 
7960 
  def read(self, iprot):
7961 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7962 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7963 
      return
7964 
    iprot.readStructBegin()
7965 
    while True:
7966 
      (fname, ftype, fid) = iprot.readFieldBegin()
7967 
      if ftype == TType.STOP:
7968 
        break
7969 
      if fid == 0:
7970 
        if ftype == TType.STRUCT:
7971 
          self.success = Affiliate()
7972 
          self.success.read(iprot)
7973 
        else:
7974 
          iprot.skip(ftype)
7975 
      elif fid == 1:
7976 
        if ftype == TType.STRUCT:
1996 vikas 7977 
          self.utx = UserAffiliateException()
1845 vikas 7978 
          self.utx.read(iprot)
7979 
        else:
7980 
          iprot.skip(ftype)
7981 
      else:
7982 
        iprot.skip(ftype)
7983 
      iprot.readFieldEnd()
7984 
    iprot.readStructEnd()
7985 
 
7986 
  def write(self, oprot):
7987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7989 
      return
7990 
    oprot.writeStructBegin('getAffiliateById_result')
7991 
    if self.success != None:
7992 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7993 
      self.success.write(oprot)
7994 
      oprot.writeFieldEnd()
7995 
    if self.utx != None:
7996 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7997 
      self.utx.write(oprot)
7998 
      oprot.writeFieldEnd()
7999 
    oprot.writeFieldStop()
8000 
    oprot.writeStructEnd()
8001 
 
8002 
  def __repr__(self):
8003 
    L = ['%s=%r' % (key, value)
8004 
      for key, value in self.__dict__.iteritems()]
8005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8006 
 
8007 
  def __eq__(self, other):
8008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8009 
 
8010 
  def __ne__(self, other):
8011 
    return not (self == other)
8012 
 
8013 
class getAffiliateByName_args:
8014 
  """
8015 
  Attributes:
8016 
   - name
8017 
  """
8018 
 
8019 
  thrift_spec = (
8020 
    None, # 0
8021 
    (1, TType.STRING, 'name', None, None, ), # 1
8022 
  )
8023 
 
8024 
  def __init__(self, name=None,):
8025 
    self.name = name
8026 
 
8027 
  def read(self, iprot):
8028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8030 
      return
8031 
    iprot.readStructBegin()
8032 
    while True:
8033 
      (fname, ftype, fid) = iprot.readFieldBegin()
8034 
      if ftype == TType.STOP:
8035 
        break
8036 
      if fid == 1:
8037 
        if ftype == TType.STRING:
8038 
          self.name = iprot.readString();
8039 
        else:
8040 
          iprot.skip(ftype)
8041 
      else:
8042 
        iprot.skip(ftype)
8043 
      iprot.readFieldEnd()
8044 
    iprot.readStructEnd()
8045 
 
8046 
  def write(self, oprot):
8047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8049 
      return
8050 
    oprot.writeStructBegin('getAffiliateByName_args')
8051 
    if self.name != None:
8052 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8053 
      oprot.writeString(self.name)
8054 
      oprot.writeFieldEnd()
8055 
    oprot.writeFieldStop()
8056 
    oprot.writeStructEnd()
8057 
 
8058 
  def __repr__(self):
8059 
    L = ['%s=%r' % (key, value)
8060 
      for key, value in self.__dict__.iteritems()]
8061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8062 
 
8063 
  def __eq__(self, other):
8064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8065 
 
8066 
  def __ne__(self, other):
8067 
    return not (self == other)
8068 
 
8069 
class getAffiliateByName_result:
8070 
  """
8071 
  Attributes:
8072 
   - success
8073 
   - utx
8074 
  """
8075 
 
8076 
  thrift_spec = (
8077 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8078 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8079 
  )
8080 
 
8081 
  def __init__(self, success=None, utx=None,):
8082 
    self.success = success
8083 
    self.utx = utx
8084 
 
8085 
  def read(self, iprot):
8086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8088 
      return
8089 
    iprot.readStructBegin()
8090 
    while True:
8091 
      (fname, ftype, fid) = iprot.readFieldBegin()
8092 
      if ftype == TType.STOP:
8093 
        break
8094 
      if fid == 0:
8095 
        if ftype == TType.STRUCT:
8096 
          self.success = Affiliate()
8097 
          self.success.read(iprot)
8098 
        else:
8099 
          iprot.skip(ftype)
8100 
      elif fid == 1:
8101 
        if ftype == TType.STRUCT:
1996 vikas 8102 
          self.utx = UserAffiliateException()
1845 vikas 8103 
          self.utx.read(iprot)
8104 
        else:
8105 
          iprot.skip(ftype)
8106 
      else:
8107 
        iprot.skip(ftype)
8108 
      iprot.readFieldEnd()
8109 
    iprot.readStructEnd()
8110 
 
8111 
  def write(self, oprot):
8112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8114 
      return
8115 
    oprot.writeStructBegin('getAffiliateByName_result')
8116 
    if self.success != None:
8117 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8118 
      self.success.write(oprot)
8119 
      oprot.writeFieldEnd()
8120 
    if self.utx != None:
8121 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8122 
      self.utx.write(oprot)
8123 
      oprot.writeFieldEnd()
8124 
    oprot.writeFieldStop()
8125 
    oprot.writeStructEnd()
8126 
 
8127 
  def __repr__(self):
8128 
    L = ['%s=%r' % (key, value)
8129 
      for key, value in self.__dict__.iteritems()]
8130 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8131 
 
8132 
  def __eq__(self, other):
8133 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8134 
 
8135 
  def __ne__(self, other):
8136 
    return not (self == other)
8137 
 
1996 vikas 8138 
class getTrackerById_args:
1845 vikas 8139 
  """
8140 
  Attributes:
8141 
   - id
8142 
  """
8143 
 
8144 
  thrift_spec = (
8145 
    None, # 0
8146 
    (1, TType.I64, 'id', None, None, ), # 1
8147 
  )
8148 
 
8149 
  def __init__(self, id=None,):
8150 
    self.id = id
8151 
 
8152 
  def read(self, iprot):
8153 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8154 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8155 
      return
8156 
    iprot.readStructBegin()
8157 
    while True:
8158 
      (fname, ftype, fid) = iprot.readFieldBegin()
8159 
      if ftype == TType.STOP:
8160 
        break
8161 
      if fid == 1:
8162 
        if ftype == TType.I64:
8163 
          self.id = iprot.readI64();
8164 
        else:
8165 
          iprot.skip(ftype)
8166 
      else:
8167 
        iprot.skip(ftype)
8168 
      iprot.readFieldEnd()
8169 
    iprot.readStructEnd()
8170 
 
8171 
  def write(self, oprot):
8172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8174 
      return
1996 vikas 8175 
    oprot.writeStructBegin('getTrackerById_args')
1845 vikas 8176 
    if self.id != None:
8177 
      oprot.writeFieldBegin('id', TType.I64, 1)
8178 
      oprot.writeI64(self.id)
8179 
      oprot.writeFieldEnd()
8180 
    oprot.writeFieldStop()
8181 
    oprot.writeStructEnd()
8182 
 
8183 
  def __repr__(self):
8184 
    L = ['%s=%r' % (key, value)
8185 
      for key, value in self.__dict__.iteritems()]
8186 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8187 
 
8188 
  def __eq__(self, other):
8189 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8190 
 
8191 
  def __ne__(self, other):
8192 
    return not (self == other)
8193 
 
8194 
class getTrackerById_result:
8195 
  """
8196 
  Attributes:
8197 
   - success
8198 
   - utx
8199 
  """
8200 
 
8201 
  thrift_spec = (
8202 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 8203 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8204 
  )
8205 
 
8206 
  def __init__(self, success=None, utx=None,):
8207 
    self.success = success
8208 
    self.utx = utx
8209 
 
8210 
  def read(self, iprot):
8211 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8212 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8213 
      return
8214 
    iprot.readStructBegin()
8215 
    while True:
8216 
      (fname, ftype, fid) = iprot.readFieldBegin()
8217 
      if ftype == TType.STOP:
8218 
        break
8219 
      if fid == 0:
8220 
        if ftype == TType.STRUCT:
8221 
          self.success = Tracker()
8222 
          self.success.read(iprot)
8223 
        else:
8224 
          iprot.skip(ftype)
8225 
      elif fid == 1:
8226 
        if ftype == TType.STRUCT:
1996 vikas 8227 
          self.utx = UserAffiliateException()
1845 vikas 8228 
          self.utx.read(iprot)
8229 
        else:
8230 
          iprot.skip(ftype)
8231 
      else:
8232 
        iprot.skip(ftype)
8233 
      iprot.readFieldEnd()
8234 
    iprot.readStructEnd()
8235 
 
8236 
  def write(self, oprot):
8237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8239 
      return
8240 
    oprot.writeStructBegin('getTrackerById_result')
8241 
    if self.success != None:
8242 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8243 
      self.success.write(oprot)
8244 
      oprot.writeFieldEnd()
8245 
    if self.utx != None:
8246 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8247 
      self.utx.write(oprot)
8248 
      oprot.writeFieldEnd()
8249 
    oprot.writeFieldStop()
8250 
    oprot.writeStructEnd()
8251 
 
8252 
  def __repr__(self):
8253 
    L = ['%s=%r' % (key, value)
8254 
      for key, value in self.__dict__.iteritems()]
8255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8256 
 
8257 
  def __eq__(self, other):
8258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8259 
 
8260 
  def __ne__(self, other):
8261 
    return not (self == other)
8262 
 
1996 vikas 8263 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 8264 
  """
8265 
  Attributes:
1996 vikas 8266 
   - id
1845 vikas 8267 
  """
8268 
 
8269 
  thrift_spec = (
8270 
    None, # 0
1996 vikas 8271 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 8272 
  )
8273 
 
1996 vikas 8274 
  def __init__(self, id=None,):
8275 
    self.id = id
1845 vikas 8276 
 
8277 
  def read(self, iprot):
8278 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8279 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8280 
      return
8281 
    iprot.readStructBegin()
8282 
    while True:
8283 
      (fname, ftype, fid) = iprot.readFieldBegin()
8284 
      if ftype == TType.STOP:
8285 
        break
8286 
      if fid == 1:
8287 
        if ftype == TType.I64:
1996 vikas 8288 
          self.id = iprot.readI64();
1845 vikas 8289 
        else:
8290 
          iprot.skip(ftype)
8291 
      else:
8292 
        iprot.skip(ftype)
8293 
      iprot.readFieldEnd()
8294 
    iprot.readStructEnd()
8295 
 
8296 
  def write(self, oprot):
8297 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8298 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8299 
      return
1996 vikas 8300 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
8301 
    if self.id != None:
8302 
      oprot.writeFieldBegin('id', TType.I64, 1)
8303 
      oprot.writeI64(self.id)
1845 vikas 8304 
      oprot.writeFieldEnd()
8305 
    oprot.writeFieldStop()
8306 
    oprot.writeStructEnd()
8307 
 
8308 
  def __repr__(self):
8309 
    L = ['%s=%r' % (key, value)
8310 
      for key, value in self.__dict__.iteritems()]
8311 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8312 
 
8313 
  def __eq__(self, other):
8314 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8315 
 
8316 
  def __ne__(self, other):
8317 
    return not (self == other)
8318 
 
1996 vikas 8319 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 8320 
  """
8321 
  Attributes:
8322 
   - success
8323 
   - utx
8324 
  """
8325 
 
8326 
  thrift_spec = (
1996 vikas 8327 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
8328 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8329 
  )
8330 
 
8331 
  def __init__(self, success=None, utx=None,):
8332 
    self.success = success
8333 
    self.utx = utx
8334 
 
8335 
  def read(self, iprot):
8336 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8337 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8338 
      return
8339 
    iprot.readStructBegin()
8340 
    while True:
8341 
      (fname, ftype, fid) = iprot.readFieldBegin()
8342 
      if ftype == TType.STOP:
8343 
        break
8344 
      if fid == 0:
8345 
        if ftype == TType.LIST:
8346 
          self.success = []
3385 varun.gupt 8347 
          (_etype66, _size63) = iprot.readListBegin()
8348 
          for _i67 in xrange(_size63):
8349 
            _elem68 = Affiliate()
8350 
            _elem68.read(iprot)
8351 
            self.success.append(_elem68)
1845 vikas 8352 
          iprot.readListEnd()
8353 
        else:
8354 
          iprot.skip(ftype)
8355 
      elif fid == 1:
8356 
        if ftype == TType.STRUCT:
1996 vikas 8357 
          self.utx = UserAffiliateException()
1845 vikas 8358 
          self.utx.read(iprot)
8359 
        else:
8360 
          iprot.skip(ftype)
8361 
      else:
8362 
        iprot.skip(ftype)
8363 
      iprot.readFieldEnd()
8364 
    iprot.readStructEnd()
8365 
 
8366 
  def write(self, oprot):
8367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8369 
      return
1996 vikas 8370 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
1845 vikas 8371 
    if self.success != None:
8372 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8373 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3385 varun.gupt 8374 
      for iter69 in self.success:
8375 
        iter69.write(oprot)
1845 vikas 8376 
      oprot.writeListEnd()
8377 
      oprot.writeFieldEnd()
8378 
    if self.utx != None:
8379 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8380 
      self.utx.write(oprot)
8381 
      oprot.writeFieldEnd()
8382 
    oprot.writeFieldStop()
8383 
    oprot.writeStructEnd()
8384 
 
8385 
  def __repr__(self):
8386 
    L = ['%s=%r' % (key, value)
8387 
      for key, value in self.__dict__.iteritems()]
8388 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8389 
 
8390 
  def __eq__(self, other):
8391 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8392 
 
8393 
  def __ne__(self, other):
8394 
    return not (self == other)
8395 
 
8396 
class addTrackLog_args:
8397 
  """
8398 
  Attributes:
1996 vikas 8399 
   - affiliateId
1845 vikas 8400 
   - userId
8401 
   - event
8402 
   - url
8403 
   - data
1859 vikas 8404 
   - addedOn
1845 vikas 8405 
  """
8406 
 
8407 
  thrift_spec = (
8408 
    None, # 0
1996 vikas 8409 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 8410 
    (2, TType.I64, 'userId', None, None, ), # 2
3378 vikas 8411 
    (3, TType.I32, 'event', None, None, ), # 3
1845 vikas 8412 
    (4, TType.STRING, 'url', None, None, ), # 4
8413 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 8414 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 8415 
  )
8416 
 
1996 vikas 8417 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
8418 
    self.affiliateId = affiliateId
1845 vikas 8419 
    self.userId = userId
8420 
    self.event = event
8421 
    self.url = url
8422 
    self.data = data
1859 vikas 8423 
    self.addedOn = addedOn
1845 vikas 8424 
 
8425 
  def read(self, iprot):
8426 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8427 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8428 
      return
8429 
    iprot.readStructBegin()
8430 
    while True:
8431 
      (fname, ftype, fid) = iprot.readFieldBegin()
8432 
      if ftype == TType.STOP:
8433 
        break
8434 
      if fid == 1:
8435 
        if ftype == TType.I64:
1996 vikas 8436 
          self.affiliateId = iprot.readI64();
1845 vikas 8437 
        else:
8438 
          iprot.skip(ftype)
8439 
      elif fid == 2:
8440 
        if ftype == TType.I64:
8441 
          self.userId = iprot.readI64();
8442 
        else:
8443 
          iprot.skip(ftype)
8444 
      elif fid == 3:
3378 vikas 8445 
        if ftype == TType.I32:
8446 
          self.event = iprot.readI32();
1845 vikas 8447 
        else:
8448 
          iprot.skip(ftype)
8449 
      elif fid == 4:
8450 
        if ftype == TType.STRING:
8451 
          self.url = iprot.readString();
8452 
        else:
8453 
          iprot.skip(ftype)
8454 
      elif fid == 5:
8455 
        if ftype == TType.STRING:
8456 
          self.data = iprot.readString();
8457 
        else:
8458 
          iprot.skip(ftype)
1859 vikas 8459 
      elif fid == 6:
8460 
        if ftype == TType.I64:
8461 
          self.addedOn = iprot.readI64();
8462 
        else:
8463 
          iprot.skip(ftype)
1845 vikas 8464 
      else:
8465 
        iprot.skip(ftype)
8466 
      iprot.readFieldEnd()
8467 
    iprot.readStructEnd()
8468 
 
8469 
  def write(self, oprot):
8470 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8471 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8472 
      return
8473 
    oprot.writeStructBegin('addTrackLog_args')
1996 vikas 8474 
    if self.affiliateId != None:
8475 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
8476 
      oprot.writeI64(self.affiliateId)
1845 vikas 8477 
      oprot.writeFieldEnd()
8478 
    if self.userId != None:
8479 
      oprot.writeFieldBegin('userId', TType.I64, 2)
8480 
      oprot.writeI64(self.userId)
8481 
      oprot.writeFieldEnd()
8482 
    if self.event != None:
3378 vikas 8483 
      oprot.writeFieldBegin('event', TType.I32, 3)
8484 
      oprot.writeI32(self.event)
1845 vikas 8485 
      oprot.writeFieldEnd()
8486 
    if self.url != None:
8487 
      oprot.writeFieldBegin('url', TType.STRING, 4)
8488 
      oprot.writeString(self.url)
8489 
      oprot.writeFieldEnd()
8490 
    if self.data != None:
8491 
      oprot.writeFieldBegin('data', TType.STRING, 5)
8492 
      oprot.writeString(self.data)
8493 
      oprot.writeFieldEnd()
1859 vikas 8494 
    if self.addedOn != None:
8495 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
8496 
      oprot.writeI64(self.addedOn)
8497 
      oprot.writeFieldEnd()
1845 vikas 8498 
    oprot.writeFieldStop()
8499 
    oprot.writeStructEnd()
8500 
 
8501 
  def __repr__(self):
8502 
    L = ['%s=%r' % (key, value)
8503 
      for key, value in self.__dict__.iteritems()]
8504 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8505 
 
8506 
  def __eq__(self, other):
8507 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8508 
 
8509 
  def __ne__(self, other):
8510 
    return not (self == other)
8511 
 
8512 
class addTrackLog_result:
8513 
  """
8514 
  Attributes:
8515 
   - success
8516 
   - utx
8517 
  """
8518 
 
8519 
  thrift_spec = (
8520 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 8521 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8522 
  )
8523 
 
8524 
  def __init__(self, success=None, utx=None,):
8525 
    self.success = success
8526 
    self.utx = utx
8527 
 
8528 
  def read(self, iprot):
8529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8531 
      return
8532 
    iprot.readStructBegin()
8533 
    while True:
8534 
      (fname, ftype, fid) = iprot.readFieldBegin()
8535 
      if ftype == TType.STOP:
8536 
        break
8537 
      if fid == 0:
8538 
        if ftype == TType.I64:
8539 
          self.success = iprot.readI64();
8540 
        else:
8541 
          iprot.skip(ftype)
8542 
      elif fid == 1:
8543 
        if ftype == TType.STRUCT:
1996 vikas 8544 
          self.utx = UserAffiliateException()
1845 vikas 8545 
          self.utx.read(iprot)
8546 
        else:
8547 
          iprot.skip(ftype)
8548 
      else:
8549 
        iprot.skip(ftype)
8550 
      iprot.readFieldEnd()
8551 
    iprot.readStructEnd()
8552 
 
8553 
  def write(self, oprot):
8554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8556 
      return
8557 
    oprot.writeStructBegin('addTrackLog_result')
8558 
    if self.success != None:
8559 
      oprot.writeFieldBegin('success', TType.I64, 0)
8560 
      oprot.writeI64(self.success)
8561 
      oprot.writeFieldEnd()
8562 
    if self.utx != None:
8563 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8564 
      self.utx.write(oprot)
8565 
      oprot.writeFieldEnd()
8566 
    oprot.writeFieldStop()
8567 
    oprot.writeStructEnd()
8568 
 
8569 
  def __repr__(self):
8570 
    L = ['%s=%r' % (key, value)
8571 
      for key, value in self.__dict__.iteritems()]
8572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8573 
 
8574 
  def __eq__(self, other):
8575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8576 
 
8577 
  def __ne__(self, other):
8578 
    return not (self == other)
8579 
 
8580 
class getTrackLogById_args:
8581 
  """
8582 
  Attributes:
8583 
   - id
8584 
  """
8585 
 
8586 
  thrift_spec = (
8587 
    None, # 0
8588 
    (1, TType.I64, 'id', None, None, ), # 1
8589 
  )
8590 
 
8591 
  def __init__(self, id=None,):
8592 
    self.id = id
8593 
 
8594 
  def read(self, iprot):
8595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8597 
      return
8598 
    iprot.readStructBegin()
8599 
    while True:
8600 
      (fname, ftype, fid) = iprot.readFieldBegin()
8601 
      if ftype == TType.STOP:
8602 
        break
8603 
      if fid == 1:
8604 
        if ftype == TType.I64:
8605 
          self.id = iprot.readI64();
8606 
        else:
8607 
          iprot.skip(ftype)
8608 
      else:
8609 
        iprot.skip(ftype)
8610 
      iprot.readFieldEnd()
8611 
    iprot.readStructEnd()
8612 
 
8613 
  def write(self, oprot):
8614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8616 
      return
8617 
    oprot.writeStructBegin('getTrackLogById_args')
8618 
    if self.id != None:
8619 
      oprot.writeFieldBegin('id', TType.I64, 1)
8620 
      oprot.writeI64(self.id)
8621 
      oprot.writeFieldEnd()
8622 
    oprot.writeFieldStop()
8623 
    oprot.writeStructEnd()
8624 
 
8625 
  def __repr__(self):
8626 
    L = ['%s=%r' % (key, value)
8627 
      for key, value in self.__dict__.iteritems()]
8628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8629 
 
8630 
  def __eq__(self, other):
8631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8632 
 
8633 
  def __ne__(self, other):
8634 
    return not (self == other)
8635 
 
8636 
class getTrackLogById_result:
8637 
  """
8638 
  Attributes:
8639 
   - success
8640 
   - utx
8641 
  """
8642 
 
8643 
  thrift_spec = (
8644 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 8645 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8646 
  )
8647 
 
8648 
  def __init__(self, success=None, utx=None,):
8649 
    self.success = success
8650 
    self.utx = utx
8651 
 
8652 
  def read(self, iprot):
8653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8655 
      return
8656 
    iprot.readStructBegin()
8657 
    while True:
8658 
      (fname, ftype, fid) = iprot.readFieldBegin()
8659 
      if ftype == TType.STOP:
8660 
        break
8661 
      if fid == 0:
8662 
        if ftype == TType.STRUCT:
8663 
          self.success = TrackLog()
8664 
          self.success.read(iprot)
8665 
        else:
8666 
          iprot.skip(ftype)
8667 
      elif fid == 1:
8668 
        if ftype == TType.STRUCT:
1996 vikas 8669 
          self.utx = UserAffiliateException()
1845 vikas 8670 
          self.utx.read(iprot)
8671 
        else:
8672 
          iprot.skip(ftype)
8673 
      else:
8674 
        iprot.skip(ftype)
8675 
      iprot.readFieldEnd()
8676 
    iprot.readStructEnd()
8677 
 
8678 
  def write(self, oprot):
8679 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8680 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8681 
      return
8682 
    oprot.writeStructBegin('getTrackLogById_result')
8683 
    if self.success != None:
8684 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8685 
      self.success.write(oprot)
8686 
      oprot.writeFieldEnd()
8687 
    if self.utx != None:
8688 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8689 
      self.utx.write(oprot)
8690 
      oprot.writeFieldEnd()
8691 
    oprot.writeFieldStop()
8692 
    oprot.writeStructEnd()
8693 
 
8694 
  def __repr__(self):
8695 
    L = ['%s=%r' % (key, value)
8696 
      for key, value in self.__dict__.iteritems()]
8697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8698 
 
8699 
  def __eq__(self, other):
8700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8701 
 
8702 
  def __ne__(self, other):
8703 
    return not (self == other)
8704 
 
1996 vikas 8705 
class getTrackLogsByAffiliate_args:
1845 vikas 8706 
  """
8707 
  Attributes:
1996 vikas 8708 
   - affiliateId
3293 vikas 8709 
   - startDate
8710 
   - endDate
1845 vikas 8711 
  """
8712 
 
8713 
  thrift_spec = (
8714 
    None, # 0
1996 vikas 8715 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
3293 vikas 8716 
    (2, TType.I64, 'startDate', None, None, ), # 2
8717 
    (3, TType.I64, 'endDate', None, None, ), # 3
1845 vikas 8718 
  )
8719 
 
3293 vikas 8720 
  def __init__(self, affiliateId=None, startDate=None, endDate=None,):
1996 vikas 8721 
    self.affiliateId = affiliateId
3293 vikas 8722 
    self.startDate = startDate
8723 
    self.endDate = endDate
1845 vikas 8724 
 
8725 
  def read(self, iprot):
8726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8728 
      return
8729 
    iprot.readStructBegin()
8730 
    while True:
8731 
      (fname, ftype, fid) = iprot.readFieldBegin()
8732 
      if ftype == TType.STOP:
8733 
        break
8734 
      if fid == 1:
8735 
        if ftype == TType.I64:
1996 vikas 8736 
          self.affiliateId = iprot.readI64();
1845 vikas 8737 
        else:
8738 
          iprot.skip(ftype)
3293 vikas 8739 
      elif fid == 2:
8740 
        if ftype == TType.I64:
8741 
          self.startDate = iprot.readI64();
8742 
        else:
8743 
          iprot.skip(ftype)
8744 
      elif fid == 3:
8745 
        if ftype == TType.I64:
8746 
          self.endDate = iprot.readI64();
8747 
        else:
8748 
          iprot.skip(ftype)
1845 vikas 8749 
      else:
8750 
        iprot.skip(ftype)
8751 
      iprot.readFieldEnd()
8752 
    iprot.readStructEnd()
8753 
 
8754 
  def write(self, oprot):
8755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8757 
      return
1996 vikas 8758 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
8759 
    if self.affiliateId != None:
8760 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
8761 
      oprot.writeI64(self.affiliateId)
1845 vikas 8762 
      oprot.writeFieldEnd()
3293 vikas 8763 
    if self.startDate != None:
8764 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
8765 
      oprot.writeI64(self.startDate)
8766 
      oprot.writeFieldEnd()
8767 
    if self.endDate != None:
8768 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
8769 
      oprot.writeI64(self.endDate)
8770 
      oprot.writeFieldEnd()
1845 vikas 8771 
    oprot.writeFieldStop()
8772 
    oprot.writeStructEnd()
8773 
 
8774 
  def __repr__(self):
8775 
    L = ['%s=%r' % (key, value)
8776 
      for key, value in self.__dict__.iteritems()]
8777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8778 
 
8779 
  def __eq__(self, other):
8780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8781 
 
8782 
  def __ne__(self, other):
8783 
    return not (self == other)
8784 
 
1996 vikas 8785 
class getTrackLogsByAffiliate_result:
1845 vikas 8786 
  """
8787 
  Attributes:
8788 
   - success
8789 
   - utx
8790 
  """
8791 
 
8792 
  thrift_spec = (
8793 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 8794 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8795 
  )
8796 
 
8797 
  def __init__(self, success=None, utx=None,):
8798 
    self.success = success
8799 
    self.utx = utx
8800 
 
8801 
  def read(self, iprot):
8802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8804 
      return
8805 
    iprot.readStructBegin()
8806 
    while True:
8807 
      (fname, ftype, fid) = iprot.readFieldBegin()
8808 
      if ftype == TType.STOP:
8809 
        break
8810 
      if fid == 0:
8811 
        if ftype == TType.LIST:
8812 
          self.success = []
3385 varun.gupt 8813 
          (_etype73, _size70) = iprot.readListBegin()
8814 
          for _i74 in xrange(_size70):
8815 
            _elem75 = TrackLog()
8816 
            _elem75.read(iprot)
8817 
            self.success.append(_elem75)
1845 vikas 8818 
          iprot.readListEnd()
8819 
        else:
8820 
          iprot.skip(ftype)
8821 
      elif fid == 1:
8822 
        if ftype == TType.STRUCT:
1996 vikas 8823 
          self.utx = UserAffiliateException()
1845 vikas 8824 
          self.utx.read(iprot)
8825 
        else:
8826 
          iprot.skip(ftype)
8827 
      else:
8828 
        iprot.skip(ftype)
8829 
      iprot.readFieldEnd()
8830 
    iprot.readStructEnd()
8831 
 
8832 
  def write(self, oprot):
8833 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8834 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8835 
      return
1996 vikas 8836 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
1845 vikas 8837 
    if self.success != None:
8838 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8839 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3385 varun.gupt 8840 
      for iter76 in self.success:
8841 
        iter76.write(oprot)
1845 vikas 8842 
      oprot.writeListEnd()
8843 
      oprot.writeFieldEnd()
8844 
    if self.utx != None:
8845 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8846 
      self.utx.write(oprot)
8847 
      oprot.writeFieldEnd()
8848 
    oprot.writeFieldStop()
8849 
    oprot.writeStructEnd()
8850 
 
8851 
  def __repr__(self):
8852 
    L = ['%s=%r' % (key, value)
8853 
      for key, value in self.__dict__.iteritems()]
8854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8855 
 
8856 
  def __eq__(self, other):
8857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8858 
 
8859 
  def __ne__(self, other):
8860 
    return not (self == other)
8861 
 
8862 
class getTrackLogsByUser_args:
8863 
  """
8864 
  Attributes:
8865 
   - userId
8866 
  """
8867 
 
8868 
  thrift_spec = (
8869 
    None, # 0
8870 
    (1, TType.I64, 'userId', None, None, ), # 1
8871 
  )
8872 
 
8873 
  def __init__(self, userId=None,):
8874 
    self.userId = userId
8875 
 
8876 
  def read(self, iprot):
8877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8879 
      return
8880 
    iprot.readStructBegin()
8881 
    while True:
8882 
      (fname, ftype, fid) = iprot.readFieldBegin()
8883 
      if ftype == TType.STOP:
8884 
        break
8885 
      if fid == 1:
8886 
        if ftype == TType.I64:
8887 
          self.userId = iprot.readI64();
8888 
        else:
8889 
          iprot.skip(ftype)
8890 
      else:
8891 
        iprot.skip(ftype)
8892 
      iprot.readFieldEnd()
8893 
    iprot.readStructEnd()
8894 
 
8895 
  def write(self, oprot):
8896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8898 
      return
8899 
    oprot.writeStructBegin('getTrackLogsByUser_args')
8900 
    if self.userId != None:
8901 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8902 
      oprot.writeI64(self.userId)
8903 
      oprot.writeFieldEnd()
8904 
    oprot.writeFieldStop()
8905 
    oprot.writeStructEnd()
8906 
 
8907 
  def __repr__(self):
8908 
    L = ['%s=%r' % (key, value)
8909 
      for key, value in self.__dict__.iteritems()]
8910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8911 
 
8912 
  def __eq__(self, other):
8913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8914 
 
8915 
  def __ne__(self, other):
8916 
    return not (self == other)
8917 
 
8918 
class getTrackLogsByUser_result:
8919 
  """
8920 
  Attributes:
8921 
   - success
8922 
   - utx
8923 
  """
8924 
 
8925 
  thrift_spec = (
8926 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 8927 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8928 
  )
8929 
 
8930 
  def __init__(self, success=None, utx=None,):
8931 
    self.success = success
8932 
    self.utx = utx
8933 
 
8934 
  def read(self, iprot):
8935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8937 
      return
8938 
    iprot.readStructBegin()
8939 
    while True:
8940 
      (fname, ftype, fid) = iprot.readFieldBegin()
8941 
      if ftype == TType.STOP:
8942 
        break
8943 
      if fid == 0:
8944 
        if ftype == TType.LIST:
8945 
          self.success = []
3385 varun.gupt 8946 
          (_etype80, _size77) = iprot.readListBegin()
8947 
          for _i81 in xrange(_size77):
8948 
            _elem82 = TrackLog()
8949 
            _elem82.read(iprot)
8950 
            self.success.append(_elem82)
1845 vikas 8951 
          iprot.readListEnd()
8952 
        else:
8953 
          iprot.skip(ftype)
8954 
      elif fid == 1:
8955 
        if ftype == TType.STRUCT:
1996 vikas 8956 
          self.utx = UserAffiliateException()
1845 vikas 8957 
          self.utx.read(iprot)
8958 
        else:
8959 
          iprot.skip(ftype)
8960 
      else:
8961 
        iprot.skip(ftype)
8962 
      iprot.readFieldEnd()
8963 
    iprot.readStructEnd()
8964 
 
8965 
  def write(self, oprot):
8966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8968 
      return
8969 
    oprot.writeStructBegin('getTrackLogsByUser_result')
8970 
    if self.success != None:
8971 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8972 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3385 varun.gupt 8973 
      for iter83 in self.success:
8974 
        iter83.write(oprot)
1845 vikas 8975 
      oprot.writeListEnd()
8976 
      oprot.writeFieldEnd()
8977 
    if self.utx != None:
8978 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8979 
      self.utx.write(oprot)
8980 
      oprot.writeFieldEnd()
8981 
    oprot.writeFieldStop()
8982 
    oprot.writeStructEnd()
8983 
 
8984 
  def __repr__(self):
8985 
    L = ['%s=%r' % (key, value)
8986 
      for key, value in self.__dict__.iteritems()]
8987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8988 
 
8989 
  def __eq__(self, other):
8990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8991 
 
8992 
  def __ne__(self, other):
8993 
    return not (self == other)
8994 
 
8995 
class getTrackLogs_args:
8996 
  """
8997 
  Attributes:
8998 
   - userId
8999 
   - event
9000 
   - url
9001 
  """
9002 
 
9003 
  thrift_spec = (
9004 
    None, # 0
1996 vikas 9005 
    (1, TType.I64, 'userId', None, None, ), # 1
9006 
    (2, TType.STRING, 'event', None, None, ), # 2
9007 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 9008 
  )
9009 
 
1996 vikas 9010 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 9011 
    self.userId = userId
9012 
    self.event = event
9013 
    self.url = url
9014 
 
9015 
  def read(self, iprot):
9016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9018 
      return
9019 
    iprot.readStructBegin()
9020 
    while True:
9021 
      (fname, ftype, fid) = iprot.readFieldBegin()
9022 
      if ftype == TType.STOP:
9023 
        break
9024 
      if fid == 1:
9025 
        if ftype == TType.I64:
1996 vikas 9026 
          self.userId = iprot.readI64();
1845 vikas 9027 
        else:
9028 
          iprot.skip(ftype)
9029 
      elif fid == 2:
9030 
        if ftype == TType.STRING:
9031 
          self.event = iprot.readString();
9032 
        else:
9033 
          iprot.skip(ftype)
1996 vikas 9034 
      elif fid == 3:
1845 vikas 9035 
        if ftype == TType.STRING:
9036 
          self.url = iprot.readString();
9037 
        else:
9038 
          iprot.skip(ftype)
9039 
      else:
9040 
        iprot.skip(ftype)
9041 
      iprot.readFieldEnd()
9042 
    iprot.readStructEnd()
9043 
 
9044 
  def write(self, oprot):
9045 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9046 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9047 
      return
9048 
    oprot.writeStructBegin('getTrackLogs_args')
9049 
    if self.userId != None:
1996 vikas 9050 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 9051 
      oprot.writeI64(self.userId)
9052 
      oprot.writeFieldEnd()
9053 
    if self.event != None:
1996 vikas 9054 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 9055 
      oprot.writeString(self.event)
9056 
      oprot.writeFieldEnd()
9057 
    if self.url != None:
1996 vikas 9058 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 9059 
      oprot.writeString(self.url)
9060 
      oprot.writeFieldEnd()
9061 
    oprot.writeFieldStop()
9062 
    oprot.writeStructEnd()
9063 
 
9064 
  def __repr__(self):
9065 
    L = ['%s=%r' % (key, value)
9066 
      for key, value in self.__dict__.iteritems()]
9067 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9068 
 
9069 
  def __eq__(self, other):
9070 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9071 
 
9072 
  def __ne__(self, other):
9073 
    return not (self == other)
9074 
 
9075 
class getTrackLogs_result:
9076 
  """
9077 
  Attributes:
9078 
   - success
9079 
   - utx
9080 
  """
9081 
 
9082 
  thrift_spec = (
9083 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 9084 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9085 
  )
9086 
 
9087 
  def __init__(self, success=None, utx=None,):
9088 
    self.success = success
9089 
    self.utx = utx
9090 
 
9091 
  def read(self, iprot):
9092 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9093 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9094 
      return
9095 
    iprot.readStructBegin()
9096 
    while True:
9097 
      (fname, ftype, fid) = iprot.readFieldBegin()
9098 
      if ftype == TType.STOP:
9099 
        break
9100 
      if fid == 0:
9101 
        if ftype == TType.LIST:
9102 
          self.success = []
3385 varun.gupt 9103 
          (_etype87, _size84) = iprot.readListBegin()
9104 
          for _i88 in xrange(_size84):
9105 
            _elem89 = TrackLog()
9106 
            _elem89.read(iprot)
9107 
            self.success.append(_elem89)
1845 vikas 9108 
          iprot.readListEnd()
9109 
        else:
9110 
          iprot.skip(ftype)
9111 
      elif fid == 1:
9112 
        if ftype == TType.STRUCT:
1996 vikas 9113 
          self.utx = UserAffiliateException()
1845 vikas 9114 
          self.utx.read(iprot)
9115 
        else:
9116 
          iprot.skip(ftype)
9117 
      else:
9118 
        iprot.skip(ftype)
9119 
      iprot.readFieldEnd()
9120 
    iprot.readStructEnd()
9121 
 
9122 
  def write(self, oprot):
9123 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9124 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9125 
      return
9126 
    oprot.writeStructBegin('getTrackLogs_result')
9127 
    if self.success != None:
9128 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9129 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3385 varun.gupt 9130 
      for iter90 in self.success:
9131 
        iter90.write(oprot)
1845 vikas 9132 
      oprot.writeListEnd()
9133 
      oprot.writeFieldEnd()
9134 
    if self.utx != None:
9135 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9136 
      self.utx.write(oprot)
9137 
      oprot.writeFieldEnd()
9138 
    oprot.writeFieldStop()
9139 
    oprot.writeStructEnd()
9140 
 
9141 
  def __repr__(self):
9142 
    L = ['%s=%r' % (key, value)
9143 
      for key, value in self.__dict__.iteritems()]
9144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9145 
 
9146 
  def __eq__(self, other):
9147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9148 
 
9149 
  def __ne__(self, other):
9150 
    return not (self == other)
9151 
 
559 chandransh 9152 
class createCart_args:
94 ashish 9153 
  """
9154 
  Attributes:
559 chandransh 9155 
   - userId
94 ashish 9156 
  """
9157 
 
9158 
  thrift_spec = (
9159 
    None, # 0
559 chandransh 9160 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 9161 
  )
9162 
 
559 chandransh 9163 
  def __init__(self, userId=None,):
9164 
    self.userId = userId
94 ashish 9165 
 
9166 
  def read(self, iprot):
9167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9169 
      return
9170 
    iprot.readStructBegin()
9171 
    while True:
9172 
      (fname, ftype, fid) = iprot.readFieldBegin()
9173 
      if ftype == TType.STOP:
9174 
        break
9175 
      if fid == 1:
9176 
        if ftype == TType.I64:
559 chandransh 9177 
          self.userId = iprot.readI64();
94 ashish 9178 
        else:
9179 
          iprot.skip(ftype)
559 chandransh 9180 
      else:
9181 
        iprot.skip(ftype)
9182 
      iprot.readFieldEnd()
9183 
    iprot.readStructEnd()
9184 
 
9185 
  def write(self, oprot):
9186 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9187 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9188 
      return
9189 
    oprot.writeStructBegin('createCart_args')
9190 
    if self.userId != None:
9191 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9192 
      oprot.writeI64(self.userId)
9193 
      oprot.writeFieldEnd()
9194 
    oprot.writeFieldStop()
9195 
    oprot.writeStructEnd()
9196 
 
9197 
  def __repr__(self):
9198 
    L = ['%s=%r' % (key, value)
9199 
      for key, value in self.__dict__.iteritems()]
9200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9201 
 
9202 
  def __eq__(self, other):
9203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9204 
 
9205 
  def __ne__(self, other):
9206 
    return not (self == other)
9207 
 
9208 
class createCart_result:
9209 
  """
9210 
  Attributes:
9211 
   - success
9212 
   - scx
9213 
  """
9214 
 
9215 
  thrift_spec = (
9216 
    (0, TType.I64, 'success', None, None, ), # 0
9217 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9218 
  )
9219 
 
9220 
  def __init__(self, success=None, scx=None,):
9221 
    self.success = success
9222 
    self.scx = scx
9223 
 
9224 
  def read(self, iprot):
9225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9227 
      return
9228 
    iprot.readStructBegin()
9229 
    while True:
9230 
      (fname, ftype, fid) = iprot.readFieldBegin()
9231 
      if ftype == TType.STOP:
9232 
        break
9233 
      if fid == 0:
94 ashish 9234 
        if ftype == TType.I64:
559 chandransh 9235 
          self.success = iprot.readI64();
94 ashish 9236 
        else:
9237 
          iprot.skip(ftype)
559 chandransh 9238 
      elif fid == 1:
9239 
        if ftype == TType.STRUCT:
9240 
          self.scx = ShoppingCartException()
9241 
          self.scx.read(iprot)
9242 
        else:
9243 
          iprot.skip(ftype)
94 ashish 9244 
      else:
9245 
        iprot.skip(ftype)
9246 
      iprot.readFieldEnd()
9247 
    iprot.readStructEnd()
9248 
 
9249 
  def write(self, oprot):
9250 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9251 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9252 
      return
559 chandransh 9253 
    oprot.writeStructBegin('createCart_result')
9254 
    if self.success != None:
9255 
      oprot.writeFieldBegin('success', TType.I64, 0)
9256 
      oprot.writeI64(self.success)
94 ashish 9257 
      oprot.writeFieldEnd()
559 chandransh 9258 
    if self.scx != None:
9259 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9260 
      self.scx.write(oprot)
94 ashish 9261 
      oprot.writeFieldEnd()
9262 
    oprot.writeFieldStop()
9263 
    oprot.writeStructEnd()
9264 
 
9265 
  def __repr__(self):
9266 
    L = ['%s=%r' % (key, value)
9267 
      for key, value in self.__dict__.iteritems()]
9268 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9269 
 
9270 
  def __eq__(self, other):
9271 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9272 
 
9273 
  def __ne__(self, other):
9274 
    return not (self == other)
9275 
 
559 chandransh 9276 
class getCurrentCart_args:
94 ashish 9277 
  """
9278 
  Attributes:
559 chandransh 9279 
   - userId
9280 
  """
9281 
 
9282 
  thrift_spec = (
9283 
    None, # 0
9284 
    (1, TType.I64, 'userId', None, None, ), # 1
9285 
  )
9286 
 
9287 
  def __init__(self, userId=None,):
9288 
    self.userId = userId
9289 
 
9290 
  def read(self, iprot):
9291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9293 
      return
9294 
    iprot.readStructBegin()
9295 
    while True:
9296 
      (fname, ftype, fid) = iprot.readFieldBegin()
9297 
      if ftype == TType.STOP:
9298 
        break
9299 
      if fid == 1:
9300 
        if ftype == TType.I64:
9301 
          self.userId = iprot.readI64();
9302 
        else:
9303 
          iprot.skip(ftype)
9304 
      else:
9305 
        iprot.skip(ftype)
9306 
      iprot.readFieldEnd()
9307 
    iprot.readStructEnd()
9308 
 
9309 
  def write(self, oprot):
9310 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9311 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9312 
      return
9313 
    oprot.writeStructBegin('getCurrentCart_args')
9314 
    if self.userId != None:
9315 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9316 
      oprot.writeI64(self.userId)
9317 
      oprot.writeFieldEnd()
9318 
    oprot.writeFieldStop()
9319 
    oprot.writeStructEnd()
9320 
 
9321 
  def __repr__(self):
9322 
    L = ['%s=%r' % (key, value)
9323 
      for key, value in self.__dict__.iteritems()]
9324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9325 
 
9326 
  def __eq__(self, other):
9327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9328 
 
9329 
  def __ne__(self, other):
9330 
    return not (self == other)
9331 
 
9332 
class getCurrentCart_result:
9333 
  """
9334 
  Attributes:
94 ashish 9335 
   - success
559 chandransh 9336 
   - scx
94 ashish 9337 
  """
9338 
 
9339 
  thrift_spec = (
559 chandransh 9340 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9341 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9342 
  )
9343 
 
559 chandransh 9344 
  def __init__(self, success=None, scx=None,):
94 ashish 9345 
    self.success = success
559 chandransh 9346 
    self.scx = scx
94 ashish 9347 
 
9348 
  def read(self, iprot):
9349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9351 
      return
9352 
    iprot.readStructBegin()
9353 
    while True:
9354 
      (fname, ftype, fid) = iprot.readFieldBegin()
9355 
      if ftype == TType.STOP:
9356 
        break
9357 
      if fid == 0:
559 chandransh 9358 
        if ftype == TType.STRUCT:
9359 
          self.success = Cart()
9360 
          self.success.read(iprot)
94 ashish 9361 
        else:
9362 
          iprot.skip(ftype)
9363 
      elif fid == 1:
9364 
        if ftype == TType.STRUCT:
559 chandransh 9365 
          self.scx = ShoppingCartException()
9366 
          self.scx.read(iprot)
94 ashish 9367 
        else:
9368 
          iprot.skip(ftype)
9369 
      else:
9370 
        iprot.skip(ftype)
9371 
      iprot.readFieldEnd()
9372 
    iprot.readStructEnd()
9373 
 
9374 
  def write(self, oprot):
9375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9377 
      return
559 chandransh 9378 
    oprot.writeStructBegin('getCurrentCart_result')
94 ashish 9379 
    if self.success != None:
559 chandransh 9380 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9381 
      self.success.write(oprot)
94 ashish 9382 
      oprot.writeFieldEnd()
559 chandransh 9383 
    if self.scx != None:
9384 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9385 
      self.scx.write(oprot)
94 ashish 9386 
      oprot.writeFieldEnd()
9387 
    oprot.writeFieldStop()
9388 
    oprot.writeStructEnd()
9389 
 
9390 
  def __repr__(self):
9391 
    L = ['%s=%r' % (key, value)
9392 
      for key, value in self.__dict__.iteritems()]
9393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9394 
 
9395 
  def __eq__(self, other):
9396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9397 
 
9398 
  def __ne__(self, other):
9399 
    return not (self == other)
9400 
 
559 chandransh 9401 
class getCart_args:
504 rajveer 9402 
  """
9403 
  Attributes:
559 chandransh 9404 
   - cartId
504 rajveer 9405 
  """
9406 
 
9407 
  thrift_spec = (
9408 
    None, # 0
559 chandransh 9409 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 9410 
  )
9411 
 
559 chandransh 9412 
  def __init__(self, cartId=None,):
9413 
    self.cartId = cartId
504 rajveer 9414 
 
9415 
  def read(self, iprot):
9416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9418 
      return
9419 
    iprot.readStructBegin()
9420 
    while True:
9421 
      (fname, ftype, fid) = iprot.readFieldBegin()
9422 
      if ftype == TType.STOP:
9423 
        break
9424 
      if fid == 1:
9425 
        if ftype == TType.I64:
559 chandransh 9426 
          self.cartId = iprot.readI64();
504 rajveer 9427 
        else:
9428 
          iprot.skip(ftype)
9429 
      else:
9430 
        iprot.skip(ftype)
9431 
      iprot.readFieldEnd()
9432 
    iprot.readStructEnd()
9433 
 
9434 
  def write(self, oprot):
9435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9437 
      return
559 chandransh 9438 
    oprot.writeStructBegin('getCart_args')
9439 
    if self.cartId != None:
9440 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9441 
      oprot.writeI64(self.cartId)
504 rajveer 9442 
      oprot.writeFieldEnd()
9443 
    oprot.writeFieldStop()
9444 
    oprot.writeStructEnd()
9445 
 
9446 
  def __repr__(self):
9447 
    L = ['%s=%r' % (key, value)
9448 
      for key, value in self.__dict__.iteritems()]
9449 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9450 
 
9451 
  def __eq__(self, other):
9452 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9453 
 
9454 
  def __ne__(self, other):
9455 
    return not (self == other)
9456 
 
559 chandransh 9457 
class getCart_result:
504 rajveer 9458 
  """
9459 
  Attributes:
9460 
   - success
559 chandransh 9461 
   - scx
504 rajveer 9462 
  """
9463 
 
9464 
  thrift_spec = (
559 chandransh 9465 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9466 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 9467 
  )
9468 
 
559 chandransh 9469 
  def __init__(self, success=None, scx=None,):
504 rajveer 9470 
    self.success = success
559 chandransh 9471 
    self.scx = scx
504 rajveer 9472 
 
9473 
  def read(self, iprot):
9474 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9475 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9476 
      return
9477 
    iprot.readStructBegin()
9478 
    while True:
9479 
      (fname, ftype, fid) = iprot.readFieldBegin()
9480 
      if ftype == TType.STOP:
9481 
        break
9482 
      if fid == 0:
559 chandransh 9483 
        if ftype == TType.STRUCT:
9484 
          self.success = Cart()
9485 
          self.success.read(iprot)
504 rajveer 9486 
        else:
9487 
          iprot.skip(ftype)
9488 
      elif fid == 1:
9489 
        if ftype == TType.STRUCT:
559 chandransh 9490 
          self.scx = ShoppingCartException()
9491 
          self.scx.read(iprot)
504 rajveer 9492 
        else:
9493 
          iprot.skip(ftype)
9494 
      else:
9495 
        iprot.skip(ftype)
9496 
      iprot.readFieldEnd()
9497 
    iprot.readStructEnd()
9498 
 
9499 
  def write(self, oprot):
9500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9502 
      return
559 chandransh 9503 
    oprot.writeStructBegin('getCart_result')
504 rajveer 9504 
    if self.success != None:
559 chandransh 9505 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9506 
      self.success.write(oprot)
504 rajveer 9507 
      oprot.writeFieldEnd()
559 chandransh 9508 
    if self.scx != None:
9509 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9510 
      self.scx.write(oprot)
504 rajveer 9511 
      oprot.writeFieldEnd()
9512 
    oprot.writeFieldStop()
9513 
    oprot.writeStructEnd()
9514 
 
9515 
  def __repr__(self):
9516 
    L = ['%s=%r' % (key, value)
9517 
      for key, value in self.__dict__.iteritems()]
9518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9519 
 
9520 
  def __eq__(self, other):
9521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9522 
 
9523 
  def __ne__(self, other):
9524 
    return not (self == other)
9525 
 
559 chandransh 9526 
class getCartsForUser_args:
94 ashish 9527 
  """
9528 
  Attributes:
559 chandransh 9529 
   - userId
9530 
   - status
94 ashish 9531 
  """
9532 
 
9533 
  thrift_spec = (
9534 
    None, # 0
559 chandransh 9535 
    (1, TType.I64, 'userId', None, None, ), # 1
9536 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 9537 
  )
9538 
 
559 chandransh 9539 
  def __init__(self, userId=None, status=None,):
9540 
    self.userId = userId
9541 
    self.status = status
94 ashish 9542 
 
9543 
  def read(self, iprot):
9544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9546 
      return
9547 
    iprot.readStructBegin()
9548 
    while True:
9549 
      (fname, ftype, fid) = iprot.readFieldBegin()
9550 
      if ftype == TType.STOP:
9551 
        break
9552 
      if fid == 1:
9553 
        if ftype == TType.I64:
559 chandransh 9554 
          self.userId = iprot.readI64();
94 ashish 9555 
        else:
9556 
          iprot.skip(ftype)
9557 
      elif fid == 2:
559 chandransh 9558 
        if ftype == TType.I32:
9559 
          self.status = iprot.readI32();
94 ashish 9560 
        else:
9561 
          iprot.skip(ftype)
9562 
      else:
9563 
        iprot.skip(ftype)
9564 
      iprot.readFieldEnd()
9565 
    iprot.readStructEnd()
9566 
 
9567 
  def write(self, oprot):
9568 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9569 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9570 
      return
559 chandransh 9571 
    oprot.writeStructBegin('getCartsForUser_args')
9572 
    if self.userId != None:
9573 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9574 
      oprot.writeI64(self.userId)
94 ashish 9575 
      oprot.writeFieldEnd()
559 chandransh 9576 
    if self.status != None:
9577 
      oprot.writeFieldBegin('status', TType.I32, 2)
9578 
      oprot.writeI32(self.status)
94 ashish 9579 
      oprot.writeFieldEnd()
9580 
    oprot.writeFieldStop()
9581 
    oprot.writeStructEnd()
9582 
 
9583 
  def __repr__(self):
9584 
    L = ['%s=%r' % (key, value)
9585 
      for key, value in self.__dict__.iteritems()]
9586 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9587 
 
9588 
  def __eq__(self, other):
9589 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9590 
 
9591 
  def __ne__(self, other):
9592 
    return not (self == other)
9593 
 
559 chandransh 9594 
class getCartsForUser_result:
94 ashish 9595 
  """
9596 
  Attributes:
9597 
   - success
559 chandransh 9598 
   - scx
94 ashish 9599 
  """
9600 
 
9601 
  thrift_spec = (
559 chandransh 9602 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9603 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9604 
  )
9605 
 
559 chandransh 9606 
  def __init__(self, success=None, scx=None,):
94 ashish 9607 
    self.success = success
559 chandransh 9608 
    self.scx = scx
94 ashish 9609 
 
9610 
  def read(self, iprot):
9611 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9612 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9613 
      return
9614 
    iprot.readStructBegin()
9615 
    while True:
9616 
      (fname, ftype, fid) = iprot.readFieldBegin()
9617 
      if ftype == TType.STOP:
9618 
        break
9619 
      if fid == 0:
559 chandransh 9620 
        if ftype == TType.LIST:
9621 
          self.success = []
3385 varun.gupt 9622 
          (_etype94, _size91) = iprot.readListBegin()
9623 
          for _i95 in xrange(_size91):
9624 
            _elem96 = Cart()
9625 
            _elem96.read(iprot)
9626 
            self.success.append(_elem96)
559 chandransh 9627 
          iprot.readListEnd()
94 ashish 9628 
        else:
9629 
          iprot.skip(ftype)
9630 
      elif fid == 1:
9631 
        if ftype == TType.STRUCT:
559 chandransh 9632 
          self.scx = ShoppingCartException()
9633 
          self.scx.read(iprot)
94 ashish 9634 
        else:
9635 
          iprot.skip(ftype)
9636 
      else:
9637 
        iprot.skip(ftype)
9638 
      iprot.readFieldEnd()
9639 
    iprot.readStructEnd()
9640 
 
9641 
  def write(self, oprot):
9642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9644 
      return
559 chandransh 9645 
    oprot.writeStructBegin('getCartsForUser_result')
94 ashish 9646 
    if self.success != None:
559 chandransh 9647 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9648 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3385 varun.gupt 9649 
      for iter97 in self.success:
9650 
        iter97.write(oprot)
559 chandransh 9651 
      oprot.writeListEnd()
94 ashish 9652 
      oprot.writeFieldEnd()
559 chandransh 9653 
    if self.scx != None:
9654 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9655 
      self.scx.write(oprot)
94 ashish 9656 
      oprot.writeFieldEnd()
9657 
    oprot.writeFieldStop()
9658 
    oprot.writeStructEnd()
9659 
 
9660 
  def __repr__(self):
9661 
    L = ['%s=%r' % (key, value)
9662 
      for key, value in self.__dict__.iteritems()]
9663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9664 
 
9665 
  def __eq__(self, other):
9666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9667 
 
9668 
  def __ne__(self, other):
9669 
    return not (self == other)
9670 
 
559 chandransh 9671 
class getCartsByStatus_args:
94 ashish 9672 
  """
9673 
  Attributes:
559 chandransh 9674 
   - status
94 ashish 9675 
  """
9676 
 
9677 
  thrift_spec = (
9678 
    None, # 0
559 chandransh 9679 
    (1, TType.I32, 'status', None, None, ), # 1
94 ashish 9680 
  )
9681 
 
559 chandransh 9682 
  def __init__(self, status=None,):
9683 
    self.status = status
94 ashish 9684 
 
9685 
  def read(self, iprot):
9686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9688 
      return
9689 
    iprot.readStructBegin()
9690 
    while True:
9691 
      (fname, ftype, fid) = iprot.readFieldBegin()
9692 
      if ftype == TType.STOP:
9693 
        break
9694 
      if fid == 1:
559 chandransh 9695 
        if ftype == TType.I32:
9696 
          self.status = iprot.readI32();
9697 
        else:
9698 
          iprot.skip(ftype)
9699 
      else:
9700 
        iprot.skip(ftype)
9701 
      iprot.readFieldEnd()
9702 
    iprot.readStructEnd()
9703 
 
9704 
  def write(self, oprot):
9705 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9706 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9707 
      return
9708 
    oprot.writeStructBegin('getCartsByStatus_args')
9709 
    if self.status != None:
9710 
      oprot.writeFieldBegin('status', TType.I32, 1)
9711 
      oprot.writeI32(self.status)
9712 
      oprot.writeFieldEnd()
9713 
    oprot.writeFieldStop()
9714 
    oprot.writeStructEnd()
9715 
 
9716 
  def __repr__(self):
9717 
    L = ['%s=%r' % (key, value)
9718 
      for key, value in self.__dict__.iteritems()]
9719 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9720 
 
9721 
  def __eq__(self, other):
9722 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9723 
 
9724 
  def __ne__(self, other):
9725 
    return not (self == other)
9726 
 
9727 
class getCartsByStatus_result:
9728 
  """
9729 
  Attributes:
9730 
   - success
9731 
   - scx
9732 
  """
9733 
 
9734 
  thrift_spec = (
9735 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9736 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9737 
  )
9738 
 
9739 
  def __init__(self, success=None, scx=None,):
9740 
    self.success = success
9741 
    self.scx = scx
9742 
 
9743 
  def read(self, iprot):
9744 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9745 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9746 
      return
9747 
    iprot.readStructBegin()
9748 
    while True:
9749 
      (fname, ftype, fid) = iprot.readFieldBegin()
9750 
      if ftype == TType.STOP:
9751 
        break
9752 
      if fid == 0:
9753 
        if ftype == TType.LIST:
9754 
          self.success = []
3385 varun.gupt 9755 
          (_etype101, _size98) = iprot.readListBegin()
9756 
          for _i102 in xrange(_size98):
9757 
            _elem103 = Cart()
9758 
            _elem103.read(iprot)
9759 
            self.success.append(_elem103)
559 chandransh 9760 
          iprot.readListEnd()
9761 
        else:
9762 
          iprot.skip(ftype)
9763 
      elif 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('getCartsByStatus_result')
9779 
    if self.success != None:
9780 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9781 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3385 varun.gupt 9782 
      for iter104 in self.success:
9783 
        iter104.write(oprot)
559 chandransh 9784 
      oprot.writeListEnd()
9785 
      oprot.writeFieldEnd()
9786 
    if self.scx != None:
9787 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9788 
      self.scx.write(oprot)
9789 
      oprot.writeFieldEnd()
9790 
    oprot.writeFieldStop()
9791 
    oprot.writeStructEnd()
9792 
 
9793 
  def __repr__(self):
9794 
    L = ['%s=%r' % (key, value)
9795 
      for key, value in self.__dict__.iteritems()]
9796 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9797 
 
9798 
  def __eq__(self, other):
9799 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9800 
 
9801 
  def __ne__(self, other):
9802 
    return not (self == other)
9803 
 
9804 
class getCartsByTime_args:
9805 
  """
9806 
  Attributes:
9807 
   - from_time
9808 
   - to_time
9809 
   - status
9810 
  """
9811 
 
9812 
  thrift_spec = (
9813 
    None, # 0
9814 
    (1, TType.I64, 'from_time', None, None, ), # 1
9815 
    (2, TType.I64, 'to_time', None, None, ), # 2
9816 
    (3, TType.I32, 'status', None, None, ), # 3
9817 
  )
9818 
 
9819 
  def __init__(self, from_time=None, to_time=None, status=None,):
9820 
    self.from_time = from_time
9821 
    self.to_time = to_time
9822 
    self.status = status
9823 
 
9824 
  def read(self, iprot):
9825 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9826 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9827 
      return
9828 
    iprot.readStructBegin()
9829 
    while True:
9830 
      (fname, ftype, fid) = iprot.readFieldBegin()
9831 
      if ftype == TType.STOP:
9832 
        break
9833 
      if fid == 1:
94 ashish 9834 
        if ftype == TType.I64:
559 chandransh 9835 
          self.from_time = iprot.readI64();
94 ashish 9836 
        else:
9837 
          iprot.skip(ftype)
122 ashish 9838 
      elif fid == 2:
559 chandransh 9839 
        if ftype == TType.I64:
9840 
          self.to_time = iprot.readI64();
122 ashish 9841 
        else:
9842 
          iprot.skip(ftype)
559 chandransh 9843 
      elif fid == 3:
9844 
        if ftype == TType.I32:
9845 
          self.status = iprot.readI32();
9846 
        else:
9847 
          iprot.skip(ftype)
94 ashish 9848 
      else:
9849 
        iprot.skip(ftype)
9850 
      iprot.readFieldEnd()
9851 
    iprot.readStructEnd()
9852 
 
9853 
  def write(self, oprot):
9854 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9855 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9856 
      return
559 chandransh 9857 
    oprot.writeStructBegin('getCartsByTime_args')
9858 
    if self.from_time != None:
9859 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
9860 
      oprot.writeI64(self.from_time)
94 ashish 9861 
      oprot.writeFieldEnd()
559 chandransh 9862 
    if self.to_time != None:
9863 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
9864 
      oprot.writeI64(self.to_time)
122 ashish 9865 
      oprot.writeFieldEnd()
559 chandransh 9866 
    if self.status != None:
9867 
      oprot.writeFieldBegin('status', TType.I32, 3)
9868 
      oprot.writeI32(self.status)
9869 
      oprot.writeFieldEnd()
94 ashish 9870 
    oprot.writeFieldStop()
9871 
    oprot.writeStructEnd()
9872 
 
9873 
  def __repr__(self):
9874 
    L = ['%s=%r' % (key, value)
9875 
      for key, value in self.__dict__.iteritems()]
9876 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9877 
 
9878 
  def __eq__(self, other):
9879 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9880 
 
9881 
  def __ne__(self, other):
9882 
    return not (self == other)
9883 
 
559 chandransh 9884 
class getCartsByTime_result:
94 ashish 9885 
  """
9886 
  Attributes:
9887 
   - success
559 chandransh 9888 
   - scx
94 ashish 9889 
  """
9890 
 
9891 
  thrift_spec = (
559 chandransh 9892 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9893 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9894 
  )
9895 
 
559 chandransh 9896 
  def __init__(self, success=None, scx=None,):
94 ashish 9897 
    self.success = success
559 chandransh 9898 
    self.scx = scx
94 ashish 9899 
 
9900 
  def read(self, iprot):
9901 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9902 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9903 
      return
9904 
    iprot.readStructBegin()
9905 
    while True:
9906 
      (fname, ftype, fid) = iprot.readFieldBegin()
9907 
      if ftype == TType.STOP:
9908 
        break
9909 
      if fid == 0:
559 chandransh 9910 
        if ftype == TType.LIST:
9911 
          self.success = []
3385 varun.gupt 9912 
          (_etype108, _size105) = iprot.readListBegin()
9913 
          for _i109 in xrange(_size105):
9914 
            _elem110 = Cart()
9915 
            _elem110.read(iprot)
9916 
            self.success.append(_elem110)
559 chandransh 9917 
          iprot.readListEnd()
94 ashish 9918 
        else:
9919 
          iprot.skip(ftype)
9920 
      elif fid == 1:
9921 
        if ftype == TType.STRUCT:
559 chandransh 9922 
          self.scx = ShoppingCartException()
9923 
          self.scx.read(iprot)
94 ashish 9924 
        else:
9925 
          iprot.skip(ftype)
9926 
      else:
9927 
        iprot.skip(ftype)
9928 
      iprot.readFieldEnd()
9929 
    iprot.readStructEnd()
9930 
 
9931 
  def write(self, oprot):
9932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9934 
      return
559 chandransh 9935 
    oprot.writeStructBegin('getCartsByTime_result')
94 ashish 9936 
    if self.success != None:
559 chandransh 9937 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9938 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3385 varun.gupt 9939 
      for iter111 in self.success:
9940 
        iter111.write(oprot)
559 chandransh 9941 
      oprot.writeListEnd()
94 ashish 9942 
      oprot.writeFieldEnd()
559 chandransh 9943 
    if self.scx != None:
9944 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9945 
      self.scx.write(oprot)
94 ashish 9946 
      oprot.writeFieldEnd()
9947 
    oprot.writeFieldStop()
9948 
    oprot.writeStructEnd()
9949 
 
9950 
  def __repr__(self):
9951 
    L = ['%s=%r' % (key, value)
9952 
      for key, value in self.__dict__.iteritems()]
9953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9954 
 
9955 
  def __eq__(self, other):
9956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9957 
 
9958 
  def __ne__(self, other):
9959 
    return not (self == other)
9960 
 
559 chandransh 9961 
class changeCartStatus_args:
94 ashish 9962 
  """
9963 
  Attributes:
559 chandransh 9964 
   - cartId
9965 
   - status
94 ashish 9966 
  """
9967 
 
9968 
  thrift_spec = (
9969 
    None, # 0
559 chandransh 9970 
    (1, TType.I64, 'cartId', None, None, ), # 1
9971 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 9972 
  )
9973 
 
559 chandransh 9974 
  def __init__(self, cartId=None, status=None,):
9975 
    self.cartId = cartId
9976 
    self.status = status
94 ashish 9977 
 
9978 
  def read(self, iprot):
9979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9981 
      return
9982 
    iprot.readStructBegin()
9983 
    while True:
9984 
      (fname, ftype, fid) = iprot.readFieldBegin()
9985 
      if ftype == TType.STOP:
9986 
        break
9987 
      if fid == 1:
9988 
        if ftype == TType.I64:
559 chandransh 9989 
          self.cartId = iprot.readI64();
94 ashish 9990 
        else:
9991 
          iprot.skip(ftype)
559 chandransh 9992 
      elif fid == 2:
9993 
        if ftype == TType.I32:
9994 
          self.status = iprot.readI32();
9995 
        else:
9996 
          iprot.skip(ftype)
94 ashish 9997 
      else:
9998 
        iprot.skip(ftype)
9999 
      iprot.readFieldEnd()
10000 
    iprot.readStructEnd()
10001 
 
10002 
  def write(self, oprot):
10003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10005 
      return
559 chandransh 10006 
    oprot.writeStructBegin('changeCartStatus_args')
10007 
    if self.cartId != None:
10008 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10009 
      oprot.writeI64(self.cartId)
94 ashish 10010 
      oprot.writeFieldEnd()
559 chandransh 10011 
    if self.status != None:
10012 
      oprot.writeFieldBegin('status', TType.I32, 2)
10013 
      oprot.writeI32(self.status)
10014 
      oprot.writeFieldEnd()
94 ashish 10015 
    oprot.writeFieldStop()
10016 
    oprot.writeStructEnd()
10017 
 
10018 
  def __repr__(self):
10019 
    L = ['%s=%r' % (key, value)
10020 
      for key, value in self.__dict__.iteritems()]
10021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10022 
 
10023 
  def __eq__(self, other):
10024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10025 
 
10026 
  def __ne__(self, other):
10027 
    return not (self == other)
10028 
 
559 chandransh 10029 
class changeCartStatus_result:
94 ashish 10030 
  """
10031 
  Attributes:
559 chandransh 10032 
   - scx
10033 
  """
10034 
 
10035 
  thrift_spec = (
10036 
    None, # 0
10037 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10038 
  )
10039 
 
10040 
  def __init__(self, scx=None,):
10041 
    self.scx = scx
10042 
 
10043 
  def read(self, iprot):
10044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10046 
      return
10047 
    iprot.readStructBegin()
10048 
    while True:
10049 
      (fname, ftype, fid) = iprot.readFieldBegin()
10050 
      if ftype == TType.STOP:
10051 
        break
10052 
      if fid == 1:
10053 
        if ftype == TType.STRUCT:
10054 
          self.scx = ShoppingCartException()
10055 
          self.scx.read(iprot)
10056 
        else:
10057 
          iprot.skip(ftype)
10058 
      else:
10059 
        iprot.skip(ftype)
10060 
      iprot.readFieldEnd()
10061 
    iprot.readStructEnd()
10062 
 
10063 
  def write(self, oprot):
10064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10066 
      return
10067 
    oprot.writeStructBegin('changeCartStatus_result')
10068 
    if self.scx != None:
10069 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10070 
      self.scx.write(oprot)
10071 
      oprot.writeFieldEnd()
10072 
    oprot.writeFieldStop()
10073 
    oprot.writeStructEnd()
10074 
 
10075 
  def __repr__(self):
10076 
    L = ['%s=%r' % (key, value)
10077 
      for key, value in self.__dict__.iteritems()]
10078 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10079 
 
10080 
  def __eq__(self, other):
10081 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10082 
 
10083 
  def __ne__(self, other):
10084 
    return not (self == other)
10085 
 
10086 
class addItemToCart_args:
10087 
  """
10088 
  Attributes:
10089 
   - cartId
10090 
   - itemId
10091 
   - quantity
10092 
  """
10093 
 
10094 
  thrift_spec = (
10095 
    None, # 0
10096 
    (1, TType.I64, 'cartId', None, None, ), # 1
10097 
    (2, TType.I64, 'itemId', None, None, ), # 2
10098 
    (3, TType.I64, 'quantity', None, None, ), # 3
10099 
  )
10100 
 
10101 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
10102 
    self.cartId = cartId
10103 
    self.itemId = itemId
10104 
    self.quantity = quantity
10105 
 
10106 
  def read(self, iprot):
10107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10109 
      return
10110 
    iprot.readStructBegin()
10111 
    while True:
10112 
      (fname, ftype, fid) = iprot.readFieldBegin()
10113 
      if ftype == TType.STOP:
10114 
        break
10115 
      if fid == 1:
10116 
        if ftype == TType.I64:
10117 
          self.cartId = iprot.readI64();
10118 
        else:
10119 
          iprot.skip(ftype)
10120 
      elif fid == 2:
10121 
        if ftype == TType.I64:
10122 
          self.itemId = iprot.readI64();
10123 
        else:
10124 
          iprot.skip(ftype)
10125 
      elif fid == 3:
10126 
        if ftype == TType.I64:
10127 
          self.quantity = iprot.readI64();
10128 
        else:
10129 
          iprot.skip(ftype)
10130 
      else:
10131 
        iprot.skip(ftype)
10132 
      iprot.readFieldEnd()
10133 
    iprot.readStructEnd()
10134 
 
10135 
  def write(self, oprot):
10136 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10137 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10138 
      return
10139 
    oprot.writeStructBegin('addItemToCart_args')
10140 
    if self.cartId != None:
10141 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10142 
      oprot.writeI64(self.cartId)
10143 
      oprot.writeFieldEnd()
10144 
    if self.itemId != None:
10145 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10146 
      oprot.writeI64(self.itemId)
10147 
      oprot.writeFieldEnd()
10148 
    if self.quantity != None:
10149 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10150 
      oprot.writeI64(self.quantity)
10151 
      oprot.writeFieldEnd()
10152 
    oprot.writeFieldStop()
10153 
    oprot.writeStructEnd()
10154 
 
10155 
  def __repr__(self):
10156 
    L = ['%s=%r' % (key, value)
10157 
      for key, value in self.__dict__.iteritems()]
10158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10159 
 
10160 
  def __eq__(self, other):
10161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10162 
 
10163 
  def __ne__(self, other):
10164 
    return not (self == other)
10165 
 
10166 
class addItemToCart_result:
10167 
  """
10168 
  Attributes:
2035 rajveer 10169 
   - success
559 chandransh 10170 
   - scx
10171 
  """
10172 
 
10173 
  thrift_spec = (
2035 rajveer 10174 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 10175 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10176 
  )
10177 
 
2035 rajveer 10178 
  def __init__(self, success=None, scx=None,):
10179 
    self.success = success
559 chandransh 10180 
    self.scx = scx
10181 
 
10182 
  def read(self, iprot):
10183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10185 
      return
10186 
    iprot.readStructBegin()
10187 
    while True:
10188 
      (fname, ftype, fid) = iprot.readFieldBegin()
10189 
      if ftype == TType.STOP:
10190 
        break
2035 rajveer 10191 
      if fid == 0:
10192 
        if ftype == TType.STRING:
10193 
          self.success = iprot.readString();
10194 
        else:
10195 
          iprot.skip(ftype)
10196 
      elif fid == 1:
559 chandransh 10197 
        if ftype == TType.STRUCT:
10198 
          self.scx = ShoppingCartException()
10199 
          self.scx.read(iprot)
10200 
        else:
10201 
          iprot.skip(ftype)
10202 
      else:
10203 
        iprot.skip(ftype)
10204 
      iprot.readFieldEnd()
10205 
    iprot.readStructEnd()
10206 
 
10207 
  def write(self, oprot):
10208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10210 
      return
10211 
    oprot.writeStructBegin('addItemToCart_result')
2035 rajveer 10212 
    if self.success != None:
10213 
      oprot.writeFieldBegin('success', TType.STRING, 0)
10214 
      oprot.writeString(self.success)
10215 
      oprot.writeFieldEnd()
559 chandransh 10216 
    if self.scx != None:
10217 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10218 
      self.scx.write(oprot)
10219 
      oprot.writeFieldEnd()
10220 
    oprot.writeFieldStop()
10221 
    oprot.writeStructEnd()
10222 
 
10223 
  def __repr__(self):
10224 
    L = ['%s=%r' % (key, value)
10225 
      for key, value in self.__dict__.iteritems()]
10226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10227 
 
10228 
  def __eq__(self, other):
10229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10230 
 
10231 
  def __ne__(self, other):
10232 
    return not (self == other)
10233 
 
10234 
class deleteItemFromCart_args:
10235 
  """
10236 
  Attributes:
10237 
   - cartId
10238 
   - itemId
10239 
  """
10240 
 
10241 
  thrift_spec = (
10242 
    None, # 0
10243 
    (1, TType.I64, 'cartId', None, None, ), # 1
10244 
    (2, TType.I64, 'itemId', None, None, ), # 2
10245 
  )
10246 
 
10247 
  def __init__(self, cartId=None, itemId=None,):
10248 
    self.cartId = cartId
10249 
    self.itemId = itemId
10250 
 
10251 
  def read(self, iprot):
10252 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10253 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10254 
      return
10255 
    iprot.readStructBegin()
10256 
    while True:
10257 
      (fname, ftype, fid) = iprot.readFieldBegin()
10258 
      if ftype == TType.STOP:
10259 
        break
10260 
      if fid == 1:
10261 
        if ftype == TType.I64:
10262 
          self.cartId = iprot.readI64();
10263 
        else:
10264 
          iprot.skip(ftype)
10265 
      elif fid == 2:
10266 
        if ftype == TType.I64:
10267 
          self.itemId = iprot.readI64();
10268 
        else:
10269 
          iprot.skip(ftype)
10270 
      else:
10271 
        iprot.skip(ftype)
10272 
      iprot.readFieldEnd()
10273 
    iprot.readStructEnd()
10274 
 
10275 
  def write(self, oprot):
10276 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10277 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10278 
      return
10279 
    oprot.writeStructBegin('deleteItemFromCart_args')
10280 
    if self.cartId != None:
10281 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10282 
      oprot.writeI64(self.cartId)
10283 
      oprot.writeFieldEnd()
10284 
    if self.itemId != None:
10285 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10286 
      oprot.writeI64(self.itemId)
10287 
      oprot.writeFieldEnd()
10288 
    oprot.writeFieldStop()
10289 
    oprot.writeStructEnd()
10290 
 
10291 
  def __repr__(self):
10292 
    L = ['%s=%r' % (key, value)
10293 
      for key, value in self.__dict__.iteritems()]
10294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10295 
 
10296 
  def __eq__(self, other):
10297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10298 
 
10299 
  def __ne__(self, other):
10300 
    return not (self == other)
10301 
 
10302 
class deleteItemFromCart_result:
10303 
  """
10304 
  Attributes:
10305 
   - scx
10306 
  """
10307 
 
10308 
  thrift_spec = (
10309 
    None, # 0
10310 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10311 
  )
10312 
 
10313 
  def __init__(self, scx=None,):
10314 
    self.scx = scx
10315 
 
10316 
  def read(self, iprot):
10317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10319 
      return
10320 
    iprot.readStructBegin()
10321 
    while True:
10322 
      (fname, ftype, fid) = iprot.readFieldBegin()
10323 
      if ftype == TType.STOP:
10324 
        break
10325 
      if fid == 1:
10326 
        if ftype == TType.STRUCT:
10327 
          self.scx = ShoppingCartException()
10328 
          self.scx.read(iprot)
10329 
        else:
10330 
          iprot.skip(ftype)
10331 
      else:
10332 
        iprot.skip(ftype)
10333 
      iprot.readFieldEnd()
10334 
    iprot.readStructEnd()
10335 
 
10336 
  def write(self, oprot):
10337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10339 
      return
10340 
    oprot.writeStructBegin('deleteItemFromCart_result')
10341 
    if self.scx != None:
10342 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10343 
      self.scx.write(oprot)
10344 
      oprot.writeFieldEnd()
10345 
    oprot.writeFieldStop()
10346 
    oprot.writeStructEnd()
10347 
 
10348 
  def __repr__(self):
10349 
    L = ['%s=%r' % (key, value)
10350 
      for key, value in self.__dict__.iteritems()]
10351 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10352 
 
10353 
  def __eq__(self, other):
10354 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10355 
 
10356 
  def __ne__(self, other):
10357 
    return not (self == other)
10358 
 
10359 
class changeQuantity_args:
10360 
  """
10361 
  Attributes:
10362 
   - cartId
10363 
   - itemId
10364 
   - quantity
10365 
  """
10366 
 
10367 
  thrift_spec = (
10368 
    None, # 0
10369 
    (1, TType.I64, 'cartId', None, None, ), # 1
10370 
    (2, TType.I64, 'itemId', None, None, ), # 2
10371 
    (3, TType.I64, 'quantity', None, None, ), # 3
10372 
  )
10373 
 
10374 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
10375 
    self.cartId = cartId
10376 
    self.itemId = itemId
10377 
    self.quantity = quantity
10378 
 
10379 
  def read(self, iprot):
10380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10382 
      return
10383 
    iprot.readStructBegin()
10384 
    while True:
10385 
      (fname, ftype, fid) = iprot.readFieldBegin()
10386 
      if ftype == TType.STOP:
10387 
        break
10388 
      if fid == 1:
10389 
        if ftype == TType.I64:
10390 
          self.cartId = iprot.readI64();
10391 
        else:
10392 
          iprot.skip(ftype)
10393 
      elif fid == 2:
10394 
        if ftype == TType.I64:
10395 
          self.itemId = iprot.readI64();
10396 
        else:
10397 
          iprot.skip(ftype)
10398 
      elif fid == 3:
10399 
        if ftype == TType.I64:
10400 
          self.quantity = iprot.readI64();
10401 
        else:
10402 
          iprot.skip(ftype)
10403 
      else:
10404 
        iprot.skip(ftype)
10405 
      iprot.readFieldEnd()
10406 
    iprot.readStructEnd()
10407 
 
10408 
  def write(self, oprot):
10409 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10410 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10411 
      return
10412 
    oprot.writeStructBegin('changeQuantity_args')
10413 
    if self.cartId != None:
10414 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10415 
      oprot.writeI64(self.cartId)
10416 
      oprot.writeFieldEnd()
10417 
    if self.itemId != None:
10418 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10419 
      oprot.writeI64(self.itemId)
10420 
      oprot.writeFieldEnd()
10421 
    if self.quantity != None:
10422 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10423 
      oprot.writeI64(self.quantity)
10424 
      oprot.writeFieldEnd()
10425 
    oprot.writeFieldStop()
10426 
    oprot.writeStructEnd()
10427 
 
10428 
  def __repr__(self):
10429 
    L = ['%s=%r' % (key, value)
10430 
      for key, value in self.__dict__.iteritems()]
10431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10432 
 
10433 
  def __eq__(self, other):
10434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10435 
 
10436 
  def __ne__(self, other):
10437 
    return not (self == other)
10438 
 
10439 
class changeQuantity_result:
10440 
  """
10441 
  Attributes:
10442 
   - scx
10443 
  """
10444 
 
10445 
  thrift_spec = (
10446 
    None, # 0
10447 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10448 
  )
10449 
 
10450 
  def __init__(self, scx=None,):
10451 
    self.scx = scx
10452 
 
10453 
  def read(self, iprot):
10454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10456 
      return
10457 
    iprot.readStructBegin()
10458 
    while True:
10459 
      (fname, ftype, fid) = iprot.readFieldBegin()
10460 
      if ftype == TType.STOP:
10461 
        break
10462 
      if fid == 1:
10463 
        if ftype == TType.STRUCT:
10464 
          self.scx = ShoppingCartException()
10465 
          self.scx.read(iprot)
10466 
        else:
10467 
          iprot.skip(ftype)
10468 
      else:
10469 
        iprot.skip(ftype)
10470 
      iprot.readFieldEnd()
10471 
    iprot.readStructEnd()
10472 
 
10473 
  def write(self, oprot):
10474 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10475 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10476 
      return
10477 
    oprot.writeStructBegin('changeQuantity_result')
10478 
    if self.scx != None:
10479 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10480 
      self.scx.write(oprot)
10481 
      oprot.writeFieldEnd()
10482 
    oprot.writeFieldStop()
10483 
    oprot.writeStructEnd()
10484 
 
10485 
  def __repr__(self):
10486 
    L = ['%s=%r' % (key, value)
10487 
      for key, value in self.__dict__.iteritems()]
10488 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10489 
 
10490 
  def __eq__(self, other):
10491 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10492 
 
10493 
  def __ne__(self, other):
10494 
    return not (self == other)
10495 
 
10496 
class changeItemStatus_args:
10497 
  """
10498 
  Attributes:
10499 
   - cartId
10500 
   - itemId
10501 
   - status
10502 
  """
10503 
 
10504 
  thrift_spec = (
10505 
    None, # 0
10506 
    (1, TType.I64, 'cartId', None, None, ), # 1
10507 
    (2, TType.I64, 'itemId', None, None, ), # 2
10508 
    (3, TType.I32, 'status', None, None, ), # 3
10509 
  )
10510 
 
10511 
  def __init__(self, cartId=None, itemId=None, status=None,):
10512 
    self.cartId = cartId
10513 
    self.itemId = itemId
10514 
    self.status = status
10515 
 
10516 
  def read(self, iprot):
10517 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10518 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10519 
      return
10520 
    iprot.readStructBegin()
10521 
    while True:
10522 
      (fname, ftype, fid) = iprot.readFieldBegin()
10523 
      if ftype == TType.STOP:
10524 
        break
10525 
      if fid == 1:
10526 
        if ftype == TType.I64:
10527 
          self.cartId = iprot.readI64();
10528 
        else:
10529 
          iprot.skip(ftype)
10530 
      elif fid == 2:
10531 
        if ftype == TType.I64:
10532 
          self.itemId = iprot.readI64();
10533 
        else:
10534 
          iprot.skip(ftype)
10535 
      elif fid == 3:
10536 
        if ftype == TType.I32:
10537 
          self.status = iprot.readI32();
10538 
        else:
10539 
          iprot.skip(ftype)
10540 
      else:
10541 
        iprot.skip(ftype)
10542 
      iprot.readFieldEnd()
10543 
    iprot.readStructEnd()
10544 
 
10545 
  def write(self, oprot):
10546 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10547 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10548 
      return
10549 
    oprot.writeStructBegin('changeItemStatus_args')
10550 
    if self.cartId != None:
10551 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10552 
      oprot.writeI64(self.cartId)
10553 
      oprot.writeFieldEnd()
10554 
    if self.itemId != None:
10555 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10556 
      oprot.writeI64(self.itemId)
10557 
      oprot.writeFieldEnd()
10558 
    if self.status != None:
10559 
      oprot.writeFieldBegin('status', TType.I32, 3)
10560 
      oprot.writeI32(self.status)
10561 
      oprot.writeFieldEnd()
10562 
    oprot.writeFieldStop()
10563 
    oprot.writeStructEnd()
10564 
 
10565 
  def __repr__(self):
10566 
    L = ['%s=%r' % (key, value)
10567 
      for key, value in self.__dict__.iteritems()]
10568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10569 
 
10570 
  def __eq__(self, other):
10571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10572 
 
10573 
  def __ne__(self, other):
10574 
    return not (self == other)
10575 
 
10576 
class changeItemStatus_result:
10577 
  """
10578 
  Attributes:
10579 
   - scx
10580 
  """
10581 
 
10582 
  thrift_spec = (
10583 
    None, # 0
10584 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10585 
  )
10586 
 
10587 
  def __init__(self, scx=None,):
10588 
    self.scx = scx
10589 
 
10590 
  def read(self, iprot):
10591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10593 
      return
10594 
    iprot.readStructBegin()
10595 
    while True:
10596 
      (fname, ftype, fid) = iprot.readFieldBegin()
10597 
      if ftype == TType.STOP:
10598 
        break
10599 
      if fid == 1:
10600 
        if ftype == TType.STRUCT:
10601 
          self.scx = ShoppingCartException()
10602 
          self.scx.read(iprot)
10603 
        else:
10604 
          iprot.skip(ftype)
10605 
      else:
10606 
        iprot.skip(ftype)
10607 
      iprot.readFieldEnd()
10608 
    iprot.readStructEnd()
10609 
 
10610 
  def write(self, oprot):
10611 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10612 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10613 
      return
10614 
    oprot.writeStructBegin('changeItemStatus_result')
10615 
    if self.scx != None:
10616 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10617 
      self.scx.write(oprot)
10618 
      oprot.writeFieldEnd()
10619 
    oprot.writeFieldStop()
10620 
    oprot.writeStructEnd()
10621 
 
10622 
  def __repr__(self):
10623 
    L = ['%s=%r' % (key, value)
10624 
      for key, value in self.__dict__.iteritems()]
10625 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10626 
 
10627 
  def __eq__(self, other):
10628 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10629 
 
10630 
  def __ne__(self, other):
10631 
    return not (self == other)
10632 
 
10633 
class addAddressToCart_args:
10634 
  """
10635 
  Attributes:
10636 
   - cartId
10637 
   - addressId
10638 
  """
10639 
 
10640 
  thrift_spec = (
10641 
    None, # 0
10642 
    (1, TType.I64, 'cartId', None, None, ), # 1
10643 
    (2, TType.I64, 'addressId', None, None, ), # 2
10644 
  )
10645 
 
10646 
  def __init__(self, cartId=None, addressId=None,):
10647 
    self.cartId = cartId
10648 
    self.addressId = addressId
10649 
 
10650 
  def read(self, iprot):
10651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10653 
      return
10654 
    iprot.readStructBegin()
10655 
    while True:
10656 
      (fname, ftype, fid) = iprot.readFieldBegin()
10657 
      if ftype == TType.STOP:
10658 
        break
10659 
      if fid == 1:
10660 
        if ftype == TType.I64:
10661 
          self.cartId = iprot.readI64();
10662 
        else:
10663 
          iprot.skip(ftype)
10664 
      elif fid == 2:
10665 
        if ftype == TType.I64:
10666 
          self.addressId = iprot.readI64();
10667 
        else:
10668 
          iprot.skip(ftype)
10669 
      else:
10670 
        iprot.skip(ftype)
10671 
      iprot.readFieldEnd()
10672 
    iprot.readStructEnd()
10673 
 
10674 
  def write(self, oprot):
10675 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10676 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10677 
      return
10678 
    oprot.writeStructBegin('addAddressToCart_args')
10679 
    if self.cartId != None:
10680 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10681 
      oprot.writeI64(self.cartId)
10682 
      oprot.writeFieldEnd()
10683 
    if self.addressId != None:
10684 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
10685 
      oprot.writeI64(self.addressId)
10686 
      oprot.writeFieldEnd()
10687 
    oprot.writeFieldStop()
10688 
    oprot.writeStructEnd()
10689 
 
10690 
  def __repr__(self):
10691 
    L = ['%s=%r' % (key, value)
10692 
      for key, value in self.__dict__.iteritems()]
10693 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10694 
 
10695 
  def __eq__(self, other):
10696 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10697 
 
10698 
  def __ne__(self, other):
10699 
    return not (self == other)
10700 
 
10701 
class addAddressToCart_result:
575 chandransh 10702 
  """
10703 
  Attributes:
10704 
   - scx
10705 
  """
559 chandransh 10706 
 
10707 
  thrift_spec = (
575 chandransh 10708 
    None, # 0
10709 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 10710 
  )
10711 
 
575 chandransh 10712 
  def __init__(self, scx=None,):
10713 
    self.scx = scx
10714 
 
559 chandransh 10715 
  def read(self, iprot):
10716 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10717 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10718 
      return
10719 
    iprot.readStructBegin()
10720 
    while True:
10721 
      (fname, ftype, fid) = iprot.readFieldBegin()
10722 
      if ftype == TType.STOP:
10723 
        break
575 chandransh 10724 
      if fid == 1:
10725 
        if ftype == TType.STRUCT:
10726 
          self.scx = ShoppingCartException()
10727 
          self.scx.read(iprot)
10728 
        else:
10729 
          iprot.skip(ftype)
559 chandransh 10730 
      else:
10731 
        iprot.skip(ftype)
10732 
      iprot.readFieldEnd()
10733 
    iprot.readStructEnd()
10734 
 
10735 
  def write(self, oprot):
10736 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10737 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10738 
      return
10739 
    oprot.writeStructBegin('addAddressToCart_result')
575 chandransh 10740 
    if self.scx != None:
10741 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10742 
      self.scx.write(oprot)
10743 
      oprot.writeFieldEnd()
559 chandransh 10744 
    oprot.writeFieldStop()
10745 
    oprot.writeStructEnd()
10746 
 
10747 
  def __repr__(self):
10748 
    L = ['%s=%r' % (key, value)
10749 
      for key, value in self.__dict__.iteritems()]
10750 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10751 
 
10752 
  def __eq__(self, other):
10753 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10754 
 
10755 
  def __ne__(self, other):
10756 
    return not (self == other)
10757 
 
1976 varun.gupt 10758 
class applyCouponToCart_args:
10759 
  """
10760 
  Attributes:
10761 
   - cartId
10762 
   - couponCode
10763 
   - totalPrice
10764 
   - discountedPrice
10765 
  """
10766 
 
10767 
  thrift_spec = (
10768 
    None, # 0
10769 
    (1, TType.I64, 'cartId', None, None, ), # 1
10770 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
10771 
    (3, TType.DOUBLE, 'totalPrice', None, None, ), # 3
10772 
    (4, TType.DOUBLE, 'discountedPrice', None, None, ), # 4
10773 
  )
10774 
 
10775 
  def __init__(self, cartId=None, couponCode=None, totalPrice=None, discountedPrice=None,):
10776 
    self.cartId = cartId
10777 
    self.couponCode = couponCode
10778 
    self.totalPrice = totalPrice
10779 
    self.discountedPrice = discountedPrice
10780 
 
10781 
  def read(self, iprot):
10782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10784 
      return
10785 
    iprot.readStructBegin()
10786 
    while True:
10787 
      (fname, ftype, fid) = iprot.readFieldBegin()
10788 
      if ftype == TType.STOP:
10789 
        break
10790 
      if fid == 1:
10791 
        if ftype == TType.I64:
10792 
          self.cartId = iprot.readI64();
10793 
        else:
10794 
          iprot.skip(ftype)
10795 
      elif fid == 2:
10796 
        if ftype == TType.STRING:
10797 
          self.couponCode = iprot.readString();
10798 
        else:
10799 
          iprot.skip(ftype)
10800 
      elif fid == 3:
10801 
        if ftype == TType.DOUBLE:
10802 
          self.totalPrice = iprot.readDouble();
10803 
        else:
10804 
          iprot.skip(ftype)
10805 
      elif fid == 4:
10806 
        if ftype == TType.DOUBLE:
10807 
          self.discountedPrice = iprot.readDouble();
10808 
        else:
10809 
          iprot.skip(ftype)
10810 
      else:
10811 
        iprot.skip(ftype)
10812 
      iprot.readFieldEnd()
10813 
    iprot.readStructEnd()
10814 
 
10815 
  def write(self, oprot):
10816 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10817 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10818 
      return
10819 
    oprot.writeStructBegin('applyCouponToCart_args')
10820 
    if self.cartId != None:
10821 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10822 
      oprot.writeI64(self.cartId)
10823 
      oprot.writeFieldEnd()
10824 
    if self.couponCode != None:
10825 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
10826 
      oprot.writeString(self.couponCode)
10827 
      oprot.writeFieldEnd()
10828 
    if self.totalPrice != None:
10829 
      oprot.writeFieldBegin('totalPrice', TType.DOUBLE, 3)
10830 
      oprot.writeDouble(self.totalPrice)
10831 
      oprot.writeFieldEnd()
10832 
    if self.discountedPrice != None:
10833 
      oprot.writeFieldBegin('discountedPrice', TType.DOUBLE, 4)
10834 
      oprot.writeDouble(self.discountedPrice)
10835 
      oprot.writeFieldEnd()
10836 
    oprot.writeFieldStop()
10837 
    oprot.writeStructEnd()
10838 
 
10839 
  def __repr__(self):
10840 
    L = ['%s=%r' % (key, value)
10841 
      for key, value in self.__dict__.iteritems()]
10842 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10843 
 
10844 
  def __eq__(self, other):
10845 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10846 
 
10847 
  def __ne__(self, other):
10848 
    return not (self == other)
10849 
 
10850 
class applyCouponToCart_result:
10851 
  """
10852 
  Attributes:
10853 
   - scx
10854 
  """
10855 
 
10856 
  thrift_spec = (
10857 
    None, # 0
10858 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10859 
  )
10860 
 
10861 
  def __init__(self, scx=None,):
10862 
    self.scx = scx
10863 
 
10864 
  def read(self, iprot):
10865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10867 
      return
10868 
    iprot.readStructBegin()
10869 
    while True:
10870 
      (fname, ftype, fid) = iprot.readFieldBegin()
10871 
      if ftype == TType.STOP:
10872 
        break
10873 
      if fid == 1:
10874 
        if ftype == TType.STRUCT:
10875 
          self.scx = ShoppingCartException()
10876 
          self.scx.read(iprot)
10877 
        else:
10878 
          iprot.skip(ftype)
10879 
      else:
10880 
        iprot.skip(ftype)
10881 
      iprot.readFieldEnd()
10882 
    iprot.readStructEnd()
10883 
 
10884 
  def write(self, oprot):
10885 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10886 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10887 
      return
10888 
    oprot.writeStructBegin('applyCouponToCart_result')
10889 
    if self.scx != None:
10890 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10891 
      self.scx.write(oprot)
10892 
      oprot.writeFieldEnd()
10893 
    oprot.writeFieldStop()
10894 
    oprot.writeStructEnd()
10895 
 
10896 
  def __repr__(self):
10897 
    L = ['%s=%r' % (key, value)
10898 
      for key, value in self.__dict__.iteritems()]
10899 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10900 
 
10901 
  def __eq__(self, other):
10902 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10903 
 
10904 
  def __ne__(self, other):
10905 
    return not (self == other)
10906 
 
10907 
class removeCoupon_args:
10908 
  """
10909 
  Attributes:
10910 
   - cartId
10911 
  """
10912 
 
10913 
  thrift_spec = (
10914 
    None, # 0
10915 
    (1, TType.I64, 'cartId', None, None, ), # 1
10916 
  )
10917 
 
10918 
  def __init__(self, cartId=None,):
10919 
    self.cartId = cartId
10920 
 
10921 
  def read(self, iprot):
10922 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10923 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10924 
      return
10925 
    iprot.readStructBegin()
10926 
    while True:
10927 
      (fname, ftype, fid) = iprot.readFieldBegin()
10928 
      if ftype == TType.STOP:
10929 
        break
10930 
      if fid == 1:
10931 
        if ftype == TType.I64:
10932 
          self.cartId = iprot.readI64();
10933 
        else:
10934 
          iprot.skip(ftype)
10935 
      else:
10936 
        iprot.skip(ftype)
10937 
      iprot.readFieldEnd()
10938 
    iprot.readStructEnd()
10939 
 
10940 
  def write(self, oprot):
10941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10943 
      return
10944 
    oprot.writeStructBegin('removeCoupon_args')
10945 
    if self.cartId != None:
10946 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10947 
      oprot.writeI64(self.cartId)
10948 
      oprot.writeFieldEnd()
10949 
    oprot.writeFieldStop()
10950 
    oprot.writeStructEnd()
10951 
 
10952 
  def __repr__(self):
10953 
    L = ['%s=%r' % (key, value)
10954 
      for key, value in self.__dict__.iteritems()]
10955 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10956 
 
10957 
  def __eq__(self, other):
10958 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10959 
 
10960 
  def __ne__(self, other):
10961 
    return not (self == other)
10962 
 
10963 
class removeCoupon_result:
10964 
  """
10965 
  Attributes:
10966 
   - scx
10967 
  """
10968 
 
10969 
  thrift_spec = (
10970 
    None, # 0
10971 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10972 
  )
10973 
 
10974 
  def __init__(self, scx=None,):
10975 
    self.scx = scx
10976 
 
10977 
  def read(self, iprot):
10978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10980 
      return
10981 
    iprot.readStructBegin()
10982 
    while True:
10983 
      (fname, ftype, fid) = iprot.readFieldBegin()
10984 
      if ftype == TType.STOP:
10985 
        break
10986 
      if fid == 1:
10987 
        if ftype == TType.STRUCT:
10988 
          self.scx = ShoppingCartException()
10989 
          self.scx.read(iprot)
10990 
        else:
10991 
          iprot.skip(ftype)
10992 
      else:
10993 
        iprot.skip(ftype)
10994 
      iprot.readFieldEnd()
10995 
    iprot.readStructEnd()
10996 
 
10997 
  def write(self, oprot):
10998 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10999 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11000 
      return
11001 
    oprot.writeStructBegin('removeCoupon_result')
11002 
    if self.scx != None:
11003 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11004 
      self.scx.write(oprot)
11005 
      oprot.writeFieldEnd()
11006 
    oprot.writeFieldStop()
11007 
    oprot.writeStructEnd()
11008 
 
11009 
  def __repr__(self):
11010 
    L = ['%s=%r' % (key, value)
11011 
      for key, value in self.__dict__.iteritems()]
11012 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11013 
 
11014 
  def __eq__(self, other):
11015 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11016 
 
11017 
  def __ne__(self, other):
11018 
    return not (self == other)
11019 
 
690 chandransh 11020 
class createOrders_args:
559 chandransh 11021 
  """
11022 
  Attributes:
11023 
   - cartId
2815 vikas 11024 
   - sessionSource
11025 
   - sessionStartTime
559 chandransh 11026 
  """
11027 
 
11028 
  thrift_spec = (
11029 
    None, # 0
11030 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 11031 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
11032 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
559 chandransh 11033 
  )
11034 
 
2815 vikas 11035 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None,):
559 chandransh 11036 
    self.cartId = cartId
2815 vikas 11037 
    self.sessionSource = sessionSource
11038 
    self.sessionStartTime = sessionStartTime
559 chandransh 11039 
 
11040 
  def read(self, iprot):
11041 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11042 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11043 
      return
11044 
    iprot.readStructBegin()
11045 
    while True:
11046 
      (fname, ftype, fid) = iprot.readFieldBegin()
11047 
      if ftype == TType.STOP:
11048 
        break
11049 
      if fid == 1:
11050 
        if ftype == TType.I64:
11051 
          self.cartId = iprot.readI64();
11052 
        else:
11053 
          iprot.skip(ftype)
2815 vikas 11054 
      elif fid == 2:
11055 
        if ftype == TType.STRING:
11056 
          self.sessionSource = iprot.readString();
11057 
        else:
11058 
          iprot.skip(ftype)
11059 
      elif fid == 3:
11060 
        if ftype == TType.I64:
11061 
          self.sessionStartTime = iprot.readI64();
11062 
        else:
11063 
          iprot.skip(ftype)
559 chandransh 11064 
      else:
11065 
        iprot.skip(ftype)
11066 
      iprot.readFieldEnd()
11067 
    iprot.readStructEnd()
11068 
 
11069 
  def write(self, oprot):
11070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11072 
      return
690 chandransh 11073 
    oprot.writeStructBegin('createOrders_args')
559 chandransh 11074 
    if self.cartId != None:
11075 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11076 
      oprot.writeI64(self.cartId)
11077 
      oprot.writeFieldEnd()
2815 vikas 11078 
    if self.sessionSource != None:
11079 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
11080 
      oprot.writeString(self.sessionSource)
11081 
      oprot.writeFieldEnd()
11082 
    if self.sessionStartTime != None:
11083 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
11084 
      oprot.writeI64(self.sessionStartTime)
11085 
      oprot.writeFieldEnd()
559 chandransh 11086 
    oprot.writeFieldStop()
11087 
    oprot.writeStructEnd()
11088 
 
11089 
  def __repr__(self):
11090 
    L = ['%s=%r' % (key, value)
11091 
      for key, value in self.__dict__.iteritems()]
11092 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11093 
 
11094 
  def __eq__(self, other):
11095 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11096 
 
11097 
  def __ne__(self, other):
11098 
    return not (self == other)
11099 
 
690 chandransh 11100 
class createOrders_result:
559 chandransh 11101 
  """
11102 
  Attributes:
94 ashish 11103 
   - success
559 chandransh 11104 
   - scx
94 ashish 11105 
  """
11106 
 
11107 
  thrift_spec = (
575 chandransh 11108 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 11109 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11110 
  )
11111 
 
559 chandransh 11112 
  def __init__(self, success=None, scx=None,):
94 ashish 11113 
    self.success = success
559 chandransh 11114 
    self.scx = scx
94 ashish 11115 
 
11116 
  def read(self, iprot):
11117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11119 
      return
11120 
    iprot.readStructBegin()
11121 
    while True:
11122 
      (fname, ftype, fid) = iprot.readFieldBegin()
11123 
      if ftype == TType.STOP:
11124 
        break
11125 
      if fid == 0:
575 chandransh 11126 
        if ftype == TType.I64:
11127 
          self.success = iprot.readI64();
94 ashish 11128 
        else:
11129 
          iprot.skip(ftype)
11130 
      elif fid == 1:
11131 
        if ftype == TType.STRUCT:
559 chandransh 11132 
          self.scx = ShoppingCartException()
11133 
          self.scx.read(iprot)
94 ashish 11134 
        else:
11135 
          iprot.skip(ftype)
11136 
      else:
11137 
        iprot.skip(ftype)
11138 
      iprot.readFieldEnd()
11139 
    iprot.readStructEnd()
11140 
 
11141 
  def write(self, oprot):
11142 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11143 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11144 
      return
690 chandransh 11145 
    oprot.writeStructBegin('createOrders_result')
94 ashish 11146 
    if self.success != None:
575 chandransh 11147 
      oprot.writeFieldBegin('success', TType.I64, 0)
11148 
      oprot.writeI64(self.success)
94 ashish 11149 
      oprot.writeFieldEnd()
559 chandransh 11150 
    if self.scx != None:
11151 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11152 
      self.scx.write(oprot)
94 ashish 11153 
      oprot.writeFieldEnd()
11154 
    oprot.writeFieldStop()
11155 
    oprot.writeStructEnd()
11156 
 
11157 
  def __repr__(self):
11158 
    L = ['%s=%r' % (key, value)
11159 
      for key, value in self.__dict__.iteritems()]
11160 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11161 
 
11162 
  def __eq__(self, other):
11163 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11164 
 
11165 
  def __ne__(self, other):
11166 
    return not (self == other)
11167 
 
559 chandransh 11168 
class validateCart_args:
94 ashish 11169 
  """
11170 
  Attributes:
559 chandransh 11171 
   - cartId
94 ashish 11172 
  """
11173 
 
11174 
  thrift_spec = (
11175 
    None, # 0
559 chandransh 11176 
    (1, TType.I64, 'cartId', None, None, ), # 1
94 ashish 11177 
  )
11178 
 
559 chandransh 11179 
  def __init__(self, cartId=None,):
11180 
    self.cartId = cartId
94 ashish 11181 
 
11182 
  def read(self, iprot):
11183 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11184 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11185 
      return
11186 
    iprot.readStructBegin()
11187 
    while True:
11188 
      (fname, ftype, fid) = iprot.readFieldBegin()
11189 
      if ftype == TType.STOP:
11190 
        break
11191 
      if fid == 1:
11192 
        if ftype == TType.I64:
559 chandransh 11193 
          self.cartId = iprot.readI64();
94 ashish 11194 
        else:
11195 
          iprot.skip(ftype)
11196 
      else:
11197 
        iprot.skip(ftype)
11198 
      iprot.readFieldEnd()
11199 
    iprot.readStructEnd()
11200 
 
11201 
  def write(self, oprot):
11202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11204 
      return
559 chandransh 11205 
    oprot.writeStructBegin('validateCart_args')
11206 
    if self.cartId != None:
11207 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11208 
      oprot.writeI64(self.cartId)
94 ashish 11209 
      oprot.writeFieldEnd()
11210 
    oprot.writeFieldStop()
11211 
    oprot.writeStructEnd()
11212 
 
11213 
  def __repr__(self):
11214 
    L = ['%s=%r' % (key, value)
11215 
      for key, value in self.__dict__.iteritems()]
11216 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11217 
 
11218 
  def __eq__(self, other):
11219 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11220 
 
11221 
  def __ne__(self, other):
11222 
    return not (self == other)
11223 
 
559 chandransh 11224 
class validateCart_result:
94 ashish 11225 
  """
11226 
  Attributes:
11227 
   - success
575 chandransh 11228 
   - scex
94 ashish 11229 
  """
11230 
 
11231 
  thrift_spec = (
1466 ankur.sing 11232 
    (0, TType.STRING, 'success', None, None, ), # 0
575 chandransh 11233 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11234 
  )
11235 
 
575 chandransh 11236 
  def __init__(self, success=None, scex=None,):
94 ashish 11237 
    self.success = success
575 chandransh 11238 
    self.scex = scex
94 ashish 11239 
 
11240 
  def read(self, iprot):
11241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11243 
      return
11244 
    iprot.readStructBegin()
11245 
    while True:
11246 
      (fname, ftype, fid) = iprot.readFieldBegin()
11247 
      if ftype == TType.STOP:
11248 
        break
11249 
      if fid == 0:
1466 ankur.sing 11250 
        if ftype == TType.STRING:
11251 
          self.success = iprot.readString();
94 ashish 11252 
        else:
11253 
          iprot.skip(ftype)
575 chandransh 11254 
      elif fid == 1:
11255 
        if ftype == TType.STRUCT:
11256 
          self.scex = ShoppingCartException()
11257 
          self.scex.read(iprot)
11258 
        else:
11259 
          iprot.skip(ftype)
94 ashish 11260 
      else:
11261 
        iprot.skip(ftype)
11262 
      iprot.readFieldEnd()
11263 
    iprot.readStructEnd()
11264 
 
11265 
  def write(self, oprot):
11266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11268 
      return
559 chandransh 11269 
    oprot.writeStructBegin('validateCart_result')
94 ashish 11270 
    if self.success != None:
1466 ankur.sing 11271 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11272 
      oprot.writeString(self.success)
94 ashish 11273 
      oprot.writeFieldEnd()
575 chandransh 11274 
    if self.scex != None:
11275 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11276 
      self.scex.write(oprot)
11277 
      oprot.writeFieldEnd()
559 chandransh 11278 
    oprot.writeFieldStop()
11279 
    oprot.writeStructEnd()
11280 
 
11281 
  def __repr__(self):
11282 
    L = ['%s=%r' % (key, value)
11283 
      for key, value in self.__dict__.iteritems()]
11284 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11285 
 
11286 
  def __eq__(self, other):
11287 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11288 
 
11289 
  def __ne__(self, other):
11290 
    return not (self == other)
11291 
 
690 chandransh 11292 
class mergeCart_args:
575 chandransh 11293 
  """
11294 
  Attributes:
690 chandransh 11295 
   - fromCartId
11296 
   - toCartId
11297 
  """
11298 
 
11299 
  thrift_spec = (
11300 
    None, # 0
11301 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
11302 
    (2, TType.I64, 'toCartId', None, None, ), # 2
11303 
  )
11304 
 
11305 
  def __init__(self, fromCartId=None, toCartId=None,):
11306 
    self.fromCartId = fromCartId
11307 
    self.toCartId = toCartId
11308 
 
11309 
  def read(self, iprot):
11310 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11311 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11312 
      return
11313 
    iprot.readStructBegin()
11314 
    while True:
11315 
      (fname, ftype, fid) = iprot.readFieldBegin()
11316 
      if ftype == TType.STOP:
11317 
        break
11318 
      if fid == 1:
11319 
        if ftype == TType.I64:
11320 
          self.fromCartId = iprot.readI64();
11321 
        else:
11322 
          iprot.skip(ftype)
11323 
      elif fid == 2:
11324 
        if ftype == TType.I64:
11325 
          self.toCartId = iprot.readI64();
11326 
        else:
11327 
          iprot.skip(ftype)
11328 
      else:
11329 
        iprot.skip(ftype)
11330 
      iprot.readFieldEnd()
11331 
    iprot.readStructEnd()
11332 
 
11333 
  def write(self, oprot):
11334 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11335 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11336 
      return
11337 
    oprot.writeStructBegin('mergeCart_args')
11338 
    if self.fromCartId != None:
11339 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
11340 
      oprot.writeI64(self.fromCartId)
11341 
      oprot.writeFieldEnd()
11342 
    if self.toCartId != None:
11343 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
11344 
      oprot.writeI64(self.toCartId)
11345 
      oprot.writeFieldEnd()
11346 
    oprot.writeFieldStop()
11347 
    oprot.writeStructEnd()
11348 
 
11349 
  def __repr__(self):
11350 
    L = ['%s=%r' % (key, value)
11351 
      for key, value in self.__dict__.iteritems()]
11352 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11353 
 
11354 
  def __eq__(self, other):
11355 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11356 
 
11357 
  def __ne__(self, other):
11358 
    return not (self == other)
11359 
 
11360 
class mergeCart_result:
11361 
 
11362 
  thrift_spec = (
11363 
  )
11364 
 
11365 
  def read(self, iprot):
11366 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11367 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11368 
      return
11369 
    iprot.readStructBegin()
11370 
    while True:
11371 
      (fname, ftype, fid) = iprot.readFieldBegin()
11372 
      if ftype == TType.STOP:
11373 
        break
11374 
      else:
11375 
        iprot.skip(ftype)
11376 
      iprot.readFieldEnd()
11377 
    iprot.readStructEnd()
11378 
 
11379 
  def write(self, oprot):
11380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11382 
      return
11383 
    oprot.writeStructBegin('mergeCart_result')
11384 
    oprot.writeFieldStop()
11385 
    oprot.writeStructEnd()
11386 
 
11387 
  def __repr__(self):
11388 
    L = ['%s=%r' % (key, value)
11389 
      for key, value in self.__dict__.iteritems()]
11390 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11391 
 
11392 
  def __eq__(self, other):
11393 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11394 
 
11395 
  def __ne__(self, other):
11396 
    return not (self == other)
11397 
 
11398 
class checkOut_args:
11399 
  """
11400 
  Attributes:
575 chandransh 11401 
   - cartId
11402 
  """
11403 
 
11404 
  thrift_spec = (
11405 
    None, # 0
11406 
    (1, TType.I64, 'cartId', None, None, ), # 1
11407 
  )
11408 
 
11409 
  def __init__(self, cartId=None,):
11410 
    self.cartId = cartId
11411 
 
11412 
  def read(self, iprot):
11413 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11414 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11415 
      return
11416 
    iprot.readStructBegin()
11417 
    while True:
11418 
      (fname, ftype, fid) = iprot.readFieldBegin()
11419 
      if ftype == TType.STOP:
11420 
        break
11421 
      if fid == 1:
11422 
        if ftype == TType.I64:
11423 
          self.cartId = iprot.readI64();
11424 
        else:
11425 
          iprot.skip(ftype)
11426 
      else:
11427 
        iprot.skip(ftype)
11428 
      iprot.readFieldEnd()
11429 
    iprot.readStructEnd()
11430 
 
11431 
  def write(self, oprot):
11432 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11433 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11434 
      return
690 chandransh 11435 
    oprot.writeStructBegin('checkOut_args')
575 chandransh 11436 
    if self.cartId != None:
11437 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11438 
      oprot.writeI64(self.cartId)
11439 
      oprot.writeFieldEnd()
11440 
    oprot.writeFieldStop()
11441 
    oprot.writeStructEnd()
11442 
 
11443 
  def __repr__(self):
11444 
    L = ['%s=%r' % (key, value)
11445 
      for key, value in self.__dict__.iteritems()]
11446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11447 
 
11448 
  def __eq__(self, other):
11449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11450 
 
11451 
  def __ne__(self, other):
11452 
    return not (self == other)
11453 
 
690 chandransh 11454 
class checkOut_result:
575 chandransh 11455 
  """
11456 
  Attributes:
11457 
   - success
11458 
   - scex
11459 
  """
11460 
 
11461 
  thrift_spec = (
11462 
    (0, TType.BOOL, 'success', None, None, ), # 0
11463 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11464 
  )
11465 
 
11466 
  def __init__(self, success=None, scex=None,):
11467 
    self.success = success
11468 
    self.scex = scex
11469 
 
11470 
  def read(self, iprot):
11471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11473 
      return
11474 
    iprot.readStructBegin()
11475 
    while True:
11476 
      (fname, ftype, fid) = iprot.readFieldBegin()
11477 
      if ftype == TType.STOP:
11478 
        break
11479 
      if fid == 0:
11480 
        if ftype == TType.BOOL:
11481 
          self.success = iprot.readBool();
11482 
        else:
11483 
          iprot.skip(ftype)
11484 
      elif fid == 1:
11485 
        if ftype == TType.STRUCT:
11486 
          self.scex = ShoppingCartException()
11487 
          self.scex.read(iprot)
11488 
        else:
11489 
          iprot.skip(ftype)
11490 
      else:
11491 
        iprot.skip(ftype)
11492 
      iprot.readFieldEnd()
11493 
    iprot.readStructEnd()
11494 
 
11495 
  def write(self, oprot):
11496 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11497 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11498 
      return
690 chandransh 11499 
    oprot.writeStructBegin('checkOut_result')
575 chandransh 11500 
    if self.success != None:
11501 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11502 
      oprot.writeBool(self.success)
11503 
      oprot.writeFieldEnd()
11504 
    if self.scex != None:
11505 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11506 
      self.scex.write(oprot)
11507 
      oprot.writeFieldEnd()
11508 
    oprot.writeFieldStop()
11509 
    oprot.writeStructEnd()
11510 
 
11511 
  def __repr__(self):
11512 
    L = ['%s=%r' % (key, value)
11513 
      for key, value in self.__dict__.iteritems()]
11514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11515 
 
11516 
  def __eq__(self, other):
11517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11518 
 
11519 
  def __ne__(self, other):
11520 
    return not (self == other)
11521 
 
690 chandransh 11522 
class resetCart_args:
559 chandransh 11523 
  """
11524 
  Attributes:
690 chandransh 11525 
   - cartId
11526 
   - items
559 chandransh 11527 
  """
11528 
 
11529 
  thrift_spec = (
11530 
    None, # 0
690 chandransh 11531 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 11532 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 11533 
  )
11534 
 
690 chandransh 11535 
  def __init__(self, cartId=None, items=None,):
11536 
    self.cartId = cartId
11537 
    self.items = items
559 chandransh 11538 
 
11539 
  def read(self, iprot):
11540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11542 
      return
11543 
    iprot.readStructBegin()
11544 
    while True:
11545 
      (fname, ftype, fid) = iprot.readFieldBegin()
11546 
      if ftype == TType.STOP:
11547 
        break
11548 
      if fid == 1:
11549 
        if ftype == TType.I64:
690 chandransh 11550 
          self.cartId = iprot.readI64();
559 chandransh 11551 
        else:
11552 
          iprot.skip(ftype)
11553 
      elif fid == 2:
690 chandransh 11554 
        if ftype == TType.MAP:
11555 
          self.items = {}
3385 varun.gupt 11556 
          (_ktype113, _vtype114, _size112 ) = iprot.readMapBegin()
11557 
          for _i116 in xrange(_size112):
11558 
            _key117 = iprot.readI64();
11559 
            _val118 = iprot.readDouble();
11560 
            self.items[_key117] = _val118
690 chandransh 11561 
          iprot.readMapEnd()
559 chandransh 11562 
        else:
11563 
          iprot.skip(ftype)
11564 
      else:
11565 
        iprot.skip(ftype)
11566 
      iprot.readFieldEnd()
11567 
    iprot.readStructEnd()
11568 
 
11569 
  def write(self, oprot):
11570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11572 
      return
690 chandransh 11573 
    oprot.writeStructBegin('resetCart_args')
11574 
    if self.cartId != None:
11575 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11576 
      oprot.writeI64(self.cartId)
94 ashish 11577 
      oprot.writeFieldEnd()
690 chandransh 11578 
    if self.items != None:
11579 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 11580 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
3385 varun.gupt 11581 
      for kiter119,viter120 in self.items.items():
11582 
        oprot.writeI64(kiter119)
11583 
        oprot.writeDouble(viter120)
690 chandransh 11584 
      oprot.writeMapEnd()
559 chandransh 11585 
      oprot.writeFieldEnd()
94 ashish 11586 
    oprot.writeFieldStop()
11587 
    oprot.writeStructEnd()
11588 
 
11589 
  def __repr__(self):
11590 
    L = ['%s=%r' % (key, value)
11591 
      for key, value in self.__dict__.iteritems()]
11592 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11593 
 
11594 
  def __eq__(self, other):
11595 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11596 
 
11597 
  def __ne__(self, other):
11598 
    return not (self == other)
11599 
 
690 chandransh 11600 
class resetCart_result:
11601 
  """
11602 
  Attributes:
11603 
   - success
11604 
   - scex
11605 
  """
559 chandransh 11606 
 
11607 
  thrift_spec = (
690 chandransh 11608 
    (0, TType.BOOL, 'success', None, None, ), # 0
11609 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11610 
  )
11611 
 
690 chandransh 11612 
  def __init__(self, success=None, scex=None,):
11613 
    self.success = success
11614 
    self.scex = scex
11615 
 
559 chandransh 11616 
  def read(self, iprot):
11617 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11618 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11619 
      return
11620 
    iprot.readStructBegin()
11621 
    while True:
11622 
      (fname, ftype, fid) = iprot.readFieldBegin()
11623 
      if ftype == TType.STOP:
11624 
        break
690 chandransh 11625 
      if fid == 0:
11626 
        if ftype == TType.BOOL:
11627 
          self.success = iprot.readBool();
11628 
        else:
11629 
          iprot.skip(ftype)
11630 
      elif fid == 1:
11631 
        if ftype == TType.STRUCT:
11632 
          self.scex = ShoppingCartException()
11633 
          self.scex.read(iprot)
11634 
        else:
11635 
          iprot.skip(ftype)
559 chandransh 11636 
      else:
11637 
        iprot.skip(ftype)
11638 
      iprot.readFieldEnd()
11639 
    iprot.readStructEnd()
11640 
 
11641 
  def write(self, oprot):
11642 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11643 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11644 
      return
690 chandransh 11645 
    oprot.writeStructBegin('resetCart_result')
11646 
    if self.success != None:
11647 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11648 
      oprot.writeBool(self.success)
11649 
      oprot.writeFieldEnd()
11650 
    if self.scex != None:
11651 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11652 
      self.scex.write(oprot)
11653 
      oprot.writeFieldEnd()
559 chandransh 11654 
    oprot.writeFieldStop()
11655 
    oprot.writeStructEnd()
11656 
 
11657 
  def __repr__(self):
11658 
    L = ['%s=%r' % (key, value)
11659 
      for key, value in self.__dict__.iteritems()]
11660 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11661 
 
11662 
  def __eq__(self, other):
11663 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11664 
 
11665 
  def __ne__(self, other):
11666 
    return not (self == other)
11667 
 
2981 rajveer 11668 
class getUserCount_args:
94 ashish 11669 
  """
11670 
  Attributes:
2981 rajveer 11671 
   - userType
559 chandransh 11672 
  """
11673 
 
11674 
  thrift_spec = (
11675 
    None, # 0
2981 rajveer 11676 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 11677 
  )
11678 
 
2981 rajveer 11679 
  def __init__(self, userType=None,):
11680 
    self.userType = userType
559 chandransh 11681 
 
11682 
  def read(self, iprot):
11683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11685 
      return
11686 
    iprot.readStructBegin()
11687 
    while True:
11688 
      (fname, ftype, fid) = iprot.readFieldBegin()
11689 
      if ftype == TType.STOP:
11690 
        break
11691 
      if fid == 1:
2981 rajveer 11692 
        if ftype == TType.I32:
11693 
          self.userType = iprot.readI32();
559 chandransh 11694 
        else:
11695 
          iprot.skip(ftype)
11696 
      else:
11697 
        iprot.skip(ftype)
11698 
      iprot.readFieldEnd()
11699 
    iprot.readStructEnd()
11700 
 
11701 
  def write(self, oprot):
11702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11704 
      return
2981 rajveer 11705 
    oprot.writeStructBegin('getUserCount_args')
11706 
    if self.userType != None:
11707 
      oprot.writeFieldBegin('userType', TType.I32, 1)
11708 
      oprot.writeI32(self.userType)
559 chandransh 11709 
      oprot.writeFieldEnd()
11710 
    oprot.writeFieldStop()
11711 
    oprot.writeStructEnd()
11712 
 
11713 
  def __repr__(self):
11714 
    L = ['%s=%r' % (key, value)
11715 
      for key, value in self.__dict__.iteritems()]
11716 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11717 
 
11718 
  def __eq__(self, other):
11719 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11720 
 
11721 
  def __ne__(self, other):
11722 
    return not (self == other)
11723 
 
2981 rajveer 11724 
class getUserCount_result:
94 ashish 11725 
  """
11726 
  Attributes:
11727 
   - success
11728 
  """
11729 
 
11730 
  thrift_spec = (
2981 rajveer 11731 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 11732 
  )
11733 
 
2981 rajveer 11734 
  def __init__(self, success=None,):
94 ashish 11735 
    self.success = success
11736 
 
11737 
  def read(self, iprot):
11738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11740 
      return
11741 
    iprot.readStructBegin()
11742 
    while True:
11743 
      (fname, ftype, fid) = iprot.readFieldBegin()
11744 
      if ftype == TType.STOP:
11745 
        break
11746 
      if fid == 0:
2981 rajveer 11747 
        if ftype == TType.I64:
11748 
          self.success = iprot.readI64();
94 ashish 11749 
        else:
11750 
          iprot.skip(ftype)
11751 
      else:
11752 
        iprot.skip(ftype)
11753 
      iprot.readFieldEnd()
11754 
    iprot.readStructEnd()
11755 
 
11756 
  def write(self, oprot):
11757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11759 
      return
2981 rajveer 11760 
    oprot.writeStructBegin('getUserCount_result')
94 ashish 11761 
    if self.success != None:
2981 rajveer 11762 
      oprot.writeFieldBegin('success', TType.I64, 0)
11763 
      oprot.writeI64(self.success)
94 ashish 11764 
      oprot.writeFieldEnd()
11765 
    oprot.writeFieldStop()
11766 
    oprot.writeStructEnd()
11767 
 
11768 
  def __repr__(self):
11769 
    L = ['%s=%r' % (key, value)
11770 
      for key, value in self.__dict__.iteritems()]
11771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11772 
 
11773 
  def __eq__(self, other):
11774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11775 
 
11776 
  def __ne__(self, other):
11777 
    return not (self == other)
11778 
 
2981 rajveer 11779 
class getAllUsers_args:
94 ashish 11780 
  """
11781 
  Attributes:
2981 rajveer 11782 
   - userType
11783 
   - startDate
11784 
   - endDate
94 ashish 11785 
  """
11786 
 
11787 
  thrift_spec = (
11788 
    None, # 0
2981 rajveer 11789 
    (1, TType.I32, 'userType', None, None, ), # 1
11790 
    (2, TType.I64, 'startDate', None, None, ), # 2
11791 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 11792 
  )
11793 
 
2981 rajveer 11794 
  def __init__(self, userType=None, startDate=None, endDate=None,):
11795 
    self.userType = userType
11796 
    self.startDate = startDate
11797 
    self.endDate = endDate
94 ashish 11798 
 
11799 
  def read(self, iprot):
11800 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11801 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11802 
      return
11803 
    iprot.readStructBegin()
11804 
    while True:
11805 
      (fname, ftype, fid) = iprot.readFieldBegin()
11806 
      if ftype == TType.STOP:
11807 
        break
11808 
      if fid == 1:
2981 rajveer 11809 
        if ftype == TType.I32:
11810 
          self.userType = iprot.readI32();
94 ashish 11811 
        else:
11812 
          iprot.skip(ftype)
11813 
      elif fid == 2:
559 chandransh 11814 
        if ftype == TType.I64:
2981 rajveer 11815 
          self.startDate = iprot.readI64();
94 ashish 11816 
        else:
11817 
          iprot.skip(ftype)
2981 rajveer 11818 
      elif fid == 3:
11819 
        if ftype == TType.I64:
11820 
          self.endDate = iprot.readI64();
11821 
        else:
11822 
          iprot.skip(ftype)
94 ashish 11823 
      else:
11824 
        iprot.skip(ftype)
11825 
      iprot.readFieldEnd()
11826 
    iprot.readStructEnd()
11827 
 
11828 
  def write(self, oprot):
11829 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11830 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11831 
      return
2981 rajveer 11832 
    oprot.writeStructBegin('getAllUsers_args')
11833 
    if self.userType != None:
11834 
      oprot.writeFieldBegin('userType', TType.I32, 1)
11835 
      oprot.writeI32(self.userType)
94 ashish 11836 
      oprot.writeFieldEnd()
2981 rajveer 11837 
    if self.startDate != None:
11838 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
11839 
      oprot.writeI64(self.startDate)
94 ashish 11840 
      oprot.writeFieldEnd()
2981 rajveer 11841 
    if self.endDate != None:
11842 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
11843 
      oprot.writeI64(self.endDate)
11844 
      oprot.writeFieldEnd()
94 ashish 11845 
    oprot.writeFieldStop()
11846 
    oprot.writeStructEnd()
11847 
 
11848 
  def __repr__(self):
11849 
    L = ['%s=%r' % (key, value)
11850 
      for key, value in self.__dict__.iteritems()]
11851 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11852 
 
11853 
  def __eq__(self, other):
11854 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11855 
 
11856 
  def __ne__(self, other):
11857 
    return not (self == other)
11858 
 
2981 rajveer 11859 
class getAllUsers_result:
94 ashish 11860 
  """
11861 
  Attributes:
11862 
   - success
11863 
  """
11864 
 
11865 
  thrift_spec = (
2981 rajveer 11866 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 11867 
  )
11868 
 
2981 rajveer 11869 
  def __init__(self, success=None,):
94 ashish 11870 
    self.success = success
11871 
 
11872 
  def read(self, iprot):
11873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11875 
      return
11876 
    iprot.readStructBegin()
11877 
    while True:
11878 
      (fname, ftype, fid) = iprot.readFieldBegin()
11879 
      if ftype == TType.STOP:
11880 
        break
11881 
      if fid == 0:
2981 rajveer 11882 
        if ftype == TType.LIST:
11883 
          self.success = []
3385 varun.gupt 11884 
          (_etype124, _size121) = iprot.readListBegin()
11885 
          for _i125 in xrange(_size121):
11886 
            _elem126 = User()
11887 
            _elem126.read(iprot)
11888 
            self.success.append(_elem126)
2981 rajveer 11889 
          iprot.readListEnd()
94 ashish 11890 
        else:
11891 
          iprot.skip(ftype)
11892 
      else:
11893 
        iprot.skip(ftype)
11894 
      iprot.readFieldEnd()
11895 
    iprot.readStructEnd()
11896 
 
11897 
  def write(self, oprot):
11898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11900 
      return
2981 rajveer 11901 
    oprot.writeStructBegin('getAllUsers_result')
94 ashish 11902 
    if self.success != None:
2981 rajveer 11903 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11904 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3385 varun.gupt 11905 
      for iter127 in self.success:
11906 
        iter127.write(oprot)
2981 rajveer 11907 
      oprot.writeListEnd()
94 ashish 11908 
      oprot.writeFieldEnd()
11909 
    oprot.writeFieldStop()
11910 
    oprot.writeStructEnd()
11911 
 
11912 
  def __repr__(self):
11913 
    L = ['%s=%r' % (key, value)
11914 
      for key, value in self.__dict__.iteritems()]
11915 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11916 
 
11917 
  def __eq__(self, other):
11918 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11919 
 
11920 
  def __ne__(self, other):
11921 
    return not (self == other)
11922 
 
2981 rajveer 11923 
class putUserNote_args:
130 ashish 11924 
  """
11925 
  Attributes:
2981 rajveer 11926 
   - user_id
11927 
   - entity_id
11928 
   - slide
11929 
   - note
130 ashish 11930 
  """
94 ashish 11931 
 
130 ashish 11932 
  thrift_spec = (
11933 
    None, # 0
2981 rajveer 11934 
    (1, TType.I64, 'user_id', None, None, ), # 1
11935 
    (2, TType.I64, 'entity_id', None, None, ), # 2
11936 
    (3, TType.STRING, 'slide', None, None, ), # 3
11937 
    (4, TType.STRING, 'note', None, None, ), # 4
130 ashish 11938 
  )
11939 
 
2981 rajveer 11940 
  def __init__(self, user_id=None, entity_id=None, slide=None, note=None,):
11941 
    self.user_id = user_id
11942 
    self.entity_id = entity_id
11943 
    self.slide = slide
11944 
    self.note = note
130 ashish 11945 
 
11946 
  def read(self, iprot):
11947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11949 
      return
11950 
    iprot.readStructBegin()
11951 
    while True:
11952 
      (fname, ftype, fid) = iprot.readFieldBegin()
11953 
      if ftype == TType.STOP:
11954 
        break
11955 
      if fid == 1:
11956 
        if ftype == TType.I64:
2981 rajveer 11957 
          self.user_id = iprot.readI64();
130 ashish 11958 
        else:
11959 
          iprot.skip(ftype)
559 chandransh 11960 
      elif fid == 2:
11961 
        if ftype == TType.I64:
2981 rajveer 11962 
          self.entity_id = iprot.readI64();
559 chandransh 11963 
        else:
11964 
          iprot.skip(ftype)
2981 rajveer 11965 
      elif fid == 3:
11966 
        if ftype == TType.STRING:
11967 
          self.slide = iprot.readString();
11968 
        else:
11969 
          iprot.skip(ftype)
11970 
      elif fid == 4:
11971 
        if ftype == TType.STRING:
11972 
          self.note = iprot.readString();
11973 
        else:
11974 
          iprot.skip(ftype)
130 ashish 11975 
      else:
11976 
        iprot.skip(ftype)
11977 
      iprot.readFieldEnd()
11978 
    iprot.readStructEnd()
11979 
 
11980 
  def write(self, oprot):
11981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11983 
      return
2981 rajveer 11984 
    oprot.writeStructBegin('putUserNote_args')
11985 
    if self.user_id != None:
11986 
      oprot.writeFieldBegin('user_id', TType.I64, 1)
11987 
      oprot.writeI64(self.user_id)
130 ashish 11988 
      oprot.writeFieldEnd()
2981 rajveer 11989 
    if self.entity_id != None:
11990 
      oprot.writeFieldBegin('entity_id', TType.I64, 2)
11991 
      oprot.writeI64(self.entity_id)
559 chandransh 11992 
      oprot.writeFieldEnd()
2981 rajveer 11993 
    if self.slide != None:
11994 
      oprot.writeFieldBegin('slide', TType.STRING, 3)
11995 
      oprot.writeString(self.slide)
11996 
      oprot.writeFieldEnd()
11997 
    if self.note != None:
11998 
      oprot.writeFieldBegin('note', TType.STRING, 4)
11999 
      oprot.writeString(self.note)
12000 
      oprot.writeFieldEnd()
130 ashish 12001 
    oprot.writeFieldStop()
12002 
    oprot.writeStructEnd()
12003 
 
12004 
  def __repr__(self):
12005 
    L = ['%s=%r' % (key, value)
12006 
      for key, value in self.__dict__.iteritems()]
12007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12008 
 
12009 
  def __eq__(self, other):
12010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12011 
 
12012 
  def __ne__(self, other):
12013 
    return not (self == other)
12014 
 
2981 rajveer 12015 
class putUserNote_result:
559 chandransh 12016 
 
12017 
  thrift_spec = (
12018 
  )
12019 
 
12020 
  def read(self, iprot):
12021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12023 
      return
12024 
    iprot.readStructBegin()
12025 
    while True:
12026 
      (fname, ftype, fid) = iprot.readFieldBegin()
12027 
      if ftype == TType.STOP:
12028 
        break
12029 
      else:
12030 
        iprot.skip(ftype)
12031 
      iprot.readFieldEnd()
12032 
    iprot.readStructEnd()
12033 
 
12034 
  def write(self, oprot):
12035 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12036 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12037 
      return
2981 rajveer 12038 
    oprot.writeStructBegin('putUserNote_result')
559 chandransh 12039 
    oprot.writeFieldStop()
12040 
    oprot.writeStructEnd()
12041 
 
12042 
  def __repr__(self):
12043 
    L = ['%s=%r' % (key, value)
12044 
      for key, value in self.__dict__.iteritems()]
12045 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12046 
 
12047 
  def __eq__(self, other):
12048 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12049 
 
12050 
  def __ne__(self, other):
12051 
    return not (self == other)
12052 
 
2981 rajveer 12053 
class getUserNotes_args:
559 chandransh 12054 
  """
12055 
  Attributes:
2981 rajveer 12056 
   - user_id
12057 
   - entity_id
559 chandransh 12058 
  """
12059 
 
12060 
  thrift_spec = (
12061 
    None, # 0
2981 rajveer 12062 
    (1, TType.I64, 'user_id', None, None, ), # 1
12063 
    (2, TType.I64, 'entity_id', None, None, ), # 2
559 chandransh 12064 
  )
12065 
 
2981 rajveer 12066 
  def __init__(self, user_id=None, entity_id=None,):
12067 
    self.user_id = user_id
12068 
    self.entity_id = entity_id
559 chandransh 12069 
 
12070 
  def read(self, iprot):
12071 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12072 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12073 
      return
12074 
    iprot.readStructBegin()
12075 
    while True:
12076 
      (fname, ftype, fid) = iprot.readFieldBegin()
12077 
      if ftype == TType.STOP:
12078 
        break
12079 
      if fid == 1:
12080 
        if ftype == TType.I64:
2981 rajveer 12081 
          self.user_id = iprot.readI64();
559 chandransh 12082 
        else:
12083 
          iprot.skip(ftype)
12084 
      elif fid == 2:
12085 
        if ftype == TType.I64:
2981 rajveer 12086 
          self.entity_id = iprot.readI64();
559 chandransh 12087 
        else:
12088 
          iprot.skip(ftype)
12089 
      else:
12090 
        iprot.skip(ftype)
12091 
      iprot.readFieldEnd()
12092 
    iprot.readStructEnd()
12093 
 
12094 
  def write(self, oprot):
12095 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12096 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12097 
      return
2981 rajveer 12098 
    oprot.writeStructBegin('getUserNotes_args')
12099 
    if self.user_id != None:
12100 
      oprot.writeFieldBegin('user_id', TType.I64, 1)
12101 
      oprot.writeI64(self.user_id)
559 chandransh 12102 
      oprot.writeFieldEnd()
2981 rajveer 12103 
    if self.entity_id != None:
12104 
      oprot.writeFieldBegin('entity_id', TType.I64, 2)
12105 
      oprot.writeI64(self.entity_id)
559 chandransh 12106 
      oprot.writeFieldEnd()
12107 
    oprot.writeFieldStop()
12108 
    oprot.writeStructEnd()
12109 
 
12110 
  def __repr__(self):
12111 
    L = ['%s=%r' % (key, value)
12112 
      for key, value in self.__dict__.iteritems()]
12113 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12114 
 
12115 
  def __eq__(self, other):
12116 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12117 
 
12118 
  def __ne__(self, other):
12119 
    return not (self == other)
12120 
 
2981 rajveer 12121 
class getUserNotes_result:
12122 
  """
12123 
  Attributes:
12124 
   - success
12125 
  """
559 chandransh 12126 
 
12127 
  thrift_spec = (
2981 rajveer 12128 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserNote, UserNote.thrift_spec)), None, ), # 0
559 chandransh 12129 
  )
12130 
 
2981 rajveer 12131 
  def __init__(self, success=None,):
12132 
    self.success = success
12133 
 
559 chandransh 12134 
  def read(self, iprot):
12135 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12136 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12137 
      return
12138 
    iprot.readStructBegin()
12139 
    while True:
12140 
      (fname, ftype, fid) = iprot.readFieldBegin()
12141 
      if ftype == TType.STOP:
12142 
        break
2981 rajveer 12143 
      if fid == 0:
12144 
        if ftype == TType.LIST:
12145 
          self.success = []
3385 varun.gupt 12146 
          (_etype131, _size128) = iprot.readListBegin()
12147 
          for _i132 in xrange(_size128):
12148 
            _elem133 = UserNote()
12149 
            _elem133.read(iprot)
12150 
            self.success.append(_elem133)
2981 rajveer 12151 
          iprot.readListEnd()
12152 
        else:
12153 
          iprot.skip(ftype)
559 chandransh 12154 
      else:
12155 
        iprot.skip(ftype)
12156 
      iprot.readFieldEnd()
12157 
    iprot.readStructEnd()
12158 
 
12159 
  def write(self, oprot):
12160 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12161 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12162 
      return
2981 rajveer 12163 
    oprot.writeStructBegin('getUserNotes_result')
12164 
    if self.success != None:
12165 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12166 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
3385 varun.gupt 12167 
      for iter134 in self.success:
12168 
        iter134.write(oprot)
2981 rajveer 12169 
      oprot.writeListEnd()
12170 
      oprot.writeFieldEnd()
559 chandransh 12171 
    oprot.writeFieldStop()
12172 
    oprot.writeStructEnd()
12173 
 
12174 
  def __repr__(self):
12175 
    L = ['%s=%r' % (key, value)
12176 
      for key, value in self.__dict__.iteritems()]
12177 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12178 
 
12179 
  def __eq__(self, other):
12180 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12181 
 
12182 
  def __ne__(self, other):
12183 
    return not (self == other)
12184 
 
2981 rajveer 12185 
class getMyResearchItems_args:
559 chandransh 12186 
  """
12187 
  Attributes:
772 rajveer 12188 
   - userId
559 chandransh 12189 
  """
12190 
 
12191 
  thrift_spec = (
12192 
    None, # 0
772 rajveer 12193 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 12194 
  )
12195 
 
772 rajveer 12196 
  def __init__(self, userId=None,):
12197 
    self.userId = userId
559 chandransh 12198 
 
12199 
  def read(self, iprot):
12200 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12201 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12202 
      return
12203 
    iprot.readStructBegin()
12204 
    while True:
12205 
      (fname, ftype, fid) = iprot.readFieldBegin()
12206 
      if ftype == TType.STOP:
12207 
        break
12208 
      if fid == 1:
12209 
        if ftype == TType.I64:
772 rajveer 12210 
          self.userId = iprot.readI64();
559 chandransh 12211 
        else:
12212 
          iprot.skip(ftype)
12213 
      else:
12214 
        iprot.skip(ftype)
12215 
      iprot.readFieldEnd()
12216 
    iprot.readStructEnd()
12217 
 
12218 
  def write(self, oprot):
12219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12221 
      return
2981 rajveer 12222 
    oprot.writeStructBegin('getMyResearchItems_args')
772 rajveer 12223 
    if self.userId != None:
12224 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12225 
      oprot.writeI64(self.userId)
559 chandransh 12226 
      oprot.writeFieldEnd()
12227 
    oprot.writeFieldStop()
12228 
    oprot.writeStructEnd()
12229 
 
12230 
  def __repr__(self):
12231 
    L = ['%s=%r' % (key, value)
12232 
      for key, value in self.__dict__.iteritems()]
12233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12234 
 
12235 
  def __eq__(self, other):
12236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12237 
 
12238 
  def __ne__(self, other):
12239 
    return not (self == other)
12240 
 
2981 rajveer 12241 
class getMyResearchItems_result:
559 chandransh 12242 
  """
12243 
  Attributes:
130 ashish 12244 
   - success
559 chandransh 12245 
   - scx
130 ashish 12246 
  """
12247 
 
12248 
  thrift_spec = (
2981 rajveer 12249 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 12250 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 12251 
  )
12252 
 
559 chandransh 12253 
  def __init__(self, success=None, scx=None,):
130 ashish 12254 
    self.success = success
559 chandransh 12255 
    self.scx = scx
130 ashish 12256 
 
12257 
  def read(self, iprot):
12258 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12259 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12260 
      return
12261 
    iprot.readStructBegin()
12262 
    while True:
12263 
      (fname, ftype, fid) = iprot.readFieldBegin()
12264 
      if ftype == TType.STOP:
12265 
        break
12266 
      if fid == 0:
2981 rajveer 12267 
        if ftype == TType.LIST:
12268 
          self.success = []
3385 varun.gupt 12269 
          (_etype138, _size135) = iprot.readListBegin()
12270 
          for _i139 in xrange(_size135):
12271 
            _elem140 = iprot.readI64();
12272 
            self.success.append(_elem140)
2981 rajveer 12273 
          iprot.readListEnd()
130 ashish 12274 
        else:
12275 
          iprot.skip(ftype)
12276 
      elif fid == 1:
12277 
        if ftype == TType.STRUCT:
559 chandransh 12278 
          self.scx = WidgetException()
12279 
          self.scx.read(iprot)
130 ashish 12280 
        else:
12281 
          iprot.skip(ftype)
12282 
      else:
12283 
        iprot.skip(ftype)
12284 
      iprot.readFieldEnd()
12285 
    iprot.readStructEnd()
12286 
 
12287 
  def write(self, oprot):
12288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12290 
      return
2981 rajveer 12291 
    oprot.writeStructBegin('getMyResearchItems_result')
130 ashish 12292 
    if self.success != None:
2981 rajveer 12293 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12294 
      oprot.writeListBegin(TType.I64, len(self.success))
3385 varun.gupt 12295 
      for iter141 in self.success:
12296 
        oprot.writeI64(iter141)
2981 rajveer 12297 
      oprot.writeListEnd()
130 ashish 12298 
      oprot.writeFieldEnd()
559 chandransh 12299 
    if self.scx != None:
12300 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12301 
      self.scx.write(oprot)
130 ashish 12302 
      oprot.writeFieldEnd()
12303 
    oprot.writeFieldStop()
12304 
    oprot.writeStructEnd()
12305 
 
12306 
  def __repr__(self):
12307 
    L = ['%s=%r' % (key, value)
12308 
      for key, value in self.__dict__.iteritems()]
12309 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12310 
 
12311 
  def __eq__(self, other):
12312 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12313 
 
12314 
  def __ne__(self, other):
12315 
    return not (self == other)
12316 
 
2981 rajveer 12317 
class updateMyResearch_args:
130 ashish 12318 
  """
12319 
  Attributes:
2981 rajveer 12320 
   - userId
12321 
   - itemId
130 ashish 12322 
  """
12323 
 
12324 
  thrift_spec = (
12325 
    None, # 0
2981 rajveer 12326 
    (1, TType.I64, 'userId', None, None, ), # 1
12327 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 12328 
  )
12329 
 
2981 rajveer 12330 
  def __init__(self, userId=None, itemId=None,):
12331 
    self.userId = userId
12332 
    self.itemId = itemId
130 ashish 12333 
 
12334 
  def read(self, iprot):
12335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12337 
      return
12338 
    iprot.readStructBegin()
12339 
    while True:
12340 
      (fname, ftype, fid) = iprot.readFieldBegin()
12341 
      if ftype == TType.STOP:
12342 
        break
12343 
      if fid == 1:
559 chandransh 12344 
        if ftype == TType.I64:
2981 rajveer 12345 
          self.userId = iprot.readI64();
130 ashish 12346 
        else:
12347 
          iprot.skip(ftype)
12348 
      elif fid == 2:
559 chandransh 12349 
        if ftype == TType.I64:
2981 rajveer 12350 
          self.itemId = iprot.readI64();
559 chandransh 12351 
        else:
12352 
          iprot.skip(ftype)
130 ashish 12353 
      else:
12354 
        iprot.skip(ftype)
12355 
      iprot.readFieldEnd()
12356 
    iprot.readStructEnd()
12357 
 
12358 
  def write(self, oprot):
12359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12361 
      return
2981 rajveer 12362 
    oprot.writeStructBegin('updateMyResearch_args')
12363 
    if self.userId != None:
12364 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12365 
      oprot.writeI64(self.userId)
130 ashish 12366 
      oprot.writeFieldEnd()
2981 rajveer 12367 
    if self.itemId != None:
12368 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12369 
      oprot.writeI64(self.itemId)
130 ashish 12370 
      oprot.writeFieldEnd()
12371 
    oprot.writeFieldStop()
12372 
    oprot.writeStructEnd()
12373 
 
12374 
  def __repr__(self):
12375 
    L = ['%s=%r' % (key, value)
12376 
      for key, value in self.__dict__.iteritems()]
12377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12378 
 
12379 
  def __eq__(self, other):
12380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12381 
 
12382 
  def __ne__(self, other):
12383 
    return not (self == other)
12384 
 
2981 rajveer 12385 
class updateMyResearch_result:
12386 
  """
12387 
  Attributes:
12388 
   - success
12389 
   - scx
12390 
  """
559 chandransh 12391 
 
12392 
  thrift_spec = (
2981 rajveer 12393 
    (0, TType.BOOL, 'success', None, None, ), # 0
12394 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 12395 
  )
12396 
 
2981 rajveer 12397 
  def __init__(self, success=None, scx=None,):
12398 
    self.success = success
12399 
    self.scx = scx
12400 
 
559 chandransh 12401 
  def read(self, iprot):
12402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12404 
      return
12405 
    iprot.readStructBegin()
12406 
    while True:
12407 
      (fname, ftype, fid) = iprot.readFieldBegin()
12408 
      if ftype == TType.STOP:
12409 
        break
2981 rajveer 12410 
      if fid == 0:
12411 
        if ftype == TType.BOOL:
12412 
          self.success = iprot.readBool();
12413 
        else:
12414 
          iprot.skip(ftype)
12415 
      elif fid == 1:
12416 
        if ftype == TType.STRUCT:
12417 
          self.scx = WidgetException()
12418 
          self.scx.read(iprot)
12419 
        else:
12420 
          iprot.skip(ftype)
559 chandransh 12421 
      else:
12422 
        iprot.skip(ftype)
12423 
      iprot.readFieldEnd()
12424 
    iprot.readStructEnd()
12425 
 
12426 
  def write(self, oprot):
12427 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12428 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12429 
      return
2981 rajveer 12430 
    oprot.writeStructBegin('updateMyResearch_result')
12431 
    if self.success != None:
12432 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12433 
      oprot.writeBool(self.success)
12434 
      oprot.writeFieldEnd()
12435 
    if self.scx != None:
12436 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12437 
      self.scx.write(oprot)
12438 
      oprot.writeFieldEnd()
559 chandransh 12439 
    oprot.writeFieldStop()
12440 
    oprot.writeStructEnd()
12441 
 
12442 
  def __repr__(self):
12443 
    L = ['%s=%r' % (key, value)
12444 
      for key, value in self.__dict__.iteritems()]
12445 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12446 
 
12447 
  def __eq__(self, other):
12448 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12449 
 
12450 
  def __ne__(self, other):
12451 
    return not (self == other)
12452 
 
2981 rajveer 12453 
class deleteItemFromMyResearch_args:
1596 ankur.sing 12454 
  """
12455 
  Attributes:
2981 rajveer 12456 
   - userId
12457 
   - itemId
1596 ankur.sing 12458 
  """
559 chandransh 12459 
 
1596 ankur.sing 12460 
  thrift_spec = (
12461 
    None, # 0
2981 rajveer 12462 
    (1, TType.I64, 'userId', None, None, ), # 1
12463 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 12464 
  )
12465 
 
2981 rajveer 12466 
  def __init__(self, userId=None, itemId=None,):
12467 
    self.userId = userId
12468 
    self.itemId = itemId
1596 ankur.sing 12469 
 
12470 
  def read(self, iprot):
12471 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12472 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12473 
      return
12474 
    iprot.readStructBegin()
12475 
    while True:
12476 
      (fname, ftype, fid) = iprot.readFieldBegin()
12477 
      if ftype == TType.STOP:
12478 
        break
12479 
      if fid == 1:
2981 rajveer 12480 
        if ftype == TType.I64:
12481 
          self.userId = iprot.readI64();
1596 ankur.sing 12482 
        else:
12483 
          iprot.skip(ftype)
2981 rajveer 12484 
      elif fid == 2:
12485 
        if ftype == TType.I64:
12486 
          self.itemId = iprot.readI64();
12487 
        else:
12488 
          iprot.skip(ftype)
1596 ankur.sing 12489 
      else:
12490 
        iprot.skip(ftype)
12491 
      iprot.readFieldEnd()
12492 
    iprot.readStructEnd()
12493 
 
12494 
  def write(self, oprot):
12495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12497 
      return
2981 rajveer 12498 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
12499 
    if self.userId != None:
12500 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12501 
      oprot.writeI64(self.userId)
1596 ankur.sing 12502 
      oprot.writeFieldEnd()
2981 rajveer 12503 
    if self.itemId != None:
12504 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12505 
      oprot.writeI64(self.itemId)
12506 
      oprot.writeFieldEnd()
1596 ankur.sing 12507 
    oprot.writeFieldStop()
12508 
    oprot.writeStructEnd()
12509 
 
12510 
  def __repr__(self):
12511 
    L = ['%s=%r' % (key, value)
12512 
      for key, value in self.__dict__.iteritems()]
12513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12514 
 
12515 
  def __eq__(self, other):
12516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12517 
 
12518 
  def __ne__(self, other):
12519 
    return not (self == other)
12520 
 
2981 rajveer 12521 
class deleteItemFromMyResearch_result:
1596 ankur.sing 12522 
  """
12523 
  Attributes:
2981 rajveer 12524 
   - scx
1596 ankur.sing 12525 
  """
12526 
 
12527 
  thrift_spec = (
2981 rajveer 12528 
    None, # 0
12529 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 12530 
  )
12531 
 
2981 rajveer 12532 
  def __init__(self, scx=None,):
12533 
    self.scx = scx
1596 ankur.sing 12534 
 
12535 
  def read(self, iprot):
12536 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12537 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12538 
      return
12539 
    iprot.readStructBegin()
12540 
    while True:
12541 
      (fname, ftype, fid) = iprot.readFieldBegin()
12542 
      if ftype == TType.STOP:
12543 
        break
2981 rajveer 12544 
      if fid == 1:
12545 
        if ftype == TType.STRUCT:
12546 
          self.scx = WidgetException()
12547 
          self.scx.read(iprot)
1596 ankur.sing 12548 
        else:
12549 
          iprot.skip(ftype)
12550 
      else:
12551 
        iprot.skip(ftype)
12552 
      iprot.readFieldEnd()
12553 
    iprot.readStructEnd()
12554 
 
12555 
  def write(self, oprot):
12556 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12557 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12558 
      return
2981 rajveer 12559 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
12560 
    if self.scx != None:
12561 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12562 
      self.scx.write(oprot)
1596 ankur.sing 12563 
      oprot.writeFieldEnd()
12564 
    oprot.writeFieldStop()
12565 
    oprot.writeStructEnd()
12566 
 
12567 
  def __repr__(self):
12568 
    L = ['%s=%r' % (key, value)
12569 
      for key, value in self.__dict__.iteritems()]
12570 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12571 
 
12572 
  def __eq__(self, other):
12573 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12574 
 
12575 
  def __ne__(self, other):
12576 
    return not (self == other)
12577 
 
2981 rajveer 12578 
class getBrowseHistoryItems_args:
1673 ankur.sing 12579 
  """
12580 
  Attributes:
2981 rajveer 12581 
   - userId
1673 ankur.sing 12582 
  """
1596 ankur.sing 12583 
 
1673 ankur.sing 12584 
  thrift_spec = (
12585 
    None, # 0
2981 rajveer 12586 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 12587 
  )
12588 
 
2981 rajveer 12589 
  def __init__(self, userId=None,):
12590 
    self.userId = userId
1673 ankur.sing 12591 
 
12592 
  def read(self, iprot):
12593 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12594 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12595 
      return
12596 
    iprot.readStructBegin()
12597 
    while True:
12598 
      (fname, ftype, fid) = iprot.readFieldBegin()
12599 
      if ftype == TType.STOP:
12600 
        break
12601 
      if fid == 1:
1891 ankur.sing 12602 
        if ftype == TType.I64:
2981 rajveer 12603 
          self.userId = iprot.readI64();
1891 ankur.sing 12604 
        else:
12605 
          iprot.skip(ftype)
1673 ankur.sing 12606 
      else:
12607 
        iprot.skip(ftype)
12608 
      iprot.readFieldEnd()
12609 
    iprot.readStructEnd()
12610 
 
12611 
  def write(self, oprot):
12612 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12613 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12614 
      return
2981 rajveer 12615 
    oprot.writeStructBegin('getBrowseHistoryItems_args')
12616 
    if self.userId != None:
12617 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12618 
      oprot.writeI64(self.userId)
1673 ankur.sing 12619 
      oprot.writeFieldEnd()
12620 
    oprot.writeFieldStop()
12621 
    oprot.writeStructEnd()
12622 
 
12623 
  def __repr__(self):
12624 
    L = ['%s=%r' % (key, value)
12625 
      for key, value in self.__dict__.iteritems()]
12626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12627 
 
12628 
  def __eq__(self, other):
12629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12630 
 
12631 
  def __ne__(self, other):
12632 
    return not (self == other)
12633 
 
2981 rajveer 12634 
class getBrowseHistoryItems_result:
1673 ankur.sing 12635 
  """
12636 
  Attributes:
12637 
   - success
2981 rajveer 12638 
   - scx
1673 ankur.sing 12639 
  """
12640 
 
12641 
  thrift_spec = (
2981 rajveer 12642 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12643 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 12644 
  )
12645 
 
2981 rajveer 12646 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 12647 
    self.success = success
2981 rajveer 12648 
    self.scx = scx
1673 ankur.sing 12649 
 
12650 
  def read(self, iprot):
12651 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12652 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12653 
      return
12654 
    iprot.readStructBegin()
12655 
    while True:
12656 
      (fname, ftype, fid) = iprot.readFieldBegin()
12657 
      if ftype == TType.STOP:
12658 
        break
12659 
      if fid == 0:
12660 
        if ftype == TType.LIST:
12661 
          self.success = []
3385 varun.gupt 12662 
          (_etype145, _size142) = iprot.readListBegin()
12663 
          for _i146 in xrange(_size142):
12664 
            _elem147 = iprot.readI64();
12665 
            self.success.append(_elem147)
1673 ankur.sing 12666 
          iprot.readListEnd()
12667 
        else:
12668 
          iprot.skip(ftype)
2981 rajveer 12669 
      elif fid == 1:
12670 
        if ftype == TType.STRUCT:
12671 
          self.scx = WidgetException()
12672 
          self.scx.read(iprot)
12673 
        else:
12674 
          iprot.skip(ftype)
1673 ankur.sing 12675 
      else:
12676 
        iprot.skip(ftype)
12677 
      iprot.readFieldEnd()
12678 
    iprot.readStructEnd()
12679 
 
12680 
  def write(self, oprot):
12681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12683 
      return
2981 rajveer 12684 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
1673 ankur.sing 12685 
    if self.success != None:
12686 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 12687 
      oprot.writeListBegin(TType.I64, len(self.success))
3385 varun.gupt 12688 
      for iter148 in self.success:
12689 
        oprot.writeI64(iter148)
1673 ankur.sing 12690 
      oprot.writeListEnd()
12691 
      oprot.writeFieldEnd()
2981 rajveer 12692 
    if self.scx != None:
12693 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12694 
      self.scx.write(oprot)
2642 varun.gupt 12695 
      oprot.writeFieldEnd()
12696 
    oprot.writeFieldStop()
12697 
    oprot.writeStructEnd()
12698 
 
12699 
  def __repr__(self):
12700 
    L = ['%s=%r' % (key, value)
12701 
      for key, value in self.__dict__.iteritems()]
12702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12703 
 
12704 
  def __eq__(self, other):
12705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12706 
 
12707 
  def __ne__(self, other):
12708 
    return not (self == other)
12709 
 
2981 rajveer 12710 
class updateBrowseHistory_args:
2642 varun.gupt 12711 
  """
12712 
  Attributes:
2981 rajveer 12713 
   - userId
12714 
   - itemId
2642 varun.gupt 12715 
  """
12716 
 
12717 
  thrift_spec = (
12718 
    None, # 0
2981 rajveer 12719 
    (1, TType.I64, 'userId', None, None, ), # 1
12720 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 12721 
  )
12722 
 
2981 rajveer 12723 
  def __init__(self, userId=None, itemId=None,):
12724 
    self.userId = userId
12725 
    self.itemId = itemId
2642 varun.gupt 12726 
 
12727 
  def read(self, iprot):
12728 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12729 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12730 
      return
12731 
    iprot.readStructBegin()
12732 
    while True:
12733 
      (fname, ftype, fid) = iprot.readFieldBegin()
12734 
      if ftype == TType.STOP:
12735 
        break
12736 
      if fid == 1:
12737 
        if ftype == TType.I64:
2981 rajveer 12738 
          self.userId = iprot.readI64();
2642 varun.gupt 12739 
        else:
12740 
          iprot.skip(ftype)
12741 
      elif fid == 2:
12742 
        if ftype == TType.I64:
2981 rajveer 12743 
          self.itemId = iprot.readI64();
2642 varun.gupt 12744 
        else:
12745 
          iprot.skip(ftype)
12746 
      else:
12747 
        iprot.skip(ftype)
12748 
      iprot.readFieldEnd()
12749 
    iprot.readStructEnd()
12750 
 
12751 
  def write(self, oprot):
12752 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12753 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12754 
      return
2981 rajveer 12755 
    oprot.writeStructBegin('updateBrowseHistory_args')
12756 
    if self.userId != None:
12757 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12758 
      oprot.writeI64(self.userId)
2642 varun.gupt 12759 
      oprot.writeFieldEnd()
2981 rajveer 12760 
    if self.itemId != None:
12761 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12762 
      oprot.writeI64(self.itemId)
2642 varun.gupt 12763 
      oprot.writeFieldEnd()
12764 
    oprot.writeFieldStop()
12765 
    oprot.writeStructEnd()
12766 
 
12767 
  def __repr__(self):
12768 
    L = ['%s=%r' % (key, value)
12769 
      for key, value in self.__dict__.iteritems()]
12770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12771 
 
12772 
  def __eq__(self, other):
12773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12774 
 
12775 
  def __ne__(self, other):
12776 
    return not (self == other)
12777 
 
2981 rajveer 12778 
class updateBrowseHistory_result:
2642 varun.gupt 12779 
 
12780 
  thrift_spec = (
12781 
  )
12782 
 
12783 
  def read(self, iprot):
12784 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12785 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12786 
      return
12787 
    iprot.readStructBegin()
12788 
    while True:
12789 
      (fname, ftype, fid) = iprot.readFieldBegin()
12790 
      if ftype == TType.STOP:
12791 
        break
12792 
      else:
12793 
        iprot.skip(ftype)
12794 
      iprot.readFieldEnd()
12795 
    iprot.readStructEnd()
12796 
 
12797 
  def write(self, oprot):
12798 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12799 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12800 
      return
2981 rajveer 12801 
    oprot.writeStructBegin('updateBrowseHistory_result')
2642 varun.gupt 12802 
    oprot.writeFieldStop()
12803 
    oprot.writeStructEnd()
12804 
 
12805 
  def __repr__(self):
12806 
    L = ['%s=%r' % (key, value)
12807 
      for key, value in self.__dict__.iteritems()]
12808 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12809 
 
12810 
  def __eq__(self, other):
12811 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12812 
 
12813 
  def __ne__(self, other):
12814 
    return not (self == other)
12815 
 
3385 varun.gupt 12816 
class getCartsWithCouponCount_args:
12817 
  """
12818 
  Attributes:
12819 
   - couponCode
12820 
  """
2642 varun.gupt 12821 
 
3385 varun.gupt 12822 
  thrift_spec = (
12823 
    None, # 0
12824 
    (1, TType.STRING, 'couponCode', None, None, ), # 1
12825 
  )
12826 
 
12827 
  def __init__(self, couponCode=None,):
12828 
    self.couponCode = couponCode
12829 
 
12830 
  def read(self, iprot):
12831 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12832 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12833 
      return
12834 
    iprot.readStructBegin()
12835 
    while True:
12836 
      (fname, ftype, fid) = iprot.readFieldBegin()
12837 
      if ftype == TType.STOP:
12838 
        break
12839 
      if fid == 1:
12840 
        if ftype == TType.STRING:
12841 
          self.couponCode = iprot.readString();
12842 
        else:
12843 
          iprot.skip(ftype)
12844 
      else:
12845 
        iprot.skip(ftype)
12846 
      iprot.readFieldEnd()
12847 
    iprot.readStructEnd()
12848 
 
12849 
  def write(self, oprot):
12850 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12851 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12852 
      return
12853 
    oprot.writeStructBegin('getCartsWithCouponCount_args')
12854 
    if self.couponCode != None:
12855 
      oprot.writeFieldBegin('couponCode', TType.STRING, 1)
12856 
      oprot.writeString(self.couponCode)
12857 
      oprot.writeFieldEnd()
12858 
    oprot.writeFieldStop()
12859 
    oprot.writeStructEnd()
12860 
 
12861 
  def __repr__(self):
12862 
    L = ['%s=%r' % (key, value)
12863 
      for key, value in self.__dict__.iteritems()]
12864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12865 
 
12866 
  def __eq__(self, other):
12867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12868 
 
12869 
  def __ne__(self, other):
12870 
    return not (self == other)
12871 
 
12872 
class getCartsWithCouponCount_result:
12873 
  """
12874 
  Attributes:
12875 
   - success
12876 
  """
12877 
 
12878 
  thrift_spec = (
12879 
    (0, TType.I64, 'success', None, None, ), # 0
12880 
  )
12881 
 
12882 
  def __init__(self, success=None,):
12883 
    self.success = success
12884 
 
12885 
  def read(self, iprot):
12886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12888 
      return
12889 
    iprot.readStructBegin()
12890 
    while True:
12891 
      (fname, ftype, fid) = iprot.readFieldBegin()
12892 
      if ftype == TType.STOP:
12893 
        break
12894 
      if fid == 0:
12895 
        if ftype == TType.I64:
12896 
          self.success = iprot.readI64();
12897 
        else:
12898 
          iprot.skip(ftype)
12899 
      else:
12900 
        iprot.skip(ftype)
12901 
      iprot.readFieldEnd()
12902 
    iprot.readStructEnd()
12903 
 
12904 
  def write(self, oprot):
12905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12907 
      return
12908 
    oprot.writeStructBegin('getCartsWithCouponCount_result')
12909 
    if self.success != None:
12910 
      oprot.writeFieldBegin('success', TType.I64, 0)
12911 
      oprot.writeI64(self.success)
12912 
      oprot.writeFieldEnd()
12913 
    oprot.writeFieldStop()
12914 
    oprot.writeStructEnd()
12915 
 
12916 
  def __repr__(self):
12917 
    L = ['%s=%r' % (key, value)
12918 
      for key, value in self.__dict__.iteritems()]
12919 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12920 
 
12921 
  def __eq__(self, other):
12922 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12923 
 
12924 
  def __ne__(self, other):
12925 
    return not (self == other)
12926 
 
12927