Subversion Repositories SmartDukaan

Rev

Rev 3376 | Rev 3385 | 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 
 
2642 varun.gupt 577 
 
3376 rajveer 578 
class Client(shop2020.thriftpy.generic.GenericService.Client, Iface):
94 ashish 579 
  """
580 
  service
581 
  """
582 
  def __init__(self, iprot, oprot=None):
3376 rajveer 583 
    shop2020.thriftpy.generic.GenericService.Client.__init__(self, iprot, oprot)
94 ashish 584 
 
559 chandransh 585 
  def createAnonymousUser(self, jsessionId):
94 ashish 586 
    """
587 
    Parameters:
559 chandransh 588 
     - jsessionId
94 ashish 589 
    """
559 chandransh 590 
    self.send_createAnonymousUser(jsessionId)
591 
    return self.recv_createAnonymousUser()
94 ashish 592 
 
559 chandransh 593 
  def send_createAnonymousUser(self, jsessionId):
594 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
595 
    args = createAnonymousUser_args()
596 
    args.jsessionId = jsessionId
94 ashish 597 
    args.write(self._oprot)
598 
    self._oprot.writeMessageEnd()
599 
    self._oprot.trans.flush()
600 
 
559 chandransh 601 
  def recv_createAnonymousUser(self, ):
94 ashish 602 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
603 
    if mtype == TMessageType.EXCEPTION:
604 
      x = TApplicationException()
605 
      x.read(self._iprot)
606 
      self._iprot.readMessageEnd()
607 
      raise x
559 chandransh 608 
    result = createAnonymousUser_result()
94 ashish 609 
    result.read(self._iprot)
610 
    self._iprot.readMessageEnd()
611 
    if result.success != None:
612 
      return result.success
559 chandransh 613 
    if result.ucex != None:
614 
      raise result.ucex
615 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 616 
 
559 chandransh 617 
  def getUserById(self, userId):
94 ashish 618 
    """
619 
    Parameters:
620 
     - userId
621 
    """
559 chandransh 622 
    self.send_getUserById(userId)
623 
    return self.recv_getUserById()
94 ashish 624 
 
559 chandransh 625 
  def send_getUserById(self, userId):
626 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
627 
    args = getUserById_args()
94 ashish 628 
    args.userId = userId
629 
    args.write(self._oprot)
630 
    self._oprot.writeMessageEnd()
631 
    self._oprot.trans.flush()
632 
 
559 chandransh 633 
  def recv_getUserById(self, ):
94 ashish 634 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
635 
    if mtype == TMessageType.EXCEPTION:
636 
      x = TApplicationException()
637 
      x.read(self._iprot)
638 
      self._iprot.readMessageEnd()
639 
      raise x
559 chandransh 640 
    result = getUserById_result()
94 ashish 641 
    result.read(self._iprot)
642 
    self._iprot.readMessageEnd()
643 
    if result.success != None:
644 
      return result.success
559 chandransh 645 
    if result.ucex != None:
646 
      raise result.ucex
647 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 648 
 
1491 vikas 649 
  def getUserByEmail(self, email):
650 
    """
651 
    Parameters:
652 
     - email
653 
    """
654 
    self.send_getUserByEmail(email)
655 
    return self.recv_getUserByEmail()
656 
 
657 
  def send_getUserByEmail(self, email):
658 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
659 
    args = getUserByEmail_args()
660 
    args.email = email
661 
    args.write(self._oprot)
662 
    self._oprot.writeMessageEnd()
663 
    self._oprot.trans.flush()
664 
 
665 
  def recv_getUserByEmail(self, ):
666 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
667 
    if mtype == TMessageType.EXCEPTION:
668 
      x = TApplicationException()
669 
      x.read(self._iprot)
670 
      self._iprot.readMessageEnd()
671 
      raise x
672 
    result = getUserByEmail_result()
673 
    result.read(self._iprot)
674 
    self._iprot.readMessageEnd()
675 
    if result.success != None:
676 
      return result.success
677 
    if result.ucex != None:
678 
      raise result.ucex
679 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
680 
 
3032 mandeep.dh 681 
  def getUserByMobileNumber(self, mobileNumber):
682 
    """
683 
    Parameters:
684 
     - mobileNumber
685 
    """
686 
    self.send_getUserByMobileNumber(mobileNumber)
687 
    return self.recv_getUserByMobileNumber()
688 
 
689 
  def send_getUserByMobileNumber(self, mobileNumber):
690 
    self._oprot.writeMessageBegin('getUserByMobileNumber', TMessageType.CALL, self._seqid)
691 
    args = getUserByMobileNumber_args()
692 
    args.mobileNumber = mobileNumber
693 
    args.write(self._oprot)
694 
    self._oprot.writeMessageEnd()
695 
    self._oprot.trans.flush()
696 
 
697 
  def recv_getUserByMobileNumber(self, ):
698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
699 
    if mtype == TMessageType.EXCEPTION:
700 
      x = TApplicationException()
701 
      x.read(self._iprot)
702 
      self._iprot.readMessageEnd()
703 
      raise x
704 
    result = getUserByMobileNumber_result()
705 
    result.read(self._iprot)
706 
    self._iprot.readMessageEnd()
707 
    if result.success != None:
708 
      return result.success
709 
    if result.ucex != None:
710 
      raise result.ucex
711 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByMobileNumber failed: unknown result");
712 
 
559 chandransh 713 
  def createUser(self, user):
94 ashish 714 
    """
715 
    Parameters:
559 chandransh 716 
     - user
94 ashish 717 
    """
559 chandransh 718 
    self.send_createUser(user)
719 
    return self.recv_createUser()
94 ashish 720 
 
559 chandransh 721 
  def send_createUser(self, user):
722 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
723 
    args = createUser_args()
724 
    args.user = user
94 ashish 725 
    args.write(self._oprot)
726 
    self._oprot.writeMessageEnd()
727 
    self._oprot.trans.flush()
728 
 
559 chandransh 729 
  def recv_createUser(self, ):
94 ashish 730 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
731 
    if mtype == TMessageType.EXCEPTION:
732 
      x = TApplicationException()
733 
      x.read(self._iprot)
734 
      self._iprot.readMessageEnd()
735 
      raise x
559 chandransh 736 
    result = createUser_result()
94 ashish 737 
    result.read(self._iprot)
738 
    self._iprot.readMessageEnd()
739 
    if result.success != None:
740 
      return result.success
559 chandransh 741 
    if result.ucex != None:
742 
      raise result.ucex
743 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 744 
 
559 chandransh 745 
  def updateUser(self, user):
94 ashish 746 
    """
747 
    Parameters:
559 chandransh 748 
     - user
94 ashish 749 
    """
559 chandransh 750 
    self.send_updateUser(user)
751 
    return self.recv_updateUser()
94 ashish 752 
 
559 chandransh 753 
  def send_updateUser(self, user):
754 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
755 
    args = updateUser_args()
756 
    args.user = user
94 ashish 757 
    args.write(self._oprot)
758 
    self._oprot.writeMessageEnd()
759 
    self._oprot.trans.flush()
760 
 
559 chandransh 761 
  def recv_updateUser(self, ):
94 ashish 762 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
763 
    if mtype == TMessageType.EXCEPTION:
764 
      x = TApplicationException()
765 
      x.read(self._iprot)
766 
      self._iprot.readMessageEnd()
767 
      raise x
559 chandransh 768 
    result = updateUser_result()
94 ashish 769 
    result.read(self._iprot)
770 
    self._iprot.readMessageEnd()
771 
    if result.success != None:
772 
      return result.success
559 chandransh 773 
    if result.ucex != None:
774 
      raise result.ucex
775 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 776 
 
559 chandransh 777 
  def deleteUser(self, userId):
94 ashish 778 
    """
779 
    Parameters:
780 
     - userId
781 
    """
559 chandransh 782 
    self.send_deleteUser(userId)
783 
    return self.recv_deleteUser()
94 ashish 784 
 
559 chandransh 785 
  def send_deleteUser(self, userId):
786 
    self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
787 
    args = deleteUser_args()
94 ashish 788 
    args.userId = userId
789 
    args.write(self._oprot)
790 
    self._oprot.writeMessageEnd()
791 
    self._oprot.trans.flush()
792 
 
559 chandransh 793 
  def recv_deleteUser(self, ):
94 ashish 794 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
795 
    if mtype == TMessageType.EXCEPTION:
796 
      x = TApplicationException()
797 
      x.read(self._iprot)
798 
      self._iprot.readMessageEnd()
799 
      raise x
559 chandransh 800 
    result = deleteUser_result()
94 ashish 801 
    result.read(self._iprot)
802 
    self._iprot.readMessageEnd()
803 
    if result.success != None:
804 
      return result.success
559 chandransh 805 
    if result.ucex != None:
806 
      raise result.ucex
807 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
94 ashish 808 
 
559 chandransh 809 
  def getUserState(self, userId):
94 ashish 810 
    """
811 
    Parameters:
812 
     - userId
813 
    """
559 chandransh 814 
    self.send_getUserState(userId)
815 
    return self.recv_getUserState()
94 ashish 816 
 
559 chandransh 817 
  def send_getUserState(self, userId):
818 
    self._oprot.writeMessageBegin('getUserState', TMessageType.CALL, self._seqid)
819 
    args = getUserState_args()
94 ashish 820 
    args.userId = userId
821 
    args.write(self._oprot)
822 
    self._oprot.writeMessageEnd()
823 
    self._oprot.trans.flush()
824 
 
559 chandransh 825 
  def recv_getUserState(self, ):
94 ashish 826 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
827 
    if mtype == TMessageType.EXCEPTION:
828 
      x = TApplicationException()
829 
      x.read(self._iprot)
830 
      self._iprot.readMessageEnd()
831 
      raise x
559 chandransh 832 
    result = getUserState_result()
94 ashish 833 
    result.read(self._iprot)
834 
    self._iprot.readMessageEnd()
835 
    if result.success != None:
836 
      return result.success
559 chandransh 837 
    if result.ucex != None:
838 
      raise result.ucex
839 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserState failed: unknown result");
94 ashish 840 
 
559 chandransh 841 
  def authenticateUser(self, email, password):
94 ashish 842 
    """
843 
    Parameters:
844 
     - email
845 
     - password
846 
    """
559 chandransh 847 
    self.send_authenticateUser(email, password)
122 ashish 848 
    return self.recv_authenticateUser()
849 
 
559 chandransh 850 
  def send_authenticateUser(self, email, password):
122 ashish 851 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
852 
    args = authenticateUser_args()
559 chandransh 853 
    args.email = email
122 ashish 854 
    args.password = password
855 
    args.write(self._oprot)
856 
    self._oprot.writeMessageEnd()
857 
    self._oprot.trans.flush()
858 
 
859 
  def recv_authenticateUser(self, ):
860 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
861 
    if mtype == TMessageType.EXCEPTION:
862 
      x = TApplicationException()
863 
      x.read(self._iprot)
864 
      self._iprot.readMessageEnd()
865 
      raise x
866 
    result = authenticateUser_result()
867 
    result.read(self._iprot)
868 
    self._iprot.readMessageEnd()
869 
    if result.success != None:
870 
      return result.success
559 chandransh 871 
    if result.auex != None:
872 
      raise result.auex
122 ashish 873 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
874 
 
94 ashish 875 
  def userExists(self, email):
876 
    """
877 
    Parameters:
878 
     - email
879 
    """
880 
    self.send_userExists(email)
881 
    return self.recv_userExists()
882 
 
883 
  def send_userExists(self, email):
884 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
885 
    args = userExists_args()
886 
    args.email = email
887 
    args.write(self._oprot)
888 
    self._oprot.writeMessageEnd()
889 
    self._oprot.trans.flush()
890 
 
891 
  def recv_userExists(self, ):
892 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
893 
    if mtype == TMessageType.EXCEPTION:
894 
      x = TApplicationException()
895 
      x.read(self._iprot)
896 
      self._iprot.readMessageEnd()
897 
      raise x
898 
    result = userExists_result()
899 
    result.read(self._iprot)
900 
    self._iprot.readMessageEnd()
901 
    if result.success != None:
902 
      return result.success
903 
    if result.ucx != None:
904 
      raise result.ucx
905 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
906 
 
567 rajveer 907 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 908 
    """
909 
    Parameters:
910 
     - userId
911 
     - address
513 rajveer 912 
     - setDefault
94 ashish 913 
    """
567 rajveer 914 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 915 
    return self.recv_addAddressForUser()
916 
 
567 rajveer 917 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 918 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
919 
    args = addAddressForUser_args()
559 chandransh 920 
    args.userId = userId
94 ashish 921 
    args.address = address
513 rajveer 922 
    args.setDefault = setDefault
94 ashish 923 
    args.write(self._oprot)
924 
    self._oprot.writeMessageEnd()
925 
    self._oprot.trans.flush()
926 
 
927 
  def recv_addAddressForUser(self, ):
928 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
929 
    if mtype == TMessageType.EXCEPTION:
930 
      x = TApplicationException()
931 
      x.read(self._iprot)
932 
      self._iprot.readMessageEnd()
933 
      raise x
934 
    result = addAddressForUser_result()
935 
    result.read(self._iprot)
936 
    self._iprot.readMessageEnd()
937 
    if result.success != None:
938 
      return result.success
939 
    if result.ucx != None:
940 
      raise result.ucx
941 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
942 
 
943 
  def removeAddressForUser(self, userid, addressId):
944 
    """
945 
    Parameters:
946 
     - userid
947 
     - addressId
948 
    """
949 
    self.send_removeAddressForUser(userid, addressId)
950 
    return self.recv_removeAddressForUser()
951 
 
952 
  def send_removeAddressForUser(self, userid, addressId):
953 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
954 
    args = removeAddressForUser_args()
955 
    args.userid = userid
956 
    args.addressId = addressId
957 
    args.write(self._oprot)
958 
    self._oprot.writeMessageEnd()
959 
    self._oprot.trans.flush()
960 
 
961 
  def recv_removeAddressForUser(self, ):
962 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
963 
    if mtype == TMessageType.EXCEPTION:
964 
      x = TApplicationException()
965 
      x.read(self._iprot)
966 
      self._iprot.readMessageEnd()
967 
      raise x
968 
    result = removeAddressForUser_result()
969 
    result.read(self._iprot)
970 
    self._iprot.readMessageEnd()
971 
    if result.success != None:
972 
      return result.success
973 
    if result.ucx != None:
974 
      raise result.ucx
975 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
976 
 
977 
  def setUserAsLoggedIn(self, userId, timestamp):
978 
    """
979 
    Parameters:
980 
     - userId
981 
     - timestamp
982 
    """
983 
    self.send_setUserAsLoggedIn(userId, timestamp)
984 
    return self.recv_setUserAsLoggedIn()
985 
 
986 
  def send_setUserAsLoggedIn(self, userId, timestamp):
987 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
988 
    args = setUserAsLoggedIn_args()
989 
    args.userId = userId
990 
    args.timestamp = timestamp
991 
    args.write(self._oprot)
992 
    self._oprot.writeMessageEnd()
993 
    self._oprot.trans.flush()
994 
 
995 
  def recv_setUserAsLoggedIn(self, ):
996 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
997 
    if mtype == TMessageType.EXCEPTION:
998 
      x = TApplicationException()
999 
      x.read(self._iprot)
1000 
      self._iprot.readMessageEnd()
1001 
      raise x
1002 
    result = setUserAsLoggedIn_result()
1003 
    result.read(self._iprot)
1004 
    self._iprot.readMessageEnd()
1005 
    if result.success != None:
1006 
      return result.success
1007 
    if result.ucx != None:
1008 
      raise result.ucx
1009 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1010 
 
1011 
  def setUserAsLoggedOut(self, userid, timestamp):
1012 
    """
1013 
    Parameters:
1014 
     - userid
1015 
     - timestamp
1016 
    """
1017 
    self.send_setUserAsLoggedOut(userid, timestamp)
1018 
    return self.recv_setUserAsLoggedOut()
1019 
 
1020 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1021 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1022 
    args = setUserAsLoggedOut_args()
1023 
    args.userid = userid
1024 
    args.timestamp = timestamp
1025 
    args.write(self._oprot)
1026 
    self._oprot.writeMessageEnd()
1027 
    self._oprot.trans.flush()
1028 
 
1029 
  def recv_setUserAsLoggedOut(self, ):
1030 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1031 
    if mtype == TMessageType.EXCEPTION:
1032 
      x = TApplicationException()
1033 
      x.read(self._iprot)
1034 
      self._iprot.readMessageEnd()
1035 
      raise x
1036 
    result = setUserAsLoggedOut_result()
1037 
    result.read(self._iprot)
1038 
    self._iprot.readMessageEnd()
1039 
    if result.success != None:
1040 
      return result.success
1041 
    if result.ucx != None:
1042 
      raise result.ucx
1043 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1044 
 
504 rajveer 1045 
  def setDefaultAddress(self, userid, addressId):
1046 
    """
1047 
    Parameters:
1048 
     - userid
1049 
     - addressId
1050 
    """
1051 
    self.send_setDefaultAddress(userid, addressId)
1052 
    return self.recv_setDefaultAddress()
1053 
 
1054 
  def send_setDefaultAddress(self, userid, addressId):
1055 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1056 
    args = setDefaultAddress_args()
1057 
    args.userid = userid
1058 
    args.addressId = addressId
1059 
    args.write(self._oprot)
1060 
    self._oprot.writeMessageEnd()
1061 
    self._oprot.trans.flush()
1062 
 
1063 
  def recv_setDefaultAddress(self, ):
1064 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1065 
    if mtype == TMessageType.EXCEPTION:
1066 
      x = TApplicationException()
1067 
      x.read(self._iprot)
1068 
      self._iprot.readMessageEnd()
1069 
      raise x
1070 
    result = setDefaultAddress_result()
1071 
    result.read(self._iprot)
1072 
    self._iprot.readMessageEnd()
1073 
    if result.success != None:
1074 
      return result.success
1075 
    if result.ucx != None:
1076 
      raise result.ucx
1077 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1078 
 
594 rajveer 1079 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1080 
    """
1081 
    Parameters:
1082 
     - userid
594 rajveer 1083 
     - oldPassword
1084 
     - newPassword
94 ashish 1085 
    """
594 rajveer 1086 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1087 
    return self.recv_updatePassword()
1088 
 
594 rajveer 1089 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1090 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1091 
    args = updatePassword_args()
1092 
    args.userid = userid
594 rajveer 1093 
    args.oldPassword = oldPassword
1094 
    args.newPassword = newPassword
94 ashish 1095 
    args.write(self._oprot)
1096 
    self._oprot.writeMessageEnd()
1097 
    self._oprot.trans.flush()
1098 
 
1099 
  def recv_updatePassword(self, ):
1100 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1101 
    if mtype == TMessageType.EXCEPTION:
1102 
      x = TApplicationException()
1103 
      x.read(self._iprot)
1104 
      self._iprot.readMessageEnd()
1105 
      raise x
1106 
    result = updatePassword_result()
1107 
    result.read(self._iprot)
1108 
    self._iprot.readMessageEnd()
1109 
    if result.success != None:
1110 
      return result.success
1111 
    if result.ucx != None:
1112 
      raise result.ucx
1113 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1114 
 
884 rajveer 1115 
  def forgotPassword(self, email, newPassword):
581 rajveer 1116 
    """
1117 
    Parameters:
1118 
     - email
884 rajveer 1119 
     - newPassword
581 rajveer 1120 
    """
884 rajveer 1121 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1122 
    return self.recv_forgotPassword()
1123 
 
884 rajveer 1124 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1125 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1126 
    args = forgotPassword_args()
1127 
    args.email = email
884 rajveer 1128 
    args.newPassword = newPassword
581 rajveer 1129 
    args.write(self._oprot)
1130 
    self._oprot.writeMessageEnd()
1131 
    self._oprot.trans.flush()
1132 
 
1133 
  def recv_forgotPassword(self, ):
1134 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1135 
    if mtype == TMessageType.EXCEPTION:
1136 
      x = TApplicationException()
1137 
      x.read(self._iprot)
1138 
      self._iprot.readMessageEnd()
1139 
      raise x
1140 
    result = forgotPassword_result()
1141 
    result.read(self._iprot)
1142 
    self._iprot.readMessageEnd()
1143 
    if result.success != None:
1144 
      return result.success
1145 
    if result.ucx != None:
1146 
      raise result.ucx
1147 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1148 
 
594 rajveer 1149 
  def getAllAddressesForUser(self, userId):
1150 
    """
1151 
    Parameters:
1152 
     - userId
1153 
    """
1154 
    self.send_getAllAddressesForUser(userId)
1155 
    return self.recv_getAllAddressesForUser()
1156 
 
1157 
  def send_getAllAddressesForUser(self, userId):
1158 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1159 
    args = getAllAddressesForUser_args()
1160 
    args.userId = userId
1161 
    args.write(self._oprot)
1162 
    self._oprot.writeMessageEnd()
1163 
    self._oprot.trans.flush()
1164 
 
1165 
  def recv_getAllAddressesForUser(self, ):
1166 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1167 
    if mtype == TMessageType.EXCEPTION:
1168 
      x = TApplicationException()
1169 
      x.read(self._iprot)
1170 
      self._iprot.readMessageEnd()
1171 
      raise x
1172 
    result = getAllAddressesForUser_result()
1173 
    result.read(self._iprot)
1174 
    self._iprot.readMessageEnd()
1175 
    if result.success != None:
1176 
      return result.success
1177 
    if result.ucx != None:
1178 
      raise result.ucx
1179 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1180 
 
1894 vikas 1181 
  def getAddressById(self, addressId):
1182 
    """
1183 
    Parameters:
1184 
     - addressId
1185 
    """
1186 
    self.send_getAddressById(addressId)
1187 
    return self.recv_getAddressById()
1188 
 
1189 
  def send_getAddressById(self, addressId):
1190 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1191 
    args = getAddressById_args()
1192 
    args.addressId = addressId
1193 
    args.write(self._oprot)
1194 
    self._oprot.writeMessageEnd()
1195 
    self._oprot.trans.flush()
1196 
 
1197 
  def recv_getAddressById(self, ):
1198 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1199 
    if mtype == TMessageType.EXCEPTION:
1200 
      x = TApplicationException()
1201 
      x.read(self._iprot)
1202 
      self._iprot.readMessageEnd()
1203 
      raise x
1204 
    result = getAddressById_result()
1205 
    result.read(self._iprot)
1206 
    self._iprot.readMessageEnd()
1207 
    if result.success != None:
1208 
      return result.success
1209 
    if result.ucx != None:
1210 
      raise result.ucx
1211 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1212 
 
594 rajveer 1213 
  def getDefaultAddressId(self, userId):
1214 
    """
1215 
    Parameters:
1216 
     - userId
1217 
    """
1218 
    self.send_getDefaultAddressId(userId)
1219 
    return self.recv_getDefaultAddressId()
1220 
 
1221 
  def send_getDefaultAddressId(self, userId):
1222 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1223 
    args = getDefaultAddressId_args()
1224 
    args.userId = userId
1225 
    args.write(self._oprot)
1226 
    self._oprot.writeMessageEnd()
1227 
    self._oprot.trans.flush()
1228 
 
1229 
  def recv_getDefaultAddressId(self, ):
1230 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1231 
    if mtype == TMessageType.EXCEPTION:
1232 
      x = TApplicationException()
1233 
      x.read(self._iprot)
1234 
      self._iprot.readMessageEnd()
1235 
      raise x
1236 
    result = getDefaultAddressId_result()
1237 
    result.read(self._iprot)
1238 
    self._iprot.readMessageEnd()
1239 
    if result.success != None:
1240 
      return result.success
1241 
    if result.ucx != None:
1242 
      raise result.ucx
1243 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1244 
 
785 rajveer 1245 
  def getDefaultPincode(self, userId):
1246 
    """
1247 
    Parameters:
1248 
     - userId
1249 
    """
1250 
    self.send_getDefaultPincode(userId)
1251 
    return self.recv_getDefaultPincode()
1252 
 
1253 
  def send_getDefaultPincode(self, userId):
1254 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1255 
    args = getDefaultPincode_args()
1256 
    args.userId = userId
1257 
    args.write(self._oprot)
1258 
    self._oprot.writeMessageEnd()
1259 
    self._oprot.trans.flush()
1260 
 
1261 
  def recv_getDefaultPincode(self, ):
1262 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1263 
    if mtype == TMessageType.EXCEPTION:
1264 
      x = TApplicationException()
1265 
      x.read(self._iprot)
1266 
      self._iprot.readMessageEnd()
1267 
      raise x
1268 
    result = getDefaultPincode_result()
1269 
    result.read(self._iprot)
1270 
    self._iprot.readMessageEnd()
1271 
    if result.success != None:
1272 
      return result.success
1273 
    if result.ucx != None:
1274 
      raise result.ucx
1275 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1276 
 
1274 varun.gupt 1277 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1278 
    """
1279 
    Parameters:
1280 
     - userId
1281 
     - replyTo
1282 
     - communicationType
1283 
     - orderId
1284 
     - airwaybillNo
1285 
     - productName
1286 
     - subject
1287 
     - message
1288 
    """
1289 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1290 
    return self.recv_saveUserCommunication()
1291 
 
1292 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1293 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1294 
    args = saveUserCommunication_args()
1295 
    args.userId = userId
1296 
    args.replyTo = replyTo
1297 
    args.communicationType = communicationType
1298 
    args.orderId = orderId
1299 
    args.airwaybillNo = airwaybillNo
1300 
    args.productName = productName
1301 
    args.subject = subject
1302 
    args.message = message
1303 
    args.write(self._oprot)
1304 
    self._oprot.writeMessageEnd()
1305 
    self._oprot.trans.flush()
1306 
 
1307 
  def recv_saveUserCommunication(self, ):
1308 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1309 
    if mtype == TMessageType.EXCEPTION:
1310 
      x = TApplicationException()
1311 
      x.read(self._iprot)
1312 
      self._iprot.readMessageEnd()
1313 
      raise x
1314 
    result = saveUserCommunication_result()
1315 
    result.read(self._iprot)
1316 
    self._iprot.readMessageEnd()
1317 
    if result.success != None:
1318 
      return result.success
1319 
    if result.ucx != None:
1320 
      raise result.ucx
1321 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1322 
 
1590 varun.gupt 1323 
  def getUserCommunicationById(self, id):
1324 
    """
1325 
    Parameters:
1326 
     - id
1327 
    """
1328 
    self.send_getUserCommunicationById(id)
1329 
    return self.recv_getUserCommunicationById()
1330 
 
1331 
  def send_getUserCommunicationById(self, id):
1332 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1333 
    args = getUserCommunicationById_args()
1334 
    args.id = id
1335 
    args.write(self._oprot)
1336 
    self._oprot.writeMessageEnd()
1337 
    self._oprot.trans.flush()
1338 
 
1339 
  def recv_getUserCommunicationById(self, ):
1340 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1341 
    if mtype == TMessageType.EXCEPTION:
1342 
      x = TApplicationException()
1343 
      x.read(self._iprot)
1344 
      self._iprot.readMessageEnd()
1345 
      raise x
1346 
    result = getUserCommunicationById_result()
1347 
    result.read(self._iprot)
1348 
    self._iprot.readMessageEnd()
1349 
    if result.success != None:
1350 
      return result.success
1351 
    if result.ucx != None:
1352 
      raise result.ucx
1353 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1354 
 
1355 
  def getUserCommunicationByUser(self, userId):
1356 
    """
1357 
    Parameters:
1358 
     - userId
1359 
    """
1360 
    self.send_getUserCommunicationByUser(userId)
1361 
    return self.recv_getUserCommunicationByUser()
1362 
 
1363 
  def send_getUserCommunicationByUser(self, userId):
1364 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1365 
    args = getUserCommunicationByUser_args()
1366 
    args.userId = userId
1367 
    args.write(self._oprot)
1368 
    self._oprot.writeMessageEnd()
1369 
    self._oprot.trans.flush()
1370 
 
1371 
  def recv_getUserCommunicationByUser(self, ):
1372 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1373 
    if mtype == TMessageType.EXCEPTION:
1374 
      x = TApplicationException()
1375 
      x.read(self._iprot)
1376 
      self._iprot.readMessageEnd()
1377 
      raise x
1378 
    result = getUserCommunicationByUser_result()
1379 
    result.read(self._iprot)
1380 
    self._iprot.readMessageEnd()
1381 
    if result.success != None:
1382 
      return result.success
1383 
    if result.ucx != None:
1384 
      raise result.ucx
1385 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1386 
 
1387 
  def getAllUserCommunications(self, ):
1388 
    self.send_getAllUserCommunications()
1389 
    return self.recv_getAllUserCommunications()
1390 
 
1391 
  def send_getAllUserCommunications(self, ):
1392 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1393 
    args = getAllUserCommunications_args()
1394 
    args.write(self._oprot)
1395 
    self._oprot.writeMessageEnd()
1396 
    self._oprot.trans.flush()
1397 
 
1398 
  def recv_getAllUserCommunications(self, ):
1399 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1400 
    if mtype == TMessageType.EXCEPTION:
1401 
      x = TApplicationException()
1402 
      x.read(self._iprot)
1403 
      self._iprot.readMessageEnd()
1404 
      raise x
1405 
    result = getAllUserCommunications_result()
1406 
    result.read(self._iprot)
1407 
    self._iprot.readMessageEnd()
1408 
    if result.success != None:
1409 
      return result.success
1410 
    if result.ucx != None:
1411 
      raise result.ucx
1412 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1413 
 
1859 vikas 1414 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1415 
    """
1416 
    Parameters:
1417 
     - name
1859 vikas 1418 
     - addedOn
1845 vikas 1419 
    """
1859 vikas 1420 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1421 
    return self.recv_createMasterAffiliate()
1422 
 
1859 vikas 1423 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1424 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1425 
    args = createMasterAffiliate_args()
1426 
    args.name = name
1859 vikas 1427 
    args.addedOn = addedOn
1845 vikas 1428 
    args.write(self._oprot)
1429 
    self._oprot.writeMessageEnd()
1430 
    self._oprot.trans.flush()
1431 
 
1432 
  def recv_createMasterAffiliate(self, ):
1433 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1434 
    if mtype == TMessageType.EXCEPTION:
1435 
      x = TApplicationException()
1436 
      x.read(self._iprot)
1437 
      self._iprot.readMessageEnd()
1438 
      raise x
1439 
    result = createMasterAffiliate_result()
1440 
    result.read(self._iprot)
1441 
    self._iprot.readMessageEnd()
1442 
    if result.success != None:
1443 
      return result.success
1444 
    if result.utx != None:
1445 
      raise result.utx
1446 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1447 
 
1899 vikas 1448 
  def getAllMasterAffiliates(self, ):
1449 
    self.send_getAllMasterAffiliates()
1450 
    return self.recv_getAllMasterAffiliates()
1451 
 
1452 
  def send_getAllMasterAffiliates(self, ):
1453 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1454 
    args = getAllMasterAffiliates_args()
1455 
    args.write(self._oprot)
1456 
    self._oprot.writeMessageEnd()
1457 
    self._oprot.trans.flush()
1458 
 
1459 
  def recv_getAllMasterAffiliates(self, ):
1460 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1461 
    if mtype == TMessageType.EXCEPTION:
1462 
      x = TApplicationException()
1463 
      x.read(self._iprot)
1464 
      self._iprot.readMessageEnd()
1465 
      raise x
1466 
    result = getAllMasterAffiliates_result()
1467 
    result.read(self._iprot)
1468 
    self._iprot.readMessageEnd()
1469 
    if result.success != None:
1470 
      return result.success
1471 
    if result.utx != None:
1472 
      raise result.utx
1473 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1474 
 
1845 vikas 1475 
  def getMasterAffiliateById(self, id):
1476 
    """
1477 
    Parameters:
1478 
     - id
1479 
    """
1480 
    self.send_getMasterAffiliateById(id)
1481 
    return self.recv_getMasterAffiliateById()
1482 
 
1483 
  def send_getMasterAffiliateById(self, id):
1484 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1485 
    args = getMasterAffiliateById_args()
1486 
    args.id = id
1487 
    args.write(self._oprot)
1488 
    self._oprot.writeMessageEnd()
1489 
    self._oprot.trans.flush()
1490 
 
1491 
  def recv_getMasterAffiliateById(self, ):
1492 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1493 
    if mtype == TMessageType.EXCEPTION:
1494 
      x = TApplicationException()
1495 
      x.read(self._iprot)
1496 
      self._iprot.readMessageEnd()
1497 
      raise x
1498 
    result = getMasterAffiliateById_result()
1499 
    result.read(self._iprot)
1500 
    self._iprot.readMessageEnd()
1501 
    if result.success != None:
1502 
      return result.success
1503 
    if result.utx != None:
1504 
      raise result.utx
1505 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1506 
 
1507 
  def getMasterAffiliateByName(self, name):
1508 
    """
1509 
    Parameters:
1510 
     - name
1511 
    """
1512 
    self.send_getMasterAffiliateByName(name)
1513 
    return self.recv_getMasterAffiliateByName()
1514 
 
1515 
  def send_getMasterAffiliateByName(self, name):
1516 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1517 
    args = getMasterAffiliateByName_args()
1518 
    args.name = name
1519 
    args.write(self._oprot)
1520 
    self._oprot.writeMessageEnd()
1521 
    self._oprot.trans.flush()
1522 
 
1523 
  def recv_getMasterAffiliateByName(self, ):
1524 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1525 
    if mtype == TMessageType.EXCEPTION:
1526 
      x = TApplicationException()
1527 
      x.read(self._iprot)
1528 
      self._iprot.readMessageEnd()
1529 
      raise x
1530 
    result = getMasterAffiliateByName_result()
1531 
    result.read(self._iprot)
1532 
    self._iprot.readMessageEnd()
1533 
    if result.success != None:
1534 
      return result.success
1535 
    if result.utx != None:
1536 
      raise result.utx
1537 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1538 
 
1859 vikas 1539 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1540 
    """
1541 
    Parameters:
1542 
     - name
1543 
     - url
1544 
     - masterAffiliateId
1859 vikas 1545 
     - addedOn
1845 vikas 1546 
    """
1859 vikas 1547 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1548 
    return self.recv_createAffiliate()
1549 
 
1859 vikas 1550 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1551 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1552 
    args = createAffiliate_args()
1553 
    args.name = name
1554 
    args.url = url
1555 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1556 
    args.addedOn = addedOn
1845 vikas 1557 
    args.write(self._oprot)
1558 
    self._oprot.writeMessageEnd()
1559 
    self._oprot.trans.flush()
1560 
 
1561 
  def recv_createAffiliate(self, ):
1562 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1563 
    if mtype == TMessageType.EXCEPTION:
1564 
      x = TApplicationException()
1565 
      x.read(self._iprot)
1566 
      self._iprot.readMessageEnd()
1567 
      raise x
1568 
    result = createAffiliate_result()
1569 
    result.read(self._iprot)
1570 
    self._iprot.readMessageEnd()
1571 
    if result.success != None:
1572 
      return result.success
1573 
    if result.utx != None:
1574 
      raise result.utx
1575 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1576 
 
1577 
  def getAffiliateById(self, id):
1578 
    """
1579 
    Parameters:
1580 
     - id
1581 
    """
1582 
    self.send_getAffiliateById(id)
1583 
    return self.recv_getAffiliateById()
1584 
 
1585 
  def send_getAffiliateById(self, id):
1586 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1587 
    args = getAffiliateById_args()
1588 
    args.id = id
1589 
    args.write(self._oprot)
1590 
    self._oprot.writeMessageEnd()
1591 
    self._oprot.trans.flush()
1592 
 
1593 
  def recv_getAffiliateById(self, ):
1594 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1595 
    if mtype == TMessageType.EXCEPTION:
1596 
      x = TApplicationException()
1597 
      x.read(self._iprot)
1598 
      self._iprot.readMessageEnd()
1599 
      raise x
1600 
    result = getAffiliateById_result()
1601 
    result.read(self._iprot)
1602 
    self._iprot.readMessageEnd()
1603 
    if result.success != None:
1604 
      return result.success
1605 
    if result.utx != None:
1606 
      raise result.utx
1607 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1608 
 
1609 
  def getAffiliateByName(self, name):
1610 
    """
1611 
    Parameters:
1612 
     - name
1613 
    """
1614 
    self.send_getAffiliateByName(name)
1615 
    return self.recv_getAffiliateByName()
1616 
 
1617 
  def send_getAffiliateByName(self, name):
1618 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1619 
    args = getAffiliateByName_args()
1620 
    args.name = name
1621 
    args.write(self._oprot)
1622 
    self._oprot.writeMessageEnd()
1623 
    self._oprot.trans.flush()
1624 
 
1625 
  def recv_getAffiliateByName(self, ):
1626 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1627 
    if mtype == TMessageType.EXCEPTION:
1628 
      x = TApplicationException()
1629 
      x.read(self._iprot)
1630 
      self._iprot.readMessageEnd()
1631 
      raise x
1632 
    result = getAffiliateByName_result()
1633 
    result.read(self._iprot)
1634 
    self._iprot.readMessageEnd()
1635 
    if result.success != None:
1636 
      return result.success
1637 
    if result.utx != None:
1638 
      raise result.utx
1639 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1640 
 
1996 vikas 1641 
  def getTrackerById(self, id):
1845 vikas 1642 
    """
1643 
    Parameters:
1644 
     - id
1645 
    """
1996 vikas 1646 
    self.send_getTrackerById(id)
1845 vikas 1647 
    return self.recv_getTrackerById()
1648 
 
1996 vikas 1649 
  def send_getTrackerById(self, id):
1845 vikas 1650 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1651 
    args = getTrackerById_args()
1996 vikas 1652 
    args.id = id
1845 vikas 1653 
    args.write(self._oprot)
1654 
    self._oprot.writeMessageEnd()
1655 
    self._oprot.trans.flush()
1656 
 
1657 
  def recv_getTrackerById(self, ):
1658 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1659 
    if mtype == TMessageType.EXCEPTION:
1660 
      x = TApplicationException()
1661 
      x.read(self._iprot)
1662 
      self._iprot.readMessageEnd()
1663 
      raise x
1664 
    result = getTrackerById_result()
1665 
    result.read(self._iprot)
1666 
    self._iprot.readMessageEnd()
1667 
    if result.success != None:
1668 
      return result.success
1669 
    if result.utx != None:
1670 
      raise result.utx
1671 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1672 
 
1996 vikas 1673 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1674 
    """
1675 
    Parameters:
1996 vikas 1676 
     - id
1845 vikas 1677 
    """
1996 vikas 1678 
    self.send_getAffiliatesByMasterAffiliate(id)
1679 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1680 
 
1996 vikas 1681 
  def send_getAffiliatesByMasterAffiliate(self, id):
1682 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1683 
    args = getAffiliatesByMasterAffiliate_args()
1684 
    args.id = id
1845 vikas 1685 
    args.write(self._oprot)
1686 
    self._oprot.writeMessageEnd()
1687 
    self._oprot.trans.flush()
1688 
 
1996 vikas 1689 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1690 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1691 
    if mtype == TMessageType.EXCEPTION:
1692 
      x = TApplicationException()
1693 
      x.read(self._iprot)
1694 
      self._iprot.readMessageEnd()
1695 
      raise x
1996 vikas 1696 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1697 
    result.read(self._iprot)
1698 
    self._iprot.readMessageEnd()
1699 
    if result.success != None:
1700 
      return result.success
1701 
    if result.utx != None:
1702 
      raise result.utx
1996 vikas 1703 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1704 
 
1996 vikas 1705 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1706 
    """
1707 
    Parameters:
1996 vikas 1708 
     - affiliateId
1845 vikas 1709 
     - userId
1710 
     - event
1711 
     - url
1712 
     - data
1859 vikas 1713 
     - addedOn
1845 vikas 1714 
    """
1996 vikas 1715 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1716 
    return self.recv_addTrackLog()
1717 
 
1996 vikas 1718 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1719 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1720 
    args = addTrackLog_args()
1996 vikas 1721 
    args.affiliateId = affiliateId
1845 vikas 1722 
    args.userId = userId
1723 
    args.event = event
1724 
    args.url = url
1725 
    args.data = data
1859 vikas 1726 
    args.addedOn = addedOn
1845 vikas 1727 
    args.write(self._oprot)
1728 
    self._oprot.writeMessageEnd()
1729 
    self._oprot.trans.flush()
1730 
 
1731 
  def recv_addTrackLog(self, ):
1732 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1733 
    if mtype == TMessageType.EXCEPTION:
1734 
      x = TApplicationException()
1735 
      x.read(self._iprot)
1736 
      self._iprot.readMessageEnd()
1737 
      raise x
1738 
    result = addTrackLog_result()
1739 
    result.read(self._iprot)
1740 
    self._iprot.readMessageEnd()
1741 
    if result.success != None:
1742 
      return result.success
1743 
    if result.utx != None:
1744 
      raise result.utx
1745 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1746 
 
1747 
  def getTrackLogById(self, id):
1748 
    """
1749 
    Parameters:
1750 
     - id
1751 
    """
1752 
    self.send_getTrackLogById(id)
1753 
    return self.recv_getTrackLogById()
1754 
 
1755 
  def send_getTrackLogById(self, id):
1756 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1757 
    args = getTrackLogById_args()
1758 
    args.id = id
1759 
    args.write(self._oprot)
1760 
    self._oprot.writeMessageEnd()
1761 
    self._oprot.trans.flush()
1762 
 
1763 
  def recv_getTrackLogById(self, ):
1764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1765 
    if mtype == TMessageType.EXCEPTION:
1766 
      x = TApplicationException()
1767 
      x.read(self._iprot)
1768 
      self._iprot.readMessageEnd()
1769 
      raise x
1770 
    result = getTrackLogById_result()
1771 
    result.read(self._iprot)
1772 
    self._iprot.readMessageEnd()
1773 
    if result.success != None:
1774 
      return result.success
1775 
    if result.utx != None:
1776 
      raise result.utx
1777 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1778 
 
3293 vikas 1779 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 1780 
    """
1781 
    Parameters:
1996 vikas 1782 
     - affiliateId
3293 vikas 1783 
     - startDate
1784 
     - endDate
1845 vikas 1785 
    """
3293 vikas 1786 
    self.send_getTrackLogsByAffiliate(affiliateId, startDate, endDate)
1996 vikas 1787 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 1788 
 
3293 vikas 1789 
  def send_getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1996 vikas 1790 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
1791 
    args = getTrackLogsByAffiliate_args()
1792 
    args.affiliateId = affiliateId
3293 vikas 1793 
    args.startDate = startDate
1794 
    args.endDate = endDate
1845 vikas 1795 
    args.write(self._oprot)
1796 
    self._oprot.writeMessageEnd()
1797 
    self._oprot.trans.flush()
1798 
 
1996 vikas 1799 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 1800 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1801 
    if mtype == TMessageType.EXCEPTION:
1802 
      x = TApplicationException()
1803 
      x.read(self._iprot)
1804 
      self._iprot.readMessageEnd()
1805 
      raise x
1996 vikas 1806 
    result = getTrackLogsByAffiliate_result()
1845 vikas 1807 
    result.read(self._iprot)
1808 
    self._iprot.readMessageEnd()
1809 
    if result.success != None:
1810 
      return result.success
1811 
    if result.utx != None:
1812 
      raise result.utx
1996 vikas 1813 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 1814 
 
1815 
  def getTrackLogsByUser(self, userId):
1816 
    """
1817 
    Parameters:
1818 
     - userId
1819 
    """
1820 
    self.send_getTrackLogsByUser(userId)
1821 
    return self.recv_getTrackLogsByUser()
1822 
 
1823 
  def send_getTrackLogsByUser(self, userId):
1824 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
1825 
    args = getTrackLogsByUser_args()
1826 
    args.userId = userId
1827 
    args.write(self._oprot)
1828 
    self._oprot.writeMessageEnd()
1829 
    self._oprot.trans.flush()
1830 
 
1831 
  def recv_getTrackLogsByUser(self, ):
1832 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1833 
    if mtype == TMessageType.EXCEPTION:
1834 
      x = TApplicationException()
1835 
      x.read(self._iprot)
1836 
      self._iprot.readMessageEnd()
1837 
      raise x
1838 
    result = getTrackLogsByUser_result()
1839 
    result.read(self._iprot)
1840 
    self._iprot.readMessageEnd()
1841 
    if result.success != None:
1842 
      return result.success
1843 
    if result.utx != None:
1844 
      raise result.utx
1845 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
1846 
 
1996 vikas 1847 
  def getTrackLogs(self, userId, event, url):
1845 vikas 1848 
    """
1849 
    Parameters:
1850 
     - userId
1851 
     - event
1852 
     - url
1853 
    """
1996 vikas 1854 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 1855 
    return self.recv_getTrackLogs()
1856 
 
1996 vikas 1857 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 1858 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
1859 
    args = getTrackLogs_args()
1860 
    args.userId = userId
1861 
    args.event = event
1862 
    args.url = url
1863 
    args.write(self._oprot)
1864 
    self._oprot.writeMessageEnd()
1865 
    self._oprot.trans.flush()
1866 
 
1867 
  def recv_getTrackLogs(self, ):
1868 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1869 
    if mtype == TMessageType.EXCEPTION:
1870 
      x = TApplicationException()
1871 
      x.read(self._iprot)
1872 
      self._iprot.readMessageEnd()
1873 
      raise x
1874 
    result = getTrackLogs_result()
1875 
    result.read(self._iprot)
1876 
    self._iprot.readMessageEnd()
1877 
    if result.success != None:
1878 
      return result.success
1879 
    if result.utx != None:
1880 
      raise result.utx
1881 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
1882 
 
559 chandransh 1883 
  def createCart(self, userId):
94 ashish 1884 
    """
1885 
    Parameters:
559 chandransh 1886 
     - userId
94 ashish 1887 
    """
559 chandransh 1888 
    self.send_createCart(userId)
1889 
    return self.recv_createCart()
94 ashish 1890 
 
559 chandransh 1891 
  def send_createCart(self, userId):
1892 
    self._oprot.writeMessageBegin('createCart', TMessageType.CALL, self._seqid)
1893 
    args = createCart_args()
1894 
    args.userId = userId
94 ashish 1895 
    args.write(self._oprot)
1896 
    self._oprot.writeMessageEnd()
1897 
    self._oprot.trans.flush()
1898 
 
559 chandransh 1899 
  def recv_createCart(self, ):
94 ashish 1900 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1901 
    if mtype == TMessageType.EXCEPTION:
1902 
      x = TApplicationException()
1903 
      x.read(self._iprot)
1904 
      self._iprot.readMessageEnd()
1905 
      raise x
559 chandransh 1906 
    result = createCart_result()
94 ashish 1907 
    result.read(self._iprot)
1908 
    self._iprot.readMessageEnd()
1909 
    if result.success != None:
1910 
      return result.success
559 chandransh 1911 
    if result.scx != None:
1912 
      raise result.scx
1913 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createCart failed: unknown result");
94 ashish 1914 
 
559 chandransh 1915 
  def getCurrentCart(self, userId):
94 ashish 1916 
    """
1917 
    Parameters:
559 chandransh 1918 
     - userId
94 ashish 1919 
    """
559 chandransh 1920 
    self.send_getCurrentCart(userId)
1921 
    return self.recv_getCurrentCart()
94 ashish 1922 
 
559 chandransh 1923 
  def send_getCurrentCart(self, userId):
1924 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
1925 
    args = getCurrentCart_args()
1926 
    args.userId = userId
94 ashish 1927 
    args.write(self._oprot)
1928 
    self._oprot.writeMessageEnd()
1929 
    self._oprot.trans.flush()
1930 
 
559 chandransh 1931 
  def recv_getCurrentCart(self, ):
94 ashish 1932 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1933 
    if mtype == TMessageType.EXCEPTION:
1934 
      x = TApplicationException()
1935 
      x.read(self._iprot)
1936 
      self._iprot.readMessageEnd()
1937 
      raise x
559 chandransh 1938 
    result = getCurrentCart_result()
94 ashish 1939 
    result.read(self._iprot)
1940 
    self._iprot.readMessageEnd()
1941 
    if result.success != None:
1942 
      return result.success
559 chandransh 1943 
    if result.scx != None:
1944 
      raise result.scx
1945 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 1946 
 
559 chandransh 1947 
  def getCart(self, cartId):
94 ashish 1948 
    """
1949 
    Parameters:
559 chandransh 1950 
     - cartId
94 ashish 1951 
    """
559 chandransh 1952 
    self.send_getCart(cartId)
1953 
    return self.recv_getCart()
94 ashish 1954 
 
559 chandransh 1955 
  def send_getCart(self, cartId):
1956 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
1957 
    args = getCart_args()
1958 
    args.cartId = cartId
94 ashish 1959 
    args.write(self._oprot)
1960 
    self._oprot.writeMessageEnd()
1961 
    self._oprot.trans.flush()
1962 
 
559 chandransh 1963 
  def recv_getCart(self, ):
94 ashish 1964 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1965 
    if mtype == TMessageType.EXCEPTION:
1966 
      x = TApplicationException()
1967 
      x.read(self._iprot)
1968 
      self._iprot.readMessageEnd()
1969 
      raise x
559 chandransh 1970 
    result = getCart_result()
94 ashish 1971 
    result.read(self._iprot)
1972 
    self._iprot.readMessageEnd()
1973 
    if result.success != None:
1974 
      return result.success
559 chandransh 1975 
    if result.scx != None:
1976 
      raise result.scx
1977 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 1978 
 
559 chandransh 1979 
  def getCartsForUser(self, userId, status):
94 ashish 1980 
    """
1981 
    Parameters:
559 chandransh 1982 
     - userId
1983 
     - status
94 ashish 1984 
    """
559 chandransh 1985 
    self.send_getCartsForUser(userId, status)
1986 
    return self.recv_getCartsForUser()
94 ashish 1987 
 
559 chandransh 1988 
  def send_getCartsForUser(self, userId, status):
1989 
    self._oprot.writeMessageBegin('getCartsForUser', TMessageType.CALL, self._seqid)
1990 
    args = getCartsForUser_args()
1991 
    args.userId = userId
1992 
    args.status = status
94 ashish 1993 
    args.write(self._oprot)
1994 
    self._oprot.writeMessageEnd()
1995 
    self._oprot.trans.flush()
1996 
 
559 chandransh 1997 
  def recv_getCartsForUser(self, ):
94 ashish 1998 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1999 
    if mtype == TMessageType.EXCEPTION:
2000 
      x = TApplicationException()
2001 
      x.read(self._iprot)
2002 
      self._iprot.readMessageEnd()
2003 
      raise x
559 chandransh 2004 
    result = getCartsForUser_result()
94 ashish 2005 
    result.read(self._iprot)
2006 
    self._iprot.readMessageEnd()
2007 
    if result.success != None:
2008 
      return result.success
559 chandransh 2009 
    if result.scx != None:
2010 
      raise result.scx
2011 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsForUser failed: unknown result");
94 ashish 2012 
 
559 chandransh 2013 
  def getCartsByStatus(self, status):
94 ashish 2014 
    """
2015 
    Parameters:
559 chandransh 2016 
     - status
94 ashish 2017 
    """
559 chandransh 2018 
    self.send_getCartsByStatus(status)
2019 
    return self.recv_getCartsByStatus()
94 ashish 2020 
 
559 chandransh 2021 
  def send_getCartsByStatus(self, status):
2022 
    self._oprot.writeMessageBegin('getCartsByStatus', TMessageType.CALL, self._seqid)
2023 
    args = getCartsByStatus_args()
2024 
    args.status = status
94 ashish 2025 
    args.write(self._oprot)
2026 
    self._oprot.writeMessageEnd()
2027 
    self._oprot.trans.flush()
2028 
 
559 chandransh 2029 
  def recv_getCartsByStatus(self, ):
94 ashish 2030 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2031 
    if mtype == TMessageType.EXCEPTION:
2032 
      x = TApplicationException()
2033 
      x.read(self._iprot)
2034 
      self._iprot.readMessageEnd()
2035 
      raise x
559 chandransh 2036 
    result = getCartsByStatus_result()
94 ashish 2037 
    result.read(self._iprot)
2038 
    self._iprot.readMessageEnd()
2039 
    if result.success != None:
2040 
      return result.success
559 chandransh 2041 
    if result.scx != None:
2042 
      raise result.scx
2043 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByStatus failed: unknown result");
94 ashish 2044 
 
559 chandransh 2045 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2046 
    """
2047 
    Parameters:
559 chandransh 2048 
     - from_time
2049 
     - to_time
2050 
     - status
94 ashish 2051 
    """
559 chandransh 2052 
    self.send_getCartsByTime(from_time, to_time, status)
2053 
    return self.recv_getCartsByTime()
94 ashish 2054 
 
559 chandransh 2055 
  def send_getCartsByTime(self, from_time, to_time, status):
2056 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2057 
    args = getCartsByTime_args()
2058 
    args.from_time = from_time
2059 
    args.to_time = to_time
2060 
    args.status = status
94 ashish 2061 
    args.write(self._oprot)
2062 
    self._oprot.writeMessageEnd()
2063 
    self._oprot.trans.flush()
2064 
 
559 chandransh 2065 
  def recv_getCartsByTime(self, ):
94 ashish 2066 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2067 
    if mtype == TMessageType.EXCEPTION:
2068 
      x = TApplicationException()
2069 
      x.read(self._iprot)
2070 
      self._iprot.readMessageEnd()
2071 
      raise x
559 chandransh 2072 
    result = getCartsByTime_result()
94 ashish 2073 
    result.read(self._iprot)
2074 
    self._iprot.readMessageEnd()
2075 
    if result.success != None:
2076 
      return result.success
559 chandransh 2077 
    if result.scx != None:
2078 
      raise result.scx
2079 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2080 
 
559 chandransh 2081 
  def changeCartStatus(self, cartId, status):
130 ashish 2082 
    """
2083 
    Parameters:
559 chandransh 2084 
     - cartId
2085 
     - status
130 ashish 2086 
    """
559 chandransh 2087 
    self.send_changeCartStatus(cartId, status)
2088 
    self.recv_changeCartStatus()
94 ashish 2089 
 
559 chandransh 2090 
  def send_changeCartStatus(self, cartId, status):
2091 
    self._oprot.writeMessageBegin('changeCartStatus', TMessageType.CALL, self._seqid)
2092 
    args = changeCartStatus_args()
2093 
    args.cartId = cartId
2094 
    args.status = status
130 ashish 2095 
    args.write(self._oprot)
2096 
    self._oprot.writeMessageEnd()
2097 
    self._oprot.trans.flush()
2098 
 
559 chandransh 2099 
  def recv_changeCartStatus(self, ):
130 ashish 2100 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2101 
    if mtype == TMessageType.EXCEPTION:
2102 
      x = TApplicationException()
2103 
      x.read(self._iprot)
2104 
      self._iprot.readMessageEnd()
2105 
      raise x
559 chandransh 2106 
    result = changeCartStatus_result()
130 ashish 2107 
    result.read(self._iprot)
2108 
    self._iprot.readMessageEnd()
559 chandransh 2109 
    if result.scx != None:
2110 
      raise result.scx
2111 
    return
2112 
 
2113 
  def addItemToCart(self, cartId, itemId, quantity):
2114 
    """
2115 
    Parameters:
2116 
     - cartId
2117 
     - itemId
2118 
     - quantity
2119 
    """
2120 
    self.send_addItemToCart(cartId, itemId, quantity)
2035 rajveer 2121 
    return self.recv_addItemToCart()
559 chandransh 2122 
 
2123 
  def send_addItemToCart(self, cartId, itemId, quantity):
2124 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2125 
    args = addItemToCart_args()
2126 
    args.cartId = cartId
2127 
    args.itemId = itemId
2128 
    args.quantity = quantity
2129 
    args.write(self._oprot)
2130 
    self._oprot.writeMessageEnd()
2131 
    self._oprot.trans.flush()
2132 
 
2133 
  def recv_addItemToCart(self, ):
2134 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2135 
    if mtype == TMessageType.EXCEPTION:
2136 
      x = TApplicationException()
2137 
      x.read(self._iprot)
2138 
      self._iprot.readMessageEnd()
2139 
      raise x
2140 
    result = addItemToCart_result()
2141 
    result.read(self._iprot)
2142 
    self._iprot.readMessageEnd()
2035 rajveer 2143 
    if result.success != None:
2144 
      return result.success
559 chandransh 2145 
    if result.scx != None:
2146 
      raise result.scx
2035 rajveer 2147 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2148 
 
2149 
  def deleteItemFromCart(self, cartId, itemId):
2150 
    """
2151 
    Parameters:
2152 
     - cartId
2153 
     - itemId
2154 
    """
2155 
    self.send_deleteItemFromCart(cartId, itemId)
2156 
    self.recv_deleteItemFromCart()
2157 
 
2158 
  def send_deleteItemFromCart(self, cartId, itemId):
2159 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2160 
    args = deleteItemFromCart_args()
2161 
    args.cartId = cartId
2162 
    args.itemId = itemId
2163 
    args.write(self._oprot)
2164 
    self._oprot.writeMessageEnd()
2165 
    self._oprot.trans.flush()
2166 
 
2167 
  def recv_deleteItemFromCart(self, ):
2168 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2169 
    if mtype == TMessageType.EXCEPTION:
2170 
      x = TApplicationException()
2171 
      x.read(self._iprot)
2172 
      self._iprot.readMessageEnd()
2173 
      raise x
2174 
    result = deleteItemFromCart_result()
2175 
    result.read(self._iprot)
2176 
    self._iprot.readMessageEnd()
2177 
    if result.scx != None:
2178 
      raise result.scx
2179 
    return
2180 
 
2181 
  def changeQuantity(self, cartId, itemId, quantity):
2182 
    """
2183 
    Parameters:
2184 
     - cartId
2185 
     - itemId
2186 
     - quantity
2187 
    """
2188 
    self.send_changeQuantity(cartId, itemId, quantity)
2189 
    self.recv_changeQuantity()
2190 
 
2191 
  def send_changeQuantity(self, cartId, itemId, quantity):
2192 
    self._oprot.writeMessageBegin('changeQuantity', TMessageType.CALL, self._seqid)
2193 
    args = changeQuantity_args()
2194 
    args.cartId = cartId
2195 
    args.itemId = itemId
2196 
    args.quantity = quantity
2197 
    args.write(self._oprot)
2198 
    self._oprot.writeMessageEnd()
2199 
    self._oprot.trans.flush()
2200 
 
2201 
  def recv_changeQuantity(self, ):
2202 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2203 
    if mtype == TMessageType.EXCEPTION:
2204 
      x = TApplicationException()
2205 
      x.read(self._iprot)
2206 
      self._iprot.readMessageEnd()
2207 
      raise x
2208 
    result = changeQuantity_result()
2209 
    result.read(self._iprot)
2210 
    self._iprot.readMessageEnd()
2211 
    if result.scx != None:
2212 
      raise result.scx
2213 
    return
2214 
 
2215 
  def changeItemStatus(self, cartId, itemId, status):
2216 
    """
2217 
    Parameters:
2218 
     - cartId
2219 
     - itemId
2220 
     - status
2221 
    """
2222 
    self.send_changeItemStatus(cartId, itemId, status)
2223 
    self.recv_changeItemStatus()
2224 
 
2225 
  def send_changeItemStatus(self, cartId, itemId, status):
2226 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
2227 
    args = changeItemStatus_args()
2228 
    args.cartId = cartId
2229 
    args.itemId = itemId
2230 
    args.status = status
2231 
    args.write(self._oprot)
2232 
    self._oprot.writeMessageEnd()
2233 
    self._oprot.trans.flush()
2234 
 
2235 
  def recv_changeItemStatus(self, ):
2236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2237 
    if mtype == TMessageType.EXCEPTION:
2238 
      x = TApplicationException()
2239 
      x.read(self._iprot)
2240 
      self._iprot.readMessageEnd()
2241 
      raise x
2242 
    result = changeItemStatus_result()
2243 
    result.read(self._iprot)
2244 
    self._iprot.readMessageEnd()
2245 
    if result.scx != None:
2246 
      raise result.scx
2247 
    return
2248 
 
2249 
  def addAddressToCart(self, cartId, addressId):
2250 
    """
2251 
    Parameters:
2252 
     - cartId
2253 
     - addressId
2254 
    """
2255 
    self.send_addAddressToCart(cartId, addressId)
2256 
    self.recv_addAddressToCart()
2257 
 
2258 
  def send_addAddressToCart(self, cartId, addressId):
2259 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2260 
    args = addAddressToCart_args()
2261 
    args.cartId = cartId
2262 
    args.addressId = addressId
2263 
    args.write(self._oprot)
2264 
    self._oprot.writeMessageEnd()
2265 
    self._oprot.trans.flush()
2266 
 
2267 
  def recv_addAddressToCart(self, ):
2268 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2269 
    if mtype == TMessageType.EXCEPTION:
2270 
      x = TApplicationException()
2271 
      x.read(self._iprot)
2272 
      self._iprot.readMessageEnd()
2273 
      raise x
2274 
    result = addAddressToCart_result()
2275 
    result.read(self._iprot)
2276 
    self._iprot.readMessageEnd()
575 chandransh 2277 
    if result.scx != None:
2278 
      raise result.scx
559 chandransh 2279 
    return
2280 
 
1976 varun.gupt 2281 
  def applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
2282 
    """
2283 
    Parameters:
2284 
     - cartId
2285 
     - couponCode
2286 
     - totalPrice
2287 
     - discountedPrice
2288 
    """
2289 
    self.send_applyCouponToCart(cartId, couponCode, totalPrice, discountedPrice)
2290 
    self.recv_applyCouponToCart()
2291 
 
2292 
  def send_applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
2293 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2294 
    args = applyCouponToCart_args()
2295 
    args.cartId = cartId
2296 
    args.couponCode = couponCode
2297 
    args.totalPrice = totalPrice
2298 
    args.discountedPrice = discountedPrice
2299 
    args.write(self._oprot)
2300 
    self._oprot.writeMessageEnd()
2301 
    self._oprot.trans.flush()
2302 
 
2303 
  def recv_applyCouponToCart(self, ):
2304 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2305 
    if mtype == TMessageType.EXCEPTION:
2306 
      x = TApplicationException()
2307 
      x.read(self._iprot)
2308 
      self._iprot.readMessageEnd()
2309 
      raise x
2310 
    result = applyCouponToCart_result()
2311 
    result.read(self._iprot)
2312 
    self._iprot.readMessageEnd()
2313 
    if result.scx != None:
2314 
      raise result.scx
2315 
    return
2316 
 
2317 
  def removeCoupon(self, cartId):
2318 
    """
2319 
    Parameters:
2320 
     - cartId
2321 
    """
2322 
    self.send_removeCoupon(cartId)
2323 
    self.recv_removeCoupon()
2324 
 
2325 
  def send_removeCoupon(self, cartId):
2326 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2327 
    args = removeCoupon_args()
2328 
    args.cartId = cartId
2329 
    args.write(self._oprot)
2330 
    self._oprot.writeMessageEnd()
2331 
    self._oprot.trans.flush()
2332 
 
2333 
  def recv_removeCoupon(self, ):
2334 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2335 
    if mtype == TMessageType.EXCEPTION:
2336 
      x = TApplicationException()
2337 
      x.read(self._iprot)
2338 
      self._iprot.readMessageEnd()
2339 
      raise x
2340 
    result = removeCoupon_result()
2341 
    result.read(self._iprot)
2342 
    self._iprot.readMessageEnd()
2343 
    if result.scx != None:
2344 
      raise result.scx
2345 
    return
2346 
 
2815 vikas 2347 
  def createOrders(self, cartId, sessionSource, sessionStartTime):
559 chandransh 2348 
    """
690 chandransh 2349 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
2350 
 
559 chandransh 2351 
    Parameters:
2352 
     - cartId
2815 vikas 2353 
     - sessionSource
2354 
     - sessionStartTime
559 chandransh 2355 
    """
2815 vikas 2356 
    self.send_createOrders(cartId, sessionSource, sessionStartTime)
690 chandransh 2357 
    return self.recv_createOrders()
559 chandransh 2358 
 
2815 vikas 2359 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime):
690 chandransh 2360 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2361 
    args = createOrders_args()
559 chandransh 2362 
    args.cartId = cartId
2815 vikas 2363 
    args.sessionSource = sessionSource
2364 
    args.sessionStartTime = sessionStartTime
559 chandransh 2365 
    args.write(self._oprot)
2366 
    self._oprot.writeMessageEnd()
2367 
    self._oprot.trans.flush()
2368 
 
690 chandransh 2369 
  def recv_createOrders(self, ):
559 chandransh 2370 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2371 
    if mtype == TMessageType.EXCEPTION:
2372 
      x = TApplicationException()
2373 
      x.read(self._iprot)
2374 
      self._iprot.readMessageEnd()
2375 
      raise x
690 chandransh 2376 
    result = createOrders_result()
559 chandransh 2377 
    result.read(self._iprot)
2378 
    self._iprot.readMessageEnd()
130 ashish 2379 
    if result.success != None:
2380 
      return result.success
559 chandransh 2381 
    if result.scx != None:
2382 
      raise result.scx
690 chandransh 2383 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2384 
 
559 chandransh 2385 
  def validateCart(self, cartId):
130 ashish 2386 
    """
690 chandransh 2387 
    Validates that:
2388 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2389 
    2. All of the lines in the cart are active items.
690 chandransh 2390 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2391 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 2392 
 
130 ashish 2393 
    Parameters:
559 chandransh 2394 
     - cartId
130 ashish 2395 
    """
559 chandransh 2396 
    self.send_validateCart(cartId)
2397 
    return self.recv_validateCart()
130 ashish 2398 
 
559 chandransh 2399 
  def send_validateCart(self, cartId):
2400 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2401 
    args = validateCart_args()
2402 
    args.cartId = cartId
130 ashish 2403 
    args.write(self._oprot)
2404 
    self._oprot.writeMessageEnd()
2405 
    self._oprot.trans.flush()
2406 
 
559 chandransh 2407 
  def recv_validateCart(self, ):
130 ashish 2408 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2409 
    if mtype == TMessageType.EXCEPTION:
2410 
      x = TApplicationException()
2411 
      x.read(self._iprot)
2412 
      self._iprot.readMessageEnd()
2413 
      raise x
559 chandransh 2414 
    result = validateCart_result()
130 ashish 2415 
    result.read(self._iprot)
2416 
    self._iprot.readMessageEnd()
2417 
    if result.success != None:
2418 
      return result.success
575 chandransh 2419 
    if result.scex != None:
2420 
      raise result.scex
559 chandransh 2421 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2422 
 
690 chandransh 2423 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2424 
    """
690 chandransh 2425 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
2426 
 
575 chandransh 2427 
    Parameters:
690 chandransh 2428 
     - fromCartId
2429 
     - toCartId
2430 
    """
2431 
    self.send_mergeCart(fromCartId, toCartId)
2432 
    self.recv_mergeCart()
2433 
 
2434 
  def send_mergeCart(self, fromCartId, toCartId):
2435 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2436 
    args = mergeCart_args()
2437 
    args.fromCartId = fromCartId
2438 
    args.toCartId = toCartId
2439 
    args.write(self._oprot)
2440 
    self._oprot.writeMessageEnd()
2441 
    self._oprot.trans.flush()
2442 
 
2443 
  def recv_mergeCart(self, ):
2444 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2445 
    if mtype == TMessageType.EXCEPTION:
2446 
      x = TApplicationException()
2447 
      x.read(self._iprot)
2448 
      self._iprot.readMessageEnd()
2449 
      raise x
2450 
    result = mergeCart_result()
2451 
    result.read(self._iprot)
2452 
    self._iprot.readMessageEnd()
2453 
    return
2454 
 
2455 
  def checkOut(self, cartId):
2456 
    """
2457 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
2458 
 
2459 
    Parameters:
575 chandransh 2460 
     - cartId
2461 
    """
690 chandransh 2462 
    self.send_checkOut(cartId)
2463 
    return self.recv_checkOut()
575 chandransh 2464 
 
690 chandransh 2465 
  def send_checkOut(self, cartId):
2466 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2467 
    args = checkOut_args()
575 chandransh 2468 
    args.cartId = cartId
2469 
    args.write(self._oprot)
2470 
    self._oprot.writeMessageEnd()
2471 
    self._oprot.trans.flush()
2472 
 
690 chandransh 2473 
  def recv_checkOut(self, ):
575 chandransh 2474 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2475 
    if mtype == TMessageType.EXCEPTION:
2476 
      x = TApplicationException()
2477 
      x.read(self._iprot)
2478 
      self._iprot.readMessageEnd()
2479 
      raise x
690 chandransh 2480 
    result = checkOut_result()
575 chandransh 2481 
    result.read(self._iprot)
2482 
    self._iprot.readMessageEnd()
2483 
    if result.success != None:
2484 
      return result.success
2485 
    if result.scex != None:
2486 
      raise result.scex
690 chandransh 2487 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2488 
 
690 chandransh 2489 
  def resetCart(self, cartId, items):
559 chandransh 2490 
    """
690 chandransh 2491 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2492 
    This methods removes the specified quantiry of the specified item from the cart.
2493 
 
559 chandransh 2494 
    Parameters:
690 chandransh 2495 
     - cartId
2496 
     - items
559 chandransh 2497 
    """
690 chandransh 2498 
    self.send_resetCart(cartId, items)
2499 
    return self.recv_resetCart()
130 ashish 2500 
 
690 chandransh 2501 
  def send_resetCart(self, cartId, items):
2502 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2503 
    args = resetCart_args()
2504 
    args.cartId = cartId
2505 
    args.items = items
559 chandransh 2506 
    args.write(self._oprot)
2507 
    self._oprot.writeMessageEnd()
2508 
    self._oprot.trans.flush()
2509 
 
690 chandransh 2510 
  def recv_resetCart(self, ):
559 chandransh 2511 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2512 
    if mtype == TMessageType.EXCEPTION:
2513 
      x = TApplicationException()
2514 
      x.read(self._iprot)
2515 
      self._iprot.readMessageEnd()
2516 
      raise x
690 chandransh 2517 
    result = resetCart_result()
559 chandransh 2518 
    result.read(self._iprot)
2519 
    self._iprot.readMessageEnd()
690 chandransh 2520 
    if result.success != None:
2521 
      return result.success
2522 
    if result.scex != None:
2523 
      raise result.scex
2524 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2525 
 
2981 rajveer 2526 
  def getUserCount(self, userType):
559 chandransh 2527 
    """
2981 rajveer 2528 
    Returns number of registered users.
2529 
    If userType = null, then it returns count of all users, including anonymous
2530 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2531 
    If userType = UserType.USER, then it returns count of non-anonymous users only
772 rajveer 2532 
 
559 chandransh 2533 
    Parameters:
2981 rajveer 2534 
     - userType
559 chandransh 2535 
    """
2981 rajveer 2536 
    self.send_getUserCount(userType)
2537 
    return self.recv_getUserCount()
559 chandransh 2538 
 
2981 rajveer 2539 
  def send_getUserCount(self, userType):
2540 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2541 
    args = getUserCount_args()
2542 
    args.userType = userType
559 chandransh 2543 
    args.write(self._oprot)
2544 
    self._oprot.writeMessageEnd()
2545 
    self._oprot.trans.flush()
2546 
 
2981 rajveer 2547 
  def recv_getUserCount(self, ):
559 chandransh 2548 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2549 
    if mtype == TMessageType.EXCEPTION:
2550 
      x = TApplicationException()
2551 
      x.read(self._iprot)
2552 
      self._iprot.readMessageEnd()
2553 
      raise x
2981 rajveer 2554 
    result = getUserCount_result()
559 chandransh 2555 
    result.read(self._iprot)
2556 
    self._iprot.readMessageEnd()
2557 
    if result.success != None:
2558 
      return result.success
2981 rajveer 2559 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2560 
 
2981 rajveer 2561 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2562 
    """
2981 rajveer 2563 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2564 
    If any of startDate or endDate is -1, then that filter is ignored.
2565 
    If userType is null, then returns all the users, irrespective of anonymous flag
2566 
 
2567 
 
559 chandransh 2568 
    Parameters:
2981 rajveer 2569 
     - userType
2570 
     - startDate
2571 
     - endDate
559 chandransh 2572 
    """
2981 rajveer 2573 
    self.send_getAllUsers(userType, startDate, endDate)
2574 
    return self.recv_getAllUsers()
559 chandransh 2575 
 
2981 rajveer 2576 
  def send_getAllUsers(self, userType, startDate, endDate):
2577 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2578 
    args = getAllUsers_args()
2579 
    args.userType = userType
2580 
    args.startDate = startDate
2581 
    args.endDate = endDate
559 chandransh 2582 
    args.write(self._oprot)
2583 
    self._oprot.writeMessageEnd()
2584 
    self._oprot.trans.flush()
2585 
 
2981 rajveer 2586 
  def recv_getAllUsers(self, ):
559 chandransh 2587 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2588 
    if mtype == TMessageType.EXCEPTION:
2589 
      x = TApplicationException()
2590 
      x.read(self._iprot)
2591 
      self._iprot.readMessageEnd()
2592 
      raise x
2981 rajveer 2593 
    result = getAllUsers_result()
559 chandransh 2594 
    result.read(self._iprot)
2595 
    self._iprot.readMessageEnd()
2596 
    if result.success != None:
2597 
      return result.success
2981 rajveer 2598 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2599 
 
2981 rajveer 2600 
  def putUserNote(self, user_id, entity_id, slide, note):
559 chandransh 2601 
    """
2602 
    Parameters:
2981 rajveer 2603 
     - user_id
2604 
     - entity_id
2605 
     - slide
2606 
     - note
559 chandransh 2607 
    """
2981 rajveer 2608 
    self.send_putUserNote(user_id, entity_id, slide, note)
2609 
    self.recv_putUserNote()
559 chandransh 2610 
 
2981 rajveer 2611 
  def send_putUserNote(self, user_id, entity_id, slide, note):
2612 
    self._oprot.writeMessageBegin('putUserNote', TMessageType.CALL, self._seqid)
2613 
    args = putUserNote_args()
2614 
    args.user_id = user_id
2615 
    args.entity_id = entity_id
2616 
    args.slide = slide
2617 
    args.note = note
559 chandransh 2618 
    args.write(self._oprot)
2619 
    self._oprot.writeMessageEnd()
2620 
    self._oprot.trans.flush()
2621 
 
2981 rajveer 2622 
  def recv_putUserNote(self, ):
559 chandransh 2623 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2624 
    if mtype == TMessageType.EXCEPTION:
2625 
      x = TApplicationException()
2626 
      x.read(self._iprot)
2627 
      self._iprot.readMessageEnd()
2628 
      raise x
2981 rajveer 2629 
    result = putUserNote_result()
559 chandransh 2630 
    result.read(self._iprot)
2631 
    self._iprot.readMessageEnd()
2632 
    return
2633 
 
2981 rajveer 2634 
  def getUserNotes(self, user_id, entity_id):
559 chandransh 2635 
    """
2636 
    Parameters:
2981 rajveer 2637 
     - user_id
2638 
     - entity_id
559 chandransh 2639 
    """
2981 rajveer 2640 
    self.send_getUserNotes(user_id, entity_id)
2641 
    return self.recv_getUserNotes()
559 chandransh 2642 
 
2981 rajveer 2643 
  def send_getUserNotes(self, user_id, entity_id):
2644 
    self._oprot.writeMessageBegin('getUserNotes', TMessageType.CALL, self._seqid)
2645 
    args = getUserNotes_args()
2646 
    args.user_id = user_id
2647 
    args.entity_id = entity_id
559 chandransh 2648 
    args.write(self._oprot)
2649 
    self._oprot.writeMessageEnd()
2650 
    self._oprot.trans.flush()
2651 
 
2981 rajveer 2652 
  def recv_getUserNotes(self, ):
559 chandransh 2653 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2654 
    if mtype == TMessageType.EXCEPTION:
2655 
      x = TApplicationException()
2656 
      x.read(self._iprot)
2657 
      self._iprot.readMessageEnd()
2658 
      raise x
2981 rajveer 2659 
    result = getUserNotes_result()
559 chandransh 2660 
    result.read(self._iprot)
2661 
    self._iprot.readMessageEnd()
2981 rajveer 2662 
    if result.success != None:
2663 
      return result.success
2664 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserNotes failed: unknown result");
559 chandransh 2665 
 
2981 rajveer 2666 
  def getMyResearchItems(self, userId):
559 chandransh 2667 
    """
2981 rajveer 2668 
    Returns list of item ids in myresearch for the user
2669 
 
559 chandransh 2670 
    Parameters:
772 rajveer 2671 
     - userId
559 chandransh 2672 
    """
2981 rajveer 2673 
    self.send_getMyResearchItems(userId)
2674 
    return self.recv_getMyResearchItems()
559 chandransh 2675 
 
2981 rajveer 2676 
  def send_getMyResearchItems(self, userId):
2677 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2678 
    args = getMyResearchItems_args()
772 rajveer 2679 
    args.userId = userId
559 chandransh 2680 
    args.write(self._oprot)
2681 
    self._oprot.writeMessageEnd()
2682 
    self._oprot.trans.flush()
2683 
 
2981 rajveer 2684 
  def recv_getMyResearchItems(self, ):
559 chandransh 2685 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2686 
    if mtype == TMessageType.EXCEPTION:
2687 
      x = TApplicationException()
2688 
      x.read(self._iprot)
2689 
      self._iprot.readMessageEnd()
2690 
      raise x
2981 rajveer 2691 
    result = getMyResearchItems_result()
559 chandransh 2692 
    result.read(self._iprot)
2693 
    self._iprot.readMessageEnd()
2694 
    if result.success != None:
2695 
      return result.success
2696 
    if result.scx != None:
2697 
      raise result.scx
2981 rajveer 2698 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2699 
 
2981 rajveer 2700 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2701 
    """
2981 rajveer 2702 
    add item to my research for a user
2703 
 
559 chandransh 2704 
    Parameters:
2981 rajveer 2705 
     - userId
2706 
     - itemId
559 chandransh 2707 
    """
2981 rajveer 2708 
    self.send_updateMyResearch(userId, itemId)
2709 
    return self.recv_updateMyResearch()
559 chandransh 2710 
 
2981 rajveer 2711 
  def send_updateMyResearch(self, userId, itemId):
2712 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2713 
    args = updateMyResearch_args()
2714 
    args.userId = userId
2715 
    args.itemId = itemId
559 chandransh 2716 
    args.write(self._oprot)
2717 
    self._oprot.writeMessageEnd()
2718 
    self._oprot.trans.flush()
2719 
 
2981 rajveer 2720 
  def recv_updateMyResearch(self, ):
559 chandransh 2721 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2722 
    if mtype == TMessageType.EXCEPTION:
2723 
      x = TApplicationException()
2724 
      x.read(self._iprot)
2725 
      self._iprot.readMessageEnd()
2726 
      raise x
2981 rajveer 2727 
    result = updateMyResearch_result()
559 chandransh 2728 
    result.read(self._iprot)
2729 
    self._iprot.readMessageEnd()
2981 rajveer 2730 
    if result.success != None:
2731 
      return result.success
2732 
    if result.scx != None:
2733 
      raise result.scx
2734 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
559 chandransh 2735 
 
2981 rajveer 2736 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2737 
    """
2981 rajveer 2738 
    delete item from my research for a user
1596 ankur.sing 2739 
 
2740 
    Parameters:
2981 rajveer 2741 
     - userId
2742 
     - itemId
1596 ankur.sing 2743 
    """
2981 rajveer 2744 
    self.send_deleteItemFromMyResearch(userId, itemId)
2745 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2746 
 
2981 rajveer 2747 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2748 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2749 
    args = deleteItemFromMyResearch_args()
2750 
    args.userId = userId
2751 
    args.itemId = itemId
1596 ankur.sing 2752 
    args.write(self._oprot)
2753 
    self._oprot.writeMessageEnd()
2754 
    self._oprot.trans.flush()
2755 
 
2981 rajveer 2756 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 2757 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2758 
    if mtype == TMessageType.EXCEPTION:
2759 
      x = TApplicationException()
2760 
      x.read(self._iprot)
2761 
      self._iprot.readMessageEnd()
2762 
      raise x
2981 rajveer 2763 
    result = deleteItemFromMyResearch_result()
1596 ankur.sing 2764 
    result.read(self._iprot)
2765 
    self._iprot.readMessageEnd()
2981 rajveer 2766 
    if result.scx != None:
2767 
      raise result.scx
2768 
    return
1596 ankur.sing 2769 
 
2981 rajveer 2770 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2771 
    """
2981 rajveer 2772 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
1673 ankur.sing 2773 
 
2774 
    Parameters:
2981 rajveer 2775 
     - userId
1673 ankur.sing 2776 
    """
2981 rajveer 2777 
    self.send_getBrowseHistoryItems(userId)
2778 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2779 
 
2981 rajveer 2780 
  def send_getBrowseHistoryItems(self, userId):
2781 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2782 
    args = getBrowseHistoryItems_args()
2783 
    args.userId = userId
1673 ankur.sing 2784 
    args.write(self._oprot)
2785 
    self._oprot.writeMessageEnd()
2786 
    self._oprot.trans.flush()
2787 
 
2981 rajveer 2788 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 2789 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2790 
    if mtype == TMessageType.EXCEPTION:
2791 
      x = TApplicationException()
2792 
      x.read(self._iprot)
2793 
      self._iprot.readMessageEnd()
2794 
      raise x
2981 rajveer 2795 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 2796 
    result.read(self._iprot)
2797 
    self._iprot.readMessageEnd()
2798 
    if result.success != None:
2799 
      return result.success
2981 rajveer 2800 
    if result.scx != None:
2801 
      raise result.scx
2802 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 2803 
 
2981 rajveer 2804 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 2805 
    """
2981 rajveer 2806 
    add item to browse history for a user
2642 varun.gupt 2807 
 
2808 
    Parameters:
2981 rajveer 2809 
     - userId
2810 
     - itemId
2642 varun.gupt 2811 
    """
2981 rajveer 2812 
    self.send_updateBrowseHistory(userId, itemId)
2813 
    self.recv_updateBrowseHistory()
1673 ankur.sing 2814 
 
2981 rajveer 2815 
  def send_updateBrowseHistory(self, userId, itemId):
2816 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2817 
    args = updateBrowseHistory_args()
2818 
    args.userId = userId
2819 
    args.itemId = itemId
2642 varun.gupt 2820 
    args.write(self._oprot)
2821 
    self._oprot.writeMessageEnd()
2822 
    self._oprot.trans.flush()
2823 
 
2981 rajveer 2824 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 2825 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2826 
    if mtype == TMessageType.EXCEPTION:
2827 
      x = TApplicationException()
2828 
      x.read(self._iprot)
2829 
      self._iprot.readMessageEnd()
2830 
      raise x
2981 rajveer 2831 
    result = updateBrowseHistory_result()
2642 varun.gupt 2832 
    result.read(self._iprot)
2833 
    self._iprot.readMessageEnd()
2834 
    return
2835 
 
2836 
 
3376 rajveer 2837 
class Processor(shop2020.thriftpy.generic.GenericService.Processor, Iface, TProcessor):
94 ashish 2838 
  def __init__(self, handler):
3376 rajveer 2839 
    shop2020.thriftpy.generic.GenericService.Processor.__init__(self, handler)
559 chandransh 2840 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
2841 
    self._processMap["getUserById"] = Processor.process_getUserById
1491 vikas 2842 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
3032 mandeep.dh 2843 
    self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
559 chandransh 2844 
    self._processMap["createUser"] = Processor.process_createUser
2845 
    self._processMap["updateUser"] = Processor.process_updateUser
2846 
    self._processMap["deleteUser"] = Processor.process_deleteUser
2847 
    self._processMap["getUserState"] = Processor.process_getUserState
122 ashish 2848 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 2849 
    self._processMap["userExists"] = Processor.process_userExists
2850 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
2851 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
2852 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
2853 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 2854 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 2855 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 2856 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 2857 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 2858 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 2859 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 2860 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 2861 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 2862 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
2863 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
2864 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
1845 vikas 2865 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 2866 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 2867 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
2868 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
2869 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
2870 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
2871 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 2872 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 2873 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
2874 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
2875 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 2876 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 2877 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
2878 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 2879 
    self._processMap["createCart"] = Processor.process_createCart
2880 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
2881 
    self._processMap["getCart"] = Processor.process_getCart
2882 
    self._processMap["getCartsForUser"] = Processor.process_getCartsForUser
2883 
    self._processMap["getCartsByStatus"] = Processor.process_getCartsByStatus
2884 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
2885 
    self._processMap["changeCartStatus"] = Processor.process_changeCartStatus
2886 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
2887 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
2888 
    self._processMap["changeQuantity"] = Processor.process_changeQuantity
2889 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
2890 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
1976 varun.gupt 2891 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
2892 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
690 chandransh 2893 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 2894 
    self._processMap["validateCart"] = Processor.process_validateCart
2895 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 2896 
    self._processMap["checkOut"] = Processor.process_checkOut
2897 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 2898 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 2899 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2642 varun.gupt 2900 
    self._processMap["putUserNote"] = Processor.process_putUserNote
2901 
    self._processMap["getUserNotes"] = Processor.process_getUserNotes
2981 rajveer 2902 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
2903 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
2904 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
2905 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
2906 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
94 ashish 2907 
 
2908 
  def process(self, iprot, oprot):
2909 
    (name, type, seqid) = iprot.readMessageBegin()
2910 
    if name not in self._processMap:
2911 
      iprot.skip(TType.STRUCT)
2912 
      iprot.readMessageEnd()
2913 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
2914 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
2915 
      x.write(oprot)
2916 
      oprot.writeMessageEnd()
2917 
      oprot.trans.flush()
2918 
      return
2919 
    else:
2920 
      self._processMap[name](self, seqid, iprot, oprot)
2921 
    return True
2922 
 
559 chandransh 2923 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
2924 
    args = createAnonymousUser_args()
94 ashish 2925 
    args.read(iprot)
2926 
    iprot.readMessageEnd()
559 chandransh 2927 
    result = createAnonymousUser_result()
94 ashish 2928 
    try:
559 chandransh 2929 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
2930 
    except UserContextException, ucex:
2931 
      result.ucex = ucex
2932 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 2933 
    result.write(oprot)
2934 
    oprot.writeMessageEnd()
2935 
    oprot.trans.flush()
2936 
 
559 chandransh 2937 
  def process_getUserById(self, seqid, iprot, oprot):
2938 
    args = getUserById_args()
94 ashish 2939 
    args.read(iprot)
2940 
    iprot.readMessageEnd()
559 chandransh 2941 
    result = getUserById_result()
94 ashish 2942 
    try:
559 chandransh 2943 
      result.success = self._handler.getUserById(args.userId)
2944 
    except UserContextException, ucex:
2945 
      result.ucex = ucex
2946 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 2947 
    result.write(oprot)
2948 
    oprot.writeMessageEnd()
2949 
    oprot.trans.flush()
2950 
 
1491 vikas 2951 
  def process_getUserByEmail(self, seqid, iprot, oprot):
2952 
    args = getUserByEmail_args()
2953 
    args.read(iprot)
2954 
    iprot.readMessageEnd()
2955 
    result = getUserByEmail_result()
2956 
    try:
2957 
      result.success = self._handler.getUserByEmail(args.email)
2958 
    except UserContextException, ucex:
2959 
      result.ucex = ucex
2960 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
2961 
    result.write(oprot)
2962 
    oprot.writeMessageEnd()
2963 
    oprot.trans.flush()
2964 
 
3032 mandeep.dh 2965 
  def process_getUserByMobileNumber(self, seqid, iprot, oprot):
2966 
    args = getUserByMobileNumber_args()
2967 
    args.read(iprot)
2968 
    iprot.readMessageEnd()
2969 
    result = getUserByMobileNumber_result()
2970 
    try:
2971 
      result.success = self._handler.getUserByMobileNumber(args.mobileNumber)
2972 
    except UserContextException, ucex:
2973 
      result.ucex = ucex
2974 
    oprot.writeMessageBegin("getUserByMobileNumber", TMessageType.REPLY, seqid)
2975 
    result.write(oprot)
2976 
    oprot.writeMessageEnd()
2977 
    oprot.trans.flush()
2978 
 
559 chandransh 2979 
  def process_createUser(self, seqid, iprot, oprot):
2980 
    args = createUser_args()
94 ashish 2981 
    args.read(iprot)
2982 
    iprot.readMessageEnd()
559 chandransh 2983 
    result = createUser_result()
94 ashish 2984 
    try:
559 chandransh 2985 
      result.success = self._handler.createUser(args.user)
2986 
    except UserContextException, ucex:
2987 
      result.ucex = ucex
2988 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 2989 
    result.write(oprot)
2990 
    oprot.writeMessageEnd()
2991 
    oprot.trans.flush()
2992 
 
559 chandransh 2993 
  def process_updateUser(self, seqid, iprot, oprot):
2994 
    args = updateUser_args()
94 ashish 2995 
    args.read(iprot)
2996 
    iprot.readMessageEnd()
559 chandransh 2997 
    result = updateUser_result()
94 ashish 2998 
    try:
559 chandransh 2999 
      result.success = self._handler.updateUser(args.user)
3000 
    except UserContextException, ucex:
3001 
      result.ucex = ucex
3002 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 3003 
    result.write(oprot)
3004 
    oprot.writeMessageEnd()
3005 
    oprot.trans.flush()
3006 
 
559 chandransh 3007 
  def process_deleteUser(self, seqid, iprot, oprot):
3008 
    args = deleteUser_args()
94 ashish 3009 
    args.read(iprot)
3010 
    iprot.readMessageEnd()
559 chandransh 3011 
    result = deleteUser_result()
94 ashish 3012 
    try:
559 chandransh 3013 
      result.success = self._handler.deleteUser(args.userId)
3014 
    except UserContextException, ucex:
3015 
      result.ucex = ucex
3016 
    oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
94 ashish 3017 
    result.write(oprot)
3018 
    oprot.writeMessageEnd()
3019 
    oprot.trans.flush()
3020 
 
559 chandransh 3021 
  def process_getUserState(self, seqid, iprot, oprot):
3022 
    args = getUserState_args()
94 ashish 3023 
    args.read(iprot)
3024 
    iprot.readMessageEnd()
559 chandransh 3025 
    result = getUserState_result()
94 ashish 3026 
    try:
559 chandransh 3027 
      result.success = self._handler.getUserState(args.userId)
3028 
    except UserContextException, ucex:
3029 
      result.ucex = ucex
3030 
    oprot.writeMessageBegin("getUserState", TMessageType.REPLY, seqid)
94 ashish 3031 
    result.write(oprot)
3032 
    oprot.writeMessageEnd()
3033 
    oprot.trans.flush()
3034 
 
122 ashish 3035 
  def process_authenticateUser(self, seqid, iprot, oprot):
3036 
    args = authenticateUser_args()
3037 
    args.read(iprot)
3038 
    iprot.readMessageEnd()
3039 
    result = authenticateUser_result()
3040 
    try:
559 chandransh 3041 
      result.success = self._handler.authenticateUser(args.email, args.password)
3042 
    except AuthenticationException, auex:
3043 
      result.auex = auex
122 ashish 3044 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
3045 
    result.write(oprot)
3046 
    oprot.writeMessageEnd()
3047 
    oprot.trans.flush()
3048 
 
94 ashish 3049 
  def process_userExists(self, seqid, iprot, oprot):
3050 
    args = userExists_args()
3051 
    args.read(iprot)
3052 
    iprot.readMessageEnd()
3053 
    result = userExists_result()
3054 
    try:
3055 
      result.success = self._handler.userExists(args.email)
3056 
    except UserContextException, ucx:
3057 
      result.ucx = ucx
3058 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
3059 
    result.write(oprot)
3060 
    oprot.writeMessageEnd()
3061 
    oprot.trans.flush()
3062 
 
3063 
  def process_addAddressForUser(self, seqid, iprot, oprot):
3064 
    args = addAddressForUser_args()
3065 
    args.read(iprot)
3066 
    iprot.readMessageEnd()
3067 
    result = addAddressForUser_result()
3068 
    try:
567 rajveer 3069 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 3070 
    except UserContextException, ucx:
3071 
      result.ucx = ucx
3072 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
3073 
    result.write(oprot)
3074 
    oprot.writeMessageEnd()
3075 
    oprot.trans.flush()
3076 
 
3077 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
3078 
    args = removeAddressForUser_args()
3079 
    args.read(iprot)
3080 
    iprot.readMessageEnd()
3081 
    result = removeAddressForUser_result()
3082 
    try:
3083 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
3084 
    except UserContextException, ucx:
3085 
      result.ucx = ucx
3086 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
3087 
    result.write(oprot)
3088 
    oprot.writeMessageEnd()
3089 
    oprot.trans.flush()
3090 
 
3091 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
3092 
    args = setUserAsLoggedIn_args()
3093 
    args.read(iprot)
3094 
    iprot.readMessageEnd()
3095 
    result = setUserAsLoggedIn_result()
3096 
    try:
3097 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
3098 
    except UserContextException, ucx:
3099 
      result.ucx = ucx
3100 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
3101 
    result.write(oprot)
3102 
    oprot.writeMessageEnd()
3103 
    oprot.trans.flush()
3104 
 
3105 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
3106 
    args = setUserAsLoggedOut_args()
3107 
    args.read(iprot)
3108 
    iprot.readMessageEnd()
3109 
    result = setUserAsLoggedOut_result()
3110 
    try:
3111 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
3112 
    except UserContextException, ucx:
3113 
      result.ucx = ucx
3114 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
3115 
    result.write(oprot)
3116 
    oprot.writeMessageEnd()
3117 
    oprot.trans.flush()
3118 
 
504 rajveer 3119 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
3120 
    args = setDefaultAddress_args()
3121 
    args.read(iprot)
3122 
    iprot.readMessageEnd()
3123 
    result = setDefaultAddress_result()
3124 
    try:
3125 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
3126 
    except UserContextException, ucx:
3127 
      result.ucx = ucx
3128 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
3129 
    result.write(oprot)
3130 
    oprot.writeMessageEnd()
3131 
    oprot.trans.flush()
3132 
 
94 ashish 3133 
  def process_updatePassword(self, seqid, iprot, oprot):
3134 
    args = updatePassword_args()
3135 
    args.read(iprot)
3136 
    iprot.readMessageEnd()
3137 
    result = updatePassword_result()
3138 
    try:
594 rajveer 3139 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 3140 
    except UserContextException, ucx:
3141 
      result.ucx = ucx
3142 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
3143 
    result.write(oprot)
3144 
    oprot.writeMessageEnd()
3145 
    oprot.trans.flush()
3146 
 
581 rajveer 3147 
  def process_forgotPassword(self, seqid, iprot, oprot):
3148 
    args = forgotPassword_args()
3149 
    args.read(iprot)
3150 
    iprot.readMessageEnd()
3151 
    result = forgotPassword_result()
3152 
    try:
884 rajveer 3153 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 3154 
    except UserContextException, ucx:
3155 
      result.ucx = ucx
3156 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
3157 
    result.write(oprot)
3158 
    oprot.writeMessageEnd()
3159 
    oprot.trans.flush()
3160 
 
594 rajveer 3161 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
3162 
    args = getAllAddressesForUser_args()
3163 
    args.read(iprot)
3164 
    iprot.readMessageEnd()
3165 
    result = getAllAddressesForUser_result()
3166 
    try:
3167 
      result.success = self._handler.getAllAddressesForUser(args.userId)
3168 
    except UserContextException, ucx:
3169 
      result.ucx = ucx
3170 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
3171 
    result.write(oprot)
3172 
    oprot.writeMessageEnd()
3173 
    oprot.trans.flush()
3174 
 
1894 vikas 3175 
  def process_getAddressById(self, seqid, iprot, oprot):
3176 
    args = getAddressById_args()
3177 
    args.read(iprot)
3178 
    iprot.readMessageEnd()
3179 
    result = getAddressById_result()
3180 
    try:
3181 
      result.success = self._handler.getAddressById(args.addressId)
3182 
    except UserContextException, ucx:
3183 
      result.ucx = ucx
3184 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
3185 
    result.write(oprot)
3186 
    oprot.writeMessageEnd()
3187 
    oprot.trans.flush()
3188 
 
594 rajveer 3189 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
3190 
    args = getDefaultAddressId_args()
3191 
    args.read(iprot)
3192 
    iprot.readMessageEnd()
3193 
    result = getDefaultAddressId_result()
3194 
    try:
3195 
      result.success = self._handler.getDefaultAddressId(args.userId)
3196 
    except UserContextException, ucx:
3197 
      result.ucx = ucx
3198 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
3199 
    result.write(oprot)
3200 
    oprot.writeMessageEnd()
3201 
    oprot.trans.flush()
3202 
 
785 rajveer 3203 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
3204 
    args = getDefaultPincode_args()
3205 
    args.read(iprot)
3206 
    iprot.readMessageEnd()
3207 
    result = getDefaultPincode_result()
3208 
    try:
3209 
      result.success = self._handler.getDefaultPincode(args.userId)
3210 
    except UserContextException, ucx:
3211 
      result.ucx = ucx
3212 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
3213 
    result.write(oprot)
3214 
    oprot.writeMessageEnd()
3215 
    oprot.trans.flush()
3216 
 
1274 varun.gupt 3217 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
3218 
    args = saveUserCommunication_args()
3219 
    args.read(iprot)
3220 
    iprot.readMessageEnd()
3221 
    result = saveUserCommunication_result()
3222 
    try:
3223 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
3224 
    except UserCommunicationException, ucx:
3225 
      result.ucx = ucx
3226 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
3227 
    result.write(oprot)
3228 
    oprot.writeMessageEnd()
3229 
    oprot.trans.flush()
3230 
 
1590 varun.gupt 3231 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
3232 
    args = getUserCommunicationById_args()
3233 
    args.read(iprot)
3234 
    iprot.readMessageEnd()
3235 
    result = getUserCommunicationById_result()
3236 
    try:
3237 
      result.success = self._handler.getUserCommunicationById(args.id)
3238 
    except UserCommunicationException, ucx:
3239 
      result.ucx = ucx
3240 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
3241 
    result.write(oprot)
3242 
    oprot.writeMessageEnd()
3243 
    oprot.trans.flush()
3244 
 
3245 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
3246 
    args = getUserCommunicationByUser_args()
3247 
    args.read(iprot)
3248 
    iprot.readMessageEnd()
3249 
    result = getUserCommunicationByUser_result()
3250 
    try:
3251 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
3252 
    except UserCommunicationException, ucx:
3253 
      result.ucx = ucx
3254 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
3255 
    result.write(oprot)
3256 
    oprot.writeMessageEnd()
3257 
    oprot.trans.flush()
3258 
 
3259 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
3260 
    args = getAllUserCommunications_args()
3261 
    args.read(iprot)
3262 
    iprot.readMessageEnd()
3263 
    result = getAllUserCommunications_result()
3264 
    try:
3265 
      result.success = self._handler.getAllUserCommunications()
3266 
    except UserCommunicationException, ucx:
3267 
      result.ucx = ucx
3268 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
3269 
    result.write(oprot)
3270 
    oprot.writeMessageEnd()
3271 
    oprot.trans.flush()
3272 
 
1845 vikas 3273 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
3274 
    args = createMasterAffiliate_args()
3275 
    args.read(iprot)
3276 
    iprot.readMessageEnd()
3277 
    result = createMasterAffiliate_result()
3278 
    try:
1859 vikas 3279 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 3280 
    except UserAffiliateException, utx:
1845 vikas 3281 
      result.utx = utx
3282 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
3283 
    result.write(oprot)
3284 
    oprot.writeMessageEnd()
3285 
    oprot.trans.flush()
3286 
 
1899 vikas 3287 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
3288 
    args = getAllMasterAffiliates_args()
3289 
    args.read(iprot)
3290 
    iprot.readMessageEnd()
3291 
    result = getAllMasterAffiliates_result()
3292 
    try:
3293 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 3294 
    except UserAffiliateException, utx:
1899 vikas 3295 
      result.utx = utx
3296 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
3297 
    result.write(oprot)
3298 
    oprot.writeMessageEnd()
3299 
    oprot.trans.flush()
3300 
 
1845 vikas 3301 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
3302 
    args = getMasterAffiliateById_args()
3303 
    args.read(iprot)
3304 
    iprot.readMessageEnd()
3305 
    result = getMasterAffiliateById_result()
3306 
    try:
3307 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 3308 
    except UserAffiliateException, utx:
1845 vikas 3309 
      result.utx = utx
3310 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
3311 
    result.write(oprot)
3312 
    oprot.writeMessageEnd()
3313 
    oprot.trans.flush()
3314 
 
3315 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
3316 
    args = getMasterAffiliateByName_args()
3317 
    args.read(iprot)
3318 
    iprot.readMessageEnd()
3319 
    result = getMasterAffiliateByName_result()
3320 
    try:
3321 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 3322 
    except UserAffiliateException, utx:
1845 vikas 3323 
      result.utx = utx
3324 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
3325 
    result.write(oprot)
3326 
    oprot.writeMessageEnd()
3327 
    oprot.trans.flush()
3328 
 
3329 
  def process_createAffiliate(self, seqid, iprot, oprot):
3330 
    args = createAffiliate_args()
3331 
    args.read(iprot)
3332 
    iprot.readMessageEnd()
3333 
    result = createAffiliate_result()
3334 
    try:
1859 vikas 3335 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 3336 
    except UserAffiliateException, utx:
1845 vikas 3337 
      result.utx = utx
3338 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
3339 
    result.write(oprot)
3340 
    oprot.writeMessageEnd()
3341 
    oprot.trans.flush()
3342 
 
3343 
  def process_getAffiliateById(self, seqid, iprot, oprot):
3344 
    args = getAffiliateById_args()
3345 
    args.read(iprot)
3346 
    iprot.readMessageEnd()
3347 
    result = getAffiliateById_result()
3348 
    try:
3349 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 3350 
    except UserAffiliateException, utx:
1845 vikas 3351 
      result.utx = utx
3352 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
3353 
    result.write(oprot)
3354 
    oprot.writeMessageEnd()
3355 
    oprot.trans.flush()
3356 
 
3357 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
3358 
    args = getAffiliateByName_args()
3359 
    args.read(iprot)
3360 
    iprot.readMessageEnd()
3361 
    result = getAffiliateByName_result()
3362 
    try:
3363 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 3364 
    except UserAffiliateException, utx:
1845 vikas 3365 
      result.utx = utx
3366 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
3367 
    result.write(oprot)
3368 
    oprot.writeMessageEnd()
3369 
    oprot.trans.flush()
3370 
 
3371 
  def process_getTrackerById(self, seqid, iprot, oprot):
3372 
    args = getTrackerById_args()
3373 
    args.read(iprot)
3374 
    iprot.readMessageEnd()
3375 
    result = getTrackerById_result()
3376 
    try:
1996 vikas 3377 
      result.success = self._handler.getTrackerById(args.id)
3378 
    except UserAffiliateException, utx:
1845 vikas 3379 
      result.utx = utx
3380 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
3381 
    result.write(oprot)
3382 
    oprot.writeMessageEnd()
3383 
    oprot.trans.flush()
3384 
 
1996 vikas 3385 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
3386 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 3387 
    args.read(iprot)
3388 
    iprot.readMessageEnd()
1996 vikas 3389 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 3390 
    try:
1996 vikas 3391 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
3392 
    except UserAffiliateException, utx:
1845 vikas 3393 
      result.utx = utx
1996 vikas 3394 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3395 
    result.write(oprot)
3396 
    oprot.writeMessageEnd()
3397 
    oprot.trans.flush()
3398 
 
3399 
  def process_addTrackLog(self, seqid, iprot, oprot):
3400 
    args = addTrackLog_args()
3401 
    args.read(iprot)
3402 
    iprot.readMessageEnd()
3403 
    result = addTrackLog_result()
3404 
    try:
1996 vikas 3405 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
3406 
    except UserAffiliateException, utx:
1845 vikas 3407 
      result.utx = utx
3408 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
3409 
    result.write(oprot)
3410 
    oprot.writeMessageEnd()
3411 
    oprot.trans.flush()
3412 
 
3413 
  def process_getTrackLogById(self, seqid, iprot, oprot):
3414 
    args = getTrackLogById_args()
3415 
    args.read(iprot)
3416 
    iprot.readMessageEnd()
3417 
    result = getTrackLogById_result()
3418 
    try:
3419 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 3420 
    except UserAffiliateException, utx:
1845 vikas 3421 
      result.utx = utx
3422 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
3423 
    result.write(oprot)
3424 
    oprot.writeMessageEnd()
3425 
    oprot.trans.flush()
3426 
 
1996 vikas 3427 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
3428 
    args = getTrackLogsByAffiliate_args()
1845 vikas 3429 
    args.read(iprot)
3430 
    iprot.readMessageEnd()
1996 vikas 3431 
    result = getTrackLogsByAffiliate_result()
1845 vikas 3432 
    try:
3293 vikas 3433 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId, args.startDate, args.endDate)
1996 vikas 3434 
    except UserAffiliateException, utx:
1845 vikas 3435 
      result.utx = utx
1996 vikas 3436 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3437 
    result.write(oprot)
3438 
    oprot.writeMessageEnd()
3439 
    oprot.trans.flush()
3440 
 
3441 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
3442 
    args = getTrackLogsByUser_args()
3443 
    args.read(iprot)
3444 
    iprot.readMessageEnd()
3445 
    result = getTrackLogsByUser_result()
3446 
    try:
3447 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 3448 
    except UserAffiliateException, utx:
1845 vikas 3449 
      result.utx = utx
3450 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
3451 
    result.write(oprot)
3452 
    oprot.writeMessageEnd()
3453 
    oprot.trans.flush()
3454 
 
3455 
  def process_getTrackLogs(self, seqid, iprot, oprot):
3456 
    args = getTrackLogs_args()
3457 
    args.read(iprot)
3458 
    iprot.readMessageEnd()
3459 
    result = getTrackLogs_result()
3460 
    try:
1996 vikas 3461 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
3462 
    except UserAffiliateException, utx:
1845 vikas 3463 
      result.utx = utx
3464 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
3465 
    result.write(oprot)
3466 
    oprot.writeMessageEnd()
3467 
    oprot.trans.flush()
3468 
 
559 chandransh 3469 
  def process_createCart(self, seqid, iprot, oprot):
3470 
    args = createCart_args()
94 ashish 3471 
    args.read(iprot)
3472 
    iprot.readMessageEnd()
559 chandransh 3473 
    result = createCart_result()
94 ashish 3474 
    try:
559 chandransh 3475 
      result.success = self._handler.createCart(args.userId)
3476 
    except ShoppingCartException, scx:
3477 
      result.scx = scx
3478 
    oprot.writeMessageBegin("createCart", TMessageType.REPLY, seqid)
94 ashish 3479 
    result.write(oprot)
3480 
    oprot.writeMessageEnd()
3481 
    oprot.trans.flush()
3482 
 
559 chandransh 3483 
  def process_getCurrentCart(self, seqid, iprot, oprot):
3484 
    args = getCurrentCart_args()
94 ashish 3485 
    args.read(iprot)
3486 
    iprot.readMessageEnd()
559 chandransh 3487 
    result = getCurrentCart_result()
94 ashish 3488 
    try:
559 chandransh 3489 
      result.success = self._handler.getCurrentCart(args.userId)
3490 
    except ShoppingCartException, scx:
3491 
      result.scx = scx
3492 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 3493 
    result.write(oprot)
3494 
    oprot.writeMessageEnd()
3495 
    oprot.trans.flush()
3496 
 
559 chandransh 3497 
  def process_getCart(self, seqid, iprot, oprot):
3498 
    args = getCart_args()
94 ashish 3499 
    args.read(iprot)
3500 
    iprot.readMessageEnd()
559 chandransh 3501 
    result = getCart_result()
94 ashish 3502 
    try:
559 chandransh 3503 
      result.success = self._handler.getCart(args.cartId)
3504 
    except ShoppingCartException, scx:
3505 
      result.scx = scx
3506 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 3507 
    result.write(oprot)
3508 
    oprot.writeMessageEnd()
3509 
    oprot.trans.flush()
3510 
 
559 chandransh 3511 
  def process_getCartsForUser(self, seqid, iprot, oprot):
3512 
    args = getCartsForUser_args()
94 ashish 3513 
    args.read(iprot)
3514 
    iprot.readMessageEnd()
559 chandransh 3515 
    result = getCartsForUser_result()
94 ashish 3516 
    try:
559 chandransh 3517 
      result.success = self._handler.getCartsForUser(args.userId, args.status)
3518 
    except ShoppingCartException, scx:
3519 
      result.scx = scx
3520 
    oprot.writeMessageBegin("getCartsForUser", TMessageType.REPLY, seqid)
94 ashish 3521 
    result.write(oprot)
3522 
    oprot.writeMessageEnd()
3523 
    oprot.trans.flush()
3524 
 
559 chandransh 3525 
  def process_getCartsByStatus(self, seqid, iprot, oprot):
3526 
    args = getCartsByStatus_args()
94 ashish 3527 
    args.read(iprot)
3528 
    iprot.readMessageEnd()
559 chandransh 3529 
    result = getCartsByStatus_result()
94 ashish 3530 
    try:
559 chandransh 3531 
      result.success = self._handler.getCartsByStatus(args.status)
3532 
    except ShoppingCartException, scx:
3533 
      result.scx = scx
3534 
    oprot.writeMessageBegin("getCartsByStatus", TMessageType.REPLY, seqid)
94 ashish 3535 
    result.write(oprot)
3536 
    oprot.writeMessageEnd()
3537 
    oprot.trans.flush()
3538 
 
559 chandransh 3539 
  def process_getCartsByTime(self, seqid, iprot, oprot):
3540 
    args = getCartsByTime_args()
94 ashish 3541 
    args.read(iprot)
3542 
    iprot.readMessageEnd()
559 chandransh 3543 
    result = getCartsByTime_result()
94 ashish 3544 
    try:
559 chandransh 3545 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
3546 
    except ShoppingCartException, scx:
3547 
      result.scx = scx
3548 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 3549 
    result.write(oprot)
3550 
    oprot.writeMessageEnd()
3551 
    oprot.trans.flush()
3552 
 
559 chandransh 3553 
  def process_changeCartStatus(self, seqid, iprot, oprot):
3554 
    args = changeCartStatus_args()
130 ashish 3555 
    args.read(iprot)
3556 
    iprot.readMessageEnd()
559 chandransh 3557 
    result = changeCartStatus_result()
130 ashish 3558 
    try:
559 chandransh 3559 
      self._handler.changeCartStatus(args.cartId, args.status)
3560 
    except ShoppingCartException, scx:
3561 
      result.scx = scx
3562 
    oprot.writeMessageBegin("changeCartStatus", TMessageType.REPLY, seqid)
130 ashish 3563 
    result.write(oprot)
3564 
    oprot.writeMessageEnd()
3565 
    oprot.trans.flush()
94 ashish 3566 
 
559 chandransh 3567 
  def process_addItemToCart(self, seqid, iprot, oprot):
3568 
    args = addItemToCart_args()
130 ashish 3569 
    args.read(iprot)
3570 
    iprot.readMessageEnd()
559 chandransh 3571 
    result = addItemToCart_result()
130 ashish 3572 
    try:
2035 rajveer 3573 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity)
559 chandransh 3574 
    except ShoppingCartException, scx:
3575 
      result.scx = scx
3576 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 3577 
    result.write(oprot)
3578 
    oprot.writeMessageEnd()
3579 
    oprot.trans.flush()
3580 
 
559 chandransh 3581 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
3582 
    args = deleteItemFromCart_args()
3583 
    args.read(iprot)
3584 
    iprot.readMessageEnd()
3585 
    result = deleteItemFromCart_result()
3586 
    try:
3587 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
3588 
    except ShoppingCartException, scx:
3589 
      result.scx = scx
3590 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
3591 
    result.write(oprot)
3592 
    oprot.writeMessageEnd()
3593 
    oprot.trans.flush()
130 ashish 3594 
 
559 chandransh 3595 
  def process_changeQuantity(self, seqid, iprot, oprot):
3596 
    args = changeQuantity_args()
3597 
    args.read(iprot)
3598 
    iprot.readMessageEnd()
3599 
    result = changeQuantity_result()
3600 
    try:
3601 
      self._handler.changeQuantity(args.cartId, args.itemId, args.quantity)
3602 
    except ShoppingCartException, scx:
3603 
      result.scx = scx
3604 
    oprot.writeMessageBegin("changeQuantity", TMessageType.REPLY, seqid)
3605 
    result.write(oprot)
3606 
    oprot.writeMessageEnd()
3607 
    oprot.trans.flush()
3608 
 
3609 
  def process_changeItemStatus(self, seqid, iprot, oprot):
3610 
    args = changeItemStatus_args()
3611 
    args.read(iprot)
3612 
    iprot.readMessageEnd()
3613 
    result = changeItemStatus_result()
3614 
    try:
3615 
      self._handler.changeItemStatus(args.cartId, args.itemId, args.status)
3616 
    except ShoppingCartException, scx:
3617 
      result.scx = scx
3618 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
3619 
    result.write(oprot)
3620 
    oprot.writeMessageEnd()
3621 
    oprot.trans.flush()
3622 
 
3623 
  def process_addAddressToCart(self, seqid, iprot, oprot):
3624 
    args = addAddressToCart_args()
3625 
    args.read(iprot)
3626 
    iprot.readMessageEnd()
3627 
    result = addAddressToCart_result()
575 chandransh 3628 
    try:
3629 
      self._handler.addAddressToCart(args.cartId, args.addressId)
3630 
    except ShoppingCartException, scx:
3631 
      result.scx = scx
559 chandransh 3632 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
3633 
    result.write(oprot)
3634 
    oprot.writeMessageEnd()
3635 
    oprot.trans.flush()
3636 
 
1976 varun.gupt 3637 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
3638 
    args = applyCouponToCart_args()
3639 
    args.read(iprot)
3640 
    iprot.readMessageEnd()
3641 
    result = applyCouponToCart_result()
3642 
    try:
3643 
      self._handler.applyCouponToCart(args.cartId, args.couponCode, args.totalPrice, args.discountedPrice)
3644 
    except ShoppingCartException, scx:
3645 
      result.scx = scx
3646 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
3647 
    result.write(oprot)
3648 
    oprot.writeMessageEnd()
3649 
    oprot.trans.flush()
3650 
 
3651 
  def process_removeCoupon(self, seqid, iprot, oprot):
3652 
    args = removeCoupon_args()
3653 
    args.read(iprot)
3654 
    iprot.readMessageEnd()
3655 
    result = removeCoupon_result()
3656 
    try:
3657 
      self._handler.removeCoupon(args.cartId)
3658 
    except ShoppingCartException, scx:
3659 
      result.scx = scx
3660 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
3661 
    result.write(oprot)
3662 
    oprot.writeMessageEnd()
3663 
    oprot.trans.flush()
3664 
 
690 chandransh 3665 
  def process_createOrders(self, seqid, iprot, oprot):
3666 
    args = createOrders_args()
559 chandransh 3667 
    args.read(iprot)
3668 
    iprot.readMessageEnd()
690 chandransh 3669 
    result = createOrders_result()
559 chandransh 3670 
    try:
2815 vikas 3671 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime)
559 chandransh 3672 
    except ShoppingCartException, scx:
3673 
      result.scx = scx
690 chandransh 3674 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 3675 
    result.write(oprot)
3676 
    oprot.writeMessageEnd()
3677 
    oprot.trans.flush()
3678 
 
3679 
  def process_validateCart(self, seqid, iprot, oprot):
3680 
    args = validateCart_args()
3681 
    args.read(iprot)
3682 
    iprot.readMessageEnd()
3683 
    result = validateCart_result()
575 chandransh 3684 
    try:
3685 
      result.success = self._handler.validateCart(args.cartId)
3686 
    except ShoppingCartException, scex:
3687 
      result.scex = scex
559 chandransh 3688 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
3689 
    result.write(oprot)
3690 
    oprot.writeMessageEnd()
3691 
    oprot.trans.flush()
3692 
 
690 chandransh 3693 
  def process_mergeCart(self, seqid, iprot, oprot):
3694 
    args = mergeCart_args()
575 chandransh 3695 
    args.read(iprot)
3696 
    iprot.readMessageEnd()
690 chandransh 3697 
    result = mergeCart_result()
3698 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
3699 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
3700 
    result.write(oprot)
3701 
    oprot.writeMessageEnd()
3702 
    oprot.trans.flush()
3703 
 
3704 
  def process_checkOut(self, seqid, iprot, oprot):
3705 
    args = checkOut_args()
3706 
    args.read(iprot)
3707 
    iprot.readMessageEnd()
3708 
    result = checkOut_result()
575 chandransh 3709 
    try:
690 chandransh 3710 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 3711 
    except ShoppingCartException, scex:
3712 
      result.scex = scex
690 chandransh 3713 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 3714 
    result.write(oprot)
3715 
    oprot.writeMessageEnd()
3716 
    oprot.trans.flush()
3717 
 
690 chandransh 3718 
  def process_resetCart(self, seqid, iprot, oprot):
3719 
    args = resetCart_args()
559 chandransh 3720 
    args.read(iprot)
3721 
    iprot.readMessageEnd()
690 chandransh 3722 
    result = resetCart_result()
3723 
    try:
3724 
      result.success = self._handler.resetCart(args.cartId, args.items)
3725 
    except ShoppingCartException, scex:
3726 
      result.scex = scex
3727 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 3728 
    result.write(oprot)
3729 
    oprot.writeMessageEnd()
3730 
    oprot.trans.flush()
3731 
 
2981 rajveer 3732 
  def process_getUserCount(self, seqid, iprot, oprot):
3733 
    args = getUserCount_args()
559 chandransh 3734 
    args.read(iprot)
3735 
    iprot.readMessageEnd()
2981 rajveer 3736 
    result = getUserCount_result()
3737 
    result.success = self._handler.getUserCount(args.userType)
3738 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 3739 
    result.write(oprot)
3740 
    oprot.writeMessageEnd()
3741 
    oprot.trans.flush()
3742 
 
2981 rajveer 3743 
  def process_getAllUsers(self, seqid, iprot, oprot):
3744 
    args = getAllUsers_args()
559 chandransh 3745 
    args.read(iprot)
3746 
    iprot.readMessageEnd()
2981 rajveer 3747 
    result = getAllUsers_result()
3748 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
3749 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 3750 
    result.write(oprot)
3751 
    oprot.writeMessageEnd()
3752 
    oprot.trans.flush()
3753 
 
2981 rajveer 3754 
  def process_putUserNote(self, seqid, iprot, oprot):
3755 
    args = putUserNote_args()
559 chandransh 3756 
    args.read(iprot)
3757 
    iprot.readMessageEnd()
2981 rajveer 3758 
    result = putUserNote_result()
3759 
    self._handler.putUserNote(args.user_id, args.entity_id, args.slide, args.note)
3760 
    oprot.writeMessageBegin("putUserNote", TMessageType.REPLY, seqid)
559 chandransh 3761 
    result.write(oprot)
3762 
    oprot.writeMessageEnd()
3763 
    oprot.trans.flush()
3764 
 
2981 rajveer 3765 
  def process_getUserNotes(self, seqid, iprot, oprot):
3766 
    args = getUserNotes_args()
559 chandransh 3767 
    args.read(iprot)
3768 
    iprot.readMessageEnd()
2981 rajveer 3769 
    result = getUserNotes_result()
3770 
    result.success = self._handler.getUserNotes(args.user_id, args.entity_id)
3771 
    oprot.writeMessageBegin("getUserNotes", TMessageType.REPLY, seqid)
559 chandransh 3772 
    result.write(oprot)
3773 
    oprot.writeMessageEnd()
3774 
    oprot.trans.flush()
3775 
 
2981 rajveer 3776 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
3777 
    args = getMyResearchItems_args()
559 chandransh 3778 
    args.read(iprot)
3779 
    iprot.readMessageEnd()
2981 rajveer 3780 
    result = getMyResearchItems_result()
559 chandransh 3781 
    try:
2981 rajveer 3782 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 3783 
    except WidgetException, scx:
3784 
      result.scx = scx
2981 rajveer 3785 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 3786 
    result.write(oprot)
3787 
    oprot.writeMessageEnd()
3788 
    oprot.trans.flush()
3789 
 
2981 rajveer 3790 
  def process_updateMyResearch(self, seqid, iprot, oprot):
3791 
    args = updateMyResearch_args()
772 rajveer 3792 
    args.read(iprot)
3793 
    iprot.readMessageEnd()
2981 rajveer 3794 
    result = updateMyResearch_result()
3795 
    try:
3796 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
3797 
    except WidgetException, scx:
3798 
      result.scx = scx
3799 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 3800 
    result.write(oprot)
3801 
    oprot.writeMessageEnd()
3802 
    oprot.trans.flush()
559 chandransh 3803 
 
2981 rajveer 3804 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
3805 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 3806 
    args.read(iprot)
3807 
    iprot.readMessageEnd()
2981 rajveer 3808 
    result = deleteItemFromMyResearch_result()
3809 
    try:
3810 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
3811 
    except WidgetException, scx:
3812 
      result.scx = scx
3813 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 3814 
    result.write(oprot)
3815 
    oprot.writeMessageEnd()
3816 
    oprot.trans.flush()
772 rajveer 3817 
 
2981 rajveer 3818 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
3819 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 3820 
    args.read(iprot)
3821 
    iprot.readMessageEnd()
2981 rajveer 3822 
    result = getBrowseHistoryItems_result()
3823 
    try:
3824 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
3825 
    except WidgetException, scx:
3826 
      result.scx = scx
3827 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 3828 
    result.write(oprot)
3829 
    oprot.writeMessageEnd()
3830 
    oprot.trans.flush()
1596 ankur.sing 3831 
 
2981 rajveer 3832 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
3833 
    args = updateBrowseHistory_args()
2642 varun.gupt 3834 
    args.read(iprot)
3835 
    iprot.readMessageEnd()
2981 rajveer 3836 
    result = updateBrowseHistory_result()
3837 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
3838 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 3839 
    result.write(oprot)
3840 
    oprot.writeMessageEnd()
3841 
    oprot.trans.flush()
1673 ankur.sing 3842 
 
2642 varun.gupt 3843 
 
94 ashish 3844 
# HELPER FUNCTIONS AND STRUCTURES
3845 
 
559 chandransh 3846 
class createAnonymousUser_args:
94 ashish 3847 
  """
3848 
  Attributes:
559 chandransh 3849 
   - jsessionId
94 ashish 3850 
  """
3851 
 
3852 
  thrift_spec = (
3853 
    None, # 0
559 chandransh 3854 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 3855 
  )
3856 
 
559 chandransh 3857 
  def __init__(self, jsessionId=None,):
3858 
    self.jsessionId = jsessionId
94 ashish 3859 
 
3860 
  def read(self, iprot):
3861 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3862 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3863 
      return
3864 
    iprot.readStructBegin()
3865 
    while True:
3866 
      (fname, ftype, fid) = iprot.readFieldBegin()
3867 
      if ftype == TType.STOP:
3868 
        break
3869 
      if fid == 1:
559 chandransh 3870 
        if ftype == TType.STRING:
3871 
          self.jsessionId = iprot.readString();
94 ashish 3872 
        else:
3873 
          iprot.skip(ftype)
3874 
      else:
3875 
        iprot.skip(ftype)
3876 
      iprot.readFieldEnd()
3877 
    iprot.readStructEnd()
3878 
 
3879 
  def write(self, oprot):
3880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3882 
      return
559 chandransh 3883 
    oprot.writeStructBegin('createAnonymousUser_args')
3884 
    if self.jsessionId != None:
3885 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
3886 
      oprot.writeString(self.jsessionId)
94 ashish 3887 
      oprot.writeFieldEnd()
3888 
    oprot.writeFieldStop()
3889 
    oprot.writeStructEnd()
3890 
 
3891 
  def __repr__(self):
3892 
    L = ['%s=%r' % (key, value)
3893 
      for key, value in self.__dict__.iteritems()]
3894 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3895 
 
3896 
  def __eq__(self, other):
3897 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3898 
 
3899 
  def __ne__(self, other):
3900 
    return not (self == other)
3901 
 
559 chandransh 3902 
class createAnonymousUser_result:
94 ashish 3903 
  """
3904 
  Attributes:
3905 
   - success
559 chandransh 3906 
   - ucex
94 ashish 3907 
  """
3908 
 
3909 
  thrift_spec = (
559 chandransh 3910 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
3911 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 3912 
  )
3913 
 
559 chandransh 3914 
  def __init__(self, success=None, ucex=None,):
94 ashish 3915 
    self.success = success
559 chandransh 3916 
    self.ucex = ucex
94 ashish 3917 
 
3918 
  def read(self, iprot):
3919 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3920 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3921 
      return
3922 
    iprot.readStructBegin()
3923 
    while True:
3924 
      (fname, ftype, fid) = iprot.readFieldBegin()
3925 
      if ftype == TType.STOP:
3926 
        break
3927 
      if fid == 0:
3928 
        if ftype == TType.STRUCT:
559 chandransh 3929 
          self.success = User()
94 ashish 3930 
          self.success.read(iprot)
3931 
        else:
3932 
          iprot.skip(ftype)
3933 
      elif fid == 1:
3934 
        if ftype == TType.STRUCT:
559 chandransh 3935 
          self.ucex = UserContextException()
3936 
          self.ucex.read(iprot)
94 ashish 3937 
        else:
3938 
          iprot.skip(ftype)
3939 
      else:
3940 
        iprot.skip(ftype)
3941 
      iprot.readFieldEnd()
3942 
    iprot.readStructEnd()
3943 
 
3944 
  def write(self, oprot):
3945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3947 
      return
559 chandransh 3948 
    oprot.writeStructBegin('createAnonymousUser_result')
94 ashish 3949 
    if self.success != None:
3950 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
3951 
      self.success.write(oprot)
3952 
      oprot.writeFieldEnd()
559 chandransh 3953 
    if self.ucex != None:
3954 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
3955 
      self.ucex.write(oprot)
94 ashish 3956 
      oprot.writeFieldEnd()
3957 
    oprot.writeFieldStop()
3958 
    oprot.writeStructEnd()
3959 
 
3960 
  def __repr__(self):
3961 
    L = ['%s=%r' % (key, value)
3962 
      for key, value in self.__dict__.iteritems()]
3963 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3964 
 
3965 
  def __eq__(self, other):
3966 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3967 
 
3968 
  def __ne__(self, other):
3969 
    return not (self == other)
3970 
 
559 chandransh 3971 
class getUserById_args:
94 ashish 3972 
  """
3973 
  Attributes:
3974 
   - userId
3975 
  """
3976 
 
3977 
  thrift_spec = (
3978 
    None, # 0
3979 
    (1, TType.I64, 'userId', None, None, ), # 1
3980 
  )
3981 
 
559 chandransh 3982 
  def __init__(self, userId=None,):
94 ashish 3983 
    self.userId = userId
3984 
 
3985 
  def read(self, iprot):
3986 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3987 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3988 
      return
3989 
    iprot.readStructBegin()
3990 
    while True:
3991 
      (fname, ftype, fid) = iprot.readFieldBegin()
3992 
      if ftype == TType.STOP:
3993 
        break
3994 
      if fid == 1:
3995 
        if ftype == TType.I64:
3996 
          self.userId = iprot.readI64();
3997 
        else:
3998 
          iprot.skip(ftype)
3999 
      else:
4000 
        iprot.skip(ftype)
4001 
      iprot.readFieldEnd()
4002 
    iprot.readStructEnd()
4003 
 
4004 
  def write(self, oprot):
4005 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4006 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4007 
      return
559 chandransh 4008 
    oprot.writeStructBegin('getUserById_args')
94 ashish 4009 
    if self.userId != None:
4010 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4011 
      oprot.writeI64(self.userId)
4012 
      oprot.writeFieldEnd()
4013 
    oprot.writeFieldStop()
4014 
    oprot.writeStructEnd()
4015 
 
4016 
  def __repr__(self):
4017 
    L = ['%s=%r' % (key, value)
4018 
      for key, value in self.__dict__.iteritems()]
4019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4020 
 
4021 
  def __eq__(self, other):
4022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4023 
 
4024 
  def __ne__(self, other):
4025 
    return not (self == other)
4026 
 
559 chandransh 4027 
class getUserById_result:
94 ashish 4028 
  """
4029 
  Attributes:
4030 
   - success
559 chandransh 4031 
   - ucex
94 ashish 4032 
  """
4033 
 
4034 
  thrift_spec = (
559 chandransh 4035 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4036 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4037 
  )
4038 
 
559 chandransh 4039 
  def __init__(self, success=None, ucex=None,):
94 ashish 4040 
    self.success = success
559 chandransh 4041 
    self.ucex = ucex
94 ashish 4042 
 
4043 
  def read(self, iprot):
4044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4046 
      return
4047 
    iprot.readStructBegin()
4048 
    while True:
4049 
      (fname, ftype, fid) = iprot.readFieldBegin()
4050 
      if ftype == TType.STOP:
4051 
        break
4052 
      if fid == 0:
4053 
        if ftype == TType.STRUCT:
559 chandransh 4054 
          self.success = User()
94 ashish 4055 
          self.success.read(iprot)
4056 
        else:
4057 
          iprot.skip(ftype)
4058 
      elif fid == 1:
4059 
        if ftype == TType.STRUCT:
559 chandransh 4060 
          self.ucex = UserContextException()
4061 
          self.ucex.read(iprot)
94 ashish 4062 
        else:
4063 
          iprot.skip(ftype)
4064 
      else:
4065 
        iprot.skip(ftype)
4066 
      iprot.readFieldEnd()
4067 
    iprot.readStructEnd()
4068 
 
4069 
  def write(self, oprot):
4070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4072 
      return
559 chandransh 4073 
    oprot.writeStructBegin('getUserById_result')
94 ashish 4074 
    if self.success != None:
4075 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4076 
      self.success.write(oprot)
4077 
      oprot.writeFieldEnd()
559 chandransh 4078 
    if self.ucex != None:
4079 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4080 
      self.ucex.write(oprot)
94 ashish 4081 
      oprot.writeFieldEnd()
4082 
    oprot.writeFieldStop()
4083 
    oprot.writeStructEnd()
4084 
 
4085 
  def __repr__(self):
4086 
    L = ['%s=%r' % (key, value)
4087 
      for key, value in self.__dict__.iteritems()]
4088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4089 
 
4090 
  def __eq__(self, other):
4091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4092 
 
4093 
  def __ne__(self, other):
4094 
    return not (self == other)
4095 
 
1491 vikas 4096 
class getUserByEmail_args:
4097 
  """
4098 
  Attributes:
4099 
   - email
4100 
  """
4101 
 
4102 
  thrift_spec = (
4103 
    None, # 0
4104 
    (1, TType.STRING, 'email', None, None, ), # 1
4105 
  )
4106 
 
4107 
  def __init__(self, email=None,):
4108 
    self.email = email
4109 
 
4110 
  def read(self, iprot):
4111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4113 
      return
4114 
    iprot.readStructBegin()
4115 
    while True:
4116 
      (fname, ftype, fid) = iprot.readFieldBegin()
4117 
      if ftype == TType.STOP:
4118 
        break
4119 
      if fid == 1:
4120 
        if ftype == TType.STRING:
4121 
          self.email = iprot.readString();
4122 
        else:
4123 
          iprot.skip(ftype)
4124 
      else:
4125 
        iprot.skip(ftype)
4126 
      iprot.readFieldEnd()
4127 
    iprot.readStructEnd()
4128 
 
4129 
  def write(self, oprot):
4130 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4131 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4132 
      return
4133 
    oprot.writeStructBegin('getUserByEmail_args')
4134 
    if self.email != None:
4135 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4136 
      oprot.writeString(self.email)
4137 
      oprot.writeFieldEnd()
4138 
    oprot.writeFieldStop()
4139 
    oprot.writeStructEnd()
4140 
 
4141 
  def __repr__(self):
4142 
    L = ['%s=%r' % (key, value)
4143 
      for key, value in self.__dict__.iteritems()]
4144 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4145 
 
4146 
  def __eq__(self, other):
4147 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4148 
 
4149 
  def __ne__(self, other):
4150 
    return not (self == other)
4151 
 
4152 
class getUserByEmail_result:
4153 
  """
4154 
  Attributes:
4155 
   - success
4156 
   - ucex
4157 
  """
4158 
 
4159 
  thrift_spec = (
4160 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4161 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4162 
  )
4163 
 
4164 
  def __init__(self, success=None, ucex=None,):
4165 
    self.success = success
4166 
    self.ucex = ucex
4167 
 
4168 
  def read(self, iprot):
4169 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4170 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4171 
      return
4172 
    iprot.readStructBegin()
4173 
    while True:
4174 
      (fname, ftype, fid) = iprot.readFieldBegin()
4175 
      if ftype == TType.STOP:
4176 
        break
4177 
      if fid == 0:
4178 
        if ftype == TType.STRUCT:
4179 
          self.success = User()
4180 
          self.success.read(iprot)
4181 
        else:
4182 
          iprot.skip(ftype)
4183 
      elif fid == 1:
4184 
        if ftype == TType.STRUCT:
4185 
          self.ucex = UserContextException()
4186 
          self.ucex.read(iprot)
4187 
        else:
4188 
          iprot.skip(ftype)
4189 
      else:
4190 
        iprot.skip(ftype)
4191 
      iprot.readFieldEnd()
4192 
    iprot.readStructEnd()
4193 
 
4194 
  def write(self, oprot):
4195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4197 
      return
4198 
    oprot.writeStructBegin('getUserByEmail_result')
4199 
    if self.success != None:
4200 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4201 
      self.success.write(oprot)
4202 
      oprot.writeFieldEnd()
4203 
    if self.ucex != None:
4204 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4205 
      self.ucex.write(oprot)
4206 
      oprot.writeFieldEnd()
4207 
    oprot.writeFieldStop()
4208 
    oprot.writeStructEnd()
4209 
 
4210 
  def __repr__(self):
4211 
    L = ['%s=%r' % (key, value)
4212 
      for key, value in self.__dict__.iteritems()]
4213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4214 
 
4215 
  def __eq__(self, other):
4216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4217 
 
4218 
  def __ne__(self, other):
4219 
    return not (self == other)
4220 
 
3032 mandeep.dh 4221 
class getUserByMobileNumber_args:
4222 
  """
4223 
  Attributes:
4224 
   - mobileNumber
4225 
  """
4226 
 
4227 
  thrift_spec = (
4228 
    None, # 0
4229 
    (1, TType.I64, 'mobileNumber', None, None, ), # 1
4230 
  )
4231 
 
4232 
  def __init__(self, mobileNumber=None,):
4233 
    self.mobileNumber = mobileNumber
4234 
 
4235 
  def read(self, iprot):
4236 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4237 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4238 
      return
4239 
    iprot.readStructBegin()
4240 
    while True:
4241 
      (fname, ftype, fid) = iprot.readFieldBegin()
4242 
      if ftype == TType.STOP:
4243 
        break
4244 
      if fid == 1:
4245 
        if ftype == TType.I64:
4246 
          self.mobileNumber = iprot.readI64();
4247 
        else:
4248 
          iprot.skip(ftype)
4249 
      else:
4250 
        iprot.skip(ftype)
4251 
      iprot.readFieldEnd()
4252 
    iprot.readStructEnd()
4253 
 
4254 
  def write(self, oprot):
4255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4257 
      return
4258 
    oprot.writeStructBegin('getUserByMobileNumber_args')
4259 
    if self.mobileNumber != None:
4260 
      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
4261 
      oprot.writeI64(self.mobileNumber)
4262 
      oprot.writeFieldEnd()
4263 
    oprot.writeFieldStop()
4264 
    oprot.writeStructEnd()
4265 
 
4266 
  def __repr__(self):
4267 
    L = ['%s=%r' % (key, value)
4268 
      for key, value in self.__dict__.iteritems()]
4269 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4270 
 
4271 
  def __eq__(self, other):
4272 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4273 
 
4274 
  def __ne__(self, other):
4275 
    return not (self == other)
4276 
 
4277 
class getUserByMobileNumber_result:
4278 
  """
4279 
  Attributes:
4280 
   - success
4281 
   - ucex
4282 
  """
4283 
 
4284 
  thrift_spec = (
4285 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4286 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4287 
  )
4288 
 
4289 
  def __init__(self, success=None, ucex=None,):
4290 
    self.success = success
4291 
    self.ucex = ucex
4292 
 
4293 
  def read(self, iprot):
4294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4296 
      return
4297 
    iprot.readStructBegin()
4298 
    while True:
4299 
      (fname, ftype, fid) = iprot.readFieldBegin()
4300 
      if ftype == TType.STOP:
4301 
        break
4302 
      if fid == 0:
4303 
        if ftype == TType.STRUCT:
4304 
          self.success = User()
4305 
          self.success.read(iprot)
4306 
        else:
4307 
          iprot.skip(ftype)
4308 
      elif fid == 1:
4309 
        if ftype == TType.STRUCT:
4310 
          self.ucex = UserContextException()
4311 
          self.ucex.read(iprot)
4312 
        else:
4313 
          iprot.skip(ftype)
4314 
      else:
4315 
        iprot.skip(ftype)
4316 
      iprot.readFieldEnd()
4317 
    iprot.readStructEnd()
4318 
 
4319 
  def write(self, oprot):
4320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4322 
      return
4323 
    oprot.writeStructBegin('getUserByMobileNumber_result')
4324 
    if self.success != None:
4325 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4326 
      self.success.write(oprot)
4327 
      oprot.writeFieldEnd()
4328 
    if self.ucex != None:
4329 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4330 
      self.ucex.write(oprot)
4331 
      oprot.writeFieldEnd()
4332 
    oprot.writeFieldStop()
4333 
    oprot.writeStructEnd()
4334 
 
4335 
  def __repr__(self):
4336 
    L = ['%s=%r' % (key, value)
4337 
      for key, value in self.__dict__.iteritems()]
4338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4339 
 
4340 
  def __eq__(self, other):
4341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4342 
 
4343 
  def __ne__(self, other):
4344 
    return not (self == other)
4345 
 
559 chandransh 4346 
class createUser_args:
94 ashish 4347 
  """
4348 
  Attributes:
559 chandransh 4349 
   - user
94 ashish 4350 
  """
4351 
 
4352 
  thrift_spec = (
4353 
    None, # 0
559 chandransh 4354 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4355 
  )
4356 
 
559 chandransh 4357 
  def __init__(self, user=None,):
4358 
    self.user = user
94 ashish 4359 
 
4360 
  def read(self, iprot):
4361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4363 
      return
4364 
    iprot.readStructBegin()
4365 
    while True:
4366 
      (fname, ftype, fid) = iprot.readFieldBegin()
4367 
      if ftype == TType.STOP:
4368 
        break
4369 
      if fid == 1:
559 chandransh 4370 
        if ftype == TType.STRUCT:
4371 
          self.user = User()
4372 
          self.user.read(iprot)
94 ashish 4373 
        else:
4374 
          iprot.skip(ftype)
4375 
      else:
4376 
        iprot.skip(ftype)
4377 
      iprot.readFieldEnd()
4378 
    iprot.readStructEnd()
4379 
 
4380 
  def write(self, oprot):
4381 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4382 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4383 
      return
559 chandransh 4384 
    oprot.writeStructBegin('createUser_args')
4385 
    if self.user != None:
4386 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4387 
      self.user.write(oprot)
94 ashish 4388 
      oprot.writeFieldEnd()
4389 
    oprot.writeFieldStop()
4390 
    oprot.writeStructEnd()
4391 
 
4392 
  def __repr__(self):
4393 
    L = ['%s=%r' % (key, value)
4394 
      for key, value in self.__dict__.iteritems()]
4395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4396 
 
4397 
  def __eq__(self, other):
4398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4399 
 
4400 
  def __ne__(self, other):
4401 
    return not (self == other)
4402 
 
559 chandransh 4403 
class createUser_result:
94 ashish 4404 
  """
4405 
  Attributes:
4406 
   - success
559 chandransh 4407 
   - ucex
94 ashish 4408 
  """
4409 
 
4410 
  thrift_spec = (
559 chandransh 4411 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4412 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4413 
  )
4414 
 
559 chandransh 4415 
  def __init__(self, success=None, ucex=None,):
94 ashish 4416 
    self.success = success
559 chandransh 4417 
    self.ucex = ucex
94 ashish 4418 
 
4419 
  def read(self, iprot):
4420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4422 
      return
4423 
    iprot.readStructBegin()
4424 
    while True:
4425 
      (fname, ftype, fid) = iprot.readFieldBegin()
4426 
      if ftype == TType.STOP:
4427 
        break
4428 
      if fid == 0:
4429 
        if ftype == TType.STRUCT:
559 chandransh 4430 
          self.success = User()
94 ashish 4431 
          self.success.read(iprot)
4432 
        else:
4433 
          iprot.skip(ftype)
4434 
      elif fid == 1:
4435 
        if ftype == TType.STRUCT:
559 chandransh 4436 
          self.ucex = UserContextException()
4437 
          self.ucex.read(iprot)
94 ashish 4438 
        else:
4439 
          iprot.skip(ftype)
4440 
      else:
4441 
        iprot.skip(ftype)
4442 
      iprot.readFieldEnd()
4443 
    iprot.readStructEnd()
4444 
 
4445 
  def write(self, oprot):
4446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4448 
      return
559 chandransh 4449 
    oprot.writeStructBegin('createUser_result')
94 ashish 4450 
    if self.success != None:
4451 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4452 
      self.success.write(oprot)
4453 
      oprot.writeFieldEnd()
559 chandransh 4454 
    if self.ucex != None:
4455 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4456 
      self.ucex.write(oprot)
94 ashish 4457 
      oprot.writeFieldEnd()
4458 
    oprot.writeFieldStop()
4459 
    oprot.writeStructEnd()
4460 
 
4461 
  def __repr__(self):
4462 
    L = ['%s=%r' % (key, value)
4463 
      for key, value in self.__dict__.iteritems()]
4464 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4465 
 
4466 
  def __eq__(self, other):
4467 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4468 
 
4469 
  def __ne__(self, other):
4470 
    return not (self == other)
4471 
 
559 chandransh 4472 
class updateUser_args:
94 ashish 4473 
  """
4474 
  Attributes:
559 chandransh 4475 
   - user
94 ashish 4476 
  """
4477 
 
4478 
  thrift_spec = (
4479 
    None, # 0
559 chandransh 4480 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4481 
  )
4482 
 
559 chandransh 4483 
  def __init__(self, user=None,):
4484 
    self.user = user
94 ashish 4485 
 
4486 
  def read(self, iprot):
4487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4489 
      return
4490 
    iprot.readStructBegin()
4491 
    while True:
4492 
      (fname, ftype, fid) = iprot.readFieldBegin()
4493 
      if ftype == TType.STOP:
4494 
        break
4495 
      if fid == 1:
559 chandransh 4496 
        if ftype == TType.STRUCT:
4497 
          self.user = User()
4498 
          self.user.read(iprot)
94 ashish 4499 
        else:
4500 
          iprot.skip(ftype)
4501 
      else:
4502 
        iprot.skip(ftype)
4503 
      iprot.readFieldEnd()
4504 
    iprot.readStructEnd()
4505 
 
4506 
  def write(self, oprot):
4507 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4508 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4509 
      return
559 chandransh 4510 
    oprot.writeStructBegin('updateUser_args')
4511 
    if self.user != None:
4512 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4513 
      self.user.write(oprot)
94 ashish 4514 
      oprot.writeFieldEnd()
4515 
    oprot.writeFieldStop()
4516 
    oprot.writeStructEnd()
4517 
 
4518 
  def __repr__(self):
4519 
    L = ['%s=%r' % (key, value)
4520 
      for key, value in self.__dict__.iteritems()]
4521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4522 
 
4523 
  def __eq__(self, other):
4524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4525 
 
4526 
  def __ne__(self, other):
4527 
    return not (self == other)
4528 
 
559 chandransh 4529 
class updateUser_result:
94 ashish 4530 
  """
4531 
  Attributes:
4532 
   - success
559 chandransh 4533 
   - ucex
94 ashish 4534 
  """
4535 
 
4536 
  thrift_spec = (
559 chandransh 4537 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4538 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4539 
  )
4540 
 
559 chandransh 4541 
  def __init__(self, success=None, ucex=None,):
94 ashish 4542 
    self.success = success
559 chandransh 4543 
    self.ucex = ucex
94 ashish 4544 
 
4545 
  def read(self, iprot):
4546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4548 
      return
4549 
    iprot.readStructBegin()
4550 
    while True:
4551 
      (fname, ftype, fid) = iprot.readFieldBegin()
4552 
      if ftype == TType.STOP:
4553 
        break
4554 
      if fid == 0:
4555 
        if ftype == TType.STRUCT:
559 chandransh 4556 
          self.success = User()
94 ashish 4557 
          self.success.read(iprot)
4558 
        else:
4559 
          iprot.skip(ftype)
4560 
      elif fid == 1:
4561 
        if ftype == TType.STRUCT:
559 chandransh 4562 
          self.ucex = UserContextException()
4563 
          self.ucex.read(iprot)
94 ashish 4564 
        else:
4565 
          iprot.skip(ftype)
4566 
      else:
4567 
        iprot.skip(ftype)
4568 
      iprot.readFieldEnd()
4569 
    iprot.readStructEnd()
4570 
 
4571 
  def write(self, oprot):
4572 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4573 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4574 
      return
559 chandransh 4575 
    oprot.writeStructBegin('updateUser_result')
94 ashish 4576 
    if self.success != None:
4577 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4578 
      self.success.write(oprot)
4579 
      oprot.writeFieldEnd()
559 chandransh 4580 
    if self.ucex != None:
4581 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4582 
      self.ucex.write(oprot)
94 ashish 4583 
      oprot.writeFieldEnd()
4584 
    oprot.writeFieldStop()
4585 
    oprot.writeStructEnd()
4586 
 
4587 
  def __repr__(self):
4588 
    L = ['%s=%r' % (key, value)
4589 
      for key, value in self.__dict__.iteritems()]
4590 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4591 
 
4592 
  def __eq__(self, other):
4593 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4594 
 
4595 
  def __ne__(self, other):
4596 
    return not (self == other)
4597 
 
559 chandransh 4598 
class deleteUser_args:
94 ashish 4599 
  """
4600 
  Attributes:
4601 
   - userId
4602 
  """
4603 
 
4604 
  thrift_spec = (
4605 
    None, # 0
4606 
    (1, TType.I64, 'userId', None, None, ), # 1
4607 
  )
4608 
 
559 chandransh 4609 
  def __init__(self, userId=None,):
94 ashish 4610 
    self.userId = userId
4611 
 
4612 
  def read(self, iprot):
4613 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4614 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4615 
      return
4616 
    iprot.readStructBegin()
4617 
    while True:
4618 
      (fname, ftype, fid) = iprot.readFieldBegin()
4619 
      if ftype == TType.STOP:
4620 
        break
4621 
      if fid == 1:
4622 
        if ftype == TType.I64:
4623 
          self.userId = iprot.readI64();
4624 
        else:
4625 
          iprot.skip(ftype)
4626 
      else:
4627 
        iprot.skip(ftype)
4628 
      iprot.readFieldEnd()
4629 
    iprot.readStructEnd()
4630 
 
4631 
  def write(self, oprot):
4632 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4633 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4634 
      return
559 chandransh 4635 
    oprot.writeStructBegin('deleteUser_args')
94 ashish 4636 
    if self.userId != None:
4637 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4638 
      oprot.writeI64(self.userId)
4639 
      oprot.writeFieldEnd()
4640 
    oprot.writeFieldStop()
4641 
    oprot.writeStructEnd()
4642 
 
4643 
  def __repr__(self):
4644 
    L = ['%s=%r' % (key, value)
4645 
      for key, value in self.__dict__.iteritems()]
4646 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4647 
 
4648 
  def __eq__(self, other):
4649 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4650 
 
4651 
  def __ne__(self, other):
4652 
    return not (self == other)
4653 
 
559 chandransh 4654 
class deleteUser_result:
94 ashish 4655 
  """
4656 
  Attributes:
4657 
   - success
559 chandransh 4658 
   - ucex
94 ashish 4659 
  """
4660 
 
4661 
  thrift_spec = (
559 chandransh 4662 
    (0, TType.BOOL, 'success', None, None, ), # 0
4663 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4664 
  )
4665 
 
559 chandransh 4666 
  def __init__(self, success=None, ucex=None,):
94 ashish 4667 
    self.success = success
559 chandransh 4668 
    self.ucex = ucex
94 ashish 4669 
 
4670 
  def read(self, iprot):
4671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4673 
      return
4674 
    iprot.readStructBegin()
4675 
    while True:
4676 
      (fname, ftype, fid) = iprot.readFieldBegin()
4677 
      if ftype == TType.STOP:
4678 
        break
4679 
      if fid == 0:
559 chandransh 4680 
        if ftype == TType.BOOL:
4681 
          self.success = iprot.readBool();
94 ashish 4682 
        else:
4683 
          iprot.skip(ftype)
4684 
      elif fid == 1:
4685 
        if ftype == TType.STRUCT:
559 chandransh 4686 
          self.ucex = UserContextException()
4687 
          self.ucex.read(iprot)
94 ashish 4688 
        else:
4689 
          iprot.skip(ftype)
4690 
      else:
4691 
        iprot.skip(ftype)
4692 
      iprot.readFieldEnd()
4693 
    iprot.readStructEnd()
4694 
 
4695 
  def write(self, oprot):
4696 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4697 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4698 
      return
559 chandransh 4699 
    oprot.writeStructBegin('deleteUser_result')
94 ashish 4700 
    if self.success != None:
559 chandransh 4701 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4702 
      oprot.writeBool(self.success)
94 ashish 4703 
      oprot.writeFieldEnd()
559 chandransh 4704 
    if self.ucex != None:
4705 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4706 
      self.ucex.write(oprot)
94 ashish 4707 
      oprot.writeFieldEnd()
4708 
    oprot.writeFieldStop()
4709 
    oprot.writeStructEnd()
4710 
 
4711 
  def __repr__(self):
4712 
    L = ['%s=%r' % (key, value)
4713 
      for key, value in self.__dict__.iteritems()]
4714 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4715 
 
4716 
  def __eq__(self, other):
4717 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4718 
 
4719 
  def __ne__(self, other):
4720 
    return not (self == other)
4721 
 
559 chandransh 4722 
class getUserState_args:
94 ashish 4723 
  """
4724 
  Attributes:
4725 
   - userId
4726 
  """
4727 
 
4728 
  thrift_spec = (
4729 
    None, # 0
4730 
    (1, TType.I64, 'userId', None, None, ), # 1
4731 
  )
4732 
 
559 chandransh 4733 
  def __init__(self, userId=None,):
94 ashish 4734 
    self.userId = userId
4735 
 
4736 
  def read(self, iprot):
4737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4739 
      return
4740 
    iprot.readStructBegin()
4741 
    while True:
4742 
      (fname, ftype, fid) = iprot.readFieldBegin()
4743 
      if ftype == TType.STOP:
4744 
        break
4745 
      if fid == 1:
4746 
        if ftype == TType.I64:
4747 
          self.userId = iprot.readI64();
4748 
        else:
4749 
          iprot.skip(ftype)
4750 
      else:
4751 
        iprot.skip(ftype)
4752 
      iprot.readFieldEnd()
4753 
    iprot.readStructEnd()
4754 
 
4755 
  def write(self, oprot):
4756 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4757 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4758 
      return
559 chandransh 4759 
    oprot.writeStructBegin('getUserState_args')
94 ashish 4760 
    if self.userId != None:
4761 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4762 
      oprot.writeI64(self.userId)
4763 
      oprot.writeFieldEnd()
4764 
    oprot.writeFieldStop()
4765 
    oprot.writeStructEnd()
4766 
 
4767 
  def __repr__(self):
4768 
    L = ['%s=%r' % (key, value)
4769 
      for key, value in self.__dict__.iteritems()]
4770 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4771 
 
4772 
  def __eq__(self, other):
4773 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4774 
 
4775 
  def __ne__(self, other):
4776 
    return not (self == other)
4777 
 
559 chandransh 4778 
class getUserState_result:
94 ashish 4779 
  """
4780 
  Attributes:
4781 
   - success
559 chandransh 4782 
   - ucex
94 ashish 4783 
  """
4784 
 
4785 
  thrift_spec = (
559 chandransh 4786 
    (0, TType.STRUCT, 'success', (UserState, UserState.thrift_spec), None, ), # 0
4787 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4788 
  )
4789 
 
559 chandransh 4790 
  def __init__(self, success=None, ucex=None,):
94 ashish 4791 
    self.success = success
559 chandransh 4792 
    self.ucex = ucex
94 ashish 4793 
 
4794 
  def read(self, iprot):
4795 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4796 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4797 
      return
4798 
    iprot.readStructBegin()
4799 
    while True:
4800 
      (fname, ftype, fid) = iprot.readFieldBegin()
4801 
      if ftype == TType.STOP:
4802 
        break
4803 
      if fid == 0:
4804 
        if ftype == TType.STRUCT:
559 chandransh 4805 
          self.success = UserState()
94 ashish 4806 
          self.success.read(iprot)
4807 
        else:
4808 
          iprot.skip(ftype)
4809 
      elif fid == 1:
4810 
        if ftype == TType.STRUCT:
559 chandransh 4811 
          self.ucex = UserContextException()
4812 
          self.ucex.read(iprot)
94 ashish 4813 
        else:
4814 
          iprot.skip(ftype)
4815 
      else:
4816 
        iprot.skip(ftype)
4817 
      iprot.readFieldEnd()
4818 
    iprot.readStructEnd()
4819 
 
4820 
  def write(self, oprot):
4821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4823 
      return
559 chandransh 4824 
    oprot.writeStructBegin('getUserState_result')
94 ashish 4825 
    if self.success != None:
4826 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4827 
      self.success.write(oprot)
4828 
      oprot.writeFieldEnd()
559 chandransh 4829 
    if self.ucex != None:
4830 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4831 
      self.ucex.write(oprot)
94 ashish 4832 
      oprot.writeFieldEnd()
4833 
    oprot.writeFieldStop()
4834 
    oprot.writeStructEnd()
4835 
 
4836 
  def __repr__(self):
4837 
    L = ['%s=%r' % (key, value)
4838 
      for key, value in self.__dict__.iteritems()]
4839 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4840 
 
4841 
  def __eq__(self, other):
4842 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4843 
 
4844 
  def __ne__(self, other):
4845 
    return not (self == other)
4846 
 
559 chandransh 4847 
class authenticateUser_args:
94 ashish 4848 
  """
4849 
  Attributes:
4850 
   - email
4851 
   - password
4852 
  """
4853 
 
4854 
  thrift_spec = (
4855 
    None, # 0
4856 
    (1, TType.STRING, 'email', None, None, ), # 1
4857 
    (2, TType.STRING, 'password', None, None, ), # 2
4858 
  )
4859 
 
4860 
  def __init__(self, email=None, password=None,):
4861 
    self.email = email
4862 
    self.password = password
4863 
 
4864 
  def read(self, iprot):
4865 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4866 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4867 
      return
4868 
    iprot.readStructBegin()
4869 
    while True:
4870 
      (fname, ftype, fid) = iprot.readFieldBegin()
4871 
      if ftype == TType.STOP:
4872 
        break
4873 
      if fid == 1:
4874 
        if ftype == TType.STRING:
4875 
          self.email = iprot.readString();
4876 
        else:
4877 
          iprot.skip(ftype)
4878 
      elif fid == 2:
4879 
        if ftype == TType.STRING:
4880 
          self.password = iprot.readString();
4881 
        else:
4882 
          iprot.skip(ftype)
4883 
      else:
4884 
        iprot.skip(ftype)
4885 
      iprot.readFieldEnd()
4886 
    iprot.readStructEnd()
4887 
 
4888 
  def write(self, oprot):
4889 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4890 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4891 
      return
559 chandransh 4892 
    oprot.writeStructBegin('authenticateUser_args')
94 ashish 4893 
    if self.email != None:
4894 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4895 
      oprot.writeString(self.email)
4896 
      oprot.writeFieldEnd()
4897 
    if self.password != None:
4898 
      oprot.writeFieldBegin('password', TType.STRING, 2)
4899 
      oprot.writeString(self.password)
4900 
      oprot.writeFieldEnd()
4901 
    oprot.writeFieldStop()
4902 
    oprot.writeStructEnd()
4903 
 
4904 
  def __repr__(self):
4905 
    L = ['%s=%r' % (key, value)
4906 
      for key, value in self.__dict__.iteritems()]
4907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4908 
 
4909 
  def __eq__(self, other):
4910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4911 
 
4912 
  def __ne__(self, other):
4913 
    return not (self == other)
4914 
 
559 chandransh 4915 
class authenticateUser_result:
94 ashish 4916 
  """
4917 
  Attributes:
4918 
   - success
559 chandransh 4919 
   - auex
94 ashish 4920 
  """
4921 
 
4922 
  thrift_spec = (
559 chandransh 4923 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4924 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 4925 
  )
4926 
 
559 chandransh 4927 
  def __init__(self, success=None, auex=None,):
94 ashish 4928 
    self.success = success
559 chandransh 4929 
    self.auex = auex
94 ashish 4930 
 
4931 
  def read(self, iprot):
4932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4934 
      return
4935 
    iprot.readStructBegin()
4936 
    while True:
4937 
      (fname, ftype, fid) = iprot.readFieldBegin()
4938 
      if ftype == TType.STOP:
4939 
        break
4940 
      if fid == 0:
4941 
        if ftype == TType.STRUCT:
559 chandransh 4942 
          self.success = User()
94 ashish 4943 
          self.success.read(iprot)
4944 
        else:
4945 
          iprot.skip(ftype)
4946 
      elif fid == 1:
4947 
        if ftype == TType.STRUCT:
559 chandransh 4948 
          self.auex = AuthenticationException()
4949 
          self.auex.read(iprot)
94 ashish 4950 
        else:
4951 
          iprot.skip(ftype)
4952 
      else:
4953 
        iprot.skip(ftype)
4954 
      iprot.readFieldEnd()
4955 
    iprot.readStructEnd()
4956 
 
4957 
  def write(self, oprot):
4958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4960 
      return
559 chandransh 4961 
    oprot.writeStructBegin('authenticateUser_result')
94 ashish 4962 
    if self.success != None:
4963 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4964 
      self.success.write(oprot)
4965 
      oprot.writeFieldEnd()
559 chandransh 4966 
    if self.auex != None:
4967 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
4968 
      self.auex.write(oprot)
94 ashish 4969 
      oprot.writeFieldEnd()
4970 
    oprot.writeFieldStop()
4971 
    oprot.writeStructEnd()
4972 
 
4973 
  def __repr__(self):
4974 
    L = ['%s=%r' % (key, value)
4975 
      for key, value in self.__dict__.iteritems()]
4976 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4977 
 
4978 
  def __eq__(self, other):
4979 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4980 
 
4981 
  def __ne__(self, other):
4982 
    return not (self == other)
4983 
 
559 chandransh 4984 
class userExists_args:
122 ashish 4985 
  """
4986 
  Attributes:
559 chandransh 4987 
   - email
122 ashish 4988 
  """
4989 
 
4990 
  thrift_spec = (
4991 
    None, # 0
559 chandransh 4992 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 4993 
  )
4994 
 
559 chandransh 4995 
  def __init__(self, email=None,):
4996 
    self.email = email
122 ashish 4997 
 
4998 
  def read(self, iprot):
4999 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5000 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5001 
      return
5002 
    iprot.readStructBegin()
5003 
    while True:
5004 
      (fname, ftype, fid) = iprot.readFieldBegin()
5005 
      if ftype == TType.STOP:
5006 
        break
5007 
      if fid == 1:
5008 
        if ftype == TType.STRING:
559 chandransh 5009 
          self.email = iprot.readString();
122 ashish 5010 
        else:
5011 
          iprot.skip(ftype)
559 chandransh 5012 
      else:
5013 
        iprot.skip(ftype)
5014 
      iprot.readFieldEnd()
5015 
    iprot.readStructEnd()
5016 
 
5017 
  def write(self, oprot):
5018 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5019 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5020 
      return
5021 
    oprot.writeStructBegin('userExists_args')
5022 
    if self.email != None:
5023 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5024 
      oprot.writeString(self.email)
5025 
      oprot.writeFieldEnd()
5026 
    oprot.writeFieldStop()
5027 
    oprot.writeStructEnd()
5028 
 
5029 
  def __repr__(self):
5030 
    L = ['%s=%r' % (key, value)
5031 
      for key, value in self.__dict__.iteritems()]
5032 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5033 
 
5034 
  def __eq__(self, other):
5035 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5036 
 
5037 
  def __ne__(self, other):
5038 
    return not (self == other)
5039 
 
5040 
class userExists_result:
5041 
  """
5042 
  Attributes:
5043 
   - success
5044 
   - ucx
5045 
  """
5046 
 
5047 
  thrift_spec = (
5048 
    (0, TType.BOOL, 'success', None, None, ), # 0
5049 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5050 
  )
5051 
 
5052 
  def __init__(self, success=None, ucx=None,):
5053 
    self.success = success
5054 
    self.ucx = ucx
5055 
 
5056 
  def read(self, iprot):
5057 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5058 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5059 
      return
5060 
    iprot.readStructBegin()
5061 
    while True:
5062 
      (fname, ftype, fid) = iprot.readFieldBegin()
5063 
      if ftype == TType.STOP:
5064 
        break
5065 
      if fid == 0:
5066 
        if ftype == TType.BOOL:
5067 
          self.success = iprot.readBool();
5068 
        else:
5069 
          iprot.skip(ftype)
5070 
      elif fid == 1:
5071 
        if ftype == TType.STRUCT:
5072 
          self.ucx = UserContextException()
5073 
          self.ucx.read(iprot)
5074 
        else:
5075 
          iprot.skip(ftype)
5076 
      else:
5077 
        iprot.skip(ftype)
5078 
      iprot.readFieldEnd()
5079 
    iprot.readStructEnd()
5080 
 
5081 
  def write(self, oprot):
5082 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5083 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5084 
      return
5085 
    oprot.writeStructBegin('userExists_result')
5086 
    if self.success != None:
5087 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5088 
      oprot.writeBool(self.success)
5089 
      oprot.writeFieldEnd()
5090 
    if self.ucx != None:
5091 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5092 
      self.ucx.write(oprot)
5093 
      oprot.writeFieldEnd()
5094 
    oprot.writeFieldStop()
5095 
    oprot.writeStructEnd()
5096 
 
5097 
  def __repr__(self):
5098 
    L = ['%s=%r' % (key, value)
5099 
      for key, value in self.__dict__.iteritems()]
5100 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5101 
 
5102 
  def __eq__(self, other):
5103 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5104 
 
5105 
  def __ne__(self, other):
5106 
    return not (self == other)
5107 
 
5108 
class addAddressForUser_args:
5109 
  """
5110 
  Attributes:
5111 
   - userId
5112 
   - address
5113 
   - setDefault
5114 
  """
5115 
 
5116 
  thrift_spec = (
5117 
    None, # 0
5118 
    (1, TType.I64, 'userId', None, None, ), # 1
5119 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 5120 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 5121 
  )
5122 
 
567 rajveer 5123 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 5124 
    self.userId = userId
5125 
    self.address = address
5126 
    self.setDefault = setDefault
5127 
 
5128 
  def read(self, iprot):
5129 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5130 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5131 
      return
5132 
    iprot.readStructBegin()
5133 
    while True:
5134 
      (fname, ftype, fid) = iprot.readFieldBegin()
5135 
      if ftype == TType.STOP:
5136 
        break
5137 
      if fid == 1:
5138 
        if ftype == TType.I64:
5139 
          self.userId = iprot.readI64();
5140 
        else:
5141 
          iprot.skip(ftype)
122 ashish 5142 
      elif fid == 2:
559 chandransh 5143 
        if ftype == TType.STRUCT:
5144 
          self.address = Address()
5145 
          self.address.read(iprot)
122 ashish 5146 
        else:
5147 
          iprot.skip(ftype)
5148 
      elif fid == 3:
5149 
        if ftype == TType.BOOL:
559 chandransh 5150 
          self.setDefault = iprot.readBool();
122 ashish 5151 
        else:
5152 
          iprot.skip(ftype)
5153 
      else:
5154 
        iprot.skip(ftype)
5155 
      iprot.readFieldEnd()
5156 
    iprot.readStructEnd()
5157 
 
5158 
  def write(self, oprot):
5159 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5160 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5161 
      return
559 chandransh 5162 
    oprot.writeStructBegin('addAddressForUser_args')
5163 
    if self.userId != None:
5164 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5165 
      oprot.writeI64(self.userId)
122 ashish 5166 
      oprot.writeFieldEnd()
559 chandransh 5167 
    if self.address != None:
5168 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
5169 
      self.address.write(oprot)
122 ashish 5170 
      oprot.writeFieldEnd()
559 chandransh 5171 
    if self.setDefault != None:
567 rajveer 5172 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 5173 
      oprot.writeBool(self.setDefault)
5174 
      oprot.writeFieldEnd()
122 ashish 5175 
    oprot.writeFieldStop()
5176 
    oprot.writeStructEnd()
5177 
 
5178 
  def __repr__(self):
5179 
    L = ['%s=%r' % (key, value)
5180 
      for key, value in self.__dict__.iteritems()]
5181 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5182 
 
5183 
  def __eq__(self, other):
5184 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5185 
 
5186 
  def __ne__(self, other):
5187 
    return not (self == other)
5188 
 
559 chandransh 5189 
class addAddressForUser_result:
122 ashish 5190 
  """
5191 
  Attributes:
5192 
   - success
559 chandransh 5193 
   - ucx
122 ashish 5194 
  """
5195 
 
5196 
  thrift_spec = (
567 rajveer 5197 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 5198 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 5199 
  )
5200 
 
559 chandransh 5201 
  def __init__(self, success=None, ucx=None,):
122 ashish 5202 
    self.success = success
559 chandransh 5203 
    self.ucx = ucx
122 ashish 5204 
 
5205 
  def read(self, iprot):
5206 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5207 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5208 
      return
5209 
    iprot.readStructBegin()
5210 
    while True:
5211 
      (fname, ftype, fid) = iprot.readFieldBegin()
5212 
      if ftype == TType.STOP:
5213 
        break
5214 
      if fid == 0:
567 rajveer 5215 
        if ftype == TType.I64:
5216 
          self.success = iprot.readI64();
122 ashish 5217 
        else:
5218 
          iprot.skip(ftype)
5219 
      elif fid == 1:
5220 
        if ftype == TType.STRUCT:
559 chandransh 5221 
          self.ucx = UserContextException()
5222 
          self.ucx.read(iprot)
122 ashish 5223 
        else:
5224 
          iprot.skip(ftype)
5225 
      else:
5226 
        iprot.skip(ftype)
5227 
      iprot.readFieldEnd()
5228 
    iprot.readStructEnd()
5229 
 
5230 
  def write(self, oprot):
5231 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5232 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5233 
      return
559 chandransh 5234 
    oprot.writeStructBegin('addAddressForUser_result')
122 ashish 5235 
    if self.success != None:
567 rajveer 5236 
      oprot.writeFieldBegin('success', TType.I64, 0)
5237 
      oprot.writeI64(self.success)
122 ashish 5238 
      oprot.writeFieldEnd()
559 chandransh 5239 
    if self.ucx != None:
5240 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5241 
      self.ucx.write(oprot)
122 ashish 5242 
      oprot.writeFieldEnd()
5243 
    oprot.writeFieldStop()
5244 
    oprot.writeStructEnd()
5245 
 
5246 
  def __repr__(self):
5247 
    L = ['%s=%r' % (key, value)
5248 
      for key, value in self.__dict__.iteritems()]
5249 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5250 
 
5251 
  def __eq__(self, other):
5252 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5253 
 
5254 
  def __ne__(self, other):
5255 
    return not (self == other)
5256 
 
559 chandransh 5257 
class removeAddressForUser_args:
94 ashish 5258 
  """
5259 
  Attributes:
559 chandransh 5260 
   - userid
5261 
   - addressId
94 ashish 5262 
  """
5263 
 
5264 
  thrift_spec = (
5265 
    None, # 0
559 chandransh 5266 
    (1, TType.I64, 'userid', None, None, ), # 1
5267 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 5268 
  )
5269 
 
559 chandransh 5270 
  def __init__(self, userid=None, addressId=None,):
5271 
    self.userid = userid
5272 
    self.addressId = addressId
94 ashish 5273 
 
5274 
  def read(self, iprot):
5275 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5276 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5277 
      return
5278 
    iprot.readStructBegin()
5279 
    while True:
5280 
      (fname, ftype, fid) = iprot.readFieldBegin()
5281 
      if ftype == TType.STOP:
5282 
        break
5283 
      if fid == 1:
559 chandransh 5284 
        if ftype == TType.I64:
5285 
          self.userid = iprot.readI64();
94 ashish 5286 
        else:
5287 
          iprot.skip(ftype)
559 chandransh 5288 
      elif fid == 2:
5289 
        if ftype == TType.I64:
5290 
          self.addressId = iprot.readI64();
5291 
        else:
5292 
          iprot.skip(ftype)
94 ashish 5293 
      else:
5294 
        iprot.skip(ftype)
5295 
      iprot.readFieldEnd()
5296 
    iprot.readStructEnd()
5297 
 
5298 
  def write(self, oprot):
5299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5301 
      return
559 chandransh 5302 
    oprot.writeStructBegin('removeAddressForUser_args')
5303 
    if self.userid != None:
5304 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5305 
      oprot.writeI64(self.userid)
94 ashish 5306 
      oprot.writeFieldEnd()
559 chandransh 5307 
    if self.addressId != None:
5308 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5309 
      oprot.writeI64(self.addressId)
5310 
      oprot.writeFieldEnd()
94 ashish 5311 
    oprot.writeFieldStop()
5312 
    oprot.writeStructEnd()
5313 
 
5314 
  def __repr__(self):
5315 
    L = ['%s=%r' % (key, value)
5316 
      for key, value in self.__dict__.iteritems()]
5317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5318 
 
5319 
  def __eq__(self, other):
5320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5321 
 
5322 
  def __ne__(self, other):
5323 
    return not (self == other)
5324 
 
559 chandransh 5325 
class removeAddressForUser_result:
94 ashish 5326 
  """
5327 
  Attributes:
5328 
   - success
5329 
   - ucx
5330 
  """
5331 
 
5332 
  thrift_spec = (
5333 
    (0, TType.BOOL, 'success', None, None, ), # 0
5334 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5335 
  )
5336 
 
5337 
  def __init__(self, success=None, ucx=None,):
5338 
    self.success = success
5339 
    self.ucx = ucx
5340 
 
5341 
  def read(self, iprot):
5342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5344 
      return
5345 
    iprot.readStructBegin()
5346 
    while True:
5347 
      (fname, ftype, fid) = iprot.readFieldBegin()
5348 
      if ftype == TType.STOP:
5349 
        break
5350 
      if fid == 0:
5351 
        if ftype == TType.BOOL:
5352 
          self.success = iprot.readBool();
5353 
        else:
5354 
          iprot.skip(ftype)
5355 
      elif fid == 1:
5356 
        if ftype == TType.STRUCT:
5357 
          self.ucx = UserContextException()
5358 
          self.ucx.read(iprot)
5359 
        else:
5360 
          iprot.skip(ftype)
5361 
      else:
5362 
        iprot.skip(ftype)
5363 
      iprot.readFieldEnd()
5364 
    iprot.readStructEnd()
5365 
 
5366 
  def write(self, oprot):
5367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5369 
      return
559 chandransh 5370 
    oprot.writeStructBegin('removeAddressForUser_result')
94 ashish 5371 
    if self.success != None:
5372 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5373 
      oprot.writeBool(self.success)
5374 
      oprot.writeFieldEnd()
5375 
    if self.ucx != None:
5376 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5377 
      self.ucx.write(oprot)
5378 
      oprot.writeFieldEnd()
5379 
    oprot.writeFieldStop()
5380 
    oprot.writeStructEnd()
5381 
 
5382 
  def __repr__(self):
5383 
    L = ['%s=%r' % (key, value)
5384 
      for key, value in self.__dict__.iteritems()]
5385 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5386 
 
5387 
  def __eq__(self, other):
5388 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5389 
 
5390 
  def __ne__(self, other):
5391 
    return not (self == other)
5392 
 
559 chandransh 5393 
class setUserAsLoggedIn_args:
94 ashish 5394 
  """
5395 
  Attributes:
559 chandransh 5396 
   - userId
94 ashish 5397 
   - timestamp
5398 
  """
5399 
 
5400 
  thrift_spec = (
5401 
    None, # 0
559 chandransh 5402 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 5403 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5404 
  )
5405 
 
559 chandransh 5406 
  def __init__(self, userId=None, timestamp=None,):
5407 
    self.userId = userId
94 ashish 5408 
    self.timestamp = timestamp
5409 
 
5410 
  def read(self, iprot):
5411 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5412 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5413 
      return
5414 
    iprot.readStructBegin()
5415 
    while True:
5416 
      (fname, ftype, fid) = iprot.readFieldBegin()
5417 
      if ftype == TType.STOP:
5418 
        break
5419 
      if fid == 1:
559 chandransh 5420 
        if ftype == TType.I64:
5421 
          self.userId = iprot.readI64();
94 ashish 5422 
        else:
5423 
          iprot.skip(ftype)
5424 
      elif fid == 2:
5425 
        if ftype == TType.I64:
5426 
          self.timestamp = iprot.readI64();
5427 
        else:
5428 
          iprot.skip(ftype)
5429 
      else:
5430 
        iprot.skip(ftype)
5431 
      iprot.readFieldEnd()
5432 
    iprot.readStructEnd()
5433 
 
5434 
  def write(self, oprot):
5435 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5436 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5437 
      return
559 chandransh 5438 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
5439 
    if self.userId != None:
5440 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5441 
      oprot.writeI64(self.userId)
94 ashish 5442 
      oprot.writeFieldEnd()
5443 
    if self.timestamp != None:
5444 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5445 
      oprot.writeI64(self.timestamp)
5446 
      oprot.writeFieldEnd()
5447 
    oprot.writeFieldStop()
5448 
    oprot.writeStructEnd()
5449 
 
5450 
  def __repr__(self):
5451 
    L = ['%s=%r' % (key, value)
5452 
      for key, value in self.__dict__.iteritems()]
5453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5454 
 
5455 
  def __eq__(self, other):
5456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5457 
 
5458 
  def __ne__(self, other):
5459 
    return not (self == other)
5460 
 
559 chandransh 5461 
class setUserAsLoggedIn_result:
94 ashish 5462 
  """
5463 
  Attributes:
5464 
   - success
5465 
   - ucx
5466 
  """
5467 
 
5468 
  thrift_spec = (
5469 
    (0, TType.BOOL, 'success', None, None, ), # 0
5470 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5471 
  )
5472 
 
5473 
  def __init__(self, success=None, ucx=None,):
5474 
    self.success = success
5475 
    self.ucx = ucx
5476 
 
5477 
  def read(self, iprot):
5478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5480 
      return
5481 
    iprot.readStructBegin()
5482 
    while True:
5483 
      (fname, ftype, fid) = iprot.readFieldBegin()
5484 
      if ftype == TType.STOP:
5485 
        break
5486 
      if fid == 0:
5487 
        if ftype == TType.BOOL:
5488 
          self.success = iprot.readBool();
5489 
        else:
5490 
          iprot.skip(ftype)
5491 
      elif fid == 1:
5492 
        if ftype == TType.STRUCT:
5493 
          self.ucx = UserContextException()
5494 
          self.ucx.read(iprot)
5495 
        else:
5496 
          iprot.skip(ftype)
5497 
      else:
5498 
        iprot.skip(ftype)
5499 
      iprot.readFieldEnd()
5500 
    iprot.readStructEnd()
5501 
 
5502 
  def write(self, oprot):
5503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5505 
      return
559 chandransh 5506 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
94 ashish 5507 
    if self.success != None:
5508 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5509 
      oprot.writeBool(self.success)
5510 
      oprot.writeFieldEnd()
5511 
    if self.ucx != None:
5512 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5513 
      self.ucx.write(oprot)
5514 
      oprot.writeFieldEnd()
5515 
    oprot.writeFieldStop()
5516 
    oprot.writeStructEnd()
5517 
 
5518 
  def __repr__(self):
5519 
    L = ['%s=%r' % (key, value)
5520 
      for key, value in self.__dict__.iteritems()]
5521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5522 
 
5523 
  def __eq__(self, other):
5524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5525 
 
5526 
  def __ne__(self, other):
5527 
    return not (self == other)
5528 
 
559 chandransh 5529 
class setUserAsLoggedOut_args:
94 ashish 5530 
  """
5531 
  Attributes:
5532 
   - userid
5533 
   - timestamp
5534 
  """
5535 
 
5536 
  thrift_spec = (
5537 
    None, # 0
559 chandransh 5538 
    (1, TType.I64, 'userid', None, None, ), # 1
5539 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 5540 
  )
5541 
 
559 chandransh 5542 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 5543 
    self.userid = userid
5544 
    self.timestamp = timestamp
5545 
 
5546 
  def read(self, iprot):
5547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5549 
      return
5550 
    iprot.readStructBegin()
5551 
    while True:
5552 
      (fname, ftype, fid) = iprot.readFieldBegin()
5553 
      if ftype == TType.STOP:
5554 
        break
5555 
      if fid == 1:
5556 
        if ftype == TType.I64:
5557 
          self.userid = iprot.readI64();
5558 
        else:
5559 
          iprot.skip(ftype)
559 chandransh 5560 
      elif fid == 2:
94 ashish 5561 
        if ftype == TType.I64:
5562 
          self.timestamp = iprot.readI64();
5563 
        else:
5564 
          iprot.skip(ftype)
5565 
      else:
5566 
        iprot.skip(ftype)
5567 
      iprot.readFieldEnd()
5568 
    iprot.readStructEnd()
5569 
 
5570 
  def write(self, oprot):
5571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5573 
      return
559 chandransh 5574 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
94 ashish 5575 
    if self.userid != None:
559 chandransh 5576 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 5577 
      oprot.writeI64(self.userid)
5578 
      oprot.writeFieldEnd()
5579 
    if self.timestamp != None:
559 chandransh 5580 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 5581 
      oprot.writeI64(self.timestamp)
5582 
      oprot.writeFieldEnd()
5583 
    oprot.writeFieldStop()
5584 
    oprot.writeStructEnd()
5585 
 
5586 
  def __repr__(self):
5587 
    L = ['%s=%r' % (key, value)
5588 
      for key, value in self.__dict__.iteritems()]
5589 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5590 
 
5591 
  def __eq__(self, other):
5592 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5593 
 
5594 
  def __ne__(self, other):
5595 
    return not (self == other)
5596 
 
559 chandransh 5597 
class setUserAsLoggedOut_result:
94 ashish 5598 
  """
5599 
  Attributes:
5600 
   - success
5601 
   - ucx
5602 
  """
5603 
 
5604 
  thrift_spec = (
5605 
    (0, TType.BOOL, 'success', None, None, ), # 0
5606 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5607 
  )
5608 
 
5609 
  def __init__(self, success=None, ucx=None,):
5610 
    self.success = success
5611 
    self.ucx = ucx
5612 
 
5613 
  def read(self, iprot):
5614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5616 
      return
5617 
    iprot.readStructBegin()
5618 
    while True:
5619 
      (fname, ftype, fid) = iprot.readFieldBegin()
5620 
      if ftype == TType.STOP:
5621 
        break
5622 
      if fid == 0:
5623 
        if ftype == TType.BOOL:
5624 
          self.success = iprot.readBool();
5625 
        else:
5626 
          iprot.skip(ftype)
5627 
      elif fid == 1:
5628 
        if ftype == TType.STRUCT:
5629 
          self.ucx = UserContextException()
5630 
          self.ucx.read(iprot)
5631 
        else:
5632 
          iprot.skip(ftype)
5633 
      else:
5634 
        iprot.skip(ftype)
5635 
      iprot.readFieldEnd()
5636 
    iprot.readStructEnd()
5637 
 
5638 
  def write(self, oprot):
5639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5641 
      return
559 chandransh 5642 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
94 ashish 5643 
    if self.success != None:
5644 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5645 
      oprot.writeBool(self.success)
5646 
      oprot.writeFieldEnd()
5647 
    if self.ucx != None:
5648 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5649 
      self.ucx.write(oprot)
5650 
      oprot.writeFieldEnd()
5651 
    oprot.writeFieldStop()
5652 
    oprot.writeStructEnd()
5653 
 
5654 
  def __repr__(self):
5655 
    L = ['%s=%r' % (key, value)
5656 
      for key, value in self.__dict__.iteritems()]
5657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5658 
 
5659 
  def __eq__(self, other):
5660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5661 
 
5662 
  def __ne__(self, other):
5663 
    return not (self == other)
5664 
 
559 chandransh 5665 
class setDefaultAddress_args:
94 ashish 5666 
  """
5667 
  Attributes:
5668 
   - userid
5669 
   - addressId
5670 
  """
5671 
 
5672 
  thrift_spec = (
5673 
    None, # 0
5674 
    (1, TType.I64, 'userid', None, None, ), # 1
5675 
    (2, TType.I64, 'addressId', None, None, ), # 2
5676 
  )
5677 
 
5678 
  def __init__(self, userid=None, addressId=None,):
5679 
    self.userid = userid
5680 
    self.addressId = addressId
5681 
 
5682 
  def read(self, iprot):
5683 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5684 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5685 
      return
5686 
    iprot.readStructBegin()
5687 
    while True:
5688 
      (fname, ftype, fid) = iprot.readFieldBegin()
5689 
      if ftype == TType.STOP:
5690 
        break
5691 
      if fid == 1:
5692 
        if ftype == TType.I64:
5693 
          self.userid = iprot.readI64();
5694 
        else:
5695 
          iprot.skip(ftype)
5696 
      elif fid == 2:
5697 
        if ftype == TType.I64:
5698 
          self.addressId = iprot.readI64();
5699 
        else:
5700 
          iprot.skip(ftype)
5701 
      else:
5702 
        iprot.skip(ftype)
5703 
      iprot.readFieldEnd()
5704 
    iprot.readStructEnd()
5705 
 
5706 
  def write(self, oprot):
5707 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5708 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5709 
      return
559 chandransh 5710 
    oprot.writeStructBegin('setDefaultAddress_args')
94 ashish 5711 
    if self.userid != None:
5712 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5713 
      oprot.writeI64(self.userid)
5714 
      oprot.writeFieldEnd()
5715 
    if self.addressId != None:
5716 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5717 
      oprot.writeI64(self.addressId)
5718 
      oprot.writeFieldEnd()
5719 
    oprot.writeFieldStop()
5720 
    oprot.writeStructEnd()
5721 
 
5722 
  def __repr__(self):
5723 
    L = ['%s=%r' % (key, value)
5724 
      for key, value in self.__dict__.iteritems()]
5725 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5726 
 
5727 
  def __eq__(self, other):
5728 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5729 
 
5730 
  def __ne__(self, other):
5731 
    return not (self == other)
5732 
 
559 chandransh 5733 
class setDefaultAddress_result:
94 ashish 5734 
  """
5735 
  Attributes:
5736 
   - success
5737 
   - ucx
5738 
  """
5739 
 
5740 
  thrift_spec = (
5741 
    (0, TType.BOOL, 'success', None, None, ), # 0
5742 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5743 
  )
5744 
 
5745 
  def __init__(self, success=None, ucx=None,):
5746 
    self.success = success
5747 
    self.ucx = ucx
5748 
 
5749 
  def read(self, iprot):
5750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5752 
      return
5753 
    iprot.readStructBegin()
5754 
    while True:
5755 
      (fname, ftype, fid) = iprot.readFieldBegin()
5756 
      if ftype == TType.STOP:
5757 
        break
5758 
      if fid == 0:
5759 
        if ftype == TType.BOOL:
5760 
          self.success = iprot.readBool();
5761 
        else:
5762 
          iprot.skip(ftype)
5763 
      elif fid == 1:
5764 
        if ftype == TType.STRUCT:
5765 
          self.ucx = UserContextException()
5766 
          self.ucx.read(iprot)
5767 
        else:
5768 
          iprot.skip(ftype)
5769 
      else:
5770 
        iprot.skip(ftype)
5771 
      iprot.readFieldEnd()
5772 
    iprot.readStructEnd()
5773 
 
5774 
  def write(self, oprot):
5775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5777 
      return
559 chandransh 5778 
    oprot.writeStructBegin('setDefaultAddress_result')
94 ashish 5779 
    if self.success != None:
5780 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5781 
      oprot.writeBool(self.success)
5782 
      oprot.writeFieldEnd()
5783 
    if self.ucx != None:
5784 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5785 
      self.ucx.write(oprot)
5786 
      oprot.writeFieldEnd()
5787 
    oprot.writeFieldStop()
5788 
    oprot.writeStructEnd()
5789 
 
5790 
  def __repr__(self):
5791 
    L = ['%s=%r' % (key, value)
5792 
      for key, value in self.__dict__.iteritems()]
5793 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5794 
 
5795 
  def __eq__(self, other):
5796 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5797 
 
5798 
  def __ne__(self, other):
5799 
    return not (self == other)
5800 
 
559 chandransh 5801 
class updatePassword_args:
94 ashish 5802 
  """
5803 
  Attributes:
559 chandransh 5804 
   - userid
594 rajveer 5805 
   - oldPassword
5806 
   - newPassword
94 ashish 5807 
  """
5808 
 
5809 
  thrift_spec = (
5810 
    None, # 0
559 chandransh 5811 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 5812 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
5813 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 5814 
  )
5815 
 
594 rajveer 5816 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 5817 
    self.userid = userid
594 rajveer 5818 
    self.oldPassword = oldPassword
5819 
    self.newPassword = newPassword
94 ashish 5820 
 
5821 
  def read(self, iprot):
5822 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5823 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5824 
      return
5825 
    iprot.readStructBegin()
5826 
    while True:
5827 
      (fname, ftype, fid) = iprot.readFieldBegin()
5828 
      if ftype == TType.STOP:
5829 
        break
5830 
      if fid == 1:
5831 
        if ftype == TType.I64:
559 chandransh 5832 
          self.userid = iprot.readI64();
94 ashish 5833 
        else:
5834 
          iprot.skip(ftype)
5835 
      elif fid == 2:
559 chandransh 5836 
        if ftype == TType.STRING:
594 rajveer 5837 
          self.oldPassword = iprot.readString();
94 ashish 5838 
        else:
5839 
          iprot.skip(ftype)
594 rajveer 5840 
      elif fid == 3:
5841 
        if ftype == TType.STRING:
5842 
          self.newPassword = iprot.readString();
5843 
        else:
5844 
          iprot.skip(ftype)
94 ashish 5845 
      else:
5846 
        iprot.skip(ftype)
5847 
      iprot.readFieldEnd()
5848 
    iprot.readStructEnd()
5849 
 
5850 
  def write(self, oprot):
5851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5853 
      return
559 chandransh 5854 
    oprot.writeStructBegin('updatePassword_args')
5855 
    if self.userid != None:
5856 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5857 
      oprot.writeI64(self.userid)
94 ashish 5858 
      oprot.writeFieldEnd()
594 rajveer 5859 
    if self.oldPassword != None:
5860 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
5861 
      oprot.writeString(self.oldPassword)
94 ashish 5862 
      oprot.writeFieldEnd()
594 rajveer 5863 
    if self.newPassword != None:
5864 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
5865 
      oprot.writeString(self.newPassword)
5866 
      oprot.writeFieldEnd()
94 ashish 5867 
    oprot.writeFieldStop()
5868 
    oprot.writeStructEnd()
5869 
 
5870 
  def __repr__(self):
5871 
    L = ['%s=%r' % (key, value)
5872 
      for key, value in self.__dict__.iteritems()]
5873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5874 
 
5875 
  def __eq__(self, other):
5876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5877 
 
5878 
  def __ne__(self, other):
5879 
    return not (self == other)
5880 
 
559 chandransh 5881 
class updatePassword_result:
94 ashish 5882 
  """
5883 
  Attributes:
5884 
   - success
5885 
   - ucx
5886 
  """
5887 
 
5888 
  thrift_spec = (
5889 
    (0, TType.BOOL, 'success', None, None, ), # 0
5890 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5891 
  )
5892 
 
5893 
  def __init__(self, success=None, ucx=None,):
5894 
    self.success = success
5895 
    self.ucx = ucx
5896 
 
5897 
  def read(self, iprot):
5898 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5899 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5900 
      return
5901 
    iprot.readStructBegin()
5902 
    while True:
5903 
      (fname, ftype, fid) = iprot.readFieldBegin()
5904 
      if ftype == TType.STOP:
5905 
        break
5906 
      if fid == 0:
5907 
        if ftype == TType.BOOL:
5908 
          self.success = iprot.readBool();
5909 
        else:
5910 
          iprot.skip(ftype)
5911 
      elif fid == 1:
5912 
        if ftype == TType.STRUCT:
5913 
          self.ucx = UserContextException()
5914 
          self.ucx.read(iprot)
5915 
        else:
5916 
          iprot.skip(ftype)
5917 
      else:
5918 
        iprot.skip(ftype)
5919 
      iprot.readFieldEnd()
5920 
    iprot.readStructEnd()
5921 
 
5922 
  def write(self, oprot):
5923 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5924 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5925 
      return
559 chandransh 5926 
    oprot.writeStructBegin('updatePassword_result')
94 ashish 5927 
    if self.success != None:
5928 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5929 
      oprot.writeBool(self.success)
5930 
      oprot.writeFieldEnd()
5931 
    if self.ucx != None:
5932 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5933 
      self.ucx.write(oprot)
5934 
      oprot.writeFieldEnd()
5935 
    oprot.writeFieldStop()
5936 
    oprot.writeStructEnd()
5937 
 
5938 
  def __repr__(self):
5939 
    L = ['%s=%r' % (key, value)
5940 
      for key, value in self.__dict__.iteritems()]
5941 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5942 
 
5943 
  def __eq__(self, other):
5944 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5945 
 
5946 
  def __ne__(self, other):
5947 
    return not (self == other)
5948 
 
581 rajveer 5949 
class forgotPassword_args:
5950 
  """
5951 
  Attributes:
5952 
   - email
884 rajveer 5953 
   - newPassword
581 rajveer 5954 
  """
5955 
 
5956 
  thrift_spec = (
5957 
    None, # 0
5958 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 5959 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 5960 
  )
5961 
 
884 rajveer 5962 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 5963 
    self.email = email
884 rajveer 5964 
    self.newPassword = newPassword
581 rajveer 5965 
 
5966 
  def read(self, iprot):
5967 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5968 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5969 
      return
5970 
    iprot.readStructBegin()
5971 
    while True:
5972 
      (fname, ftype, fid) = iprot.readFieldBegin()
5973 
      if ftype == TType.STOP:
5974 
        break
5975 
      if fid == 1:
5976 
        if ftype == TType.STRING:
5977 
          self.email = iprot.readString();
5978 
        else:
5979 
          iprot.skip(ftype)
884 rajveer 5980 
      elif fid == 2:
5981 
        if ftype == TType.STRING:
5982 
          self.newPassword = iprot.readString();
5983 
        else:
5984 
          iprot.skip(ftype)
581 rajveer 5985 
      else:
5986 
        iprot.skip(ftype)
5987 
      iprot.readFieldEnd()
5988 
    iprot.readStructEnd()
5989 
 
5990 
  def write(self, oprot):
5991 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5992 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5993 
      return
5994 
    oprot.writeStructBegin('forgotPassword_args')
5995 
    if self.email != None:
5996 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5997 
      oprot.writeString(self.email)
5998 
      oprot.writeFieldEnd()
884 rajveer 5999 
    if self.newPassword != None:
6000 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
6001 
      oprot.writeString(self.newPassword)
6002 
      oprot.writeFieldEnd()
581 rajveer 6003 
    oprot.writeFieldStop()
6004 
    oprot.writeStructEnd()
6005 
 
6006 
  def __repr__(self):
6007 
    L = ['%s=%r' % (key, value)
6008 
      for key, value in self.__dict__.iteritems()]
6009 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6010 
 
6011 
  def __eq__(self, other):
6012 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6013 
 
6014 
  def __ne__(self, other):
6015 
    return not (self == other)
6016 
 
6017 
class forgotPassword_result:
6018 
  """
6019 
  Attributes:
6020 
   - success
6021 
   - ucx
6022 
  """
6023 
 
6024 
  thrift_spec = (
6025 
    (0, TType.BOOL, 'success', None, None, ), # 0
6026 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6027 
  )
6028 
 
6029 
  def __init__(self, success=None, ucx=None,):
6030 
    self.success = success
6031 
    self.ucx = ucx
6032 
 
6033 
  def read(self, iprot):
6034 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6035 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6036 
      return
6037 
    iprot.readStructBegin()
6038 
    while True:
6039 
      (fname, ftype, fid) = iprot.readFieldBegin()
6040 
      if ftype == TType.STOP:
6041 
        break
6042 
      if fid == 0:
6043 
        if ftype == TType.BOOL:
6044 
          self.success = iprot.readBool();
6045 
        else:
6046 
          iprot.skip(ftype)
6047 
      elif fid == 1:
6048 
        if ftype == TType.STRUCT:
6049 
          self.ucx = UserContextException()
6050 
          self.ucx.read(iprot)
6051 
        else:
6052 
          iprot.skip(ftype)
6053 
      else:
6054 
        iprot.skip(ftype)
6055 
      iprot.readFieldEnd()
6056 
    iprot.readStructEnd()
6057 
 
6058 
  def write(self, oprot):
6059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6061 
      return
6062 
    oprot.writeStructBegin('forgotPassword_result')
6063 
    if self.success != None:
6064 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6065 
      oprot.writeBool(self.success)
6066 
      oprot.writeFieldEnd()
6067 
    if self.ucx != None:
6068 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6069 
      self.ucx.write(oprot)
6070 
      oprot.writeFieldEnd()
6071 
    oprot.writeFieldStop()
6072 
    oprot.writeStructEnd()
6073 
 
6074 
  def __repr__(self):
6075 
    L = ['%s=%r' % (key, value)
6076 
      for key, value in self.__dict__.iteritems()]
6077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6078 
 
6079 
  def __eq__(self, other):
6080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6081 
 
6082 
  def __ne__(self, other):
6083 
    return not (self == other)
6084 
 
594 rajveer 6085 
class getAllAddressesForUser_args:
6086 
  """
6087 
  Attributes:
6088 
   - userId
6089 
  """
6090 
 
6091 
  thrift_spec = (
6092 
    None, # 0
6093 
    (1, TType.I64, 'userId', None, None, ), # 1
6094 
  )
6095 
 
6096 
  def __init__(self, userId=None,):
6097 
    self.userId = userId
6098 
 
6099 
  def read(self, iprot):
6100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6102 
      return
6103 
    iprot.readStructBegin()
6104 
    while True:
6105 
      (fname, ftype, fid) = iprot.readFieldBegin()
6106 
      if ftype == TType.STOP:
6107 
        break
6108 
      if fid == 1:
6109 
        if ftype == TType.I64:
6110 
          self.userId = iprot.readI64();
6111 
        else:
6112 
          iprot.skip(ftype)
6113 
      else:
6114 
        iprot.skip(ftype)
6115 
      iprot.readFieldEnd()
6116 
    iprot.readStructEnd()
6117 
 
6118 
  def write(self, oprot):
6119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6121 
      return
6122 
    oprot.writeStructBegin('getAllAddressesForUser_args')
6123 
    if self.userId != None:
6124 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6125 
      oprot.writeI64(self.userId)
6126 
      oprot.writeFieldEnd()
6127 
    oprot.writeFieldStop()
6128 
    oprot.writeStructEnd()
6129 
 
6130 
  def __repr__(self):
6131 
    L = ['%s=%r' % (key, value)
6132 
      for key, value in self.__dict__.iteritems()]
6133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6134 
 
6135 
  def __eq__(self, other):
6136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6137 
 
6138 
  def __ne__(self, other):
6139 
    return not (self == other)
6140 
 
6141 
class getAllAddressesForUser_result:
6142 
  """
6143 
  Attributes:
6144 
   - success
6145 
   - ucx
6146 
  """
6147 
 
6148 
  thrift_spec = (
6149 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
6150 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6151 
  )
6152 
 
6153 
  def __init__(self, success=None, ucx=None,):
6154 
    self.success = success
6155 
    self.ucx = ucx
6156 
 
6157 
  def read(self, iprot):
6158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6160 
      return
6161 
    iprot.readStructBegin()
6162 
    while True:
6163 
      (fname, ftype, fid) = iprot.readFieldBegin()
6164 
      if ftype == TType.STOP:
6165 
        break
6166 
      if fid == 0:
6167 
        if ftype == TType.LIST:
6168 
          self.success = []
2981 rajveer 6169 
          (_etype31, _size28) = iprot.readListBegin()
6170 
          for _i32 in xrange(_size28):
6171 
            _elem33 = Address()
6172 
            _elem33.read(iprot)
6173 
            self.success.append(_elem33)
594 rajveer 6174 
          iprot.readListEnd()
6175 
        else:
6176 
          iprot.skip(ftype)
6177 
      elif fid == 1:
6178 
        if ftype == TType.STRUCT:
6179 
          self.ucx = UserContextException()
6180 
          self.ucx.read(iprot)
6181 
        else:
6182 
          iprot.skip(ftype)
6183 
      else:
6184 
        iprot.skip(ftype)
6185 
      iprot.readFieldEnd()
6186 
    iprot.readStructEnd()
6187 
 
6188 
  def write(self, oprot):
6189 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6190 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6191 
      return
6192 
    oprot.writeStructBegin('getAllAddressesForUser_result')
6193 
    if self.success != None:
6194 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6195 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 6196 
      for iter34 in self.success:
6197 
        iter34.write(oprot)
594 rajveer 6198 
      oprot.writeListEnd()
6199 
      oprot.writeFieldEnd()
6200 
    if self.ucx != None:
6201 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6202 
      self.ucx.write(oprot)
6203 
      oprot.writeFieldEnd()
6204 
    oprot.writeFieldStop()
6205 
    oprot.writeStructEnd()
6206 
 
6207 
  def __repr__(self):
6208 
    L = ['%s=%r' % (key, value)
6209 
      for key, value in self.__dict__.iteritems()]
6210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6211 
 
6212 
  def __eq__(self, other):
6213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6214 
 
6215 
  def __ne__(self, other):
6216 
    return not (self == other)
6217 
 
1894 vikas 6218 
class getAddressById_args:
6219 
  """
6220 
  Attributes:
6221 
   - addressId
6222 
  """
6223 
 
6224 
  thrift_spec = (
6225 
    None, # 0
6226 
    (1, TType.I64, 'addressId', None, None, ), # 1
6227 
  )
6228 
 
6229 
  def __init__(self, addressId=None,):
6230 
    self.addressId = addressId
6231 
 
6232 
  def read(self, iprot):
6233 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6234 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6235 
      return
6236 
    iprot.readStructBegin()
6237 
    while True:
6238 
      (fname, ftype, fid) = iprot.readFieldBegin()
6239 
      if ftype == TType.STOP:
6240 
        break
6241 
      if fid == 1:
6242 
        if ftype == TType.I64:
6243 
          self.addressId = iprot.readI64();
6244 
        else:
6245 
          iprot.skip(ftype)
6246 
      else:
6247 
        iprot.skip(ftype)
6248 
      iprot.readFieldEnd()
6249 
    iprot.readStructEnd()
6250 
 
6251 
  def write(self, oprot):
6252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6254 
      return
6255 
    oprot.writeStructBegin('getAddressById_args')
6256 
    if self.addressId != None:
6257 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
6258 
      oprot.writeI64(self.addressId)
6259 
      oprot.writeFieldEnd()
6260 
    oprot.writeFieldStop()
6261 
    oprot.writeStructEnd()
6262 
 
6263 
  def __repr__(self):
6264 
    L = ['%s=%r' % (key, value)
6265 
      for key, value in self.__dict__.iteritems()]
6266 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6267 
 
6268 
  def __eq__(self, other):
6269 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6270 
 
6271 
  def __ne__(self, other):
6272 
    return not (self == other)
6273 
 
6274 
class getAddressById_result:
6275 
  """
6276 
  Attributes:
6277 
   - success
6278 
   - ucx
6279 
  """
6280 
 
6281 
  thrift_spec = (
6282 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
6283 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6284 
  )
6285 
 
6286 
  def __init__(self, success=None, ucx=None,):
6287 
    self.success = success
6288 
    self.ucx = ucx
6289 
 
6290 
  def read(self, iprot):
6291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6293 
      return
6294 
    iprot.readStructBegin()
6295 
    while True:
6296 
      (fname, ftype, fid) = iprot.readFieldBegin()
6297 
      if ftype == TType.STOP:
6298 
        break
6299 
      if fid == 0:
6300 
        if ftype == TType.STRUCT:
6301 
          self.success = Address()
6302 
          self.success.read(iprot)
6303 
        else:
6304 
          iprot.skip(ftype)
6305 
      elif fid == 1:
6306 
        if ftype == TType.STRUCT:
6307 
          self.ucx = UserContextException()
6308 
          self.ucx.read(iprot)
6309 
        else:
6310 
          iprot.skip(ftype)
6311 
      else:
6312 
        iprot.skip(ftype)
6313 
      iprot.readFieldEnd()
6314 
    iprot.readStructEnd()
6315 
 
6316 
  def write(self, oprot):
6317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6319 
      return
6320 
    oprot.writeStructBegin('getAddressById_result')
6321 
    if self.success != None:
6322 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6323 
      self.success.write(oprot)
6324 
      oprot.writeFieldEnd()
6325 
    if self.ucx != None:
6326 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6327 
      self.ucx.write(oprot)
6328 
      oprot.writeFieldEnd()
6329 
    oprot.writeFieldStop()
6330 
    oprot.writeStructEnd()
6331 
 
6332 
  def __repr__(self):
6333 
    L = ['%s=%r' % (key, value)
6334 
      for key, value in self.__dict__.iteritems()]
6335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6336 
 
6337 
  def __eq__(self, other):
6338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6339 
 
6340 
  def __ne__(self, other):
6341 
    return not (self == other)
6342 
 
594 rajveer 6343 
class getDefaultAddressId_args:
6344 
  """
6345 
  Attributes:
6346 
   - userId
6347 
  """
6348 
 
6349 
  thrift_spec = (
6350 
    None, # 0
6351 
    (1, TType.I64, 'userId', None, None, ), # 1
6352 
  )
6353 
 
6354 
  def __init__(self, userId=None,):
6355 
    self.userId = userId
6356 
 
6357 
  def read(self, iprot):
6358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6360 
      return
6361 
    iprot.readStructBegin()
6362 
    while True:
6363 
      (fname, ftype, fid) = iprot.readFieldBegin()
6364 
      if ftype == TType.STOP:
6365 
        break
6366 
      if fid == 1:
6367 
        if ftype == TType.I64:
6368 
          self.userId = iprot.readI64();
6369 
        else:
6370 
          iprot.skip(ftype)
6371 
      else:
6372 
        iprot.skip(ftype)
6373 
      iprot.readFieldEnd()
6374 
    iprot.readStructEnd()
6375 
 
6376 
  def write(self, oprot):
6377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6379 
      return
6380 
    oprot.writeStructBegin('getDefaultAddressId_args')
6381 
    if self.userId != None:
6382 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6383 
      oprot.writeI64(self.userId)
6384 
      oprot.writeFieldEnd()
6385 
    oprot.writeFieldStop()
6386 
    oprot.writeStructEnd()
6387 
 
6388 
  def __repr__(self):
6389 
    L = ['%s=%r' % (key, value)
6390 
      for key, value in self.__dict__.iteritems()]
6391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6392 
 
6393 
  def __eq__(self, other):
6394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6395 
 
6396 
  def __ne__(self, other):
6397 
    return not (self == other)
6398 
 
6399 
class getDefaultAddressId_result:
6400 
  """
6401 
  Attributes:
6402 
   - success
6403 
   - ucx
6404 
  """
6405 
 
6406 
  thrift_spec = (
6407 
    (0, TType.I64, 'success', None, None, ), # 0
6408 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6409 
  )
6410 
 
6411 
  def __init__(self, success=None, ucx=None,):
6412 
    self.success = success
6413 
    self.ucx = ucx
6414 
 
6415 
  def read(self, iprot):
6416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6418 
      return
6419 
    iprot.readStructBegin()
6420 
    while True:
6421 
      (fname, ftype, fid) = iprot.readFieldBegin()
6422 
      if ftype == TType.STOP:
6423 
        break
6424 
      if fid == 0:
6425 
        if ftype == TType.I64:
6426 
          self.success = iprot.readI64();
6427 
        else:
6428 
          iprot.skip(ftype)
6429 
      elif fid == 1:
6430 
        if ftype == TType.STRUCT:
6431 
          self.ucx = UserContextException()
6432 
          self.ucx.read(iprot)
6433 
        else:
6434 
          iprot.skip(ftype)
6435 
      else:
6436 
        iprot.skip(ftype)
6437 
      iprot.readFieldEnd()
6438 
    iprot.readStructEnd()
6439 
 
6440 
  def write(self, oprot):
6441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6443 
      return
6444 
    oprot.writeStructBegin('getDefaultAddressId_result')
6445 
    if self.success != None:
6446 
      oprot.writeFieldBegin('success', TType.I64, 0)
6447 
      oprot.writeI64(self.success)
6448 
      oprot.writeFieldEnd()
6449 
    if self.ucx != None:
6450 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6451 
      self.ucx.write(oprot)
6452 
      oprot.writeFieldEnd()
6453 
    oprot.writeFieldStop()
6454 
    oprot.writeStructEnd()
6455 
 
6456 
  def __repr__(self):
6457 
    L = ['%s=%r' % (key, value)
6458 
      for key, value in self.__dict__.iteritems()]
6459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6460 
 
6461 
  def __eq__(self, other):
6462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6463 
 
6464 
  def __ne__(self, other):
6465 
    return not (self == other)
6466 
 
785 rajveer 6467 
class getDefaultPincode_args:
6468 
  """
6469 
  Attributes:
6470 
   - userId
6471 
  """
6472 
 
6473 
  thrift_spec = (
6474 
    None, # 0
6475 
    (1, TType.I64, 'userId', None, None, ), # 1
6476 
  )
6477 
 
6478 
  def __init__(self, userId=None,):
6479 
    self.userId = userId
6480 
 
6481 
  def read(self, iprot):
6482 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6483 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6484 
      return
6485 
    iprot.readStructBegin()
6486 
    while True:
6487 
      (fname, ftype, fid) = iprot.readFieldBegin()
6488 
      if ftype == TType.STOP:
6489 
        break
6490 
      if fid == 1:
6491 
        if ftype == TType.I64:
6492 
          self.userId = iprot.readI64();
6493 
        else:
6494 
          iprot.skip(ftype)
6495 
      else:
6496 
        iprot.skip(ftype)
6497 
      iprot.readFieldEnd()
6498 
    iprot.readStructEnd()
6499 
 
6500 
  def write(self, oprot):
6501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6503 
      return
6504 
    oprot.writeStructBegin('getDefaultPincode_args')
6505 
    if self.userId != None:
6506 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6507 
      oprot.writeI64(self.userId)
6508 
      oprot.writeFieldEnd()
6509 
    oprot.writeFieldStop()
6510 
    oprot.writeStructEnd()
6511 
 
6512 
  def __repr__(self):
6513 
    L = ['%s=%r' % (key, value)
6514 
      for key, value in self.__dict__.iteritems()]
6515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6516 
 
6517 
  def __eq__(self, other):
6518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6519 
 
6520 
  def __ne__(self, other):
6521 
    return not (self == other)
6522 
 
6523 
class getDefaultPincode_result:
6524 
  """
6525 
  Attributes:
6526 
   - success
6527 
   - ucx
6528 
  """
6529 
 
6530 
  thrift_spec = (
6531 
    (0, TType.STRING, 'success', None, None, ), # 0
6532 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6533 
  )
6534 
 
6535 
  def __init__(self, success=None, ucx=None,):
6536 
    self.success = success
6537 
    self.ucx = ucx
6538 
 
6539 
  def read(self, iprot):
6540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6542 
      return
6543 
    iprot.readStructBegin()
6544 
    while True:
6545 
      (fname, ftype, fid) = iprot.readFieldBegin()
6546 
      if ftype == TType.STOP:
6547 
        break
6548 
      if fid == 0:
6549 
        if ftype == TType.STRING:
6550 
          self.success = iprot.readString();
6551 
        else:
6552 
          iprot.skip(ftype)
6553 
      elif fid == 1:
6554 
        if ftype == TType.STRUCT:
6555 
          self.ucx = UserContextException()
6556 
          self.ucx.read(iprot)
6557 
        else:
6558 
          iprot.skip(ftype)
6559 
      else:
6560 
        iprot.skip(ftype)
6561 
      iprot.readFieldEnd()
6562 
    iprot.readStructEnd()
6563 
 
6564 
  def write(self, oprot):
6565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6567 
      return
6568 
    oprot.writeStructBegin('getDefaultPincode_result')
6569 
    if self.success != None:
6570 
      oprot.writeFieldBegin('success', TType.STRING, 0)
6571 
      oprot.writeString(self.success)
6572 
      oprot.writeFieldEnd()
6573 
    if self.ucx != None:
6574 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6575 
      self.ucx.write(oprot)
6576 
      oprot.writeFieldEnd()
6577 
    oprot.writeFieldStop()
6578 
    oprot.writeStructEnd()
6579 
 
6580 
  def __repr__(self):
6581 
    L = ['%s=%r' % (key, value)
6582 
      for key, value in self.__dict__.iteritems()]
6583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6584 
 
6585 
  def __eq__(self, other):
6586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6587 
 
6588 
  def __ne__(self, other):
6589 
    return not (self == other)
6590 
 
1274 varun.gupt 6591 
class saveUserCommunication_args:
6592 
  """
6593 
  Attributes:
6594 
   - userId
6595 
   - replyTo
6596 
   - communicationType
6597 
   - orderId
6598 
   - airwaybillNo
6599 
   - productName
6600 
   - subject
6601 
   - message
6602 
  """
6603 
 
6604 
  thrift_spec = (
6605 
    None, # 0
6606 
    (1, TType.I64, 'userId', None, None, ), # 1
6607 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
6608 
    (3, TType.I64, 'communicationType', None, None, ), # 3
6609 
    (4, TType.I64, 'orderId', None, None, ), # 4
6610 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
6611 
    (6, TType.STRING, 'productName', None, None, ), # 6
6612 
    (7, TType.STRING, 'subject', None, None, ), # 7
6613 
    (8, TType.STRING, 'message', None, None, ), # 8
6614 
  )
6615 
 
6616 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
6617 
    self.userId = userId
6618 
    self.replyTo = replyTo
6619 
    self.communicationType = communicationType
6620 
    self.orderId = orderId
6621 
    self.airwaybillNo = airwaybillNo
6622 
    self.productName = productName
6623 
    self.subject = subject
6624 
    self.message = message
6625 
 
6626 
  def read(self, iprot):
6627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6629 
      return
6630 
    iprot.readStructBegin()
6631 
    while True:
6632 
      (fname, ftype, fid) = iprot.readFieldBegin()
6633 
      if ftype == TType.STOP:
6634 
        break
6635 
      if fid == 1:
6636 
        if ftype == TType.I64:
6637 
          self.userId = iprot.readI64();
6638 
        else:
6639 
          iprot.skip(ftype)
6640 
      elif fid == 2:
6641 
        if ftype == TType.STRING:
6642 
          self.replyTo = iprot.readString();
6643 
        else:
6644 
          iprot.skip(ftype)
6645 
      elif fid == 3:
6646 
        if ftype == TType.I64:
6647 
          self.communicationType = iprot.readI64();
6648 
        else:
6649 
          iprot.skip(ftype)
6650 
      elif fid == 4:
6651 
        if ftype == TType.I64:
6652 
          self.orderId = iprot.readI64();
6653 
        else:
6654 
          iprot.skip(ftype)
6655 
      elif fid == 5:
6656 
        if ftype == TType.STRING:
6657 
          self.airwaybillNo = iprot.readString();
6658 
        else:
6659 
          iprot.skip(ftype)
6660 
      elif fid == 6:
6661 
        if ftype == TType.STRING:
6662 
          self.productName = iprot.readString();
6663 
        else:
6664 
          iprot.skip(ftype)
6665 
      elif fid == 7:
6666 
        if ftype == TType.STRING:
6667 
          self.subject = iprot.readString();
6668 
        else:
6669 
          iprot.skip(ftype)
6670 
      elif fid == 8:
6671 
        if ftype == TType.STRING:
6672 
          self.message = iprot.readString();
6673 
        else:
6674 
          iprot.skip(ftype)
6675 
      else:
6676 
        iprot.skip(ftype)
6677 
      iprot.readFieldEnd()
6678 
    iprot.readStructEnd()
6679 
 
6680 
  def write(self, oprot):
6681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6683 
      return
6684 
    oprot.writeStructBegin('saveUserCommunication_args')
6685 
    if self.userId != None:
6686 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6687 
      oprot.writeI64(self.userId)
6688 
      oprot.writeFieldEnd()
6689 
    if self.replyTo != None:
6690 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
6691 
      oprot.writeString(self.replyTo)
6692 
      oprot.writeFieldEnd()
6693 
    if self.communicationType != None:
6694 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
6695 
      oprot.writeI64(self.communicationType)
6696 
      oprot.writeFieldEnd()
6697 
    if self.orderId != None:
6698 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
6699 
      oprot.writeI64(self.orderId)
6700 
      oprot.writeFieldEnd()
6701 
    if self.airwaybillNo != None:
6702 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
6703 
      oprot.writeString(self.airwaybillNo)
6704 
      oprot.writeFieldEnd()
6705 
    if self.productName != None:
6706 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
6707 
      oprot.writeString(self.productName)
6708 
      oprot.writeFieldEnd()
6709 
    if self.subject != None:
6710 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
6711 
      oprot.writeString(self.subject)
6712 
      oprot.writeFieldEnd()
6713 
    if self.message != None:
6714 
      oprot.writeFieldBegin('message', TType.STRING, 8)
6715 
      oprot.writeString(self.message)
6716 
      oprot.writeFieldEnd()
6717 
    oprot.writeFieldStop()
6718 
    oprot.writeStructEnd()
6719 
 
6720 
  def __repr__(self):
6721 
    L = ['%s=%r' % (key, value)
6722 
      for key, value in self.__dict__.iteritems()]
6723 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6724 
 
6725 
  def __eq__(self, other):
6726 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6727 
 
6728 
  def __ne__(self, other):
6729 
    return not (self == other)
6730 
 
6731 
class saveUserCommunication_result:
6732 
  """
6733 
  Attributes:
6734 
   - success
6735 
   - ucx
6736 
  """
6737 
 
6738 
  thrift_spec = (
6739 
    (0, TType.BOOL, 'success', None, None, ), # 0
6740 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6741 
  )
6742 
 
6743 
  def __init__(self, success=None, ucx=None,):
6744 
    self.success = success
6745 
    self.ucx = ucx
6746 
 
6747 
  def read(self, iprot):
6748 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6749 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6750 
      return
6751 
    iprot.readStructBegin()
6752 
    while True:
6753 
      (fname, ftype, fid) = iprot.readFieldBegin()
6754 
      if ftype == TType.STOP:
6755 
        break
6756 
      if fid == 0:
6757 
        if ftype == TType.BOOL:
6758 
          self.success = iprot.readBool();
6759 
        else:
6760 
          iprot.skip(ftype)
6761 
      elif fid == 1:
6762 
        if ftype == TType.STRUCT:
6763 
          self.ucx = UserCommunicationException()
6764 
          self.ucx.read(iprot)
6765 
        else:
6766 
          iprot.skip(ftype)
6767 
      else:
6768 
        iprot.skip(ftype)
6769 
      iprot.readFieldEnd()
6770 
    iprot.readStructEnd()
6771 
 
6772 
  def write(self, oprot):
6773 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6774 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6775 
      return
6776 
    oprot.writeStructBegin('saveUserCommunication_result')
6777 
    if self.success != None:
6778 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6779 
      oprot.writeBool(self.success)
6780 
      oprot.writeFieldEnd()
6781 
    if self.ucx != None:
6782 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6783 
      self.ucx.write(oprot)
6784 
      oprot.writeFieldEnd()
6785 
    oprot.writeFieldStop()
6786 
    oprot.writeStructEnd()
6787 
 
6788 
  def __repr__(self):
6789 
    L = ['%s=%r' % (key, value)
6790 
      for key, value in self.__dict__.iteritems()]
6791 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6792 
 
6793 
  def __eq__(self, other):
6794 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6795 
 
6796 
  def __ne__(self, other):
6797 
    return not (self == other)
6798 
 
1590 varun.gupt 6799 
class getUserCommunicationById_args:
6800 
  """
6801 
  Attributes:
6802 
   - id
6803 
  """
6804 
 
6805 
  thrift_spec = (
6806 
    None, # 0
6807 
    (1, TType.I64, 'id', None, None, ), # 1
6808 
  )
6809 
 
6810 
  def __init__(self, id=None,):
6811 
    self.id = id
6812 
 
6813 
  def read(self, iprot):
6814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6816 
      return
6817 
    iprot.readStructBegin()
6818 
    while True:
6819 
      (fname, ftype, fid) = iprot.readFieldBegin()
6820 
      if ftype == TType.STOP:
6821 
        break
6822 
      if fid == 1:
6823 
        if ftype == TType.I64:
6824 
          self.id = iprot.readI64();
6825 
        else:
6826 
          iprot.skip(ftype)
6827 
      else:
6828 
        iprot.skip(ftype)
6829 
      iprot.readFieldEnd()
6830 
    iprot.readStructEnd()
6831 
 
6832 
  def write(self, oprot):
6833 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6834 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6835 
      return
6836 
    oprot.writeStructBegin('getUserCommunicationById_args')
6837 
    if self.id != None:
6838 
      oprot.writeFieldBegin('id', TType.I64, 1)
6839 
      oprot.writeI64(self.id)
6840 
      oprot.writeFieldEnd()
6841 
    oprot.writeFieldStop()
6842 
    oprot.writeStructEnd()
6843 
 
6844 
  def __repr__(self):
6845 
    L = ['%s=%r' % (key, value)
6846 
      for key, value in self.__dict__.iteritems()]
6847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6848 
 
6849 
  def __eq__(self, other):
6850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6851 
 
6852 
  def __ne__(self, other):
6853 
    return not (self == other)
6854 
 
6855 
class getUserCommunicationById_result:
6856 
  """
6857 
  Attributes:
6858 
   - success
6859 
   - ucx
6860 
  """
6861 
 
6862 
  thrift_spec = (
6863 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
6864 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6865 
  )
6866 
 
6867 
  def __init__(self, success=None, ucx=None,):
6868 
    self.success = success
6869 
    self.ucx = ucx
6870 
 
6871 
  def read(self, iprot):
6872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6874 
      return
6875 
    iprot.readStructBegin()
6876 
    while True:
6877 
      (fname, ftype, fid) = iprot.readFieldBegin()
6878 
      if ftype == TType.STOP:
6879 
        break
6880 
      if fid == 0:
6881 
        if ftype == TType.STRUCT:
6882 
          self.success = UserCommunication()
6883 
          self.success.read(iprot)
6884 
        else:
6885 
          iprot.skip(ftype)
6886 
      elif fid == 1:
6887 
        if ftype == TType.STRUCT:
6888 
          self.ucx = UserCommunicationException()
6889 
          self.ucx.read(iprot)
6890 
        else:
6891 
          iprot.skip(ftype)
6892 
      else:
6893 
        iprot.skip(ftype)
6894 
      iprot.readFieldEnd()
6895 
    iprot.readStructEnd()
6896 
 
6897 
  def write(self, oprot):
6898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6900 
      return
6901 
    oprot.writeStructBegin('getUserCommunicationById_result')
6902 
    if self.success != None:
6903 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6904 
      self.success.write(oprot)
6905 
      oprot.writeFieldEnd()
6906 
    if self.ucx != None:
6907 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6908 
      self.ucx.write(oprot)
6909 
      oprot.writeFieldEnd()
6910 
    oprot.writeFieldStop()
6911 
    oprot.writeStructEnd()
6912 
 
6913 
  def __repr__(self):
6914 
    L = ['%s=%r' % (key, value)
6915 
      for key, value in self.__dict__.iteritems()]
6916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6917 
 
6918 
  def __eq__(self, other):
6919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6920 
 
6921 
  def __ne__(self, other):
6922 
    return not (self == other)
6923 
 
6924 
class getUserCommunicationByUser_args:
6925 
  """
6926 
  Attributes:
6927 
   - userId
6928 
  """
6929 
 
6930 
  thrift_spec = (
6931 
    None, # 0
6932 
    (1, TType.I64, 'userId', None, None, ), # 1
6933 
  )
6934 
 
6935 
  def __init__(self, userId=None,):
6936 
    self.userId = userId
6937 
 
6938 
  def read(self, iprot):
6939 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6940 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6941 
      return
6942 
    iprot.readStructBegin()
6943 
    while True:
6944 
      (fname, ftype, fid) = iprot.readFieldBegin()
6945 
      if ftype == TType.STOP:
6946 
        break
6947 
      if fid == 1:
6948 
        if ftype == TType.I64:
6949 
          self.userId = iprot.readI64();
6950 
        else:
6951 
          iprot.skip(ftype)
6952 
      else:
6953 
        iprot.skip(ftype)
6954 
      iprot.readFieldEnd()
6955 
    iprot.readStructEnd()
6956 
 
6957 
  def write(self, oprot):
6958 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6959 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6960 
      return
6961 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
6962 
    if self.userId != None:
6963 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6964 
      oprot.writeI64(self.userId)
6965 
      oprot.writeFieldEnd()
6966 
    oprot.writeFieldStop()
6967 
    oprot.writeStructEnd()
6968 
 
6969 
  def __repr__(self):
6970 
    L = ['%s=%r' % (key, value)
6971 
      for key, value in self.__dict__.iteritems()]
6972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6973 
 
6974 
  def __eq__(self, other):
6975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6976 
 
6977 
  def __ne__(self, other):
6978 
    return not (self == other)
6979 
 
6980 
class getUserCommunicationByUser_result:
6981 
  """
6982 
  Attributes:
6983 
   - success
6984 
   - ucx
6985 
  """
6986 
 
6987 
  thrift_spec = (
6988 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
6989 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6990 
  )
6991 
 
6992 
  def __init__(self, success=None, ucx=None,):
6993 
    self.success = success
6994 
    self.ucx = ucx
6995 
 
6996 
  def read(self, iprot):
6997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6999 
      return
7000 
    iprot.readStructBegin()
7001 
    while True:
7002 
      (fname, ftype, fid) = iprot.readFieldBegin()
7003 
      if ftype == TType.STOP:
7004 
        break
7005 
      if fid == 0:
7006 
        if ftype == TType.LIST:
7007 
          self.success = []
2981 rajveer 7008 
          (_etype38, _size35) = iprot.readListBegin()
7009 
          for _i39 in xrange(_size35):
7010 
            _elem40 = UserCommunication()
7011 
            _elem40.read(iprot)
7012 
            self.success.append(_elem40)
1590 varun.gupt 7013 
          iprot.readListEnd()
7014 
        else:
7015 
          iprot.skip(ftype)
7016 
      elif fid == 1:
7017 
        if ftype == TType.STRUCT:
7018 
          self.ucx = UserCommunicationException()
7019 
          self.ucx.read(iprot)
7020 
        else:
7021 
          iprot.skip(ftype)
7022 
      else:
7023 
        iprot.skip(ftype)
7024 
      iprot.readFieldEnd()
7025 
    iprot.readStructEnd()
7026 
 
7027 
  def write(self, oprot):
7028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7030 
      return
7031 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
7032 
    if self.success != None:
7033 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7034 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 7035 
      for iter41 in self.success:
7036 
        iter41.write(oprot)
1590 varun.gupt 7037 
      oprot.writeListEnd()
7038 
      oprot.writeFieldEnd()
7039 
    if self.ucx != None:
7040 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7041 
      self.ucx.write(oprot)
7042 
      oprot.writeFieldEnd()
7043 
    oprot.writeFieldStop()
7044 
    oprot.writeStructEnd()
7045 
 
7046 
  def __repr__(self):
7047 
    L = ['%s=%r' % (key, value)
7048 
      for key, value in self.__dict__.iteritems()]
7049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7050 
 
7051 
  def __eq__(self, other):
7052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7053 
 
7054 
  def __ne__(self, other):
7055 
    return not (self == other)
7056 
 
7057 
class getAllUserCommunications_args:
7058 
 
7059 
  thrift_spec = (
7060 
  )
7061 
 
7062 
  def read(self, iprot):
7063 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7064 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7065 
      return
7066 
    iprot.readStructBegin()
7067 
    while True:
7068 
      (fname, ftype, fid) = iprot.readFieldBegin()
7069 
      if ftype == TType.STOP:
7070 
        break
7071 
      else:
7072 
        iprot.skip(ftype)
7073 
      iprot.readFieldEnd()
7074 
    iprot.readStructEnd()
7075 
 
7076 
  def write(self, oprot):
7077 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7078 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7079 
      return
7080 
    oprot.writeStructBegin('getAllUserCommunications_args')
7081 
    oprot.writeFieldStop()
7082 
    oprot.writeStructEnd()
7083 
 
7084 
  def __repr__(self):
7085 
    L = ['%s=%r' % (key, value)
7086 
      for key, value in self.__dict__.iteritems()]
7087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7088 
 
7089 
  def __eq__(self, other):
7090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7091 
 
7092 
  def __ne__(self, other):
7093 
    return not (self == other)
7094 
 
7095 
class getAllUserCommunications_result:
7096 
  """
7097 
  Attributes:
7098 
   - success
7099 
   - ucx
7100 
  """
7101 
 
7102 
  thrift_spec = (
7103 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
7104 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7105 
  )
7106 
 
7107 
  def __init__(self, success=None, ucx=None,):
7108 
    self.success = success
7109 
    self.ucx = ucx
7110 
 
7111 
  def read(self, iprot):
7112 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7113 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7114 
      return
7115 
    iprot.readStructBegin()
7116 
    while True:
7117 
      (fname, ftype, fid) = iprot.readFieldBegin()
7118 
      if ftype == TType.STOP:
7119 
        break
7120 
      if fid == 0:
7121 
        if ftype == TType.LIST:
7122 
          self.success = []
2981 rajveer 7123 
          (_etype45, _size42) = iprot.readListBegin()
7124 
          for _i46 in xrange(_size42):
7125 
            _elem47 = UserCommunication()
7126 
            _elem47.read(iprot)
7127 
            self.success.append(_elem47)
1590 varun.gupt 7128 
          iprot.readListEnd()
7129 
        else:
7130 
          iprot.skip(ftype)
7131 
      elif fid == 1:
7132 
        if ftype == TType.STRUCT:
7133 
          self.ucx = UserCommunicationException()
7134 
          self.ucx.read(iprot)
7135 
        else:
7136 
          iprot.skip(ftype)
7137 
      else:
7138 
        iprot.skip(ftype)
7139 
      iprot.readFieldEnd()
7140 
    iprot.readStructEnd()
7141 
 
7142 
  def write(self, oprot):
7143 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7144 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7145 
      return
7146 
    oprot.writeStructBegin('getAllUserCommunications_result')
7147 
    if self.success != None:
7148 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7149 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 7150 
      for iter48 in self.success:
7151 
        iter48.write(oprot)
1590 varun.gupt 7152 
      oprot.writeListEnd()
7153 
      oprot.writeFieldEnd()
7154 
    if self.ucx != None:
7155 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7156 
      self.ucx.write(oprot)
7157 
      oprot.writeFieldEnd()
7158 
    oprot.writeFieldStop()
7159 
    oprot.writeStructEnd()
7160 
 
7161 
  def __repr__(self):
7162 
    L = ['%s=%r' % (key, value)
7163 
      for key, value in self.__dict__.iteritems()]
7164 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7165 
 
7166 
  def __eq__(self, other):
7167 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7168 
 
7169 
  def __ne__(self, other):
7170 
    return not (self == other)
7171 
 
1845 vikas 7172 
class createMasterAffiliate_args:
7173 
  """
7174 
  Attributes:
7175 
   - name
1859 vikas 7176 
   - addedOn
1845 vikas 7177 
  """
7178 
 
7179 
  thrift_spec = (
7180 
    None, # 0
7181 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 7182 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 7183 
  )
7184 
 
1859 vikas 7185 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 7186 
    self.name = name
1859 vikas 7187 
    self.addedOn = addedOn
1845 vikas 7188 
 
7189 
  def read(self, iprot):
7190 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7191 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7192 
      return
7193 
    iprot.readStructBegin()
7194 
    while True:
7195 
      (fname, ftype, fid) = iprot.readFieldBegin()
7196 
      if ftype == TType.STOP:
7197 
        break
7198 
      if fid == 1:
7199 
        if ftype == TType.STRING:
7200 
          self.name = iprot.readString();
7201 
        else:
7202 
          iprot.skip(ftype)
1859 vikas 7203 
      elif fid == 2:
7204 
        if ftype == TType.I64:
7205 
          self.addedOn = iprot.readI64();
7206 
        else:
7207 
          iprot.skip(ftype)
1845 vikas 7208 
      else:
7209 
        iprot.skip(ftype)
7210 
      iprot.readFieldEnd()
7211 
    iprot.readStructEnd()
7212 
 
7213 
  def write(self, oprot):
7214 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7215 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7216 
      return
7217 
    oprot.writeStructBegin('createMasterAffiliate_args')
7218 
    if self.name != None:
7219 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7220 
      oprot.writeString(self.name)
7221 
      oprot.writeFieldEnd()
1859 vikas 7222 
    if self.addedOn != None:
7223 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
7224 
      oprot.writeI64(self.addedOn)
7225 
      oprot.writeFieldEnd()
1845 vikas 7226 
    oprot.writeFieldStop()
7227 
    oprot.writeStructEnd()
7228 
 
7229 
  def __repr__(self):
7230 
    L = ['%s=%r' % (key, value)
7231 
      for key, value in self.__dict__.iteritems()]
7232 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7233 
 
7234 
  def __eq__(self, other):
7235 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7236 
 
7237 
  def __ne__(self, other):
7238 
    return not (self == other)
7239 
 
7240 
class createMasterAffiliate_result:
7241 
  """
7242 
  Attributes:
7243 
   - success
7244 
   - utx
7245 
  """
7246 
 
7247 
  thrift_spec = (
7248 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7249 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7250 
  )
7251 
 
7252 
  def __init__(self, success=None, utx=None,):
7253 
    self.success = success
7254 
    self.utx = utx
7255 
 
7256 
  def read(self, iprot):
7257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7259 
      return
7260 
    iprot.readStructBegin()
7261 
    while True:
7262 
      (fname, ftype, fid) = iprot.readFieldBegin()
7263 
      if ftype == TType.STOP:
7264 
        break
7265 
      if fid == 0:
7266 
        if ftype == TType.STRUCT:
7267 
          self.success = MasterAffiliate()
7268 
          self.success.read(iprot)
7269 
        else:
7270 
          iprot.skip(ftype)
7271 
      elif fid == 1:
7272 
        if ftype == TType.STRUCT:
1996 vikas 7273 
          self.utx = UserAffiliateException()
1845 vikas 7274 
          self.utx.read(iprot)
7275 
        else:
7276 
          iprot.skip(ftype)
7277 
      else:
7278 
        iprot.skip(ftype)
7279 
      iprot.readFieldEnd()
7280 
    iprot.readStructEnd()
7281 
 
7282 
  def write(self, oprot):
7283 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7284 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7285 
      return
7286 
    oprot.writeStructBegin('createMasterAffiliate_result')
7287 
    if self.success != None:
7288 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7289 
      self.success.write(oprot)
7290 
      oprot.writeFieldEnd()
7291 
    if self.utx != None:
7292 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7293 
      self.utx.write(oprot)
7294 
      oprot.writeFieldEnd()
7295 
    oprot.writeFieldStop()
7296 
    oprot.writeStructEnd()
7297 
 
7298 
  def __repr__(self):
7299 
    L = ['%s=%r' % (key, value)
7300 
      for key, value in self.__dict__.iteritems()]
7301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7302 
 
7303 
  def __eq__(self, other):
7304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7305 
 
7306 
  def __ne__(self, other):
7307 
    return not (self == other)
7308 
 
1899 vikas 7309 
class getAllMasterAffiliates_args:
7310 
 
7311 
  thrift_spec = (
7312 
  )
7313 
 
7314 
  def read(self, iprot):
7315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7317 
      return
7318 
    iprot.readStructBegin()
7319 
    while True:
7320 
      (fname, ftype, fid) = iprot.readFieldBegin()
7321 
      if ftype == TType.STOP:
7322 
        break
7323 
      else:
7324 
        iprot.skip(ftype)
7325 
      iprot.readFieldEnd()
7326 
    iprot.readStructEnd()
7327 
 
7328 
  def write(self, oprot):
7329 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7330 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7331 
      return
7332 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
7333 
    oprot.writeFieldStop()
7334 
    oprot.writeStructEnd()
7335 
 
7336 
  def __repr__(self):
7337 
    L = ['%s=%r' % (key, value)
7338 
      for key, value in self.__dict__.iteritems()]
7339 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7340 
 
7341 
  def __eq__(self, other):
7342 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7343 
 
7344 
  def __ne__(self, other):
7345 
    return not (self == other)
7346 
 
7347 
class getAllMasterAffiliates_result:
7348 
  """
7349 
  Attributes:
7350 
   - success
7351 
   - utx
7352 
  """
7353 
 
7354 
  thrift_spec = (
7355 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 7356 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 7357 
  )
7358 
 
7359 
  def __init__(self, success=None, utx=None,):
7360 
    self.success = success
7361 
    self.utx = utx
7362 
 
7363 
  def read(self, iprot):
7364 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7365 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7366 
      return
7367 
    iprot.readStructBegin()
7368 
    while True:
7369 
      (fname, ftype, fid) = iprot.readFieldBegin()
7370 
      if ftype == TType.STOP:
7371 
        break
7372 
      if fid == 0:
7373 
        if ftype == TType.LIST:
7374 
          self.success = []
2981 rajveer 7375 
          (_etype52, _size49) = iprot.readListBegin()
7376 
          for _i53 in xrange(_size49):
7377 
            _elem54 = MasterAffiliate()
7378 
            _elem54.read(iprot)
7379 
            self.success.append(_elem54)
1899 vikas 7380 
          iprot.readListEnd()
7381 
        else:
7382 
          iprot.skip(ftype)
7383 
      elif fid == 1:
7384 
        if ftype == TType.STRUCT:
1996 vikas 7385 
          self.utx = UserAffiliateException()
1899 vikas 7386 
          self.utx.read(iprot)
7387 
        else:
7388 
          iprot.skip(ftype)
7389 
      else:
7390 
        iprot.skip(ftype)
7391 
      iprot.readFieldEnd()
7392 
    iprot.readStructEnd()
7393 
 
7394 
  def write(self, oprot):
7395 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7396 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7397 
      return
7398 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
7399 
    if self.success != None:
7400 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7401 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 7402 
      for iter55 in self.success:
7403 
        iter55.write(oprot)
1899 vikas 7404 
      oprot.writeListEnd()
7405 
      oprot.writeFieldEnd()
7406 
    if self.utx != None:
7407 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7408 
      self.utx.write(oprot)
7409 
      oprot.writeFieldEnd()
7410 
    oprot.writeFieldStop()
7411 
    oprot.writeStructEnd()
7412 
 
7413 
  def __repr__(self):
7414 
    L = ['%s=%r' % (key, value)
7415 
      for key, value in self.__dict__.iteritems()]
7416 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7417 
 
7418 
  def __eq__(self, other):
7419 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7420 
 
7421 
  def __ne__(self, other):
7422 
    return not (self == other)
7423 
 
1845 vikas 7424 
class getMasterAffiliateById_args:
7425 
  """
7426 
  Attributes:
7427 
   - id
7428 
  """
7429 
 
7430 
  thrift_spec = (
7431 
    None, # 0
7432 
    (1, TType.I64, 'id', None, None, ), # 1
7433 
  )
7434 
 
7435 
  def __init__(self, id=None,):
7436 
    self.id = id
7437 
 
7438 
  def read(self, iprot):
7439 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7440 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7441 
      return
7442 
    iprot.readStructBegin()
7443 
    while True:
7444 
      (fname, ftype, fid) = iprot.readFieldBegin()
7445 
      if ftype == TType.STOP:
7446 
        break
7447 
      if fid == 1:
7448 
        if ftype == TType.I64:
7449 
          self.id = iprot.readI64();
7450 
        else:
7451 
          iprot.skip(ftype)
7452 
      else:
7453 
        iprot.skip(ftype)
7454 
      iprot.readFieldEnd()
7455 
    iprot.readStructEnd()
7456 
 
7457 
  def write(self, oprot):
7458 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7459 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7460 
      return
7461 
    oprot.writeStructBegin('getMasterAffiliateById_args')
7462 
    if self.id != None:
7463 
      oprot.writeFieldBegin('id', TType.I64, 1)
7464 
      oprot.writeI64(self.id)
7465 
      oprot.writeFieldEnd()
7466 
    oprot.writeFieldStop()
7467 
    oprot.writeStructEnd()
7468 
 
7469 
  def __repr__(self):
7470 
    L = ['%s=%r' % (key, value)
7471 
      for key, value in self.__dict__.iteritems()]
7472 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7473 
 
7474 
  def __eq__(self, other):
7475 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7476 
 
7477 
  def __ne__(self, other):
7478 
    return not (self == other)
7479 
 
7480 
class getMasterAffiliateById_result:
7481 
  """
7482 
  Attributes:
7483 
   - success
7484 
   - utx
7485 
  """
7486 
 
7487 
  thrift_spec = (
7488 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7489 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7490 
  )
7491 
 
7492 
  def __init__(self, success=None, utx=None,):
7493 
    self.success = success
7494 
    self.utx = utx
7495 
 
7496 
  def read(self, iprot):
7497 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7498 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7499 
      return
7500 
    iprot.readStructBegin()
7501 
    while True:
7502 
      (fname, ftype, fid) = iprot.readFieldBegin()
7503 
      if ftype == TType.STOP:
7504 
        break
7505 
      if fid == 0:
7506 
        if ftype == TType.STRUCT:
7507 
          self.success = MasterAffiliate()
7508 
          self.success.read(iprot)
7509 
        else:
7510 
          iprot.skip(ftype)
7511 
      elif fid == 1:
7512 
        if ftype == TType.STRUCT:
1996 vikas 7513 
          self.utx = UserAffiliateException()
1845 vikas 7514 
          self.utx.read(iprot)
7515 
        else:
7516 
          iprot.skip(ftype)
7517 
      else:
7518 
        iprot.skip(ftype)
7519 
      iprot.readFieldEnd()
7520 
    iprot.readStructEnd()
7521 
 
7522 
  def write(self, oprot):
7523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7525 
      return
7526 
    oprot.writeStructBegin('getMasterAffiliateById_result')
7527 
    if self.success != None:
7528 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7529 
      self.success.write(oprot)
7530 
      oprot.writeFieldEnd()
7531 
    if self.utx != None:
7532 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7533 
      self.utx.write(oprot)
7534 
      oprot.writeFieldEnd()
7535 
    oprot.writeFieldStop()
7536 
    oprot.writeStructEnd()
7537 
 
7538 
  def __repr__(self):
7539 
    L = ['%s=%r' % (key, value)
7540 
      for key, value in self.__dict__.iteritems()]
7541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7542 
 
7543 
  def __eq__(self, other):
7544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7545 
 
7546 
  def __ne__(self, other):
7547 
    return not (self == other)
7548 
 
7549 
class getMasterAffiliateByName_args:
7550 
  """
7551 
  Attributes:
7552 
   - name
7553 
  """
7554 
 
7555 
  thrift_spec = (
7556 
    None, # 0
7557 
    (1, TType.STRING, 'name', None, None, ), # 1
7558 
  )
7559 
 
7560 
  def __init__(self, name=None,):
7561 
    self.name = name
7562 
 
7563 
  def read(self, iprot):
7564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7566 
      return
7567 
    iprot.readStructBegin()
7568 
    while True:
7569 
      (fname, ftype, fid) = iprot.readFieldBegin()
7570 
      if ftype == TType.STOP:
7571 
        break
7572 
      if fid == 1:
7573 
        if ftype == TType.STRING:
7574 
          self.name = iprot.readString();
7575 
        else:
7576 
          iprot.skip(ftype)
7577 
      else:
7578 
        iprot.skip(ftype)
7579 
      iprot.readFieldEnd()
7580 
    iprot.readStructEnd()
7581 
 
7582 
  def write(self, oprot):
7583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7585 
      return
7586 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
7587 
    if self.name != None:
7588 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7589 
      oprot.writeString(self.name)
7590 
      oprot.writeFieldEnd()
7591 
    oprot.writeFieldStop()
7592 
    oprot.writeStructEnd()
7593 
 
7594 
  def __repr__(self):
7595 
    L = ['%s=%r' % (key, value)
7596 
      for key, value in self.__dict__.iteritems()]
7597 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7598 
 
7599 
  def __eq__(self, other):
7600 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7601 
 
7602 
  def __ne__(self, other):
7603 
    return not (self == other)
7604 
 
7605 
class getMasterAffiliateByName_result:
7606 
  """
7607 
  Attributes:
7608 
   - success
7609 
   - utx
7610 
  """
7611 
 
7612 
  thrift_spec = (
7613 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7614 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7615 
  )
7616 
 
7617 
  def __init__(self, success=None, utx=None,):
7618 
    self.success = success
7619 
    self.utx = utx
7620 
 
7621 
  def read(self, iprot):
7622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7624 
      return
7625 
    iprot.readStructBegin()
7626 
    while True:
7627 
      (fname, ftype, fid) = iprot.readFieldBegin()
7628 
      if ftype == TType.STOP:
7629 
        break
7630 
      if fid == 0:
7631 
        if ftype == TType.STRUCT:
7632 
          self.success = MasterAffiliate()
7633 
          self.success.read(iprot)
7634 
        else:
7635 
          iprot.skip(ftype)
7636 
      elif fid == 1:
7637 
        if ftype == TType.STRUCT:
1996 vikas 7638 
          self.utx = UserAffiliateException()
1845 vikas 7639 
          self.utx.read(iprot)
7640 
        else:
7641 
          iprot.skip(ftype)
7642 
      else:
7643 
        iprot.skip(ftype)
7644 
      iprot.readFieldEnd()
7645 
    iprot.readStructEnd()
7646 
 
7647 
  def write(self, oprot):
7648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7650 
      return
7651 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
7652 
    if self.success != None:
7653 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7654 
      self.success.write(oprot)
7655 
      oprot.writeFieldEnd()
7656 
    if self.utx != None:
7657 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7658 
      self.utx.write(oprot)
7659 
      oprot.writeFieldEnd()
7660 
    oprot.writeFieldStop()
7661 
    oprot.writeStructEnd()
7662 
 
7663 
  def __repr__(self):
7664 
    L = ['%s=%r' % (key, value)
7665 
      for key, value in self.__dict__.iteritems()]
7666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7667 
 
7668 
  def __eq__(self, other):
7669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7670 
 
7671 
  def __ne__(self, other):
7672 
    return not (self == other)
7673 
 
7674 
class createAffiliate_args:
7675 
  """
7676 
  Attributes:
7677 
   - name
7678 
   - url
7679 
   - masterAffiliateId
1859 vikas 7680 
   - addedOn
1845 vikas 7681 
  """
7682 
 
7683 
  thrift_spec = (
7684 
    None, # 0
7685 
    (1, TType.STRING, 'name', None, None, ), # 1
7686 
    (2, TType.STRING, 'url', None, None, ), # 2
7687 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 7688 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 7689 
  )
7690 
 
1859 vikas 7691 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 7692 
    self.name = name
7693 
    self.url = url
7694 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 7695 
    self.addedOn = addedOn
1845 vikas 7696 
 
7697 
  def read(self, iprot):
7698 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7699 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7700 
      return
7701 
    iprot.readStructBegin()
7702 
    while True:
7703 
      (fname, ftype, fid) = iprot.readFieldBegin()
7704 
      if ftype == TType.STOP:
7705 
        break
7706 
      if fid == 1:
7707 
        if ftype == TType.STRING:
7708 
          self.name = iprot.readString();
7709 
        else:
7710 
          iprot.skip(ftype)
7711 
      elif fid == 2:
7712 
        if ftype == TType.STRING:
7713 
          self.url = iprot.readString();
7714 
        else:
7715 
          iprot.skip(ftype)
7716 
      elif fid == 3:
7717 
        if ftype == TType.I64:
7718 
          self.masterAffiliateId = iprot.readI64();
7719 
        else:
7720 
          iprot.skip(ftype)
1859 vikas 7721 
      elif fid == 4:
7722 
        if ftype == TType.I64:
7723 
          self.addedOn = iprot.readI64();
7724 
        else:
7725 
          iprot.skip(ftype)
1845 vikas 7726 
      else:
7727 
        iprot.skip(ftype)
7728 
      iprot.readFieldEnd()
7729 
    iprot.readStructEnd()
7730 
 
7731 
  def write(self, oprot):
7732 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7733 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7734 
      return
7735 
    oprot.writeStructBegin('createAffiliate_args')
7736 
    if self.name != None:
7737 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7738 
      oprot.writeString(self.name)
7739 
      oprot.writeFieldEnd()
7740 
    if self.url != None:
7741 
      oprot.writeFieldBegin('url', TType.STRING, 2)
7742 
      oprot.writeString(self.url)
7743 
      oprot.writeFieldEnd()
7744 
    if self.masterAffiliateId != None:
7745 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
7746 
      oprot.writeI64(self.masterAffiliateId)
7747 
      oprot.writeFieldEnd()
1859 vikas 7748 
    if self.addedOn != None:
7749 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
7750 
      oprot.writeI64(self.addedOn)
7751 
      oprot.writeFieldEnd()
1845 vikas 7752 
    oprot.writeFieldStop()
7753 
    oprot.writeStructEnd()
7754 
 
7755 
  def __repr__(self):
7756 
    L = ['%s=%r' % (key, value)
7757 
      for key, value in self.__dict__.iteritems()]
7758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7759 
 
7760 
  def __eq__(self, other):
7761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7762 
 
7763 
  def __ne__(self, other):
7764 
    return not (self == other)
7765 
 
7766 
class createAffiliate_result:
7767 
  """
7768 
  Attributes:
7769 
   - success
7770 
   - utx
7771 
  """
7772 
 
7773 
  thrift_spec = (
7774 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 7775 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7776 
  )
7777 
 
7778 
  def __init__(self, success=None, utx=None,):
7779 
    self.success = success
7780 
    self.utx = utx
7781 
 
7782 
  def read(self, iprot):
7783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7785 
      return
7786 
    iprot.readStructBegin()
7787 
    while True:
7788 
      (fname, ftype, fid) = iprot.readFieldBegin()
7789 
      if ftype == TType.STOP:
7790 
        break
7791 
      if fid == 0:
7792 
        if ftype == TType.STRUCT:
7793 
          self.success = Affiliate()
7794 
          self.success.read(iprot)
7795 
        else:
7796 
          iprot.skip(ftype)
7797 
      elif fid == 1:
7798 
        if ftype == TType.STRUCT:
1996 vikas 7799 
          self.utx = UserAffiliateException()
1845 vikas 7800 
          self.utx.read(iprot)
7801 
        else:
7802 
          iprot.skip(ftype)
7803 
      else:
7804 
        iprot.skip(ftype)
7805 
      iprot.readFieldEnd()
7806 
    iprot.readStructEnd()
7807 
 
7808 
  def write(self, oprot):
7809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7811 
      return
7812 
    oprot.writeStructBegin('createAffiliate_result')
7813 
    if self.success != None:
7814 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7815 
      self.success.write(oprot)
7816 
      oprot.writeFieldEnd()
7817 
    if self.utx != None:
7818 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7819 
      self.utx.write(oprot)
7820 
      oprot.writeFieldEnd()
7821 
    oprot.writeFieldStop()
7822 
    oprot.writeStructEnd()
7823 
 
7824 
  def __repr__(self):
7825 
    L = ['%s=%r' % (key, value)
7826 
      for key, value in self.__dict__.iteritems()]
7827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7828 
 
7829 
  def __eq__(self, other):
7830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7831 
 
7832 
  def __ne__(self, other):
7833 
    return not (self == other)
7834 
 
7835 
class getAffiliateById_args:
7836 
  """
7837 
  Attributes:
7838 
   - id
7839 
  """
7840 
 
7841 
  thrift_spec = (
7842 
    None, # 0
7843 
    (1, TType.I64, 'id', None, None, ), # 1
7844 
  )
7845 
 
7846 
  def __init__(self, id=None,):
7847 
    self.id = id
7848 
 
7849 
  def read(self, iprot):
7850 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7851 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7852 
      return
7853 
    iprot.readStructBegin()
7854 
    while True:
7855 
      (fname, ftype, fid) = iprot.readFieldBegin()
7856 
      if ftype == TType.STOP:
7857 
        break
7858 
      if fid == 1:
7859 
        if ftype == TType.I64:
7860 
          self.id = iprot.readI64();
7861 
        else:
7862 
          iprot.skip(ftype)
7863 
      else:
7864 
        iprot.skip(ftype)
7865 
      iprot.readFieldEnd()
7866 
    iprot.readStructEnd()
7867 
 
7868 
  def write(self, oprot):
7869 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7870 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7871 
      return
7872 
    oprot.writeStructBegin('getAffiliateById_args')
7873 
    if self.id != None:
7874 
      oprot.writeFieldBegin('id', TType.I64, 1)
7875 
      oprot.writeI64(self.id)
7876 
      oprot.writeFieldEnd()
7877 
    oprot.writeFieldStop()
7878 
    oprot.writeStructEnd()
7879 
 
7880 
  def __repr__(self):
7881 
    L = ['%s=%r' % (key, value)
7882 
      for key, value in self.__dict__.iteritems()]
7883 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7884 
 
7885 
  def __eq__(self, other):
7886 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7887 
 
7888 
  def __ne__(self, other):
7889 
    return not (self == other)
7890 
 
7891 
class getAffiliateById_result:
7892 
  """
7893 
  Attributes:
7894 
   - success
7895 
   - utx
7896 
  """
7897 
 
7898 
  thrift_spec = (
7899 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 7900 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7901 
  )
7902 
 
7903 
  def __init__(self, success=None, utx=None,):
7904 
    self.success = success
7905 
    self.utx = utx
7906 
 
7907 
  def read(self, iprot):
7908 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7909 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7910 
      return
7911 
    iprot.readStructBegin()
7912 
    while True:
7913 
      (fname, ftype, fid) = iprot.readFieldBegin()
7914 
      if ftype == TType.STOP:
7915 
        break
7916 
      if fid == 0:
7917 
        if ftype == TType.STRUCT:
7918 
          self.success = Affiliate()
7919 
          self.success.read(iprot)
7920 
        else:
7921 
          iprot.skip(ftype)
7922 
      elif fid == 1:
7923 
        if ftype == TType.STRUCT:
1996 vikas 7924 
          self.utx = UserAffiliateException()
1845 vikas 7925 
          self.utx.read(iprot)
7926 
        else:
7927 
          iprot.skip(ftype)
7928 
      else:
7929 
        iprot.skip(ftype)
7930 
      iprot.readFieldEnd()
7931 
    iprot.readStructEnd()
7932 
 
7933 
  def write(self, oprot):
7934 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7935 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7936 
      return
7937 
    oprot.writeStructBegin('getAffiliateById_result')
7938 
    if self.success != None:
7939 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7940 
      self.success.write(oprot)
7941 
      oprot.writeFieldEnd()
7942 
    if self.utx != None:
7943 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7944 
      self.utx.write(oprot)
7945 
      oprot.writeFieldEnd()
7946 
    oprot.writeFieldStop()
7947 
    oprot.writeStructEnd()
7948 
 
7949 
  def __repr__(self):
7950 
    L = ['%s=%r' % (key, value)
7951 
      for key, value in self.__dict__.iteritems()]
7952 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7953 
 
7954 
  def __eq__(self, other):
7955 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7956 
 
7957 
  def __ne__(self, other):
7958 
    return not (self == other)
7959 
 
7960 
class getAffiliateByName_args:
7961 
  """
7962 
  Attributes:
7963 
   - name
7964 
  """
7965 
 
7966 
  thrift_spec = (
7967 
    None, # 0
7968 
    (1, TType.STRING, 'name', None, None, ), # 1
7969 
  )
7970 
 
7971 
  def __init__(self, name=None,):
7972 
    self.name = name
7973 
 
7974 
  def read(self, iprot):
7975 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7976 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7977 
      return
7978 
    iprot.readStructBegin()
7979 
    while True:
7980 
      (fname, ftype, fid) = iprot.readFieldBegin()
7981 
      if ftype == TType.STOP:
7982 
        break
7983 
      if fid == 1:
7984 
        if ftype == TType.STRING:
7985 
          self.name = iprot.readString();
7986 
        else:
7987 
          iprot.skip(ftype)
7988 
      else:
7989 
        iprot.skip(ftype)
7990 
      iprot.readFieldEnd()
7991 
    iprot.readStructEnd()
7992 
 
7993 
  def write(self, oprot):
7994 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7995 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7996 
      return
7997 
    oprot.writeStructBegin('getAffiliateByName_args')
7998 
    if self.name != None:
7999 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8000 
      oprot.writeString(self.name)
8001 
      oprot.writeFieldEnd()
8002 
    oprot.writeFieldStop()
8003 
    oprot.writeStructEnd()
8004 
 
8005 
  def __repr__(self):
8006 
    L = ['%s=%r' % (key, value)
8007 
      for key, value in self.__dict__.iteritems()]
8008 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8009 
 
8010 
  def __eq__(self, other):
8011 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8012 
 
8013 
  def __ne__(self, other):
8014 
    return not (self == other)
8015 
 
8016 
class getAffiliateByName_result:
8017 
  """
8018 
  Attributes:
8019 
   - success
8020 
   - utx
8021 
  """
8022 
 
8023 
  thrift_spec = (
8024 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8025 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8026 
  )
8027 
 
8028 
  def __init__(self, success=None, utx=None,):
8029 
    self.success = success
8030 
    self.utx = utx
8031 
 
8032 
  def read(self, iprot):
8033 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8034 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8035 
      return
8036 
    iprot.readStructBegin()
8037 
    while True:
8038 
      (fname, ftype, fid) = iprot.readFieldBegin()
8039 
      if ftype == TType.STOP:
8040 
        break
8041 
      if fid == 0:
8042 
        if ftype == TType.STRUCT:
8043 
          self.success = Affiliate()
8044 
          self.success.read(iprot)
8045 
        else:
8046 
          iprot.skip(ftype)
8047 
      elif fid == 1:
8048 
        if ftype == TType.STRUCT:
1996 vikas 8049 
          self.utx = UserAffiliateException()
1845 vikas 8050 
          self.utx.read(iprot)
8051 
        else:
8052 
          iprot.skip(ftype)
8053 
      else:
8054 
        iprot.skip(ftype)
8055 
      iprot.readFieldEnd()
8056 
    iprot.readStructEnd()
8057 
 
8058 
  def write(self, oprot):
8059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8061 
      return
8062 
    oprot.writeStructBegin('getAffiliateByName_result')
8063 
    if self.success != None:
8064 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8065 
      self.success.write(oprot)
8066 
      oprot.writeFieldEnd()
8067 
    if self.utx != None:
8068 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8069 
      self.utx.write(oprot)
8070 
      oprot.writeFieldEnd()
8071 
    oprot.writeFieldStop()
8072 
    oprot.writeStructEnd()
8073 
 
8074 
  def __repr__(self):
8075 
    L = ['%s=%r' % (key, value)
8076 
      for key, value in self.__dict__.iteritems()]
8077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8078 
 
8079 
  def __eq__(self, other):
8080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8081 
 
8082 
  def __ne__(self, other):
8083 
    return not (self == other)
8084 
 
1996 vikas 8085 
class getTrackerById_args:
1845 vikas 8086 
  """
8087 
  Attributes:
8088 
   - id
8089 
  """
8090 
 
8091 
  thrift_spec = (
8092 
    None, # 0
8093 
    (1, TType.I64, 'id', None, None, ), # 1
8094 
  )
8095 
 
8096 
  def __init__(self, id=None,):
8097 
    self.id = id
8098 
 
8099 
  def read(self, iprot):
8100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8102 
      return
8103 
    iprot.readStructBegin()
8104 
    while True:
8105 
      (fname, ftype, fid) = iprot.readFieldBegin()
8106 
      if ftype == TType.STOP:
8107 
        break
8108 
      if fid == 1:
8109 
        if ftype == TType.I64:
8110 
          self.id = iprot.readI64();
8111 
        else:
8112 
          iprot.skip(ftype)
8113 
      else:
8114 
        iprot.skip(ftype)
8115 
      iprot.readFieldEnd()
8116 
    iprot.readStructEnd()
8117 
 
8118 
  def write(self, oprot):
8119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8121 
      return
1996 vikas 8122 
    oprot.writeStructBegin('getTrackerById_args')
1845 vikas 8123 
    if self.id != None:
8124 
      oprot.writeFieldBegin('id', TType.I64, 1)
8125 
      oprot.writeI64(self.id)
8126 
      oprot.writeFieldEnd()
8127 
    oprot.writeFieldStop()
8128 
    oprot.writeStructEnd()
8129 
 
8130 
  def __repr__(self):
8131 
    L = ['%s=%r' % (key, value)
8132 
      for key, value in self.__dict__.iteritems()]
8133 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8134 
 
8135 
  def __eq__(self, other):
8136 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8137 
 
8138 
  def __ne__(self, other):
8139 
    return not (self == other)
8140 
 
8141 
class getTrackerById_result:
8142 
  """
8143 
  Attributes:
8144 
   - success
8145 
   - utx
8146 
  """
8147 
 
8148 
  thrift_spec = (
8149 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 8150 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8151 
  )
8152 
 
8153 
  def __init__(self, success=None, utx=None,):
8154 
    self.success = success
8155 
    self.utx = utx
8156 
 
8157 
  def read(self, iprot):
8158 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8159 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8160 
      return
8161 
    iprot.readStructBegin()
8162 
    while True:
8163 
      (fname, ftype, fid) = iprot.readFieldBegin()
8164 
      if ftype == TType.STOP:
8165 
        break
8166 
      if fid == 0:
8167 
        if ftype == TType.STRUCT:
8168 
          self.success = Tracker()
8169 
          self.success.read(iprot)
8170 
        else:
8171 
          iprot.skip(ftype)
8172 
      elif fid == 1:
8173 
        if ftype == TType.STRUCT:
1996 vikas 8174 
          self.utx = UserAffiliateException()
1845 vikas 8175 
          self.utx.read(iprot)
8176 
        else:
8177 
          iprot.skip(ftype)
8178 
      else:
8179 
        iprot.skip(ftype)
8180 
      iprot.readFieldEnd()
8181 
    iprot.readStructEnd()
8182 
 
8183 
  def write(self, oprot):
8184 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8185 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8186 
      return
8187 
    oprot.writeStructBegin('getTrackerById_result')
8188 
    if self.success != None:
8189 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8190 
      self.success.write(oprot)
8191 
      oprot.writeFieldEnd()
8192 
    if self.utx != None:
8193 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8194 
      self.utx.write(oprot)
8195 
      oprot.writeFieldEnd()
8196 
    oprot.writeFieldStop()
8197 
    oprot.writeStructEnd()
8198 
 
8199 
  def __repr__(self):
8200 
    L = ['%s=%r' % (key, value)
8201 
      for key, value in self.__dict__.iteritems()]
8202 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8203 
 
8204 
  def __eq__(self, other):
8205 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8206 
 
8207 
  def __ne__(self, other):
8208 
    return not (self == other)
8209 
 
1996 vikas 8210 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 8211 
  """
8212 
  Attributes:
1996 vikas 8213 
   - id
1845 vikas 8214 
  """
8215 
 
8216 
  thrift_spec = (
8217 
    None, # 0
1996 vikas 8218 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 8219 
  )
8220 
 
1996 vikas 8221 
  def __init__(self, id=None,):
8222 
    self.id = id
1845 vikas 8223 
 
8224 
  def read(self, iprot):
8225 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8226 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8227 
      return
8228 
    iprot.readStructBegin()
8229 
    while True:
8230 
      (fname, ftype, fid) = iprot.readFieldBegin()
8231 
      if ftype == TType.STOP:
8232 
        break
8233 
      if fid == 1:
8234 
        if ftype == TType.I64:
1996 vikas 8235 
          self.id = iprot.readI64();
1845 vikas 8236 
        else:
8237 
          iprot.skip(ftype)
8238 
      else:
8239 
        iprot.skip(ftype)
8240 
      iprot.readFieldEnd()
8241 
    iprot.readStructEnd()
8242 
 
8243 
  def write(self, oprot):
8244 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8245 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8246 
      return
1996 vikas 8247 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
8248 
    if self.id != None:
8249 
      oprot.writeFieldBegin('id', TType.I64, 1)
8250 
      oprot.writeI64(self.id)
1845 vikas 8251 
      oprot.writeFieldEnd()
8252 
    oprot.writeFieldStop()
8253 
    oprot.writeStructEnd()
8254 
 
8255 
  def __repr__(self):
8256 
    L = ['%s=%r' % (key, value)
8257 
      for key, value in self.__dict__.iteritems()]
8258 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8259 
 
8260 
  def __eq__(self, other):
8261 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8262 
 
8263 
  def __ne__(self, other):
8264 
    return not (self == other)
8265 
 
1996 vikas 8266 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 8267 
  """
8268 
  Attributes:
8269 
   - success
8270 
   - utx
8271 
  """
8272 
 
8273 
  thrift_spec = (
1996 vikas 8274 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
8275 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8276 
  )
8277 
 
8278 
  def __init__(self, success=None, utx=None,):
8279 
    self.success = success
8280 
    self.utx = utx
8281 
 
8282 
  def read(self, iprot):
8283 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8284 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8285 
      return
8286 
    iprot.readStructBegin()
8287 
    while True:
8288 
      (fname, ftype, fid) = iprot.readFieldBegin()
8289 
      if ftype == TType.STOP:
8290 
        break
8291 
      if fid == 0:
8292 
        if ftype == TType.LIST:
8293 
          self.success = []
2981 rajveer 8294 
          (_etype59, _size56) = iprot.readListBegin()
8295 
          for _i60 in xrange(_size56):
8296 
            _elem61 = Affiliate()
8297 
            _elem61.read(iprot)
8298 
            self.success.append(_elem61)
1845 vikas 8299 
          iprot.readListEnd()
8300 
        else:
8301 
          iprot.skip(ftype)
8302 
      elif fid == 1:
8303 
        if ftype == TType.STRUCT:
1996 vikas 8304 
          self.utx = UserAffiliateException()
1845 vikas 8305 
          self.utx.read(iprot)
8306 
        else:
8307 
          iprot.skip(ftype)
8308 
      else:
8309 
        iprot.skip(ftype)
8310 
      iprot.readFieldEnd()
8311 
    iprot.readStructEnd()
8312 
 
8313 
  def write(self, oprot):
8314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8316 
      return
1996 vikas 8317 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
1845 vikas 8318 
    if self.success != None:
8319 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8320 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 8321 
      for iter62 in self.success:
8322 
        iter62.write(oprot)
1845 vikas 8323 
      oprot.writeListEnd()
8324 
      oprot.writeFieldEnd()
8325 
    if self.utx != None:
8326 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8327 
      self.utx.write(oprot)
8328 
      oprot.writeFieldEnd()
8329 
    oprot.writeFieldStop()
8330 
    oprot.writeStructEnd()
8331 
 
8332 
  def __repr__(self):
8333 
    L = ['%s=%r' % (key, value)
8334 
      for key, value in self.__dict__.iteritems()]
8335 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8336 
 
8337 
  def __eq__(self, other):
8338 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8339 
 
8340 
  def __ne__(self, other):
8341 
    return not (self == other)
8342 
 
8343 
class addTrackLog_args:
8344 
  """
8345 
  Attributes:
1996 vikas 8346 
   - affiliateId
1845 vikas 8347 
   - userId
8348 
   - event
8349 
   - url
8350 
   - data
1859 vikas 8351 
   - addedOn
1845 vikas 8352 
  """
8353 
 
8354 
  thrift_spec = (
8355 
    None, # 0
1996 vikas 8356 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 8357 
    (2, TType.I64, 'userId', None, None, ), # 2
3378 vikas 8358 
    (3, TType.I32, 'event', None, None, ), # 3
1845 vikas 8359 
    (4, TType.STRING, 'url', None, None, ), # 4
8360 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 8361 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 8362 
  )
8363 
 
1996 vikas 8364 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
8365 
    self.affiliateId = affiliateId
1845 vikas 8366 
    self.userId = userId
8367 
    self.event = event
8368 
    self.url = url
8369 
    self.data = data
1859 vikas 8370 
    self.addedOn = addedOn
1845 vikas 8371 
 
8372 
  def read(self, iprot):
8373 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8374 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8375 
      return
8376 
    iprot.readStructBegin()
8377 
    while True:
8378 
      (fname, ftype, fid) = iprot.readFieldBegin()
8379 
      if ftype == TType.STOP:
8380 
        break
8381 
      if fid == 1:
8382 
        if ftype == TType.I64:
1996 vikas 8383 
          self.affiliateId = iprot.readI64();
1845 vikas 8384 
        else:
8385 
          iprot.skip(ftype)
8386 
      elif fid == 2:
8387 
        if ftype == TType.I64:
8388 
          self.userId = iprot.readI64();
8389 
        else:
8390 
          iprot.skip(ftype)
8391 
      elif fid == 3:
3378 vikas 8392 
        if ftype == TType.I32:
8393 
          self.event = iprot.readI32();
1845 vikas 8394 
        else:
8395 
          iprot.skip(ftype)
8396 
      elif fid == 4:
8397 
        if ftype == TType.STRING:
8398 
          self.url = iprot.readString();
8399 
        else:
8400 
          iprot.skip(ftype)
8401 
      elif fid == 5:
8402 
        if ftype == TType.STRING:
8403 
          self.data = iprot.readString();
8404 
        else:
8405 
          iprot.skip(ftype)
1859 vikas 8406 
      elif fid == 6:
8407 
        if ftype == TType.I64:
8408 
          self.addedOn = iprot.readI64();
8409 
        else:
8410 
          iprot.skip(ftype)
1845 vikas 8411 
      else:
8412 
        iprot.skip(ftype)
8413 
      iprot.readFieldEnd()
8414 
    iprot.readStructEnd()
8415 
 
8416 
  def write(self, oprot):
8417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8419 
      return
8420 
    oprot.writeStructBegin('addTrackLog_args')
1996 vikas 8421 
    if self.affiliateId != None:
8422 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
8423 
      oprot.writeI64(self.affiliateId)
1845 vikas 8424 
      oprot.writeFieldEnd()
8425 
    if self.userId != None:
8426 
      oprot.writeFieldBegin('userId', TType.I64, 2)
8427 
      oprot.writeI64(self.userId)
8428 
      oprot.writeFieldEnd()
8429 
    if self.event != None:
3378 vikas 8430 
      oprot.writeFieldBegin('event', TType.I32, 3)
8431 
      oprot.writeI32(self.event)
1845 vikas 8432 
      oprot.writeFieldEnd()
8433 
    if self.url != None:
8434 
      oprot.writeFieldBegin('url', TType.STRING, 4)
8435 
      oprot.writeString(self.url)
8436 
      oprot.writeFieldEnd()
8437 
    if self.data != None:
8438 
      oprot.writeFieldBegin('data', TType.STRING, 5)
8439 
      oprot.writeString(self.data)
8440 
      oprot.writeFieldEnd()
1859 vikas 8441 
    if self.addedOn != None:
8442 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
8443 
      oprot.writeI64(self.addedOn)
8444 
      oprot.writeFieldEnd()
1845 vikas 8445 
    oprot.writeFieldStop()
8446 
    oprot.writeStructEnd()
8447 
 
8448 
  def __repr__(self):
8449 
    L = ['%s=%r' % (key, value)
8450 
      for key, value in self.__dict__.iteritems()]
8451 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8452 
 
8453 
  def __eq__(self, other):
8454 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8455 
 
8456 
  def __ne__(self, other):
8457 
    return not (self == other)
8458 
 
8459 
class addTrackLog_result:
8460 
  """
8461 
  Attributes:
8462 
   - success
8463 
   - utx
8464 
  """
8465 
 
8466 
  thrift_spec = (
8467 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 8468 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8469 
  )
8470 
 
8471 
  def __init__(self, success=None, utx=None,):
8472 
    self.success = success
8473 
    self.utx = utx
8474 
 
8475 
  def read(self, iprot):
8476 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8477 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8478 
      return
8479 
    iprot.readStructBegin()
8480 
    while True:
8481 
      (fname, ftype, fid) = iprot.readFieldBegin()
8482 
      if ftype == TType.STOP:
8483 
        break
8484 
      if fid == 0:
8485 
        if ftype == TType.I64:
8486 
          self.success = iprot.readI64();
8487 
        else:
8488 
          iprot.skip(ftype)
8489 
      elif fid == 1:
8490 
        if ftype == TType.STRUCT:
1996 vikas 8491 
          self.utx = UserAffiliateException()
1845 vikas 8492 
          self.utx.read(iprot)
8493 
        else:
8494 
          iprot.skip(ftype)
8495 
      else:
8496 
        iprot.skip(ftype)
8497 
      iprot.readFieldEnd()
8498 
    iprot.readStructEnd()
8499 
 
8500 
  def write(self, oprot):
8501 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8502 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8503 
      return
8504 
    oprot.writeStructBegin('addTrackLog_result')
8505 
    if self.success != None:
8506 
      oprot.writeFieldBegin('success', TType.I64, 0)
8507 
      oprot.writeI64(self.success)
8508 
      oprot.writeFieldEnd()
8509 
    if self.utx != None:
8510 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8511 
      self.utx.write(oprot)
8512 
      oprot.writeFieldEnd()
8513 
    oprot.writeFieldStop()
8514 
    oprot.writeStructEnd()
8515 
 
8516 
  def __repr__(self):
8517 
    L = ['%s=%r' % (key, value)
8518 
      for key, value in self.__dict__.iteritems()]
8519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8520 
 
8521 
  def __eq__(self, other):
8522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8523 
 
8524 
  def __ne__(self, other):
8525 
    return not (self == other)
8526 
 
8527 
class getTrackLogById_args:
8528 
  """
8529 
  Attributes:
8530 
   - id
8531 
  """
8532 
 
8533 
  thrift_spec = (
8534 
    None, # 0
8535 
    (1, TType.I64, 'id', None, None, ), # 1
8536 
  )
8537 
 
8538 
  def __init__(self, id=None,):
8539 
    self.id = id
8540 
 
8541 
  def read(self, iprot):
8542 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8543 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8544 
      return
8545 
    iprot.readStructBegin()
8546 
    while True:
8547 
      (fname, ftype, fid) = iprot.readFieldBegin()
8548 
      if ftype == TType.STOP:
8549 
        break
8550 
      if fid == 1:
8551 
        if ftype == TType.I64:
8552 
          self.id = iprot.readI64();
8553 
        else:
8554 
          iprot.skip(ftype)
8555 
      else:
8556 
        iprot.skip(ftype)
8557 
      iprot.readFieldEnd()
8558 
    iprot.readStructEnd()
8559 
 
8560 
  def write(self, oprot):
8561 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8562 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8563 
      return
8564 
    oprot.writeStructBegin('getTrackLogById_args')
8565 
    if self.id != None:
8566 
      oprot.writeFieldBegin('id', TType.I64, 1)
8567 
      oprot.writeI64(self.id)
8568 
      oprot.writeFieldEnd()
8569 
    oprot.writeFieldStop()
8570 
    oprot.writeStructEnd()
8571 
 
8572 
  def __repr__(self):
8573 
    L = ['%s=%r' % (key, value)
8574 
      for key, value in self.__dict__.iteritems()]
8575 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8576 
 
8577 
  def __eq__(self, other):
8578 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8579 
 
8580 
  def __ne__(self, other):
8581 
    return not (self == other)
8582 
 
8583 
class getTrackLogById_result:
8584 
  """
8585 
  Attributes:
8586 
   - success
8587 
   - utx
8588 
  """
8589 
 
8590 
  thrift_spec = (
8591 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 8592 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8593 
  )
8594 
 
8595 
  def __init__(self, success=None, utx=None,):
8596 
    self.success = success
8597 
    self.utx = utx
8598 
 
8599 
  def read(self, iprot):
8600 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8601 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8602 
      return
8603 
    iprot.readStructBegin()
8604 
    while True:
8605 
      (fname, ftype, fid) = iprot.readFieldBegin()
8606 
      if ftype == TType.STOP:
8607 
        break
8608 
      if fid == 0:
8609 
        if ftype == TType.STRUCT:
8610 
          self.success = TrackLog()
8611 
          self.success.read(iprot)
8612 
        else:
8613 
          iprot.skip(ftype)
8614 
      elif fid == 1:
8615 
        if ftype == TType.STRUCT:
1996 vikas 8616 
          self.utx = UserAffiliateException()
1845 vikas 8617 
          self.utx.read(iprot)
8618 
        else:
8619 
          iprot.skip(ftype)
8620 
      else:
8621 
        iprot.skip(ftype)
8622 
      iprot.readFieldEnd()
8623 
    iprot.readStructEnd()
8624 
 
8625 
  def write(self, oprot):
8626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8628 
      return
8629 
    oprot.writeStructBegin('getTrackLogById_result')
8630 
    if self.success != None:
8631 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8632 
      self.success.write(oprot)
8633 
      oprot.writeFieldEnd()
8634 
    if self.utx != None:
8635 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8636 
      self.utx.write(oprot)
8637 
      oprot.writeFieldEnd()
8638 
    oprot.writeFieldStop()
8639 
    oprot.writeStructEnd()
8640 
 
8641 
  def __repr__(self):
8642 
    L = ['%s=%r' % (key, value)
8643 
      for key, value in self.__dict__.iteritems()]
8644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8645 
 
8646 
  def __eq__(self, other):
8647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8648 
 
8649 
  def __ne__(self, other):
8650 
    return not (self == other)
8651 
 
1996 vikas 8652 
class getTrackLogsByAffiliate_args:
1845 vikas 8653 
  """
8654 
  Attributes:
1996 vikas 8655 
   - affiliateId
3293 vikas 8656 
   - startDate
8657 
   - endDate
1845 vikas 8658 
  """
8659 
 
8660 
  thrift_spec = (
8661 
    None, # 0
1996 vikas 8662 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
3293 vikas 8663 
    (2, TType.I64, 'startDate', None, None, ), # 2
8664 
    (3, TType.I64, 'endDate', None, None, ), # 3
1845 vikas 8665 
  )
8666 
 
3293 vikas 8667 
  def __init__(self, affiliateId=None, startDate=None, endDate=None,):
1996 vikas 8668 
    self.affiliateId = affiliateId
3293 vikas 8669 
    self.startDate = startDate
8670 
    self.endDate = endDate
1845 vikas 8671 
 
8672 
  def read(self, iprot):
8673 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8674 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8675 
      return
8676 
    iprot.readStructBegin()
8677 
    while True:
8678 
      (fname, ftype, fid) = iprot.readFieldBegin()
8679 
      if ftype == TType.STOP:
8680 
        break
8681 
      if fid == 1:
8682 
        if ftype == TType.I64:
1996 vikas 8683 
          self.affiliateId = iprot.readI64();
1845 vikas 8684 
        else:
8685 
          iprot.skip(ftype)
3293 vikas 8686 
      elif fid == 2:
8687 
        if ftype == TType.I64:
8688 
          self.startDate = iprot.readI64();
8689 
        else:
8690 
          iprot.skip(ftype)
8691 
      elif fid == 3:
8692 
        if ftype == TType.I64:
8693 
          self.endDate = iprot.readI64();
8694 
        else:
8695 
          iprot.skip(ftype)
1845 vikas 8696 
      else:
8697 
        iprot.skip(ftype)
8698 
      iprot.readFieldEnd()
8699 
    iprot.readStructEnd()
8700 
 
8701 
  def write(self, oprot):
8702 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8703 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8704 
      return
1996 vikas 8705 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
8706 
    if self.affiliateId != None:
8707 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
8708 
      oprot.writeI64(self.affiliateId)
1845 vikas 8709 
      oprot.writeFieldEnd()
3293 vikas 8710 
    if self.startDate != None:
8711 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
8712 
      oprot.writeI64(self.startDate)
8713 
      oprot.writeFieldEnd()
8714 
    if self.endDate != None:
8715 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
8716 
      oprot.writeI64(self.endDate)
8717 
      oprot.writeFieldEnd()
1845 vikas 8718 
    oprot.writeFieldStop()
8719 
    oprot.writeStructEnd()
8720 
 
8721 
  def __repr__(self):
8722 
    L = ['%s=%r' % (key, value)
8723 
      for key, value in self.__dict__.iteritems()]
8724 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8725 
 
8726 
  def __eq__(self, other):
8727 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8728 
 
8729 
  def __ne__(self, other):
8730 
    return not (self == other)
8731 
 
1996 vikas 8732 
class getTrackLogsByAffiliate_result:
1845 vikas 8733 
  """
8734 
  Attributes:
8735 
   - success
8736 
   - utx
8737 
  """
8738 
 
8739 
  thrift_spec = (
8740 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 8741 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8742 
  )
8743 
 
8744 
  def __init__(self, success=None, utx=None,):
8745 
    self.success = success
8746 
    self.utx = utx
8747 
 
8748 
  def read(self, iprot):
8749 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8750 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8751 
      return
8752 
    iprot.readStructBegin()
8753 
    while True:
8754 
      (fname, ftype, fid) = iprot.readFieldBegin()
8755 
      if ftype == TType.STOP:
8756 
        break
8757 
      if fid == 0:
8758 
        if ftype == TType.LIST:
8759 
          self.success = []
2981 rajveer 8760 
          (_etype66, _size63) = iprot.readListBegin()
8761 
          for _i67 in xrange(_size63):
8762 
            _elem68 = TrackLog()
8763 
            _elem68.read(iprot)
8764 
            self.success.append(_elem68)
1845 vikas 8765 
          iprot.readListEnd()
8766 
        else:
8767 
          iprot.skip(ftype)
8768 
      elif fid == 1:
8769 
        if ftype == TType.STRUCT:
1996 vikas 8770 
          self.utx = UserAffiliateException()
1845 vikas 8771 
          self.utx.read(iprot)
8772 
        else:
8773 
          iprot.skip(ftype)
8774 
      else:
8775 
        iprot.skip(ftype)
8776 
      iprot.readFieldEnd()
8777 
    iprot.readStructEnd()
8778 
 
8779 
  def write(self, oprot):
8780 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8781 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8782 
      return
1996 vikas 8783 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
1845 vikas 8784 
    if self.success != None:
8785 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8786 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 8787 
      for iter69 in self.success:
8788 
        iter69.write(oprot)
1845 vikas 8789 
      oprot.writeListEnd()
8790 
      oprot.writeFieldEnd()
8791 
    if self.utx != None:
8792 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8793 
      self.utx.write(oprot)
8794 
      oprot.writeFieldEnd()
8795 
    oprot.writeFieldStop()
8796 
    oprot.writeStructEnd()
8797 
 
8798 
  def __repr__(self):
8799 
    L = ['%s=%r' % (key, value)
8800 
      for key, value in self.__dict__.iteritems()]
8801 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8802 
 
8803 
  def __eq__(self, other):
8804 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8805 
 
8806 
  def __ne__(self, other):
8807 
    return not (self == other)
8808 
 
8809 
class getTrackLogsByUser_args:
8810 
  """
8811 
  Attributes:
8812 
   - userId
8813 
  """
8814 
 
8815 
  thrift_spec = (
8816 
    None, # 0
8817 
    (1, TType.I64, 'userId', None, None, ), # 1
8818 
  )
8819 
 
8820 
  def __init__(self, userId=None,):
8821 
    self.userId = userId
8822 
 
8823 
  def read(self, iprot):
8824 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8825 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8826 
      return
8827 
    iprot.readStructBegin()
8828 
    while True:
8829 
      (fname, ftype, fid) = iprot.readFieldBegin()
8830 
      if ftype == TType.STOP:
8831 
        break
8832 
      if fid == 1:
8833 
        if ftype == TType.I64:
8834 
          self.userId = iprot.readI64();
8835 
        else:
8836 
          iprot.skip(ftype)
8837 
      else:
8838 
        iprot.skip(ftype)
8839 
      iprot.readFieldEnd()
8840 
    iprot.readStructEnd()
8841 
 
8842 
  def write(self, oprot):
8843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8845 
      return
8846 
    oprot.writeStructBegin('getTrackLogsByUser_args')
8847 
    if self.userId != None:
8848 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8849 
      oprot.writeI64(self.userId)
8850 
      oprot.writeFieldEnd()
8851 
    oprot.writeFieldStop()
8852 
    oprot.writeStructEnd()
8853 
 
8854 
  def __repr__(self):
8855 
    L = ['%s=%r' % (key, value)
8856 
      for key, value in self.__dict__.iteritems()]
8857 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8858 
 
8859 
  def __eq__(self, other):
8860 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8861 
 
8862 
  def __ne__(self, other):
8863 
    return not (self == other)
8864 
 
8865 
class getTrackLogsByUser_result:
8866 
  """
8867 
  Attributes:
8868 
   - success
8869 
   - utx
8870 
  """
8871 
 
8872 
  thrift_spec = (
8873 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 8874 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8875 
  )
8876 
 
8877 
  def __init__(self, success=None, utx=None,):
8878 
    self.success = success
8879 
    self.utx = utx
8880 
 
8881 
  def read(self, iprot):
8882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8884 
      return
8885 
    iprot.readStructBegin()
8886 
    while True:
8887 
      (fname, ftype, fid) = iprot.readFieldBegin()
8888 
      if ftype == TType.STOP:
8889 
        break
8890 
      if fid == 0:
8891 
        if ftype == TType.LIST:
8892 
          self.success = []
2981 rajveer 8893 
          (_etype73, _size70) = iprot.readListBegin()
8894 
          for _i74 in xrange(_size70):
8895 
            _elem75 = TrackLog()
8896 
            _elem75.read(iprot)
8897 
            self.success.append(_elem75)
1845 vikas 8898 
          iprot.readListEnd()
8899 
        else:
8900 
          iprot.skip(ftype)
8901 
      elif fid == 1:
8902 
        if ftype == TType.STRUCT:
1996 vikas 8903 
          self.utx = UserAffiliateException()
1845 vikas 8904 
          self.utx.read(iprot)
8905 
        else:
8906 
          iprot.skip(ftype)
8907 
      else:
8908 
        iprot.skip(ftype)
8909 
      iprot.readFieldEnd()
8910 
    iprot.readStructEnd()
8911 
 
8912 
  def write(self, oprot):
8913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8915 
      return
8916 
    oprot.writeStructBegin('getTrackLogsByUser_result')
8917 
    if self.success != None:
8918 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8919 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 8920 
      for iter76 in self.success:
8921 
        iter76.write(oprot)
1845 vikas 8922 
      oprot.writeListEnd()
8923 
      oprot.writeFieldEnd()
8924 
    if self.utx != None:
8925 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8926 
      self.utx.write(oprot)
8927 
      oprot.writeFieldEnd()
8928 
    oprot.writeFieldStop()
8929 
    oprot.writeStructEnd()
8930 
 
8931 
  def __repr__(self):
8932 
    L = ['%s=%r' % (key, value)
8933 
      for key, value in self.__dict__.iteritems()]
8934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8935 
 
8936 
  def __eq__(self, other):
8937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8938 
 
8939 
  def __ne__(self, other):
8940 
    return not (self == other)
8941 
 
8942 
class getTrackLogs_args:
8943 
  """
8944 
  Attributes:
8945 
   - userId
8946 
   - event
8947 
   - url
8948 
  """
8949 
 
8950 
  thrift_spec = (
8951 
    None, # 0
1996 vikas 8952 
    (1, TType.I64, 'userId', None, None, ), # 1
8953 
    (2, TType.STRING, 'event', None, None, ), # 2
8954 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 8955 
  )
8956 
 
1996 vikas 8957 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 8958 
    self.userId = userId
8959 
    self.event = event
8960 
    self.url = url
8961 
 
8962 
  def read(self, iprot):
8963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8965 
      return
8966 
    iprot.readStructBegin()
8967 
    while True:
8968 
      (fname, ftype, fid) = iprot.readFieldBegin()
8969 
      if ftype == TType.STOP:
8970 
        break
8971 
      if fid == 1:
8972 
        if ftype == TType.I64:
1996 vikas 8973 
          self.userId = iprot.readI64();
1845 vikas 8974 
        else:
8975 
          iprot.skip(ftype)
8976 
      elif fid == 2:
8977 
        if ftype == TType.STRING:
8978 
          self.event = iprot.readString();
8979 
        else:
8980 
          iprot.skip(ftype)
1996 vikas 8981 
      elif fid == 3:
1845 vikas 8982 
        if ftype == TType.STRING:
8983 
          self.url = iprot.readString();
8984 
        else:
8985 
          iprot.skip(ftype)
8986 
      else:
8987 
        iprot.skip(ftype)
8988 
      iprot.readFieldEnd()
8989 
    iprot.readStructEnd()
8990 
 
8991 
  def write(self, oprot):
8992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8994 
      return
8995 
    oprot.writeStructBegin('getTrackLogs_args')
8996 
    if self.userId != None:
1996 vikas 8997 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 8998 
      oprot.writeI64(self.userId)
8999 
      oprot.writeFieldEnd()
9000 
    if self.event != None:
1996 vikas 9001 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 9002 
      oprot.writeString(self.event)
9003 
      oprot.writeFieldEnd()
9004 
    if self.url != None:
1996 vikas 9005 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 9006 
      oprot.writeString(self.url)
9007 
      oprot.writeFieldEnd()
9008 
    oprot.writeFieldStop()
9009 
    oprot.writeStructEnd()
9010 
 
9011 
  def __repr__(self):
9012 
    L = ['%s=%r' % (key, value)
9013 
      for key, value in self.__dict__.iteritems()]
9014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9015 
 
9016 
  def __eq__(self, other):
9017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9018 
 
9019 
  def __ne__(self, other):
9020 
    return not (self == other)
9021 
 
9022 
class getTrackLogs_result:
9023 
  """
9024 
  Attributes:
9025 
   - success
9026 
   - utx
9027 
  """
9028 
 
9029 
  thrift_spec = (
9030 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 9031 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9032 
  )
9033 
 
9034 
  def __init__(self, success=None, utx=None,):
9035 
    self.success = success
9036 
    self.utx = utx
9037 
 
9038 
  def read(self, iprot):
9039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9041 
      return
9042 
    iprot.readStructBegin()
9043 
    while True:
9044 
      (fname, ftype, fid) = iprot.readFieldBegin()
9045 
      if ftype == TType.STOP:
9046 
        break
9047 
      if fid == 0:
9048 
        if ftype == TType.LIST:
9049 
          self.success = []
2981 rajveer 9050 
          (_etype80, _size77) = iprot.readListBegin()
9051 
          for _i81 in xrange(_size77):
9052 
            _elem82 = TrackLog()
9053 
            _elem82.read(iprot)
9054 
            self.success.append(_elem82)
1845 vikas 9055 
          iprot.readListEnd()
9056 
        else:
9057 
          iprot.skip(ftype)
9058 
      elif fid == 1:
9059 
        if ftype == TType.STRUCT:
1996 vikas 9060 
          self.utx = UserAffiliateException()
1845 vikas 9061 
          self.utx.read(iprot)
9062 
        else:
9063 
          iprot.skip(ftype)
9064 
      else:
9065 
        iprot.skip(ftype)
9066 
      iprot.readFieldEnd()
9067 
    iprot.readStructEnd()
9068 
 
9069 
  def write(self, oprot):
9070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9072 
      return
9073 
    oprot.writeStructBegin('getTrackLogs_result')
9074 
    if self.success != None:
9075 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9076 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 9077 
      for iter83 in self.success:
9078 
        iter83.write(oprot)
1845 vikas 9079 
      oprot.writeListEnd()
9080 
      oprot.writeFieldEnd()
9081 
    if self.utx != None:
9082 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9083 
      self.utx.write(oprot)
9084 
      oprot.writeFieldEnd()
9085 
    oprot.writeFieldStop()
9086 
    oprot.writeStructEnd()
9087 
 
9088 
  def __repr__(self):
9089 
    L = ['%s=%r' % (key, value)
9090 
      for key, value in self.__dict__.iteritems()]
9091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9092 
 
9093 
  def __eq__(self, other):
9094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9095 
 
9096 
  def __ne__(self, other):
9097 
    return not (self == other)
9098 
 
559 chandransh 9099 
class createCart_args:
94 ashish 9100 
  """
9101 
  Attributes:
559 chandransh 9102 
   - userId
94 ashish 9103 
  """
9104 
 
9105 
  thrift_spec = (
9106 
    None, # 0
559 chandransh 9107 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 9108 
  )
9109 
 
559 chandransh 9110 
  def __init__(self, userId=None,):
9111 
    self.userId = userId
94 ashish 9112 
 
9113 
  def read(self, iprot):
9114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9116 
      return
9117 
    iprot.readStructBegin()
9118 
    while True:
9119 
      (fname, ftype, fid) = iprot.readFieldBegin()
9120 
      if ftype == TType.STOP:
9121 
        break
9122 
      if fid == 1:
9123 
        if ftype == TType.I64:
559 chandransh 9124 
          self.userId = iprot.readI64();
94 ashish 9125 
        else:
9126 
          iprot.skip(ftype)
559 chandransh 9127 
      else:
9128 
        iprot.skip(ftype)
9129 
      iprot.readFieldEnd()
9130 
    iprot.readStructEnd()
9131 
 
9132 
  def write(self, oprot):
9133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9135 
      return
9136 
    oprot.writeStructBegin('createCart_args')
9137 
    if self.userId != None:
9138 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9139 
      oprot.writeI64(self.userId)
9140 
      oprot.writeFieldEnd()
9141 
    oprot.writeFieldStop()
9142 
    oprot.writeStructEnd()
9143 
 
9144 
  def __repr__(self):
9145 
    L = ['%s=%r' % (key, value)
9146 
      for key, value in self.__dict__.iteritems()]
9147 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9148 
 
9149 
  def __eq__(self, other):
9150 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9151 
 
9152 
  def __ne__(self, other):
9153 
    return not (self == other)
9154 
 
9155 
class createCart_result:
9156 
  """
9157 
  Attributes:
9158 
   - success
9159 
   - scx
9160 
  """
9161 
 
9162 
  thrift_spec = (
9163 
    (0, TType.I64, 'success', None, None, ), # 0
9164 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9165 
  )
9166 
 
9167 
  def __init__(self, success=None, scx=None,):
9168 
    self.success = success
9169 
    self.scx = scx
9170 
 
9171 
  def read(self, iprot):
9172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9174 
      return
9175 
    iprot.readStructBegin()
9176 
    while True:
9177 
      (fname, ftype, fid) = iprot.readFieldBegin()
9178 
      if ftype == TType.STOP:
9179 
        break
9180 
      if fid == 0:
94 ashish 9181 
        if ftype == TType.I64:
559 chandransh 9182 
          self.success = iprot.readI64();
94 ashish 9183 
        else:
9184 
          iprot.skip(ftype)
559 chandransh 9185 
      elif fid == 1:
9186 
        if ftype == TType.STRUCT:
9187 
          self.scx = ShoppingCartException()
9188 
          self.scx.read(iprot)
9189 
        else:
9190 
          iprot.skip(ftype)
94 ashish 9191 
      else:
9192 
        iprot.skip(ftype)
9193 
      iprot.readFieldEnd()
9194 
    iprot.readStructEnd()
9195 
 
9196 
  def write(self, oprot):
9197 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9198 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9199 
      return
559 chandransh 9200 
    oprot.writeStructBegin('createCart_result')
9201 
    if self.success != None:
9202 
      oprot.writeFieldBegin('success', TType.I64, 0)
9203 
      oprot.writeI64(self.success)
94 ashish 9204 
      oprot.writeFieldEnd()
559 chandransh 9205 
    if self.scx != None:
9206 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9207 
      self.scx.write(oprot)
94 ashish 9208 
      oprot.writeFieldEnd()
9209 
    oprot.writeFieldStop()
9210 
    oprot.writeStructEnd()
9211 
 
9212 
  def __repr__(self):
9213 
    L = ['%s=%r' % (key, value)
9214 
      for key, value in self.__dict__.iteritems()]
9215 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9216 
 
9217 
  def __eq__(self, other):
9218 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9219 
 
9220 
  def __ne__(self, other):
9221 
    return not (self == other)
9222 
 
559 chandransh 9223 
class getCurrentCart_args:
94 ashish 9224 
  """
9225 
  Attributes:
559 chandransh 9226 
   - userId
9227 
  """
9228 
 
9229 
  thrift_spec = (
9230 
    None, # 0
9231 
    (1, TType.I64, 'userId', None, None, ), # 1
9232 
  )
9233 
 
9234 
  def __init__(self, userId=None,):
9235 
    self.userId = userId
9236 
 
9237 
  def read(self, iprot):
9238 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9239 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9240 
      return
9241 
    iprot.readStructBegin()
9242 
    while True:
9243 
      (fname, ftype, fid) = iprot.readFieldBegin()
9244 
      if ftype == TType.STOP:
9245 
        break
9246 
      if fid == 1:
9247 
        if ftype == TType.I64:
9248 
          self.userId = iprot.readI64();
9249 
        else:
9250 
          iprot.skip(ftype)
9251 
      else:
9252 
        iprot.skip(ftype)
9253 
      iprot.readFieldEnd()
9254 
    iprot.readStructEnd()
9255 
 
9256 
  def write(self, oprot):
9257 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9258 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9259 
      return
9260 
    oprot.writeStructBegin('getCurrentCart_args')
9261 
    if self.userId != None:
9262 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9263 
      oprot.writeI64(self.userId)
9264 
      oprot.writeFieldEnd()
9265 
    oprot.writeFieldStop()
9266 
    oprot.writeStructEnd()
9267 
 
9268 
  def __repr__(self):
9269 
    L = ['%s=%r' % (key, value)
9270 
      for key, value in self.__dict__.iteritems()]
9271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9272 
 
9273 
  def __eq__(self, other):
9274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9275 
 
9276 
  def __ne__(self, other):
9277 
    return not (self == other)
9278 
 
9279 
class getCurrentCart_result:
9280 
  """
9281 
  Attributes:
94 ashish 9282 
   - success
559 chandransh 9283 
   - scx
94 ashish 9284 
  """
9285 
 
9286 
  thrift_spec = (
559 chandransh 9287 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9288 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9289 
  )
9290 
 
559 chandransh 9291 
  def __init__(self, success=None, scx=None,):
94 ashish 9292 
    self.success = success
559 chandransh 9293 
    self.scx = scx
94 ashish 9294 
 
9295 
  def read(self, iprot):
9296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9298 
      return
9299 
    iprot.readStructBegin()
9300 
    while True:
9301 
      (fname, ftype, fid) = iprot.readFieldBegin()
9302 
      if ftype == TType.STOP:
9303 
        break
9304 
      if fid == 0:
559 chandransh 9305 
        if ftype == TType.STRUCT:
9306 
          self.success = Cart()
9307 
          self.success.read(iprot)
94 ashish 9308 
        else:
9309 
          iprot.skip(ftype)
9310 
      elif fid == 1:
9311 
        if ftype == TType.STRUCT:
559 chandransh 9312 
          self.scx = ShoppingCartException()
9313 
          self.scx.read(iprot)
94 ashish 9314 
        else:
9315 
          iprot.skip(ftype)
9316 
      else:
9317 
        iprot.skip(ftype)
9318 
      iprot.readFieldEnd()
9319 
    iprot.readStructEnd()
9320 
 
9321 
  def write(self, oprot):
9322 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9323 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9324 
      return
559 chandransh 9325 
    oprot.writeStructBegin('getCurrentCart_result')
94 ashish 9326 
    if self.success != None:
559 chandransh 9327 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9328 
      self.success.write(oprot)
94 ashish 9329 
      oprot.writeFieldEnd()
559 chandransh 9330 
    if self.scx != None:
9331 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9332 
      self.scx.write(oprot)
94 ashish 9333 
      oprot.writeFieldEnd()
9334 
    oprot.writeFieldStop()
9335 
    oprot.writeStructEnd()
9336 
 
9337 
  def __repr__(self):
9338 
    L = ['%s=%r' % (key, value)
9339 
      for key, value in self.__dict__.iteritems()]
9340 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9341 
 
9342 
  def __eq__(self, other):
9343 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9344 
 
9345 
  def __ne__(self, other):
9346 
    return not (self == other)
9347 
 
559 chandransh 9348 
class getCart_args:
504 rajveer 9349 
  """
9350 
  Attributes:
559 chandransh 9351 
   - cartId
504 rajveer 9352 
  """
9353 
 
9354 
  thrift_spec = (
9355 
    None, # 0
559 chandransh 9356 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 9357 
  )
9358 
 
559 chandransh 9359 
  def __init__(self, cartId=None,):
9360 
    self.cartId = cartId
504 rajveer 9361 
 
9362 
  def read(self, iprot):
9363 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9364 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9365 
      return
9366 
    iprot.readStructBegin()
9367 
    while True:
9368 
      (fname, ftype, fid) = iprot.readFieldBegin()
9369 
      if ftype == TType.STOP:
9370 
        break
9371 
      if fid == 1:
9372 
        if ftype == TType.I64:
559 chandransh 9373 
          self.cartId = iprot.readI64();
504 rajveer 9374 
        else:
9375 
          iprot.skip(ftype)
9376 
      else:
9377 
        iprot.skip(ftype)
9378 
      iprot.readFieldEnd()
9379 
    iprot.readStructEnd()
9380 
 
9381 
  def write(self, oprot):
9382 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9383 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9384 
      return
559 chandransh 9385 
    oprot.writeStructBegin('getCart_args')
9386 
    if self.cartId != None:
9387 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9388 
      oprot.writeI64(self.cartId)
504 rajveer 9389 
      oprot.writeFieldEnd()
9390 
    oprot.writeFieldStop()
9391 
    oprot.writeStructEnd()
9392 
 
9393 
  def __repr__(self):
9394 
    L = ['%s=%r' % (key, value)
9395 
      for key, value in self.__dict__.iteritems()]
9396 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9397 
 
9398 
  def __eq__(self, other):
9399 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9400 
 
9401 
  def __ne__(self, other):
9402 
    return not (self == other)
9403 
 
559 chandransh 9404 
class getCart_result:
504 rajveer 9405 
  """
9406 
  Attributes:
9407 
   - success
559 chandransh 9408 
   - scx
504 rajveer 9409 
  """
9410 
 
9411 
  thrift_spec = (
559 chandransh 9412 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9413 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 9414 
  )
9415 
 
559 chandransh 9416 
  def __init__(self, success=None, scx=None,):
504 rajveer 9417 
    self.success = success
559 chandransh 9418 
    self.scx = scx
504 rajveer 9419 
 
9420 
  def read(self, iprot):
9421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9423 
      return
9424 
    iprot.readStructBegin()
9425 
    while True:
9426 
      (fname, ftype, fid) = iprot.readFieldBegin()
9427 
      if ftype == TType.STOP:
9428 
        break
9429 
      if fid == 0:
559 chandransh 9430 
        if ftype == TType.STRUCT:
9431 
          self.success = Cart()
9432 
          self.success.read(iprot)
504 rajveer 9433 
        else:
9434 
          iprot.skip(ftype)
9435 
      elif fid == 1:
9436 
        if ftype == TType.STRUCT:
559 chandransh 9437 
          self.scx = ShoppingCartException()
9438 
          self.scx.read(iprot)
504 rajveer 9439 
        else:
9440 
          iprot.skip(ftype)
9441 
      else:
9442 
        iprot.skip(ftype)
9443 
      iprot.readFieldEnd()
9444 
    iprot.readStructEnd()
9445 
 
9446 
  def write(self, oprot):
9447 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9448 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9449 
      return
559 chandransh 9450 
    oprot.writeStructBegin('getCart_result')
504 rajveer 9451 
    if self.success != None:
559 chandransh 9452 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9453 
      self.success.write(oprot)
504 rajveer 9454 
      oprot.writeFieldEnd()
559 chandransh 9455 
    if self.scx != None:
9456 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9457 
      self.scx.write(oprot)
504 rajveer 9458 
      oprot.writeFieldEnd()
9459 
    oprot.writeFieldStop()
9460 
    oprot.writeStructEnd()
9461 
 
9462 
  def __repr__(self):
9463 
    L = ['%s=%r' % (key, value)
9464 
      for key, value in self.__dict__.iteritems()]
9465 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9466 
 
9467 
  def __eq__(self, other):
9468 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9469 
 
9470 
  def __ne__(self, other):
9471 
    return not (self == other)
9472 
 
559 chandransh 9473 
class getCartsForUser_args:
94 ashish 9474 
  """
9475 
  Attributes:
559 chandransh 9476 
   - userId
9477 
   - status
94 ashish 9478 
  """
9479 
 
9480 
  thrift_spec = (
9481 
    None, # 0
559 chandransh 9482 
    (1, TType.I64, 'userId', None, None, ), # 1
9483 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 9484 
  )
9485 
 
559 chandransh 9486 
  def __init__(self, userId=None, status=None,):
9487 
    self.userId = userId
9488 
    self.status = status
94 ashish 9489 
 
9490 
  def read(self, iprot):
9491 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9492 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9493 
      return
9494 
    iprot.readStructBegin()
9495 
    while True:
9496 
      (fname, ftype, fid) = iprot.readFieldBegin()
9497 
      if ftype == TType.STOP:
9498 
        break
9499 
      if fid == 1:
9500 
        if ftype == TType.I64:
559 chandransh 9501 
          self.userId = iprot.readI64();
94 ashish 9502 
        else:
9503 
          iprot.skip(ftype)
9504 
      elif fid == 2:
559 chandransh 9505 
        if ftype == TType.I32:
9506 
          self.status = iprot.readI32();
94 ashish 9507 
        else:
9508 
          iprot.skip(ftype)
9509 
      else:
9510 
        iprot.skip(ftype)
9511 
      iprot.readFieldEnd()
9512 
    iprot.readStructEnd()
9513 
 
9514 
  def write(self, oprot):
9515 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9516 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9517 
      return
559 chandransh 9518 
    oprot.writeStructBegin('getCartsForUser_args')
9519 
    if self.userId != None:
9520 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9521 
      oprot.writeI64(self.userId)
94 ashish 9522 
      oprot.writeFieldEnd()
559 chandransh 9523 
    if self.status != None:
9524 
      oprot.writeFieldBegin('status', TType.I32, 2)
9525 
      oprot.writeI32(self.status)
94 ashish 9526 
      oprot.writeFieldEnd()
9527 
    oprot.writeFieldStop()
9528 
    oprot.writeStructEnd()
9529 
 
9530 
  def __repr__(self):
9531 
    L = ['%s=%r' % (key, value)
9532 
      for key, value in self.__dict__.iteritems()]
9533 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9534 
 
9535 
  def __eq__(self, other):
9536 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9537 
 
9538 
  def __ne__(self, other):
9539 
    return not (self == other)
9540 
 
559 chandransh 9541 
class getCartsForUser_result:
94 ashish 9542 
  """
9543 
  Attributes:
9544 
   - success
559 chandransh 9545 
   - scx
94 ashish 9546 
  """
9547 
 
9548 
  thrift_spec = (
559 chandransh 9549 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9550 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9551 
  )
9552 
 
559 chandransh 9553 
  def __init__(self, success=None, scx=None,):
94 ashish 9554 
    self.success = success
559 chandransh 9555 
    self.scx = scx
94 ashish 9556 
 
9557 
  def read(self, iprot):
9558 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9559 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9560 
      return
9561 
    iprot.readStructBegin()
9562 
    while True:
9563 
      (fname, ftype, fid) = iprot.readFieldBegin()
9564 
      if ftype == TType.STOP:
9565 
        break
9566 
      if fid == 0:
559 chandransh 9567 
        if ftype == TType.LIST:
9568 
          self.success = []
2981 rajveer 9569 
          (_etype87, _size84) = iprot.readListBegin()
9570 
          for _i88 in xrange(_size84):
9571 
            _elem89 = Cart()
9572 
            _elem89.read(iprot)
9573 
            self.success.append(_elem89)
559 chandransh 9574 
          iprot.readListEnd()
94 ashish 9575 
        else:
9576 
          iprot.skip(ftype)
9577 
      elif fid == 1:
9578 
        if ftype == TType.STRUCT:
559 chandransh 9579 
          self.scx = ShoppingCartException()
9580 
          self.scx.read(iprot)
94 ashish 9581 
        else:
9582 
          iprot.skip(ftype)
9583 
      else:
9584 
        iprot.skip(ftype)
9585 
      iprot.readFieldEnd()
9586 
    iprot.readStructEnd()
9587 
 
9588 
  def write(self, oprot):
9589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9591 
      return
559 chandransh 9592 
    oprot.writeStructBegin('getCartsForUser_result')
94 ashish 9593 
    if self.success != None:
559 chandransh 9594 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9595 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 9596 
      for iter90 in self.success:
9597 
        iter90.write(oprot)
559 chandransh 9598 
      oprot.writeListEnd()
94 ashish 9599 
      oprot.writeFieldEnd()
559 chandransh 9600 
    if self.scx != None:
9601 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9602 
      self.scx.write(oprot)
94 ashish 9603 
      oprot.writeFieldEnd()
9604 
    oprot.writeFieldStop()
9605 
    oprot.writeStructEnd()
9606 
 
9607 
  def __repr__(self):
9608 
    L = ['%s=%r' % (key, value)
9609 
      for key, value in self.__dict__.iteritems()]
9610 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9611 
 
9612 
  def __eq__(self, other):
9613 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9614 
 
9615 
  def __ne__(self, other):
9616 
    return not (self == other)
9617 
 
559 chandransh 9618 
class getCartsByStatus_args:
94 ashish 9619 
  """
9620 
  Attributes:
559 chandransh 9621 
   - status
94 ashish 9622 
  """
9623 
 
9624 
  thrift_spec = (
9625 
    None, # 0
559 chandransh 9626 
    (1, TType.I32, 'status', None, None, ), # 1
94 ashish 9627 
  )
9628 
 
559 chandransh 9629 
  def __init__(self, status=None,):
9630 
    self.status = status
94 ashish 9631 
 
9632 
  def read(self, iprot):
9633 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9634 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9635 
      return
9636 
    iprot.readStructBegin()
9637 
    while True:
9638 
      (fname, ftype, fid) = iprot.readFieldBegin()
9639 
      if ftype == TType.STOP:
9640 
        break
9641 
      if fid == 1:
559 chandransh 9642 
        if ftype == TType.I32:
9643 
          self.status = iprot.readI32();
9644 
        else:
9645 
          iprot.skip(ftype)
9646 
      else:
9647 
        iprot.skip(ftype)
9648 
      iprot.readFieldEnd()
9649 
    iprot.readStructEnd()
9650 
 
9651 
  def write(self, oprot):
9652 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9653 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9654 
      return
9655 
    oprot.writeStructBegin('getCartsByStatus_args')
9656 
    if self.status != None:
9657 
      oprot.writeFieldBegin('status', TType.I32, 1)
9658 
      oprot.writeI32(self.status)
9659 
      oprot.writeFieldEnd()
9660 
    oprot.writeFieldStop()
9661 
    oprot.writeStructEnd()
9662 
 
9663 
  def __repr__(self):
9664 
    L = ['%s=%r' % (key, value)
9665 
      for key, value in self.__dict__.iteritems()]
9666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9667 
 
9668 
  def __eq__(self, other):
9669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9670 
 
9671 
  def __ne__(self, other):
9672 
    return not (self == other)
9673 
 
9674 
class getCartsByStatus_result:
9675 
  """
9676 
  Attributes:
9677 
   - success
9678 
   - scx
9679 
  """
9680 
 
9681 
  thrift_spec = (
9682 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9683 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9684 
  )
9685 
 
9686 
  def __init__(self, success=None, scx=None,):
9687 
    self.success = success
9688 
    self.scx = scx
9689 
 
9690 
  def read(self, iprot):
9691 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9692 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9693 
      return
9694 
    iprot.readStructBegin()
9695 
    while True:
9696 
      (fname, ftype, fid) = iprot.readFieldBegin()
9697 
      if ftype == TType.STOP:
9698 
        break
9699 
      if fid == 0:
9700 
        if ftype == TType.LIST:
9701 
          self.success = []
2981 rajveer 9702 
          (_etype94, _size91) = iprot.readListBegin()
9703 
          for _i95 in xrange(_size91):
9704 
            _elem96 = Cart()
9705 
            _elem96.read(iprot)
9706 
            self.success.append(_elem96)
559 chandransh 9707 
          iprot.readListEnd()
9708 
        else:
9709 
          iprot.skip(ftype)
9710 
      elif fid == 1:
9711 
        if ftype == TType.STRUCT:
9712 
          self.scx = ShoppingCartException()
9713 
          self.scx.read(iprot)
9714 
        else:
9715 
          iprot.skip(ftype)
9716 
      else:
9717 
        iprot.skip(ftype)
9718 
      iprot.readFieldEnd()
9719 
    iprot.readStructEnd()
9720 
 
9721 
  def write(self, oprot):
9722 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9723 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9724 
      return
9725 
    oprot.writeStructBegin('getCartsByStatus_result')
9726 
    if self.success != None:
9727 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9728 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 9729 
      for iter97 in self.success:
9730 
        iter97.write(oprot)
559 chandransh 9731 
      oprot.writeListEnd()
9732 
      oprot.writeFieldEnd()
9733 
    if self.scx != None:
9734 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9735 
      self.scx.write(oprot)
9736 
      oprot.writeFieldEnd()
9737 
    oprot.writeFieldStop()
9738 
    oprot.writeStructEnd()
9739 
 
9740 
  def __repr__(self):
9741 
    L = ['%s=%r' % (key, value)
9742 
      for key, value in self.__dict__.iteritems()]
9743 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9744 
 
9745 
  def __eq__(self, other):
9746 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9747 
 
9748 
  def __ne__(self, other):
9749 
    return not (self == other)
9750 
 
9751 
class getCartsByTime_args:
9752 
  """
9753 
  Attributes:
9754 
   - from_time
9755 
   - to_time
9756 
   - status
9757 
  """
9758 
 
9759 
  thrift_spec = (
9760 
    None, # 0
9761 
    (1, TType.I64, 'from_time', None, None, ), # 1
9762 
    (2, TType.I64, 'to_time', None, None, ), # 2
9763 
    (3, TType.I32, 'status', None, None, ), # 3
9764 
  )
9765 
 
9766 
  def __init__(self, from_time=None, to_time=None, status=None,):
9767 
    self.from_time = from_time
9768 
    self.to_time = to_time
9769 
    self.status = status
9770 
 
9771 
  def read(self, iprot):
9772 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9773 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9774 
      return
9775 
    iprot.readStructBegin()
9776 
    while True:
9777 
      (fname, ftype, fid) = iprot.readFieldBegin()
9778 
      if ftype == TType.STOP:
9779 
        break
9780 
      if fid == 1:
94 ashish 9781 
        if ftype == TType.I64:
559 chandransh 9782 
          self.from_time = iprot.readI64();
94 ashish 9783 
        else:
9784 
          iprot.skip(ftype)
122 ashish 9785 
      elif fid == 2:
559 chandransh 9786 
        if ftype == TType.I64:
9787 
          self.to_time = iprot.readI64();
122 ashish 9788 
        else:
9789 
          iprot.skip(ftype)
559 chandransh 9790 
      elif fid == 3:
9791 
        if ftype == TType.I32:
9792 
          self.status = iprot.readI32();
9793 
        else:
9794 
          iprot.skip(ftype)
94 ashish 9795 
      else:
9796 
        iprot.skip(ftype)
9797 
      iprot.readFieldEnd()
9798 
    iprot.readStructEnd()
9799 
 
9800 
  def write(self, oprot):
9801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9803 
      return
559 chandransh 9804 
    oprot.writeStructBegin('getCartsByTime_args')
9805 
    if self.from_time != None:
9806 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
9807 
      oprot.writeI64(self.from_time)
94 ashish 9808 
      oprot.writeFieldEnd()
559 chandransh 9809 
    if self.to_time != None:
9810 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
9811 
      oprot.writeI64(self.to_time)
122 ashish 9812 
      oprot.writeFieldEnd()
559 chandransh 9813 
    if self.status != None:
9814 
      oprot.writeFieldBegin('status', TType.I32, 3)
9815 
      oprot.writeI32(self.status)
9816 
      oprot.writeFieldEnd()
94 ashish 9817 
    oprot.writeFieldStop()
9818 
    oprot.writeStructEnd()
9819 
 
9820 
  def __repr__(self):
9821 
    L = ['%s=%r' % (key, value)
9822 
      for key, value in self.__dict__.iteritems()]
9823 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9824 
 
9825 
  def __eq__(self, other):
9826 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9827 
 
9828 
  def __ne__(self, other):
9829 
    return not (self == other)
9830 
 
559 chandransh 9831 
class getCartsByTime_result:
94 ashish 9832 
  """
9833 
  Attributes:
9834 
   - success
559 chandransh 9835 
   - scx
94 ashish 9836 
  """
9837 
 
9838 
  thrift_spec = (
559 chandransh 9839 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9840 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9841 
  )
9842 
 
559 chandransh 9843 
  def __init__(self, success=None, scx=None,):
94 ashish 9844 
    self.success = success
559 chandransh 9845 
    self.scx = scx
94 ashish 9846 
 
9847 
  def read(self, iprot):
9848 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9849 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9850 
      return
9851 
    iprot.readStructBegin()
9852 
    while True:
9853 
      (fname, ftype, fid) = iprot.readFieldBegin()
9854 
      if ftype == TType.STOP:
9855 
        break
9856 
      if fid == 0:
559 chandransh 9857 
        if ftype == TType.LIST:
9858 
          self.success = []
2981 rajveer 9859 
          (_etype101, _size98) = iprot.readListBegin()
9860 
          for _i102 in xrange(_size98):
9861 
            _elem103 = Cart()
9862 
            _elem103.read(iprot)
9863 
            self.success.append(_elem103)
559 chandransh 9864 
          iprot.readListEnd()
94 ashish 9865 
        else:
9866 
          iprot.skip(ftype)
9867 
      elif fid == 1:
9868 
        if ftype == TType.STRUCT:
559 chandransh 9869 
          self.scx = ShoppingCartException()
9870 
          self.scx.read(iprot)
94 ashish 9871 
        else:
9872 
          iprot.skip(ftype)
9873 
      else:
9874 
        iprot.skip(ftype)
9875 
      iprot.readFieldEnd()
9876 
    iprot.readStructEnd()
9877 
 
9878 
  def write(self, oprot):
9879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9881 
      return
559 chandransh 9882 
    oprot.writeStructBegin('getCartsByTime_result')
94 ashish 9883 
    if self.success != None:
559 chandransh 9884 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9885 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 9886 
      for iter104 in self.success:
9887 
        iter104.write(oprot)
559 chandransh 9888 
      oprot.writeListEnd()
94 ashish 9889 
      oprot.writeFieldEnd()
559 chandransh 9890 
    if self.scx != None:
9891 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9892 
      self.scx.write(oprot)
94 ashish 9893 
      oprot.writeFieldEnd()
9894 
    oprot.writeFieldStop()
9895 
    oprot.writeStructEnd()
9896 
 
9897 
  def __repr__(self):
9898 
    L = ['%s=%r' % (key, value)
9899 
      for key, value in self.__dict__.iteritems()]
9900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9901 
 
9902 
  def __eq__(self, other):
9903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9904 
 
9905 
  def __ne__(self, other):
9906 
    return not (self == other)
9907 
 
559 chandransh 9908 
class changeCartStatus_args:
94 ashish 9909 
  """
9910 
  Attributes:
559 chandransh 9911 
   - cartId
9912 
   - status
94 ashish 9913 
  """
9914 
 
9915 
  thrift_spec = (
9916 
    None, # 0
559 chandransh 9917 
    (1, TType.I64, 'cartId', None, None, ), # 1
9918 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 9919 
  )
9920 
 
559 chandransh 9921 
  def __init__(self, cartId=None, status=None,):
9922 
    self.cartId = cartId
9923 
    self.status = status
94 ashish 9924 
 
9925 
  def read(self, iprot):
9926 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9927 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9928 
      return
9929 
    iprot.readStructBegin()
9930 
    while True:
9931 
      (fname, ftype, fid) = iprot.readFieldBegin()
9932 
      if ftype == TType.STOP:
9933 
        break
9934 
      if fid == 1:
9935 
        if ftype == TType.I64:
559 chandransh 9936 
          self.cartId = iprot.readI64();
94 ashish 9937 
        else:
9938 
          iprot.skip(ftype)
559 chandransh 9939 
      elif fid == 2:
9940 
        if ftype == TType.I32:
9941 
          self.status = iprot.readI32();
9942 
        else:
9943 
          iprot.skip(ftype)
94 ashish 9944 
      else:
9945 
        iprot.skip(ftype)
9946 
      iprot.readFieldEnd()
9947 
    iprot.readStructEnd()
9948 
 
9949 
  def write(self, oprot):
9950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9952 
      return
559 chandransh 9953 
    oprot.writeStructBegin('changeCartStatus_args')
9954 
    if self.cartId != None:
9955 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9956 
      oprot.writeI64(self.cartId)
94 ashish 9957 
      oprot.writeFieldEnd()
559 chandransh 9958 
    if self.status != None:
9959 
      oprot.writeFieldBegin('status', TType.I32, 2)
9960 
      oprot.writeI32(self.status)
9961 
      oprot.writeFieldEnd()
94 ashish 9962 
    oprot.writeFieldStop()
9963 
    oprot.writeStructEnd()
9964 
 
9965 
  def __repr__(self):
9966 
    L = ['%s=%r' % (key, value)
9967 
      for key, value in self.__dict__.iteritems()]
9968 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9969 
 
9970 
  def __eq__(self, other):
9971 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9972 
 
9973 
  def __ne__(self, other):
9974 
    return not (self == other)
9975 
 
559 chandransh 9976 
class changeCartStatus_result:
94 ashish 9977 
  """
9978 
  Attributes:
559 chandransh 9979 
   - scx
9980 
  """
9981 
 
9982 
  thrift_spec = (
9983 
    None, # 0
9984 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9985 
  )
9986 
 
9987 
  def __init__(self, scx=None,):
9988 
    self.scx = scx
9989 
 
9990 
  def read(self, iprot):
9991 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9992 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9993 
      return
9994 
    iprot.readStructBegin()
9995 
    while True:
9996 
      (fname, ftype, fid) = iprot.readFieldBegin()
9997 
      if ftype == TType.STOP:
9998 
        break
9999 
      if fid == 1:
10000 
        if ftype == TType.STRUCT:
10001 
          self.scx = ShoppingCartException()
10002 
          self.scx.read(iprot)
10003 
        else:
10004 
          iprot.skip(ftype)
10005 
      else:
10006 
        iprot.skip(ftype)
10007 
      iprot.readFieldEnd()
10008 
    iprot.readStructEnd()
10009 
 
10010 
  def write(self, oprot):
10011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10013 
      return
10014 
    oprot.writeStructBegin('changeCartStatus_result')
10015 
    if self.scx != None:
10016 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10017 
      self.scx.write(oprot)
10018 
      oprot.writeFieldEnd()
10019 
    oprot.writeFieldStop()
10020 
    oprot.writeStructEnd()
10021 
 
10022 
  def __repr__(self):
10023 
    L = ['%s=%r' % (key, value)
10024 
      for key, value in self.__dict__.iteritems()]
10025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10026 
 
10027 
  def __eq__(self, other):
10028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10029 
 
10030 
  def __ne__(self, other):
10031 
    return not (self == other)
10032 
 
10033 
class addItemToCart_args:
10034 
  """
10035 
  Attributes:
10036 
   - cartId
10037 
   - itemId
10038 
   - quantity
10039 
  """
10040 
 
10041 
  thrift_spec = (
10042 
    None, # 0
10043 
    (1, TType.I64, 'cartId', None, None, ), # 1
10044 
    (2, TType.I64, 'itemId', None, None, ), # 2
10045 
    (3, TType.I64, 'quantity', None, None, ), # 3
10046 
  )
10047 
 
10048 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
10049 
    self.cartId = cartId
10050 
    self.itemId = itemId
10051 
    self.quantity = quantity
10052 
 
10053 
  def read(self, iprot):
10054 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10055 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10056 
      return
10057 
    iprot.readStructBegin()
10058 
    while True:
10059 
      (fname, ftype, fid) = iprot.readFieldBegin()
10060 
      if ftype == TType.STOP:
10061 
        break
10062 
      if fid == 1:
10063 
        if ftype == TType.I64:
10064 
          self.cartId = iprot.readI64();
10065 
        else:
10066 
          iprot.skip(ftype)
10067 
      elif fid == 2:
10068 
        if ftype == TType.I64:
10069 
          self.itemId = iprot.readI64();
10070 
        else:
10071 
          iprot.skip(ftype)
10072 
      elif fid == 3:
10073 
        if ftype == TType.I64:
10074 
          self.quantity = iprot.readI64();
10075 
        else:
10076 
          iprot.skip(ftype)
10077 
      else:
10078 
        iprot.skip(ftype)
10079 
      iprot.readFieldEnd()
10080 
    iprot.readStructEnd()
10081 
 
10082 
  def write(self, oprot):
10083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10085 
      return
10086 
    oprot.writeStructBegin('addItemToCart_args')
10087 
    if self.cartId != None:
10088 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10089 
      oprot.writeI64(self.cartId)
10090 
      oprot.writeFieldEnd()
10091 
    if self.itemId != None:
10092 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10093 
      oprot.writeI64(self.itemId)
10094 
      oprot.writeFieldEnd()
10095 
    if self.quantity != None:
10096 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10097 
      oprot.writeI64(self.quantity)
10098 
      oprot.writeFieldEnd()
10099 
    oprot.writeFieldStop()
10100 
    oprot.writeStructEnd()
10101 
 
10102 
  def __repr__(self):
10103 
    L = ['%s=%r' % (key, value)
10104 
      for key, value in self.__dict__.iteritems()]
10105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10106 
 
10107 
  def __eq__(self, other):
10108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10109 
 
10110 
  def __ne__(self, other):
10111 
    return not (self == other)
10112 
 
10113 
class addItemToCart_result:
10114 
  """
10115 
  Attributes:
2035 rajveer 10116 
   - success
559 chandransh 10117 
   - scx
10118 
  """
10119 
 
10120 
  thrift_spec = (
2035 rajveer 10121 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 10122 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10123 
  )
10124 
 
2035 rajveer 10125 
  def __init__(self, success=None, scx=None,):
10126 
    self.success = success
559 chandransh 10127 
    self.scx = scx
10128 
 
10129 
  def read(self, iprot):
10130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10132 
      return
10133 
    iprot.readStructBegin()
10134 
    while True:
10135 
      (fname, ftype, fid) = iprot.readFieldBegin()
10136 
      if ftype == TType.STOP:
10137 
        break
2035 rajveer 10138 
      if fid == 0:
10139 
        if ftype == TType.STRING:
10140 
          self.success = iprot.readString();
10141 
        else:
10142 
          iprot.skip(ftype)
10143 
      elif fid == 1:
559 chandransh 10144 
        if ftype == TType.STRUCT:
10145 
          self.scx = ShoppingCartException()
10146 
          self.scx.read(iprot)
10147 
        else:
10148 
          iprot.skip(ftype)
10149 
      else:
10150 
        iprot.skip(ftype)
10151 
      iprot.readFieldEnd()
10152 
    iprot.readStructEnd()
10153 
 
10154 
  def write(self, oprot):
10155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10157 
      return
10158 
    oprot.writeStructBegin('addItemToCart_result')
2035 rajveer 10159 
    if self.success != None:
10160 
      oprot.writeFieldBegin('success', TType.STRING, 0)
10161 
      oprot.writeString(self.success)
10162 
      oprot.writeFieldEnd()
559 chandransh 10163 
    if self.scx != None:
10164 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10165 
      self.scx.write(oprot)
10166 
      oprot.writeFieldEnd()
10167 
    oprot.writeFieldStop()
10168 
    oprot.writeStructEnd()
10169 
 
10170 
  def __repr__(self):
10171 
    L = ['%s=%r' % (key, value)
10172 
      for key, value in self.__dict__.iteritems()]
10173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10174 
 
10175 
  def __eq__(self, other):
10176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10177 
 
10178 
  def __ne__(self, other):
10179 
    return not (self == other)
10180 
 
10181 
class deleteItemFromCart_args:
10182 
  """
10183 
  Attributes:
10184 
   - cartId
10185 
   - itemId
10186 
  """
10187 
 
10188 
  thrift_spec = (
10189 
    None, # 0
10190 
    (1, TType.I64, 'cartId', None, None, ), # 1
10191 
    (2, TType.I64, 'itemId', None, None, ), # 2
10192 
  )
10193 
 
10194 
  def __init__(self, cartId=None, itemId=None,):
10195 
    self.cartId = cartId
10196 
    self.itemId = itemId
10197 
 
10198 
  def read(self, iprot):
10199 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10200 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10201 
      return
10202 
    iprot.readStructBegin()
10203 
    while True:
10204 
      (fname, ftype, fid) = iprot.readFieldBegin()
10205 
      if ftype == TType.STOP:
10206 
        break
10207 
      if fid == 1:
10208 
        if ftype == TType.I64:
10209 
          self.cartId = iprot.readI64();
10210 
        else:
10211 
          iprot.skip(ftype)
10212 
      elif fid == 2:
10213 
        if ftype == TType.I64:
10214 
          self.itemId = iprot.readI64();
10215 
        else:
10216 
          iprot.skip(ftype)
10217 
      else:
10218 
        iprot.skip(ftype)
10219 
      iprot.readFieldEnd()
10220 
    iprot.readStructEnd()
10221 
 
10222 
  def write(self, oprot):
10223 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10224 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10225 
      return
10226 
    oprot.writeStructBegin('deleteItemFromCart_args')
10227 
    if self.cartId != None:
10228 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10229 
      oprot.writeI64(self.cartId)
10230 
      oprot.writeFieldEnd()
10231 
    if self.itemId != None:
10232 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10233 
      oprot.writeI64(self.itemId)
10234 
      oprot.writeFieldEnd()
10235 
    oprot.writeFieldStop()
10236 
    oprot.writeStructEnd()
10237 
 
10238 
  def __repr__(self):
10239 
    L = ['%s=%r' % (key, value)
10240 
      for key, value in self.__dict__.iteritems()]
10241 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10242 
 
10243 
  def __eq__(self, other):
10244 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10245 
 
10246 
  def __ne__(self, other):
10247 
    return not (self == other)
10248 
 
10249 
class deleteItemFromCart_result:
10250 
  """
10251 
  Attributes:
10252 
   - scx
10253 
  """
10254 
 
10255 
  thrift_spec = (
10256 
    None, # 0
10257 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10258 
  )
10259 
 
10260 
  def __init__(self, scx=None,):
10261 
    self.scx = scx
10262 
 
10263 
  def read(self, iprot):
10264 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10265 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10266 
      return
10267 
    iprot.readStructBegin()
10268 
    while True:
10269 
      (fname, ftype, fid) = iprot.readFieldBegin()
10270 
      if ftype == TType.STOP:
10271 
        break
10272 
      if fid == 1:
10273 
        if ftype == TType.STRUCT:
10274 
          self.scx = ShoppingCartException()
10275 
          self.scx.read(iprot)
10276 
        else:
10277 
          iprot.skip(ftype)
10278 
      else:
10279 
        iprot.skip(ftype)
10280 
      iprot.readFieldEnd()
10281 
    iprot.readStructEnd()
10282 
 
10283 
  def write(self, oprot):
10284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10286 
      return
10287 
    oprot.writeStructBegin('deleteItemFromCart_result')
10288 
    if self.scx != None:
10289 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10290 
      self.scx.write(oprot)
10291 
      oprot.writeFieldEnd()
10292 
    oprot.writeFieldStop()
10293 
    oprot.writeStructEnd()
10294 
 
10295 
  def __repr__(self):
10296 
    L = ['%s=%r' % (key, value)
10297 
      for key, value in self.__dict__.iteritems()]
10298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10299 
 
10300 
  def __eq__(self, other):
10301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10302 
 
10303 
  def __ne__(self, other):
10304 
    return not (self == other)
10305 
 
10306 
class changeQuantity_args:
10307 
  """
10308 
  Attributes:
10309 
   - cartId
10310 
   - itemId
10311 
   - quantity
10312 
  """
10313 
 
10314 
  thrift_spec = (
10315 
    None, # 0
10316 
    (1, TType.I64, 'cartId', None, None, ), # 1
10317 
    (2, TType.I64, 'itemId', None, None, ), # 2
10318 
    (3, TType.I64, 'quantity', None, None, ), # 3
10319 
  )
10320 
 
10321 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
10322 
    self.cartId = cartId
10323 
    self.itemId = itemId
10324 
    self.quantity = quantity
10325 
 
10326 
  def read(self, iprot):
10327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10329 
      return
10330 
    iprot.readStructBegin()
10331 
    while True:
10332 
      (fname, ftype, fid) = iprot.readFieldBegin()
10333 
      if ftype == TType.STOP:
10334 
        break
10335 
      if fid == 1:
10336 
        if ftype == TType.I64:
10337 
          self.cartId = iprot.readI64();
10338 
        else:
10339 
          iprot.skip(ftype)
10340 
      elif fid == 2:
10341 
        if ftype == TType.I64:
10342 
          self.itemId = iprot.readI64();
10343 
        else:
10344 
          iprot.skip(ftype)
10345 
      elif fid == 3:
10346 
        if ftype == TType.I64:
10347 
          self.quantity = iprot.readI64();
10348 
        else:
10349 
          iprot.skip(ftype)
10350 
      else:
10351 
        iprot.skip(ftype)
10352 
      iprot.readFieldEnd()
10353 
    iprot.readStructEnd()
10354 
 
10355 
  def write(self, oprot):
10356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10358 
      return
10359 
    oprot.writeStructBegin('changeQuantity_args')
10360 
    if self.cartId != None:
10361 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10362 
      oprot.writeI64(self.cartId)
10363 
      oprot.writeFieldEnd()
10364 
    if self.itemId != None:
10365 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10366 
      oprot.writeI64(self.itemId)
10367 
      oprot.writeFieldEnd()
10368 
    if self.quantity != None:
10369 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10370 
      oprot.writeI64(self.quantity)
10371 
      oprot.writeFieldEnd()
10372 
    oprot.writeFieldStop()
10373 
    oprot.writeStructEnd()
10374 
 
10375 
  def __repr__(self):
10376 
    L = ['%s=%r' % (key, value)
10377 
      for key, value in self.__dict__.iteritems()]
10378 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10379 
 
10380 
  def __eq__(self, other):
10381 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10382 
 
10383 
  def __ne__(self, other):
10384 
    return not (self == other)
10385 
 
10386 
class changeQuantity_result:
10387 
  """
10388 
  Attributes:
10389 
   - scx
10390 
  """
10391 
 
10392 
  thrift_spec = (
10393 
    None, # 0
10394 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10395 
  )
10396 
 
10397 
  def __init__(self, scx=None,):
10398 
    self.scx = scx
10399 
 
10400 
  def read(self, iprot):
10401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10403 
      return
10404 
    iprot.readStructBegin()
10405 
    while True:
10406 
      (fname, ftype, fid) = iprot.readFieldBegin()
10407 
      if ftype == TType.STOP:
10408 
        break
10409 
      if fid == 1:
10410 
        if ftype == TType.STRUCT:
10411 
          self.scx = ShoppingCartException()
10412 
          self.scx.read(iprot)
10413 
        else:
10414 
          iprot.skip(ftype)
10415 
      else:
10416 
        iprot.skip(ftype)
10417 
      iprot.readFieldEnd()
10418 
    iprot.readStructEnd()
10419 
 
10420 
  def write(self, oprot):
10421 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10422 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10423 
      return
10424 
    oprot.writeStructBegin('changeQuantity_result')
10425 
    if self.scx != None:
10426 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10427 
      self.scx.write(oprot)
10428 
      oprot.writeFieldEnd()
10429 
    oprot.writeFieldStop()
10430 
    oprot.writeStructEnd()
10431 
 
10432 
  def __repr__(self):
10433 
    L = ['%s=%r' % (key, value)
10434 
      for key, value in self.__dict__.iteritems()]
10435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10436 
 
10437 
  def __eq__(self, other):
10438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10439 
 
10440 
  def __ne__(self, other):
10441 
    return not (self == other)
10442 
 
10443 
class changeItemStatus_args:
10444 
  """
10445 
  Attributes:
10446 
   - cartId
10447 
   - itemId
10448 
   - status
10449 
  """
10450 
 
10451 
  thrift_spec = (
10452 
    None, # 0
10453 
    (1, TType.I64, 'cartId', None, None, ), # 1
10454 
    (2, TType.I64, 'itemId', None, None, ), # 2
10455 
    (3, TType.I32, 'status', None, None, ), # 3
10456 
  )
10457 
 
10458 
  def __init__(self, cartId=None, itemId=None, status=None,):
10459 
    self.cartId = cartId
10460 
    self.itemId = itemId
10461 
    self.status = status
10462 
 
10463 
  def read(self, iprot):
10464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10466 
      return
10467 
    iprot.readStructBegin()
10468 
    while True:
10469 
      (fname, ftype, fid) = iprot.readFieldBegin()
10470 
      if ftype == TType.STOP:
10471 
        break
10472 
      if fid == 1:
10473 
        if ftype == TType.I64:
10474 
          self.cartId = iprot.readI64();
10475 
        else:
10476 
          iprot.skip(ftype)
10477 
      elif fid == 2:
10478 
        if ftype == TType.I64:
10479 
          self.itemId = iprot.readI64();
10480 
        else:
10481 
          iprot.skip(ftype)
10482 
      elif fid == 3:
10483 
        if ftype == TType.I32:
10484 
          self.status = iprot.readI32();
10485 
        else:
10486 
          iprot.skip(ftype)
10487 
      else:
10488 
        iprot.skip(ftype)
10489 
      iprot.readFieldEnd()
10490 
    iprot.readStructEnd()
10491 
 
10492 
  def write(self, oprot):
10493 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10494 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10495 
      return
10496 
    oprot.writeStructBegin('changeItemStatus_args')
10497 
    if self.cartId != None:
10498 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10499 
      oprot.writeI64(self.cartId)
10500 
      oprot.writeFieldEnd()
10501 
    if self.itemId != None:
10502 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10503 
      oprot.writeI64(self.itemId)
10504 
      oprot.writeFieldEnd()
10505 
    if self.status != None:
10506 
      oprot.writeFieldBegin('status', TType.I32, 3)
10507 
      oprot.writeI32(self.status)
10508 
      oprot.writeFieldEnd()
10509 
    oprot.writeFieldStop()
10510 
    oprot.writeStructEnd()
10511 
 
10512 
  def __repr__(self):
10513 
    L = ['%s=%r' % (key, value)
10514 
      for key, value in self.__dict__.iteritems()]
10515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10516 
 
10517 
  def __eq__(self, other):
10518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10519 
 
10520 
  def __ne__(self, other):
10521 
    return not (self == other)
10522 
 
10523 
class changeItemStatus_result:
10524 
  """
10525 
  Attributes:
10526 
   - scx
10527 
  """
10528 
 
10529 
  thrift_spec = (
10530 
    None, # 0
10531 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10532 
  )
10533 
 
10534 
  def __init__(self, scx=None,):
10535 
    self.scx = scx
10536 
 
10537 
  def read(self, iprot):
10538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10540 
      return
10541 
    iprot.readStructBegin()
10542 
    while True:
10543 
      (fname, ftype, fid) = iprot.readFieldBegin()
10544 
      if ftype == TType.STOP:
10545 
        break
10546 
      if fid == 1:
10547 
        if ftype == TType.STRUCT:
10548 
          self.scx = ShoppingCartException()
10549 
          self.scx.read(iprot)
10550 
        else:
10551 
          iprot.skip(ftype)
10552 
      else:
10553 
        iprot.skip(ftype)
10554 
      iprot.readFieldEnd()
10555 
    iprot.readStructEnd()
10556 
 
10557 
  def write(self, oprot):
10558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10560 
      return
10561 
    oprot.writeStructBegin('changeItemStatus_result')
10562 
    if self.scx != None:
10563 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10564 
      self.scx.write(oprot)
10565 
      oprot.writeFieldEnd()
10566 
    oprot.writeFieldStop()
10567 
    oprot.writeStructEnd()
10568 
 
10569 
  def __repr__(self):
10570 
    L = ['%s=%r' % (key, value)
10571 
      for key, value in self.__dict__.iteritems()]
10572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10573 
 
10574 
  def __eq__(self, other):
10575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10576 
 
10577 
  def __ne__(self, other):
10578 
    return not (self == other)
10579 
 
10580 
class addAddressToCart_args:
10581 
  """
10582 
  Attributes:
10583 
   - cartId
10584 
   - addressId
10585 
  """
10586 
 
10587 
  thrift_spec = (
10588 
    None, # 0
10589 
    (1, TType.I64, 'cartId', None, None, ), # 1
10590 
    (2, TType.I64, 'addressId', None, None, ), # 2
10591 
  )
10592 
 
10593 
  def __init__(self, cartId=None, addressId=None,):
10594 
    self.cartId = cartId
10595 
    self.addressId = addressId
10596 
 
10597 
  def read(self, iprot):
10598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10600 
      return
10601 
    iprot.readStructBegin()
10602 
    while True:
10603 
      (fname, ftype, fid) = iprot.readFieldBegin()
10604 
      if ftype == TType.STOP:
10605 
        break
10606 
      if fid == 1:
10607 
        if ftype == TType.I64:
10608 
          self.cartId = iprot.readI64();
10609 
        else:
10610 
          iprot.skip(ftype)
10611 
      elif fid == 2:
10612 
        if ftype == TType.I64:
10613 
          self.addressId = iprot.readI64();
10614 
        else:
10615 
          iprot.skip(ftype)
10616 
      else:
10617 
        iprot.skip(ftype)
10618 
      iprot.readFieldEnd()
10619 
    iprot.readStructEnd()
10620 
 
10621 
  def write(self, oprot):
10622 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10623 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10624 
      return
10625 
    oprot.writeStructBegin('addAddressToCart_args')
10626 
    if self.cartId != None:
10627 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10628 
      oprot.writeI64(self.cartId)
10629 
      oprot.writeFieldEnd()
10630 
    if self.addressId != None:
10631 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
10632 
      oprot.writeI64(self.addressId)
10633 
      oprot.writeFieldEnd()
10634 
    oprot.writeFieldStop()
10635 
    oprot.writeStructEnd()
10636 
 
10637 
  def __repr__(self):
10638 
    L = ['%s=%r' % (key, value)
10639 
      for key, value in self.__dict__.iteritems()]
10640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10641 
 
10642 
  def __eq__(self, other):
10643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10644 
 
10645 
  def __ne__(self, other):
10646 
    return not (self == other)
10647 
 
10648 
class addAddressToCart_result:
575 chandransh 10649 
  """
10650 
  Attributes:
10651 
   - scx
10652 
  """
559 chandransh 10653 
 
10654 
  thrift_spec = (
575 chandransh 10655 
    None, # 0
10656 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 10657 
  )
10658 
 
575 chandransh 10659 
  def __init__(self, scx=None,):
10660 
    self.scx = scx
10661 
 
559 chandransh 10662 
  def read(self, iprot):
10663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10665 
      return
10666 
    iprot.readStructBegin()
10667 
    while True:
10668 
      (fname, ftype, fid) = iprot.readFieldBegin()
10669 
      if ftype == TType.STOP:
10670 
        break
575 chandransh 10671 
      if fid == 1:
10672 
        if ftype == TType.STRUCT:
10673 
          self.scx = ShoppingCartException()
10674 
          self.scx.read(iprot)
10675 
        else:
10676 
          iprot.skip(ftype)
559 chandransh 10677 
      else:
10678 
        iprot.skip(ftype)
10679 
      iprot.readFieldEnd()
10680 
    iprot.readStructEnd()
10681 
 
10682 
  def write(self, oprot):
10683 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10684 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10685 
      return
10686 
    oprot.writeStructBegin('addAddressToCart_result')
575 chandransh 10687 
    if self.scx != None:
10688 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10689 
      self.scx.write(oprot)
10690 
      oprot.writeFieldEnd()
559 chandransh 10691 
    oprot.writeFieldStop()
10692 
    oprot.writeStructEnd()
10693 
 
10694 
  def __repr__(self):
10695 
    L = ['%s=%r' % (key, value)
10696 
      for key, value in self.__dict__.iteritems()]
10697 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10698 
 
10699 
  def __eq__(self, other):
10700 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10701 
 
10702 
  def __ne__(self, other):
10703 
    return not (self == other)
10704 
 
1976 varun.gupt 10705 
class applyCouponToCart_args:
10706 
  """
10707 
  Attributes:
10708 
   - cartId
10709 
   - couponCode
10710 
   - totalPrice
10711 
   - discountedPrice
10712 
  """
10713 
 
10714 
  thrift_spec = (
10715 
    None, # 0
10716 
    (1, TType.I64, 'cartId', None, None, ), # 1
10717 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
10718 
    (3, TType.DOUBLE, 'totalPrice', None, None, ), # 3
10719 
    (4, TType.DOUBLE, 'discountedPrice', None, None, ), # 4
10720 
  )
10721 
 
10722 
  def __init__(self, cartId=None, couponCode=None, totalPrice=None, discountedPrice=None,):
10723 
    self.cartId = cartId
10724 
    self.couponCode = couponCode
10725 
    self.totalPrice = totalPrice
10726 
    self.discountedPrice = discountedPrice
10727 
 
10728 
  def read(self, iprot):
10729 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10730 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10731 
      return
10732 
    iprot.readStructBegin()
10733 
    while True:
10734 
      (fname, ftype, fid) = iprot.readFieldBegin()
10735 
      if ftype == TType.STOP:
10736 
        break
10737 
      if fid == 1:
10738 
        if ftype == TType.I64:
10739 
          self.cartId = iprot.readI64();
10740 
        else:
10741 
          iprot.skip(ftype)
10742 
      elif fid == 2:
10743 
        if ftype == TType.STRING:
10744 
          self.couponCode = iprot.readString();
10745 
        else:
10746 
          iprot.skip(ftype)
10747 
      elif fid == 3:
10748 
        if ftype == TType.DOUBLE:
10749 
          self.totalPrice = iprot.readDouble();
10750 
        else:
10751 
          iprot.skip(ftype)
10752 
      elif fid == 4:
10753 
        if ftype == TType.DOUBLE:
10754 
          self.discountedPrice = iprot.readDouble();
10755 
        else:
10756 
          iprot.skip(ftype)
10757 
      else:
10758 
        iprot.skip(ftype)
10759 
      iprot.readFieldEnd()
10760 
    iprot.readStructEnd()
10761 
 
10762 
  def write(self, oprot):
10763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10765 
      return
10766 
    oprot.writeStructBegin('applyCouponToCart_args')
10767 
    if self.cartId != None:
10768 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10769 
      oprot.writeI64(self.cartId)
10770 
      oprot.writeFieldEnd()
10771 
    if self.couponCode != None:
10772 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
10773 
      oprot.writeString(self.couponCode)
10774 
      oprot.writeFieldEnd()
10775 
    if self.totalPrice != None:
10776 
      oprot.writeFieldBegin('totalPrice', TType.DOUBLE, 3)
10777 
      oprot.writeDouble(self.totalPrice)
10778 
      oprot.writeFieldEnd()
10779 
    if self.discountedPrice != None:
10780 
      oprot.writeFieldBegin('discountedPrice', TType.DOUBLE, 4)
10781 
      oprot.writeDouble(self.discountedPrice)
10782 
      oprot.writeFieldEnd()
10783 
    oprot.writeFieldStop()
10784 
    oprot.writeStructEnd()
10785 
 
10786 
  def __repr__(self):
10787 
    L = ['%s=%r' % (key, value)
10788 
      for key, value in self.__dict__.iteritems()]
10789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10790 
 
10791 
  def __eq__(self, other):
10792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10793 
 
10794 
  def __ne__(self, other):
10795 
    return not (self == other)
10796 
 
10797 
class applyCouponToCart_result:
10798 
  """
10799 
  Attributes:
10800 
   - scx
10801 
  """
10802 
 
10803 
  thrift_spec = (
10804 
    None, # 0
10805 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10806 
  )
10807 
 
10808 
  def __init__(self, scx=None,):
10809 
    self.scx = scx
10810 
 
10811 
  def read(self, iprot):
10812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10814 
      return
10815 
    iprot.readStructBegin()
10816 
    while True:
10817 
      (fname, ftype, fid) = iprot.readFieldBegin()
10818 
      if ftype == TType.STOP:
10819 
        break
10820 
      if fid == 1:
10821 
        if ftype == TType.STRUCT:
10822 
          self.scx = ShoppingCartException()
10823 
          self.scx.read(iprot)
10824 
        else:
10825 
          iprot.skip(ftype)
10826 
      else:
10827 
        iprot.skip(ftype)
10828 
      iprot.readFieldEnd()
10829 
    iprot.readStructEnd()
10830 
 
10831 
  def write(self, oprot):
10832 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10833 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10834 
      return
10835 
    oprot.writeStructBegin('applyCouponToCart_result')
10836 
    if self.scx != None:
10837 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10838 
      self.scx.write(oprot)
10839 
      oprot.writeFieldEnd()
10840 
    oprot.writeFieldStop()
10841 
    oprot.writeStructEnd()
10842 
 
10843 
  def __repr__(self):
10844 
    L = ['%s=%r' % (key, value)
10845 
      for key, value in self.__dict__.iteritems()]
10846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10847 
 
10848 
  def __eq__(self, other):
10849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10850 
 
10851 
  def __ne__(self, other):
10852 
    return not (self == other)
10853 
 
10854 
class removeCoupon_args:
10855 
  """
10856 
  Attributes:
10857 
   - cartId
10858 
  """
10859 
 
10860 
  thrift_spec = (
10861 
    None, # 0
10862 
    (1, TType.I64, 'cartId', None, None, ), # 1
10863 
  )
10864 
 
10865 
  def __init__(self, cartId=None,):
10866 
    self.cartId = cartId
10867 
 
10868 
  def read(self, iprot):
10869 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10870 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10871 
      return
10872 
    iprot.readStructBegin()
10873 
    while True:
10874 
      (fname, ftype, fid) = iprot.readFieldBegin()
10875 
      if ftype == TType.STOP:
10876 
        break
10877 
      if fid == 1:
10878 
        if ftype == TType.I64:
10879 
          self.cartId = iprot.readI64();
10880 
        else:
10881 
          iprot.skip(ftype)
10882 
      else:
10883 
        iprot.skip(ftype)
10884 
      iprot.readFieldEnd()
10885 
    iprot.readStructEnd()
10886 
 
10887 
  def write(self, oprot):
10888 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10889 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10890 
      return
10891 
    oprot.writeStructBegin('removeCoupon_args')
10892 
    if self.cartId != None:
10893 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10894 
      oprot.writeI64(self.cartId)
10895 
      oprot.writeFieldEnd()
10896 
    oprot.writeFieldStop()
10897 
    oprot.writeStructEnd()
10898 
 
10899 
  def __repr__(self):
10900 
    L = ['%s=%r' % (key, value)
10901 
      for key, value in self.__dict__.iteritems()]
10902 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10903 
 
10904 
  def __eq__(self, other):
10905 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10906 
 
10907 
  def __ne__(self, other):
10908 
    return not (self == other)
10909 
 
10910 
class removeCoupon_result:
10911 
  """
10912 
  Attributes:
10913 
   - scx
10914 
  """
10915 
 
10916 
  thrift_spec = (
10917 
    None, # 0
10918 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10919 
  )
10920 
 
10921 
  def __init__(self, scx=None,):
10922 
    self.scx = scx
10923 
 
10924 
  def read(self, iprot):
10925 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10926 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10927 
      return
10928 
    iprot.readStructBegin()
10929 
    while True:
10930 
      (fname, ftype, fid) = iprot.readFieldBegin()
10931 
      if ftype == TType.STOP:
10932 
        break
10933 
      if fid == 1:
10934 
        if ftype == TType.STRUCT:
10935 
          self.scx = ShoppingCartException()
10936 
          self.scx.read(iprot)
10937 
        else:
10938 
          iprot.skip(ftype)
10939 
      else:
10940 
        iprot.skip(ftype)
10941 
      iprot.readFieldEnd()
10942 
    iprot.readStructEnd()
10943 
 
10944 
  def write(self, oprot):
10945 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10946 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10947 
      return
10948 
    oprot.writeStructBegin('removeCoupon_result')
10949 
    if self.scx != None:
10950 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10951 
      self.scx.write(oprot)
10952 
      oprot.writeFieldEnd()
10953 
    oprot.writeFieldStop()
10954 
    oprot.writeStructEnd()
10955 
 
10956 
  def __repr__(self):
10957 
    L = ['%s=%r' % (key, value)
10958 
      for key, value in self.__dict__.iteritems()]
10959 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10960 
 
10961 
  def __eq__(self, other):
10962 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10963 
 
10964 
  def __ne__(self, other):
10965 
    return not (self == other)
10966 
 
690 chandransh 10967 
class createOrders_args:
559 chandransh 10968 
  """
10969 
  Attributes:
10970 
   - cartId
2815 vikas 10971 
   - sessionSource
10972 
   - sessionStartTime
559 chandransh 10973 
  """
10974 
 
10975 
  thrift_spec = (
10976 
    None, # 0
10977 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 10978 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
10979 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
559 chandransh 10980 
  )
10981 
 
2815 vikas 10982 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None,):
559 chandransh 10983 
    self.cartId = cartId
2815 vikas 10984 
    self.sessionSource = sessionSource
10985 
    self.sessionStartTime = sessionStartTime
559 chandransh 10986 
 
10987 
  def read(self, iprot):
10988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10990 
      return
10991 
    iprot.readStructBegin()
10992 
    while True:
10993 
      (fname, ftype, fid) = iprot.readFieldBegin()
10994 
      if ftype == TType.STOP:
10995 
        break
10996 
      if fid == 1:
10997 
        if ftype == TType.I64:
10998 
          self.cartId = iprot.readI64();
10999 
        else:
11000 
          iprot.skip(ftype)
2815 vikas 11001 
      elif fid == 2:
11002 
        if ftype == TType.STRING:
11003 
          self.sessionSource = iprot.readString();
11004 
        else:
11005 
          iprot.skip(ftype)
11006 
      elif fid == 3:
11007 
        if ftype == TType.I64:
11008 
          self.sessionStartTime = iprot.readI64();
11009 
        else:
11010 
          iprot.skip(ftype)
559 chandransh 11011 
      else:
11012 
        iprot.skip(ftype)
11013 
      iprot.readFieldEnd()
11014 
    iprot.readStructEnd()
11015 
 
11016 
  def write(self, oprot):
11017 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11018 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11019 
      return
690 chandransh 11020 
    oprot.writeStructBegin('createOrders_args')
559 chandransh 11021 
    if self.cartId != None:
11022 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11023 
      oprot.writeI64(self.cartId)
11024 
      oprot.writeFieldEnd()
2815 vikas 11025 
    if self.sessionSource != None:
11026 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
11027 
      oprot.writeString(self.sessionSource)
11028 
      oprot.writeFieldEnd()
11029 
    if self.sessionStartTime != None:
11030 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
11031 
      oprot.writeI64(self.sessionStartTime)
11032 
      oprot.writeFieldEnd()
559 chandransh 11033 
    oprot.writeFieldStop()
11034 
    oprot.writeStructEnd()
11035 
 
11036 
  def __repr__(self):
11037 
    L = ['%s=%r' % (key, value)
11038 
      for key, value in self.__dict__.iteritems()]
11039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11040 
 
11041 
  def __eq__(self, other):
11042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11043 
 
11044 
  def __ne__(self, other):
11045 
    return not (self == other)
11046 
 
690 chandransh 11047 
class createOrders_result:
559 chandransh 11048 
  """
11049 
  Attributes:
94 ashish 11050 
   - success
559 chandransh 11051 
   - scx
94 ashish 11052 
  """
11053 
 
11054 
  thrift_spec = (
575 chandransh 11055 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 11056 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11057 
  )
11058 
 
559 chandransh 11059 
  def __init__(self, success=None, scx=None,):
94 ashish 11060 
    self.success = success
559 chandransh 11061 
    self.scx = scx
94 ashish 11062 
 
11063 
  def read(self, iprot):
11064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11066 
      return
11067 
    iprot.readStructBegin()
11068 
    while True:
11069 
      (fname, ftype, fid) = iprot.readFieldBegin()
11070 
      if ftype == TType.STOP:
11071 
        break
11072 
      if fid == 0:
575 chandransh 11073 
        if ftype == TType.I64:
11074 
          self.success = iprot.readI64();
94 ashish 11075 
        else:
11076 
          iprot.skip(ftype)
11077 
      elif fid == 1:
11078 
        if ftype == TType.STRUCT:
559 chandransh 11079 
          self.scx = ShoppingCartException()
11080 
          self.scx.read(iprot)
94 ashish 11081 
        else:
11082 
          iprot.skip(ftype)
11083 
      else:
11084 
        iprot.skip(ftype)
11085 
      iprot.readFieldEnd()
11086 
    iprot.readStructEnd()
11087 
 
11088 
  def write(self, oprot):
11089 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11090 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11091 
      return
690 chandransh 11092 
    oprot.writeStructBegin('createOrders_result')
94 ashish 11093 
    if self.success != None:
575 chandransh 11094 
      oprot.writeFieldBegin('success', TType.I64, 0)
11095 
      oprot.writeI64(self.success)
94 ashish 11096 
      oprot.writeFieldEnd()
559 chandransh 11097 
    if self.scx != None:
11098 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11099 
      self.scx.write(oprot)
94 ashish 11100 
      oprot.writeFieldEnd()
11101 
    oprot.writeFieldStop()
11102 
    oprot.writeStructEnd()
11103 
 
11104 
  def __repr__(self):
11105 
    L = ['%s=%r' % (key, value)
11106 
      for key, value in self.__dict__.iteritems()]
11107 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11108 
 
11109 
  def __eq__(self, other):
11110 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11111 
 
11112 
  def __ne__(self, other):
11113 
    return not (self == other)
11114 
 
559 chandransh 11115 
class validateCart_args:
94 ashish 11116 
  """
11117 
  Attributes:
559 chandransh 11118 
   - cartId
94 ashish 11119 
  """
11120 
 
11121 
  thrift_spec = (
11122 
    None, # 0
559 chandransh 11123 
    (1, TType.I64, 'cartId', None, None, ), # 1
94 ashish 11124 
  )
11125 
 
559 chandransh 11126 
  def __init__(self, cartId=None,):
11127 
    self.cartId = cartId
94 ashish 11128 
 
11129 
  def read(self, iprot):
11130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11132 
      return
11133 
    iprot.readStructBegin()
11134 
    while True:
11135 
      (fname, ftype, fid) = iprot.readFieldBegin()
11136 
      if ftype == TType.STOP:
11137 
        break
11138 
      if fid == 1:
11139 
        if ftype == TType.I64:
559 chandransh 11140 
          self.cartId = iprot.readI64();
94 ashish 11141 
        else:
11142 
          iprot.skip(ftype)
11143 
      else:
11144 
        iprot.skip(ftype)
11145 
      iprot.readFieldEnd()
11146 
    iprot.readStructEnd()
11147 
 
11148 
  def write(self, oprot):
11149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11151 
      return
559 chandransh 11152 
    oprot.writeStructBegin('validateCart_args')
11153 
    if self.cartId != None:
11154 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11155 
      oprot.writeI64(self.cartId)
94 ashish 11156 
      oprot.writeFieldEnd()
11157 
    oprot.writeFieldStop()
11158 
    oprot.writeStructEnd()
11159 
 
11160 
  def __repr__(self):
11161 
    L = ['%s=%r' % (key, value)
11162 
      for key, value in self.__dict__.iteritems()]
11163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11164 
 
11165 
  def __eq__(self, other):
11166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11167 
 
11168 
  def __ne__(self, other):
11169 
    return not (self == other)
11170 
 
559 chandransh 11171 
class validateCart_result:
94 ashish 11172 
  """
11173 
  Attributes:
11174 
   - success
575 chandransh 11175 
   - scex
94 ashish 11176 
  """
11177 
 
11178 
  thrift_spec = (
1466 ankur.sing 11179 
    (0, TType.STRING, 'success', None, None, ), # 0
575 chandransh 11180 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11181 
  )
11182 
 
575 chandransh 11183 
  def __init__(self, success=None, scex=None,):
94 ashish 11184 
    self.success = success
575 chandransh 11185 
    self.scex = scex
94 ashish 11186 
 
11187 
  def read(self, iprot):
11188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11190 
      return
11191 
    iprot.readStructBegin()
11192 
    while True:
11193 
      (fname, ftype, fid) = iprot.readFieldBegin()
11194 
      if ftype == TType.STOP:
11195 
        break
11196 
      if fid == 0:
1466 ankur.sing 11197 
        if ftype == TType.STRING:
11198 
          self.success = iprot.readString();
94 ashish 11199 
        else:
11200 
          iprot.skip(ftype)
575 chandransh 11201 
      elif fid == 1:
11202 
        if ftype == TType.STRUCT:
11203 
          self.scex = ShoppingCartException()
11204 
          self.scex.read(iprot)
11205 
        else:
11206 
          iprot.skip(ftype)
94 ashish 11207 
      else:
11208 
        iprot.skip(ftype)
11209 
      iprot.readFieldEnd()
11210 
    iprot.readStructEnd()
11211 
 
11212 
  def write(self, oprot):
11213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11215 
      return
559 chandransh 11216 
    oprot.writeStructBegin('validateCart_result')
94 ashish 11217 
    if self.success != None:
1466 ankur.sing 11218 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11219 
      oprot.writeString(self.success)
94 ashish 11220 
      oprot.writeFieldEnd()
575 chandransh 11221 
    if self.scex != None:
11222 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11223 
      self.scex.write(oprot)
11224 
      oprot.writeFieldEnd()
559 chandransh 11225 
    oprot.writeFieldStop()
11226 
    oprot.writeStructEnd()
11227 
 
11228 
  def __repr__(self):
11229 
    L = ['%s=%r' % (key, value)
11230 
      for key, value in self.__dict__.iteritems()]
11231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11232 
 
11233 
  def __eq__(self, other):
11234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11235 
 
11236 
  def __ne__(self, other):
11237 
    return not (self == other)
11238 
 
690 chandransh 11239 
class mergeCart_args:
575 chandransh 11240 
  """
11241 
  Attributes:
690 chandransh 11242 
   - fromCartId
11243 
   - toCartId
11244 
  """
11245 
 
11246 
  thrift_spec = (
11247 
    None, # 0
11248 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
11249 
    (2, TType.I64, 'toCartId', None, None, ), # 2
11250 
  )
11251 
 
11252 
  def __init__(self, fromCartId=None, toCartId=None,):
11253 
    self.fromCartId = fromCartId
11254 
    self.toCartId = toCartId
11255 
 
11256 
  def read(self, iprot):
11257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11259 
      return
11260 
    iprot.readStructBegin()
11261 
    while True:
11262 
      (fname, ftype, fid) = iprot.readFieldBegin()
11263 
      if ftype == TType.STOP:
11264 
        break
11265 
      if fid == 1:
11266 
        if ftype == TType.I64:
11267 
          self.fromCartId = iprot.readI64();
11268 
        else:
11269 
          iprot.skip(ftype)
11270 
      elif fid == 2:
11271 
        if ftype == TType.I64:
11272 
          self.toCartId = iprot.readI64();
11273 
        else:
11274 
          iprot.skip(ftype)
11275 
      else:
11276 
        iprot.skip(ftype)
11277 
      iprot.readFieldEnd()
11278 
    iprot.readStructEnd()
11279 
 
11280 
  def write(self, oprot):
11281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11283 
      return
11284 
    oprot.writeStructBegin('mergeCart_args')
11285 
    if self.fromCartId != None:
11286 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
11287 
      oprot.writeI64(self.fromCartId)
11288 
      oprot.writeFieldEnd()
11289 
    if self.toCartId != None:
11290 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
11291 
      oprot.writeI64(self.toCartId)
11292 
      oprot.writeFieldEnd()
11293 
    oprot.writeFieldStop()
11294 
    oprot.writeStructEnd()
11295 
 
11296 
  def __repr__(self):
11297 
    L = ['%s=%r' % (key, value)
11298 
      for key, value in self.__dict__.iteritems()]
11299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11300 
 
11301 
  def __eq__(self, other):
11302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11303 
 
11304 
  def __ne__(self, other):
11305 
    return not (self == other)
11306 
 
11307 
class mergeCart_result:
11308 
 
11309 
  thrift_spec = (
11310 
  )
11311 
 
11312 
  def read(self, iprot):
11313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11315 
      return
11316 
    iprot.readStructBegin()
11317 
    while True:
11318 
      (fname, ftype, fid) = iprot.readFieldBegin()
11319 
      if ftype == TType.STOP:
11320 
        break
11321 
      else:
11322 
        iprot.skip(ftype)
11323 
      iprot.readFieldEnd()
11324 
    iprot.readStructEnd()
11325 
 
11326 
  def write(self, oprot):
11327 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11328 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11329 
      return
11330 
    oprot.writeStructBegin('mergeCart_result')
11331 
    oprot.writeFieldStop()
11332 
    oprot.writeStructEnd()
11333 
 
11334 
  def __repr__(self):
11335 
    L = ['%s=%r' % (key, value)
11336 
      for key, value in self.__dict__.iteritems()]
11337 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11338 
 
11339 
  def __eq__(self, other):
11340 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11341 
 
11342 
  def __ne__(self, other):
11343 
    return not (self == other)
11344 
 
11345 
class checkOut_args:
11346 
  """
11347 
  Attributes:
575 chandransh 11348 
   - cartId
11349 
  """
11350 
 
11351 
  thrift_spec = (
11352 
    None, # 0
11353 
    (1, TType.I64, 'cartId', None, None, ), # 1
11354 
  )
11355 
 
11356 
  def __init__(self, cartId=None,):
11357 
    self.cartId = cartId
11358 
 
11359 
  def read(self, iprot):
11360 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11361 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11362 
      return
11363 
    iprot.readStructBegin()
11364 
    while True:
11365 
      (fname, ftype, fid) = iprot.readFieldBegin()
11366 
      if ftype == TType.STOP:
11367 
        break
11368 
      if fid == 1:
11369 
        if ftype == TType.I64:
11370 
          self.cartId = iprot.readI64();
11371 
        else:
11372 
          iprot.skip(ftype)
11373 
      else:
11374 
        iprot.skip(ftype)
11375 
      iprot.readFieldEnd()
11376 
    iprot.readStructEnd()
11377 
 
11378 
  def write(self, oprot):
11379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11381 
      return
690 chandransh 11382 
    oprot.writeStructBegin('checkOut_args')
575 chandransh 11383 
    if self.cartId != None:
11384 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11385 
      oprot.writeI64(self.cartId)
11386 
      oprot.writeFieldEnd()
11387 
    oprot.writeFieldStop()
11388 
    oprot.writeStructEnd()
11389 
 
11390 
  def __repr__(self):
11391 
    L = ['%s=%r' % (key, value)
11392 
      for key, value in self.__dict__.iteritems()]
11393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11394 
 
11395 
  def __eq__(self, other):
11396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11397 
 
11398 
  def __ne__(self, other):
11399 
    return not (self == other)
11400 
 
690 chandransh 11401 
class checkOut_result:
575 chandransh 11402 
  """
11403 
  Attributes:
11404 
   - success
11405 
   - scex
11406 
  """
11407 
 
11408 
  thrift_spec = (
11409 
    (0, TType.BOOL, 'success', None, None, ), # 0
11410 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11411 
  )
11412 
 
11413 
  def __init__(self, success=None, scex=None,):
11414 
    self.success = success
11415 
    self.scex = scex
11416 
 
11417 
  def read(self, iprot):
11418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11420 
      return
11421 
    iprot.readStructBegin()
11422 
    while True:
11423 
      (fname, ftype, fid) = iprot.readFieldBegin()
11424 
      if ftype == TType.STOP:
11425 
        break
11426 
      if fid == 0:
11427 
        if ftype == TType.BOOL:
11428 
          self.success = iprot.readBool();
11429 
        else:
11430 
          iprot.skip(ftype)
11431 
      elif fid == 1:
11432 
        if ftype == TType.STRUCT:
11433 
          self.scex = ShoppingCartException()
11434 
          self.scex.read(iprot)
11435 
        else:
11436 
          iprot.skip(ftype)
11437 
      else:
11438 
        iprot.skip(ftype)
11439 
      iprot.readFieldEnd()
11440 
    iprot.readStructEnd()
11441 
 
11442 
  def write(self, oprot):
11443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11445 
      return
690 chandransh 11446 
    oprot.writeStructBegin('checkOut_result')
575 chandransh 11447 
    if self.success != None:
11448 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11449 
      oprot.writeBool(self.success)
11450 
      oprot.writeFieldEnd()
11451 
    if self.scex != None:
11452 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11453 
      self.scex.write(oprot)
11454 
      oprot.writeFieldEnd()
11455 
    oprot.writeFieldStop()
11456 
    oprot.writeStructEnd()
11457 
 
11458 
  def __repr__(self):
11459 
    L = ['%s=%r' % (key, value)
11460 
      for key, value in self.__dict__.iteritems()]
11461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11462 
 
11463 
  def __eq__(self, other):
11464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11465 
 
11466 
  def __ne__(self, other):
11467 
    return not (self == other)
11468 
 
690 chandransh 11469 
class resetCart_args:
559 chandransh 11470 
  """
11471 
  Attributes:
690 chandransh 11472 
   - cartId
11473 
   - items
559 chandransh 11474 
  """
11475 
 
11476 
  thrift_spec = (
11477 
    None, # 0
690 chandransh 11478 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 11479 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 11480 
  )
11481 
 
690 chandransh 11482 
  def __init__(self, cartId=None, items=None,):
11483 
    self.cartId = cartId
11484 
    self.items = items
559 chandransh 11485 
 
11486 
  def read(self, iprot):
11487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11489 
      return
11490 
    iprot.readStructBegin()
11491 
    while True:
11492 
      (fname, ftype, fid) = iprot.readFieldBegin()
11493 
      if ftype == TType.STOP:
11494 
        break
11495 
      if fid == 1:
11496 
        if ftype == TType.I64:
690 chandransh 11497 
          self.cartId = iprot.readI64();
559 chandransh 11498 
        else:
11499 
          iprot.skip(ftype)
11500 
      elif fid == 2:
690 chandransh 11501 
        if ftype == TType.MAP:
11502 
          self.items = {}
2981 rajveer 11503 
          (_ktype106, _vtype107, _size105 ) = iprot.readMapBegin()
11504 
          for _i109 in xrange(_size105):
11505 
            _key110 = iprot.readI64();
11506 
            _val111 = iprot.readDouble();
11507 
            self.items[_key110] = _val111
690 chandransh 11508 
          iprot.readMapEnd()
559 chandransh 11509 
        else:
11510 
          iprot.skip(ftype)
11511 
      else:
11512 
        iprot.skip(ftype)
11513 
      iprot.readFieldEnd()
11514 
    iprot.readStructEnd()
11515 
 
11516 
  def write(self, oprot):
11517 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11518 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11519 
      return
690 chandransh 11520 
    oprot.writeStructBegin('resetCart_args')
11521 
    if self.cartId != None:
11522 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11523 
      oprot.writeI64(self.cartId)
94 ashish 11524 
      oprot.writeFieldEnd()
690 chandransh 11525 
    if self.items != None:
11526 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 11527 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
2981 rajveer 11528 
      for kiter112,viter113 in self.items.items():
11529 
        oprot.writeI64(kiter112)
11530 
        oprot.writeDouble(viter113)
690 chandransh 11531 
      oprot.writeMapEnd()
559 chandransh 11532 
      oprot.writeFieldEnd()
94 ashish 11533 
    oprot.writeFieldStop()
11534 
    oprot.writeStructEnd()
11535 
 
11536 
  def __repr__(self):
11537 
    L = ['%s=%r' % (key, value)
11538 
      for key, value in self.__dict__.iteritems()]
11539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11540 
 
11541 
  def __eq__(self, other):
11542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11543 
 
11544 
  def __ne__(self, other):
11545 
    return not (self == other)
11546 
 
690 chandransh 11547 
class resetCart_result:
11548 
  """
11549 
  Attributes:
11550 
   - success
11551 
   - scex
11552 
  """
559 chandransh 11553 
 
11554 
  thrift_spec = (
690 chandransh 11555 
    (0, TType.BOOL, 'success', None, None, ), # 0
11556 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11557 
  )
11558 
 
690 chandransh 11559 
  def __init__(self, success=None, scex=None,):
11560 
    self.success = success
11561 
    self.scex = scex
11562 
 
559 chandransh 11563 
  def read(self, iprot):
11564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11566 
      return
11567 
    iprot.readStructBegin()
11568 
    while True:
11569 
      (fname, ftype, fid) = iprot.readFieldBegin()
11570 
      if ftype == TType.STOP:
11571 
        break
690 chandransh 11572 
      if fid == 0:
11573 
        if ftype == TType.BOOL:
11574 
          self.success = iprot.readBool();
11575 
        else:
11576 
          iprot.skip(ftype)
11577 
      elif fid == 1:
11578 
        if ftype == TType.STRUCT:
11579 
          self.scex = ShoppingCartException()
11580 
          self.scex.read(iprot)
11581 
        else:
11582 
          iprot.skip(ftype)
559 chandransh 11583 
      else:
11584 
        iprot.skip(ftype)
11585 
      iprot.readFieldEnd()
11586 
    iprot.readStructEnd()
11587 
 
11588 
  def write(self, oprot):
11589 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11590 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11591 
      return
690 chandransh 11592 
    oprot.writeStructBegin('resetCart_result')
11593 
    if self.success != None:
11594 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11595 
      oprot.writeBool(self.success)
11596 
      oprot.writeFieldEnd()
11597 
    if self.scex != None:
11598 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11599 
      self.scex.write(oprot)
11600 
      oprot.writeFieldEnd()
559 chandransh 11601 
    oprot.writeFieldStop()
11602 
    oprot.writeStructEnd()
11603 
 
11604 
  def __repr__(self):
11605 
    L = ['%s=%r' % (key, value)
11606 
      for key, value in self.__dict__.iteritems()]
11607 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11608 
 
11609 
  def __eq__(self, other):
11610 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11611 
 
11612 
  def __ne__(self, other):
11613 
    return not (self == other)
11614 
 
2981 rajveer 11615 
class getUserCount_args:
94 ashish 11616 
  """
11617 
  Attributes:
2981 rajveer 11618 
   - userType
559 chandransh 11619 
  """
11620 
 
11621 
  thrift_spec = (
11622 
    None, # 0
2981 rajveer 11623 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 11624 
  )
11625 
 
2981 rajveer 11626 
  def __init__(self, userType=None,):
11627 
    self.userType = userType
559 chandransh 11628 
 
11629 
  def read(self, iprot):
11630 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11631 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11632 
      return
11633 
    iprot.readStructBegin()
11634 
    while True:
11635 
      (fname, ftype, fid) = iprot.readFieldBegin()
11636 
      if ftype == TType.STOP:
11637 
        break
11638 
      if fid == 1:
2981 rajveer 11639 
        if ftype == TType.I32:
11640 
          self.userType = iprot.readI32();
559 chandransh 11641 
        else:
11642 
          iprot.skip(ftype)
11643 
      else:
11644 
        iprot.skip(ftype)
11645 
      iprot.readFieldEnd()
11646 
    iprot.readStructEnd()
11647 
 
11648 
  def write(self, oprot):
11649 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11650 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11651 
      return
2981 rajveer 11652 
    oprot.writeStructBegin('getUserCount_args')
11653 
    if self.userType != None:
11654 
      oprot.writeFieldBegin('userType', TType.I32, 1)
11655 
      oprot.writeI32(self.userType)
559 chandransh 11656 
      oprot.writeFieldEnd()
11657 
    oprot.writeFieldStop()
11658 
    oprot.writeStructEnd()
11659 
 
11660 
  def __repr__(self):
11661 
    L = ['%s=%r' % (key, value)
11662 
      for key, value in self.__dict__.iteritems()]
11663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11664 
 
11665 
  def __eq__(self, other):
11666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11667 
 
11668 
  def __ne__(self, other):
11669 
    return not (self == other)
11670 
 
2981 rajveer 11671 
class getUserCount_result:
94 ashish 11672 
  """
11673 
  Attributes:
11674 
   - success
11675 
  """
11676 
 
11677 
  thrift_spec = (
2981 rajveer 11678 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 11679 
  )
11680 
 
2981 rajveer 11681 
  def __init__(self, success=None,):
94 ashish 11682 
    self.success = success
11683 
 
11684 
  def read(self, iprot):
11685 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11686 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11687 
      return
11688 
    iprot.readStructBegin()
11689 
    while True:
11690 
      (fname, ftype, fid) = iprot.readFieldBegin()
11691 
      if ftype == TType.STOP:
11692 
        break
11693 
      if fid == 0:
2981 rajveer 11694 
        if ftype == TType.I64:
11695 
          self.success = iprot.readI64();
94 ashish 11696 
        else:
11697 
          iprot.skip(ftype)
11698 
      else:
11699 
        iprot.skip(ftype)
11700 
      iprot.readFieldEnd()
11701 
    iprot.readStructEnd()
11702 
 
11703 
  def write(self, oprot):
11704 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11705 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11706 
      return
2981 rajveer 11707 
    oprot.writeStructBegin('getUserCount_result')
94 ashish 11708 
    if self.success != None:
2981 rajveer 11709 
      oprot.writeFieldBegin('success', TType.I64, 0)
11710 
      oprot.writeI64(self.success)
94 ashish 11711 
      oprot.writeFieldEnd()
11712 
    oprot.writeFieldStop()
11713 
    oprot.writeStructEnd()
11714 
 
11715 
  def __repr__(self):
11716 
    L = ['%s=%r' % (key, value)
11717 
      for key, value in self.__dict__.iteritems()]
11718 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11719 
 
11720 
  def __eq__(self, other):
11721 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11722 
 
11723 
  def __ne__(self, other):
11724 
    return not (self == other)
11725 
 
2981 rajveer 11726 
class getAllUsers_args:
94 ashish 11727 
  """
11728 
  Attributes:
2981 rajveer 11729 
   - userType
11730 
   - startDate
11731 
   - endDate
94 ashish 11732 
  """
11733 
 
11734 
  thrift_spec = (
11735 
    None, # 0
2981 rajveer 11736 
    (1, TType.I32, 'userType', None, None, ), # 1
11737 
    (2, TType.I64, 'startDate', None, None, ), # 2
11738 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 11739 
  )
11740 
 
2981 rajveer 11741 
  def __init__(self, userType=None, startDate=None, endDate=None,):
11742 
    self.userType = userType
11743 
    self.startDate = startDate
11744 
    self.endDate = endDate
94 ashish 11745 
 
11746 
  def read(self, iprot):
11747 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11748 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11749 
      return
11750 
    iprot.readStructBegin()
11751 
    while True:
11752 
      (fname, ftype, fid) = iprot.readFieldBegin()
11753 
      if ftype == TType.STOP:
11754 
        break
11755 
      if fid == 1:
2981 rajveer 11756 
        if ftype == TType.I32:
11757 
          self.userType = iprot.readI32();
94 ashish 11758 
        else:
11759 
          iprot.skip(ftype)
11760 
      elif fid == 2:
559 chandransh 11761 
        if ftype == TType.I64:
2981 rajveer 11762 
          self.startDate = iprot.readI64();
94 ashish 11763 
        else:
11764 
          iprot.skip(ftype)
2981 rajveer 11765 
      elif fid == 3:
11766 
        if ftype == TType.I64:
11767 
          self.endDate = iprot.readI64();
11768 
        else:
11769 
          iprot.skip(ftype)
94 ashish 11770 
      else:
11771 
        iprot.skip(ftype)
11772 
      iprot.readFieldEnd()
11773 
    iprot.readStructEnd()
11774 
 
11775 
  def write(self, oprot):
11776 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11777 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11778 
      return
2981 rajveer 11779 
    oprot.writeStructBegin('getAllUsers_args')
11780 
    if self.userType != None:
11781 
      oprot.writeFieldBegin('userType', TType.I32, 1)
11782 
      oprot.writeI32(self.userType)
94 ashish 11783 
      oprot.writeFieldEnd()
2981 rajveer 11784 
    if self.startDate != None:
11785 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
11786 
      oprot.writeI64(self.startDate)
94 ashish 11787 
      oprot.writeFieldEnd()
2981 rajveer 11788 
    if self.endDate != None:
11789 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
11790 
      oprot.writeI64(self.endDate)
11791 
      oprot.writeFieldEnd()
94 ashish 11792 
    oprot.writeFieldStop()
11793 
    oprot.writeStructEnd()
11794 
 
11795 
  def __repr__(self):
11796 
    L = ['%s=%r' % (key, value)
11797 
      for key, value in self.__dict__.iteritems()]
11798 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11799 
 
11800 
  def __eq__(self, other):
11801 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11802 
 
11803 
  def __ne__(self, other):
11804 
    return not (self == other)
11805 
 
2981 rajveer 11806 
class getAllUsers_result:
94 ashish 11807 
  """
11808 
  Attributes:
11809 
   - success
11810 
  """
11811 
 
11812 
  thrift_spec = (
2981 rajveer 11813 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 11814 
  )
11815 
 
2981 rajveer 11816 
  def __init__(self, success=None,):
94 ashish 11817 
    self.success = success
11818 
 
11819 
  def read(self, iprot):
11820 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11821 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11822 
      return
11823 
    iprot.readStructBegin()
11824 
    while True:
11825 
      (fname, ftype, fid) = iprot.readFieldBegin()
11826 
      if ftype == TType.STOP:
11827 
        break
11828 
      if fid == 0:
2981 rajveer 11829 
        if ftype == TType.LIST:
11830 
          self.success = []
11831 
          (_etype117, _size114) = iprot.readListBegin()
11832 
          for _i118 in xrange(_size114):
11833 
            _elem119 = User()
11834 
            _elem119.read(iprot)
11835 
            self.success.append(_elem119)
11836 
          iprot.readListEnd()
94 ashish 11837 
        else:
11838 
          iprot.skip(ftype)
11839 
      else:
11840 
        iprot.skip(ftype)
11841 
      iprot.readFieldEnd()
11842 
    iprot.readStructEnd()
11843 
 
11844 
  def write(self, oprot):
11845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11847 
      return
2981 rajveer 11848 
    oprot.writeStructBegin('getAllUsers_result')
94 ashish 11849 
    if self.success != None:
2981 rajveer 11850 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11851 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11852 
      for iter120 in self.success:
11853 
        iter120.write(oprot)
11854 
      oprot.writeListEnd()
94 ashish 11855 
      oprot.writeFieldEnd()
11856 
    oprot.writeFieldStop()
11857 
    oprot.writeStructEnd()
11858 
 
11859 
  def __repr__(self):
11860 
    L = ['%s=%r' % (key, value)
11861 
      for key, value in self.__dict__.iteritems()]
11862 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11863 
 
11864 
  def __eq__(self, other):
11865 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11866 
 
11867 
  def __ne__(self, other):
11868 
    return not (self == other)
11869 
 
2981 rajveer 11870 
class putUserNote_args:
130 ashish 11871 
  """
11872 
  Attributes:
2981 rajveer 11873 
   - user_id
11874 
   - entity_id
11875 
   - slide
11876 
   - note
130 ashish 11877 
  """
94 ashish 11878 
 
130 ashish 11879 
  thrift_spec = (
11880 
    None, # 0
2981 rajveer 11881 
    (1, TType.I64, 'user_id', None, None, ), # 1
11882 
    (2, TType.I64, 'entity_id', None, None, ), # 2
11883 
    (3, TType.STRING, 'slide', None, None, ), # 3
11884 
    (4, TType.STRING, 'note', None, None, ), # 4
130 ashish 11885 
  )
11886 
 
2981 rajveer 11887 
  def __init__(self, user_id=None, entity_id=None, slide=None, note=None,):
11888 
    self.user_id = user_id
11889 
    self.entity_id = entity_id
11890 
    self.slide = slide
11891 
    self.note = note
130 ashish 11892 
 
11893 
  def read(self, iprot):
11894 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11895 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11896 
      return
11897 
    iprot.readStructBegin()
11898 
    while True:
11899 
      (fname, ftype, fid) = iprot.readFieldBegin()
11900 
      if ftype == TType.STOP:
11901 
        break
11902 
      if fid == 1:
11903 
        if ftype == TType.I64:
2981 rajveer 11904 
          self.user_id = iprot.readI64();
130 ashish 11905 
        else:
11906 
          iprot.skip(ftype)
559 chandransh 11907 
      elif fid == 2:
11908 
        if ftype == TType.I64:
2981 rajveer 11909 
          self.entity_id = iprot.readI64();
559 chandransh 11910 
        else:
11911 
          iprot.skip(ftype)
2981 rajveer 11912 
      elif fid == 3:
11913 
        if ftype == TType.STRING:
11914 
          self.slide = iprot.readString();
11915 
        else:
11916 
          iprot.skip(ftype)
11917 
      elif fid == 4:
11918 
        if ftype == TType.STRING:
11919 
          self.note = iprot.readString();
11920 
        else:
11921 
          iprot.skip(ftype)
130 ashish 11922 
      else:
11923 
        iprot.skip(ftype)
11924 
      iprot.readFieldEnd()
11925 
    iprot.readStructEnd()
11926 
 
11927 
  def write(self, oprot):
11928 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11929 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11930 
      return
2981 rajveer 11931 
    oprot.writeStructBegin('putUserNote_args')
11932 
    if self.user_id != None:
11933 
      oprot.writeFieldBegin('user_id', TType.I64, 1)
11934 
      oprot.writeI64(self.user_id)
130 ashish 11935 
      oprot.writeFieldEnd()
2981 rajveer 11936 
    if self.entity_id != None:
11937 
      oprot.writeFieldBegin('entity_id', TType.I64, 2)
11938 
      oprot.writeI64(self.entity_id)
559 chandransh 11939 
      oprot.writeFieldEnd()
2981 rajveer 11940 
    if self.slide != None:
11941 
      oprot.writeFieldBegin('slide', TType.STRING, 3)
11942 
      oprot.writeString(self.slide)
11943 
      oprot.writeFieldEnd()
11944 
    if self.note != None:
11945 
      oprot.writeFieldBegin('note', TType.STRING, 4)
11946 
      oprot.writeString(self.note)
11947 
      oprot.writeFieldEnd()
130 ashish 11948 
    oprot.writeFieldStop()
11949 
    oprot.writeStructEnd()
11950 
 
11951 
  def __repr__(self):
11952 
    L = ['%s=%r' % (key, value)
11953 
      for key, value in self.__dict__.iteritems()]
11954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11955 
 
11956 
  def __eq__(self, other):
11957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11958 
 
11959 
  def __ne__(self, other):
11960 
    return not (self == other)
11961 
 
2981 rajveer 11962 
class putUserNote_result:
559 chandransh 11963 
 
11964 
  thrift_spec = (
11965 
  )
11966 
 
11967 
  def read(self, iprot):
11968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11970 
      return
11971 
    iprot.readStructBegin()
11972 
    while True:
11973 
      (fname, ftype, fid) = iprot.readFieldBegin()
11974 
      if ftype == TType.STOP:
11975 
        break
11976 
      else:
11977 
        iprot.skip(ftype)
11978 
      iprot.readFieldEnd()
11979 
    iprot.readStructEnd()
11980 
 
11981 
  def write(self, oprot):
11982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11984 
      return
2981 rajveer 11985 
    oprot.writeStructBegin('putUserNote_result')
559 chandransh 11986 
    oprot.writeFieldStop()
11987 
    oprot.writeStructEnd()
11988 
 
11989 
  def __repr__(self):
11990 
    L = ['%s=%r' % (key, value)
11991 
      for key, value in self.__dict__.iteritems()]
11992 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11993 
 
11994 
  def __eq__(self, other):
11995 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11996 
 
11997 
  def __ne__(self, other):
11998 
    return not (self == other)
11999 
 
2981 rajveer 12000 
class getUserNotes_args:
559 chandransh 12001 
  """
12002 
  Attributes:
2981 rajveer 12003 
   - user_id
12004 
   - entity_id
559 chandransh 12005 
  """
12006 
 
12007 
  thrift_spec = (
12008 
    None, # 0
2981 rajveer 12009 
    (1, TType.I64, 'user_id', None, None, ), # 1
12010 
    (2, TType.I64, 'entity_id', None, None, ), # 2
559 chandransh 12011 
  )
12012 
 
2981 rajveer 12013 
  def __init__(self, user_id=None, entity_id=None,):
12014 
    self.user_id = user_id
12015 
    self.entity_id = entity_id
559 chandransh 12016 
 
12017 
  def read(self, iprot):
12018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12020 
      return
12021 
    iprot.readStructBegin()
12022 
    while True:
12023 
      (fname, ftype, fid) = iprot.readFieldBegin()
12024 
      if ftype == TType.STOP:
12025 
        break
12026 
      if fid == 1:
12027 
        if ftype == TType.I64:
2981 rajveer 12028 
          self.user_id = iprot.readI64();
559 chandransh 12029 
        else:
12030 
          iprot.skip(ftype)
12031 
      elif fid == 2:
12032 
        if ftype == TType.I64:
2981 rajveer 12033 
          self.entity_id = iprot.readI64();
559 chandransh 12034 
        else:
12035 
          iprot.skip(ftype)
12036 
      else:
12037 
        iprot.skip(ftype)
12038 
      iprot.readFieldEnd()
12039 
    iprot.readStructEnd()
12040 
 
12041 
  def write(self, oprot):
12042 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12043 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12044 
      return
2981 rajveer 12045 
    oprot.writeStructBegin('getUserNotes_args')
12046 
    if self.user_id != None:
12047 
      oprot.writeFieldBegin('user_id', TType.I64, 1)
12048 
      oprot.writeI64(self.user_id)
559 chandransh 12049 
      oprot.writeFieldEnd()
2981 rajveer 12050 
    if self.entity_id != None:
12051 
      oprot.writeFieldBegin('entity_id', TType.I64, 2)
12052 
      oprot.writeI64(self.entity_id)
559 chandransh 12053 
      oprot.writeFieldEnd()
12054 
    oprot.writeFieldStop()
12055 
    oprot.writeStructEnd()
12056 
 
12057 
  def __repr__(self):
12058 
    L = ['%s=%r' % (key, value)
12059 
      for key, value in self.__dict__.iteritems()]
12060 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12061 
 
12062 
  def __eq__(self, other):
12063 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12064 
 
12065 
  def __ne__(self, other):
12066 
    return not (self == other)
12067 
 
2981 rajveer 12068 
class getUserNotes_result:
12069 
  """
12070 
  Attributes:
12071 
   - success
12072 
  """
559 chandransh 12073 
 
12074 
  thrift_spec = (
2981 rajveer 12075 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserNote, UserNote.thrift_spec)), None, ), # 0
559 chandransh 12076 
  )
12077 
 
2981 rajveer 12078 
  def __init__(self, success=None,):
12079 
    self.success = success
12080 
 
559 chandransh 12081 
  def read(self, iprot):
12082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12084 
      return
12085 
    iprot.readStructBegin()
12086 
    while True:
12087 
      (fname, ftype, fid) = iprot.readFieldBegin()
12088 
      if ftype == TType.STOP:
12089 
        break
2981 rajveer 12090 
      if fid == 0:
12091 
        if ftype == TType.LIST:
12092 
          self.success = []
12093 
          (_etype124, _size121) = iprot.readListBegin()
12094 
          for _i125 in xrange(_size121):
12095 
            _elem126 = UserNote()
12096 
            _elem126.read(iprot)
12097 
            self.success.append(_elem126)
12098 
          iprot.readListEnd()
12099 
        else:
12100 
          iprot.skip(ftype)
559 chandransh 12101 
      else:
12102 
        iprot.skip(ftype)
12103 
      iprot.readFieldEnd()
12104 
    iprot.readStructEnd()
12105 
 
12106 
  def write(self, oprot):
12107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12109 
      return
2981 rajveer 12110 
    oprot.writeStructBegin('getUserNotes_result')
12111 
    if self.success != None:
12112 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12113 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
12114 
      for iter127 in self.success:
12115 
        iter127.write(oprot)
12116 
      oprot.writeListEnd()
12117 
      oprot.writeFieldEnd()
559 chandransh 12118 
    oprot.writeFieldStop()
12119 
    oprot.writeStructEnd()
12120 
 
12121 
  def __repr__(self):
12122 
    L = ['%s=%r' % (key, value)
12123 
      for key, value in self.__dict__.iteritems()]
12124 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12125 
 
12126 
  def __eq__(self, other):
12127 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12128 
 
12129 
  def __ne__(self, other):
12130 
    return not (self == other)
12131 
 
2981 rajveer 12132 
class getMyResearchItems_args:
559 chandransh 12133 
  """
12134 
  Attributes:
772 rajveer 12135 
   - userId
559 chandransh 12136 
  """
12137 
 
12138 
  thrift_spec = (
12139 
    None, # 0
772 rajveer 12140 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 12141 
  )
12142 
 
772 rajveer 12143 
  def __init__(self, userId=None,):
12144 
    self.userId = userId
559 chandransh 12145 
 
12146 
  def read(self, iprot):
12147 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12148 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12149 
      return
12150 
    iprot.readStructBegin()
12151 
    while True:
12152 
      (fname, ftype, fid) = iprot.readFieldBegin()
12153 
      if ftype == TType.STOP:
12154 
        break
12155 
      if fid == 1:
12156 
        if ftype == TType.I64:
772 rajveer 12157 
          self.userId = iprot.readI64();
559 chandransh 12158 
        else:
12159 
          iprot.skip(ftype)
12160 
      else:
12161 
        iprot.skip(ftype)
12162 
      iprot.readFieldEnd()
12163 
    iprot.readStructEnd()
12164 
 
12165 
  def write(self, oprot):
12166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12168 
      return
2981 rajveer 12169 
    oprot.writeStructBegin('getMyResearchItems_args')
772 rajveer 12170 
    if self.userId != None:
12171 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12172 
      oprot.writeI64(self.userId)
559 chandransh 12173 
      oprot.writeFieldEnd()
12174 
    oprot.writeFieldStop()
12175 
    oprot.writeStructEnd()
12176 
 
12177 
  def __repr__(self):
12178 
    L = ['%s=%r' % (key, value)
12179 
      for key, value in self.__dict__.iteritems()]
12180 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12181 
 
12182 
  def __eq__(self, other):
12183 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12184 
 
12185 
  def __ne__(self, other):
12186 
    return not (self == other)
12187 
 
2981 rajveer 12188 
class getMyResearchItems_result:
559 chandransh 12189 
  """
12190 
  Attributes:
130 ashish 12191 
   - success
559 chandransh 12192 
   - scx
130 ashish 12193 
  """
12194 
 
12195 
  thrift_spec = (
2981 rajveer 12196 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 12197 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 12198 
  )
12199 
 
559 chandransh 12200 
  def __init__(self, success=None, scx=None,):
130 ashish 12201 
    self.success = success
559 chandransh 12202 
    self.scx = scx
130 ashish 12203 
 
12204 
  def read(self, iprot):
12205 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12206 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12207 
      return
12208 
    iprot.readStructBegin()
12209 
    while True:
12210 
      (fname, ftype, fid) = iprot.readFieldBegin()
12211 
      if ftype == TType.STOP:
12212 
        break
12213 
      if fid == 0:
2981 rajveer 12214 
        if ftype == TType.LIST:
12215 
          self.success = []
12216 
          (_etype131, _size128) = iprot.readListBegin()
12217 
          for _i132 in xrange(_size128):
12218 
            _elem133 = iprot.readI64();
12219 
            self.success.append(_elem133)
12220 
          iprot.readListEnd()
130 ashish 12221 
        else:
12222 
          iprot.skip(ftype)
12223 
      elif fid == 1:
12224 
        if ftype == TType.STRUCT:
559 chandransh 12225 
          self.scx = WidgetException()
12226 
          self.scx.read(iprot)
130 ashish 12227 
        else:
12228 
          iprot.skip(ftype)
12229 
      else:
12230 
        iprot.skip(ftype)
12231 
      iprot.readFieldEnd()
12232 
    iprot.readStructEnd()
12233 
 
12234 
  def write(self, oprot):
12235 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12236 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12237 
      return
2981 rajveer 12238 
    oprot.writeStructBegin('getMyResearchItems_result')
130 ashish 12239 
    if self.success != None:
2981 rajveer 12240 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12241 
      oprot.writeListBegin(TType.I64, len(self.success))
12242 
      for iter134 in self.success:
12243 
        oprot.writeI64(iter134)
12244 
      oprot.writeListEnd()
130 ashish 12245 
      oprot.writeFieldEnd()
559 chandransh 12246 
    if self.scx != None:
12247 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12248 
      self.scx.write(oprot)
130 ashish 12249 
      oprot.writeFieldEnd()
12250 
    oprot.writeFieldStop()
12251 
    oprot.writeStructEnd()
12252 
 
12253 
  def __repr__(self):
12254 
    L = ['%s=%r' % (key, value)
12255 
      for key, value in self.__dict__.iteritems()]
12256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12257 
 
12258 
  def __eq__(self, other):
12259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12260 
 
12261 
  def __ne__(self, other):
12262 
    return not (self == other)
12263 
 
2981 rajveer 12264 
class updateMyResearch_args:
130 ashish 12265 
  """
12266 
  Attributes:
2981 rajveer 12267 
   - userId
12268 
   - itemId
130 ashish 12269 
  """
12270 
 
12271 
  thrift_spec = (
12272 
    None, # 0
2981 rajveer 12273 
    (1, TType.I64, 'userId', None, None, ), # 1
12274 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 12275 
  )
12276 
 
2981 rajveer 12277 
  def __init__(self, userId=None, itemId=None,):
12278 
    self.userId = userId
12279 
    self.itemId = itemId
130 ashish 12280 
 
12281 
  def read(self, iprot):
12282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12284 
      return
12285 
    iprot.readStructBegin()
12286 
    while True:
12287 
      (fname, ftype, fid) = iprot.readFieldBegin()
12288 
      if ftype == TType.STOP:
12289 
        break
12290 
      if fid == 1:
559 chandransh 12291 
        if ftype == TType.I64:
2981 rajveer 12292 
          self.userId = iprot.readI64();
130 ashish 12293 
        else:
12294 
          iprot.skip(ftype)
12295 
      elif fid == 2:
559 chandransh 12296 
        if ftype == TType.I64:
2981 rajveer 12297 
          self.itemId = iprot.readI64();
559 chandransh 12298 
        else:
12299 
          iprot.skip(ftype)
130 ashish 12300 
      else:
12301 
        iprot.skip(ftype)
12302 
      iprot.readFieldEnd()
12303 
    iprot.readStructEnd()
12304 
 
12305 
  def write(self, oprot):
12306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12308 
      return
2981 rajveer 12309 
    oprot.writeStructBegin('updateMyResearch_args')
12310 
    if self.userId != None:
12311 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12312 
      oprot.writeI64(self.userId)
130 ashish 12313 
      oprot.writeFieldEnd()
2981 rajveer 12314 
    if self.itemId != None:
12315 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12316 
      oprot.writeI64(self.itemId)
130 ashish 12317 
      oprot.writeFieldEnd()
12318 
    oprot.writeFieldStop()
12319 
    oprot.writeStructEnd()
12320 
 
12321 
  def __repr__(self):
12322 
    L = ['%s=%r' % (key, value)
12323 
      for key, value in self.__dict__.iteritems()]
12324 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12325 
 
12326 
  def __eq__(self, other):
12327 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12328 
 
12329 
  def __ne__(self, other):
12330 
    return not (self == other)
12331 
 
2981 rajveer 12332 
class updateMyResearch_result:
12333 
  """
12334 
  Attributes:
12335 
   - success
12336 
   - scx
12337 
  """
559 chandransh 12338 
 
12339 
  thrift_spec = (
2981 rajveer 12340 
    (0, TType.BOOL, 'success', None, None, ), # 0
12341 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 12342 
  )
12343 
 
2981 rajveer 12344 
  def __init__(self, success=None, scx=None,):
12345 
    self.success = success
12346 
    self.scx = scx
12347 
 
559 chandransh 12348 
  def read(self, iprot):
12349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12351 
      return
12352 
    iprot.readStructBegin()
12353 
    while True:
12354 
      (fname, ftype, fid) = iprot.readFieldBegin()
12355 
      if ftype == TType.STOP:
12356 
        break
2981 rajveer 12357 
      if fid == 0:
12358 
        if ftype == TType.BOOL:
12359 
          self.success = iprot.readBool();
12360 
        else:
12361 
          iprot.skip(ftype)
12362 
      elif fid == 1:
12363 
        if ftype == TType.STRUCT:
12364 
          self.scx = WidgetException()
12365 
          self.scx.read(iprot)
12366 
        else:
12367 
          iprot.skip(ftype)
559 chandransh 12368 
      else:
12369 
        iprot.skip(ftype)
12370 
      iprot.readFieldEnd()
12371 
    iprot.readStructEnd()
12372 
 
12373 
  def write(self, oprot):
12374 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12375 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12376 
      return
2981 rajveer 12377 
    oprot.writeStructBegin('updateMyResearch_result')
12378 
    if self.success != None:
12379 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12380 
      oprot.writeBool(self.success)
12381 
      oprot.writeFieldEnd()
12382 
    if self.scx != None:
12383 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12384 
      self.scx.write(oprot)
12385 
      oprot.writeFieldEnd()
559 chandransh 12386 
    oprot.writeFieldStop()
12387 
    oprot.writeStructEnd()
12388 
 
12389 
  def __repr__(self):
12390 
    L = ['%s=%r' % (key, value)
12391 
      for key, value in self.__dict__.iteritems()]
12392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12393 
 
12394 
  def __eq__(self, other):
12395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12396 
 
12397 
  def __ne__(self, other):
12398 
    return not (self == other)
12399 
 
2981 rajveer 12400 
class deleteItemFromMyResearch_args:
1596 ankur.sing 12401 
  """
12402 
  Attributes:
2981 rajveer 12403 
   - userId
12404 
   - itemId
1596 ankur.sing 12405 
  """
559 chandransh 12406 
 
1596 ankur.sing 12407 
  thrift_spec = (
12408 
    None, # 0
2981 rajveer 12409 
    (1, TType.I64, 'userId', None, None, ), # 1
12410 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 12411 
  )
12412 
 
2981 rajveer 12413 
  def __init__(self, userId=None, itemId=None,):
12414 
    self.userId = userId
12415 
    self.itemId = itemId
1596 ankur.sing 12416 
 
12417 
  def read(self, iprot):
12418 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12419 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12420 
      return
12421 
    iprot.readStructBegin()
12422 
    while True:
12423 
      (fname, ftype, fid) = iprot.readFieldBegin()
12424 
      if ftype == TType.STOP:
12425 
        break
12426 
      if fid == 1:
2981 rajveer 12427 
        if ftype == TType.I64:
12428 
          self.userId = iprot.readI64();
1596 ankur.sing 12429 
        else:
12430 
          iprot.skip(ftype)
2981 rajveer 12431 
      elif fid == 2:
12432 
        if ftype == TType.I64:
12433 
          self.itemId = iprot.readI64();
12434 
        else:
12435 
          iprot.skip(ftype)
1596 ankur.sing 12436 
      else:
12437 
        iprot.skip(ftype)
12438 
      iprot.readFieldEnd()
12439 
    iprot.readStructEnd()
12440 
 
12441 
  def write(self, oprot):
12442 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12443 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12444 
      return
2981 rajveer 12445 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
12446 
    if self.userId != None:
12447 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12448 
      oprot.writeI64(self.userId)
1596 ankur.sing 12449 
      oprot.writeFieldEnd()
2981 rajveer 12450 
    if self.itemId != None:
12451 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12452 
      oprot.writeI64(self.itemId)
12453 
      oprot.writeFieldEnd()
1596 ankur.sing 12454 
    oprot.writeFieldStop()
12455 
    oprot.writeStructEnd()
12456 
 
12457 
  def __repr__(self):
12458 
    L = ['%s=%r' % (key, value)
12459 
      for key, value in self.__dict__.iteritems()]
12460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12461 
 
12462 
  def __eq__(self, other):
12463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12464 
 
12465 
  def __ne__(self, other):
12466 
    return not (self == other)
12467 
 
2981 rajveer 12468 
class deleteItemFromMyResearch_result:
1596 ankur.sing 12469 
  """
12470 
  Attributes:
2981 rajveer 12471 
   - scx
1596 ankur.sing 12472 
  """
12473 
 
12474 
  thrift_spec = (
2981 rajveer 12475 
    None, # 0
12476 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 12477 
  )
12478 
 
2981 rajveer 12479 
  def __init__(self, scx=None,):
12480 
    self.scx = scx
1596 ankur.sing 12481 
 
12482 
  def read(self, iprot):
12483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12485 
      return
12486 
    iprot.readStructBegin()
12487 
    while True:
12488 
      (fname, ftype, fid) = iprot.readFieldBegin()
12489 
      if ftype == TType.STOP:
12490 
        break
2981 rajveer 12491 
      if fid == 1:
12492 
        if ftype == TType.STRUCT:
12493 
          self.scx = WidgetException()
12494 
          self.scx.read(iprot)
1596 ankur.sing 12495 
        else:
12496 
          iprot.skip(ftype)
12497 
      else:
12498 
        iprot.skip(ftype)
12499 
      iprot.readFieldEnd()
12500 
    iprot.readStructEnd()
12501 
 
12502 
  def write(self, oprot):
12503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12505 
      return
2981 rajveer 12506 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
12507 
    if self.scx != None:
12508 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12509 
      self.scx.write(oprot)
1596 ankur.sing 12510 
      oprot.writeFieldEnd()
12511 
    oprot.writeFieldStop()
12512 
    oprot.writeStructEnd()
12513 
 
12514 
  def __repr__(self):
12515 
    L = ['%s=%r' % (key, value)
12516 
      for key, value in self.__dict__.iteritems()]
12517 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12518 
 
12519 
  def __eq__(self, other):
12520 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12521 
 
12522 
  def __ne__(self, other):
12523 
    return not (self == other)
12524 
 
2981 rajveer 12525 
class getBrowseHistoryItems_args:
1673 ankur.sing 12526 
  """
12527 
  Attributes:
2981 rajveer 12528 
   - userId
1673 ankur.sing 12529 
  """
1596 ankur.sing 12530 
 
1673 ankur.sing 12531 
  thrift_spec = (
12532 
    None, # 0
2981 rajveer 12533 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 12534 
  )
12535 
 
2981 rajveer 12536 
  def __init__(self, userId=None,):
12537 
    self.userId = userId
1673 ankur.sing 12538 
 
12539 
  def read(self, iprot):
12540 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12541 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12542 
      return
12543 
    iprot.readStructBegin()
12544 
    while True:
12545 
      (fname, ftype, fid) = iprot.readFieldBegin()
12546 
      if ftype == TType.STOP:
12547 
        break
12548 
      if fid == 1:
1891 ankur.sing 12549 
        if ftype == TType.I64:
2981 rajveer 12550 
          self.userId = iprot.readI64();
1891 ankur.sing 12551 
        else:
12552 
          iprot.skip(ftype)
1673 ankur.sing 12553 
      else:
12554 
        iprot.skip(ftype)
12555 
      iprot.readFieldEnd()
12556 
    iprot.readStructEnd()
12557 
 
12558 
  def write(self, oprot):
12559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12561 
      return
2981 rajveer 12562 
    oprot.writeStructBegin('getBrowseHistoryItems_args')
12563 
    if self.userId != None:
12564 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12565 
      oprot.writeI64(self.userId)
1673 ankur.sing 12566 
      oprot.writeFieldEnd()
12567 
    oprot.writeFieldStop()
12568 
    oprot.writeStructEnd()
12569 
 
12570 
  def __repr__(self):
12571 
    L = ['%s=%r' % (key, value)
12572 
      for key, value in self.__dict__.iteritems()]
12573 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12574 
 
12575 
  def __eq__(self, other):
12576 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12577 
 
12578 
  def __ne__(self, other):
12579 
    return not (self == other)
12580 
 
2981 rajveer 12581 
class getBrowseHistoryItems_result:
1673 ankur.sing 12582 
  """
12583 
  Attributes:
12584 
   - success
2981 rajveer 12585 
   - scx
1673 ankur.sing 12586 
  """
12587 
 
12588 
  thrift_spec = (
2981 rajveer 12589 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12590 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 12591 
  )
12592 
 
2981 rajveer 12593 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 12594 
    self.success = success
2981 rajveer 12595 
    self.scx = scx
1673 ankur.sing 12596 
 
12597 
  def read(self, iprot):
12598 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12599 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12600 
      return
12601 
    iprot.readStructBegin()
12602 
    while True:
12603 
      (fname, ftype, fid) = iprot.readFieldBegin()
12604 
      if ftype == TType.STOP:
12605 
        break
12606 
      if fid == 0:
12607 
        if ftype == TType.LIST:
12608 
          self.success = []
2981 rajveer 12609 
          (_etype138, _size135) = iprot.readListBegin()
12610 
          for _i139 in xrange(_size135):
12611 
            _elem140 = iprot.readI64();
12612 
            self.success.append(_elem140)
1673 ankur.sing 12613 
          iprot.readListEnd()
12614 
        else:
12615 
          iprot.skip(ftype)
2981 rajveer 12616 
      elif fid == 1:
12617 
        if ftype == TType.STRUCT:
12618 
          self.scx = WidgetException()
12619 
          self.scx.read(iprot)
12620 
        else:
12621 
          iprot.skip(ftype)
1673 ankur.sing 12622 
      else:
12623 
        iprot.skip(ftype)
12624 
      iprot.readFieldEnd()
12625 
    iprot.readStructEnd()
12626 
 
12627 
  def write(self, oprot):
12628 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12629 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12630 
      return
2981 rajveer 12631 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
1673 ankur.sing 12632 
    if self.success != None:
12633 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 12634 
      oprot.writeListBegin(TType.I64, len(self.success))
12635 
      for iter141 in self.success:
12636 
        oprot.writeI64(iter141)
1673 ankur.sing 12637 
      oprot.writeListEnd()
12638 
      oprot.writeFieldEnd()
2981 rajveer 12639 
    if self.scx != None:
12640 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12641 
      self.scx.write(oprot)
2642 varun.gupt 12642 
      oprot.writeFieldEnd()
12643 
    oprot.writeFieldStop()
12644 
    oprot.writeStructEnd()
12645 
 
12646 
  def __repr__(self):
12647 
    L = ['%s=%r' % (key, value)
12648 
      for key, value in self.__dict__.iteritems()]
12649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12650 
 
12651 
  def __eq__(self, other):
12652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12653 
 
12654 
  def __ne__(self, other):
12655 
    return not (self == other)
12656 
 
2981 rajveer 12657 
class updateBrowseHistory_args:
2642 varun.gupt 12658 
  """
12659 
  Attributes:
2981 rajveer 12660 
   - userId
12661 
   - itemId
2642 varun.gupt 12662 
  """
12663 
 
12664 
  thrift_spec = (
12665 
    None, # 0
2981 rajveer 12666 
    (1, TType.I64, 'userId', None, None, ), # 1
12667 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 12668 
  )
12669 
 
2981 rajveer 12670 
  def __init__(self, userId=None, itemId=None,):
12671 
    self.userId = userId
12672 
    self.itemId = itemId
2642 varun.gupt 12673 
 
12674 
  def read(self, iprot):
12675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12677 
      return
12678 
    iprot.readStructBegin()
12679 
    while True:
12680 
      (fname, ftype, fid) = iprot.readFieldBegin()
12681 
      if ftype == TType.STOP:
12682 
        break
12683 
      if fid == 1:
12684 
        if ftype == TType.I64:
2981 rajveer 12685 
          self.userId = iprot.readI64();
2642 varun.gupt 12686 
        else:
12687 
          iprot.skip(ftype)
12688 
      elif fid == 2:
12689 
        if ftype == TType.I64:
2981 rajveer 12690 
          self.itemId = iprot.readI64();
2642 varun.gupt 12691 
        else:
12692 
          iprot.skip(ftype)
12693 
      else:
12694 
        iprot.skip(ftype)
12695 
      iprot.readFieldEnd()
12696 
    iprot.readStructEnd()
12697 
 
12698 
  def write(self, oprot):
12699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12701 
      return
2981 rajveer 12702 
    oprot.writeStructBegin('updateBrowseHistory_args')
12703 
    if self.userId != None:
12704 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12705 
      oprot.writeI64(self.userId)
2642 varun.gupt 12706 
      oprot.writeFieldEnd()
2981 rajveer 12707 
    if self.itemId != None:
12708 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12709 
      oprot.writeI64(self.itemId)
2642 varun.gupt 12710 
      oprot.writeFieldEnd()
12711 
    oprot.writeFieldStop()
12712 
    oprot.writeStructEnd()
12713 
 
12714 
  def __repr__(self):
12715 
    L = ['%s=%r' % (key, value)
12716 
      for key, value in self.__dict__.iteritems()]
12717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12718 
 
12719 
  def __eq__(self, other):
12720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12721 
 
12722 
  def __ne__(self, other):
12723 
    return not (self == other)
12724 
 
2981 rajveer 12725 
class updateBrowseHistory_result:
2642 varun.gupt 12726 
 
12727 
  thrift_spec = (
12728 
  )
12729 
 
12730 
  def read(self, iprot):
12731 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12732 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12733 
      return
12734 
    iprot.readStructBegin()
12735 
    while True:
12736 
      (fname, ftype, fid) = iprot.readFieldBegin()
12737 
      if ftype == TType.STOP:
12738 
        break
12739 
      else:
12740 
        iprot.skip(ftype)
12741 
      iprot.readFieldEnd()
12742 
    iprot.readStructEnd()
12743 
 
12744 
  def write(self, oprot):
12745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12747 
      return
2981 rajveer 12748 
    oprot.writeStructBegin('updateBrowseHistory_result')
2642 varun.gupt 12749 
    oprot.writeFieldStop()
12750 
    oprot.writeStructEnd()
12751 
 
12752 
  def __repr__(self):
12753 
    L = ['%s=%r' % (key, value)
12754 
      for key, value in self.__dict__.iteritems()]
12755 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12756 
 
12757 
  def __eq__(self, other):
12758 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12759 
 
12760 
  def __ne__(self, other):
12761 
    return not (self == other)
12762 
 
12763