Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
2 
# Autogenerated by Thrift
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
from ttypes import *
9 
from thrift.Thrift import TProcessor
10 
from thrift.transport import TTransport
11 
from thrift.protocol import TBinaryProtocol
12 
try:
13 
  from thrift.protocol import fastbinary
14 
except:
15 
  fastbinary = None
16 
 
17 
 
18 
class Iface:
19 
  """
20 
  service
21 
  """
765 rajveer 22 
  def closeSession(self, ):
23 
    """
24 
    For closing the open session in sqlalchemy
25 
    """
26 
    pass
27 
 
559 chandransh 28 
  def createAnonymousUser(self, jsessionId):
94 ashish 29 
    """
30 
    Parameters:
559 chandransh 31 
     - jsessionId
94 ashish 32 
    """
33 
    pass
34 
 
559 chandransh 35 
  def getUserById(self, userId):
94 ashish 36 
    """
37 
    Parameters:
38 
     - userId
39 
    """
40 
    pass
41 
 
1491 vikas 42 
  def getUserByEmail(self, email):
43 
    """
44 
    Parameters:
45 
     - email
46 
    """
47 
    pass
48 
 
3032 mandeep.dh 49 
  def getUserByMobileNumber(self, mobileNumber):
50 
    """
51 
    Parameters:
52 
     - mobileNumber
53 
    """
54 
    pass
55 
 
559 chandransh 56 
  def createUser(self, user):
94 ashish 57 
    """
58 
    Parameters:
559 chandransh 59 
     - user
94 ashish 60 
    """
61 
    pass
62 
 
559 chandransh 63 
  def updateUser(self, user):
94 ashish 64 
    """
65 
    Parameters:
559 chandransh 66 
     - user
94 ashish 67 
    """
68 
    pass
69 
 
559 chandransh 70 
  def deleteUser(self, userId):
94 ashish 71 
    """
72 
    Parameters:
73 
     - userId
74 
    """
75 
    pass
76 
 
559 chandransh 77 
  def getUserState(self, userId):
94 ashish 78 
    """
79 
    Parameters:
80 
     - userId
81 
    """
82 
    pass
83 
 
559 chandransh 84 
  def authenticateUser(self, email, password):
94 ashish 85 
    """
86 
    Parameters:
87 
     - email
88 
     - password
89 
    """
90 
    pass
91 
 
92 
  def userExists(self, email):
93 
    """
94 
    Parameters:
95 
     - email
96 
    """
97 
    pass
98 
 
567 rajveer 99 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 100 
    """
101 
    Parameters:
102 
     - userId
103 
     - address
513 rajveer 104 
     - setDefault
94 ashish 105 
    """
106 
    pass
107 
 
108 
  def removeAddressForUser(self, userid, addressId):
109 
    """
110 
    Parameters:
111 
     - userid
112 
     - addressId
113 
    """
114 
    pass
115 
 
116 
  def setUserAsLoggedIn(self, userId, timestamp):
117 
    """
118 
    Parameters:
119 
     - userId
120 
     - timestamp
121 
    """
122 
    pass
123 
 
124 
  def setUserAsLoggedOut(self, userid, timestamp):
125 
    """
126 
    Parameters:
127 
     - userid
128 
     - timestamp
129 
    """
130 
    pass
131 
 
504 rajveer 132 
  def setDefaultAddress(self, userid, addressId):
133 
    """
134 
    Parameters:
135 
     - userid
136 
     - addressId
137 
    """
138 
    pass
139 
 
594 rajveer 140 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 141 
    """
142 
    Parameters:
143 
     - userid
594 rajveer 144 
     - oldPassword
145 
     - newPassword
94 ashish 146 
    """
147 
    pass
148 
 
884 rajveer 149 
  def forgotPassword(self, email, newPassword):
581 rajveer 150 
    """
151 
    Parameters:
152 
     - email
884 rajveer 153 
     - newPassword
581 rajveer 154 
    """
155 
    pass
156 
 
594 rajveer 157 
  def getAllAddressesForUser(self, userId):
158 
    """
159 
    Parameters:
160 
     - userId
161 
    """
162 
    pass
163 
 
1894 vikas 164 
  def getAddressById(self, addressId):
165 
    """
166 
    Parameters:
167 
     - addressId
168 
    """
169 
    pass
170 
 
594 rajveer 171 
  def getDefaultAddressId(self, userId):
172 
    """
173 
    Parameters:
174 
     - userId
175 
    """
176 
    pass
177 
 
785 rajveer 178 
  def getDefaultPincode(self, userId):
179 
    """
180 
    Parameters:
181 
     - userId
182 
    """
183 
    pass
184 
 
1274 varun.gupt 185 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
186 
    """
187 
    Parameters:
188 
     - userId
189 
     - replyTo
190 
     - communicationType
191 
     - orderId
192 
     - airwaybillNo
193 
     - productName
194 
     - subject
195 
     - message
196 
    """
197 
    pass
198 
 
1590 varun.gupt 199 
  def getUserCommunicationById(self, id):
200 
    """
201 
    Parameters:
202 
     - id
203 
    """
204 
    pass
205 
 
206 
  def getUserCommunicationByUser(self, userId):
207 
    """
208 
    Parameters:
209 
     - userId
210 
    """
211 
    pass
212 
 
213 
  def getAllUserCommunications(self, ):
214 
    pass
215 
 
1859 vikas 216 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 217 
    """
218 
    Parameters:
219 
     - name
1859 vikas 220 
     - addedOn
1845 vikas 221 
    """
222 
    pass
223 
 
1899 vikas 224 
  def getAllMasterAffiliates(self, ):
225 
    pass
226 
 
1845 vikas 227 
  def getMasterAffiliateById(self, id):
228 
    """
229 
    Parameters:
230 
     - id
231 
    """
232 
    pass
233 
 
234 
  def getMasterAffiliateByName(self, name):
235 
    """
236 
    Parameters:
237 
     - name
238 
    """
239 
    pass
240 
 
1859 vikas 241 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 242 
    """
243 
    Parameters:
244 
     - name
245 
     - url
246 
     - masterAffiliateId
1859 vikas 247 
     - addedOn
1845 vikas 248 
    """
249 
    pass
250 
 
251 
  def getAffiliateById(self, id):
252 
    """
253 
    Parameters:
254 
     - id
255 
    """
256 
    pass
257 
 
258 
  def getAffiliateByName(self, name):
259 
    """
260 
    Parameters:
261 
     - name
262 
    """
263 
    pass
264 
 
1996 vikas 265 
  def getTrackerById(self, id):
1845 vikas 266 
    """
267 
    Parameters:
268 
     - id
269 
    """
270 
    pass
271 
 
1996 vikas 272 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 273 
    """
274 
    Parameters:
1996 vikas 275 
     - id
1845 vikas 276 
    """
277 
    pass
278 
 
1996 vikas 279 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 280 
    """
281 
    Parameters:
282 
     - affiliateId
283 
     - userId
284 
     - event
285 
     - url
286 
     - data
1859 vikas 287 
     - addedOn
1845 vikas 288 
    """
289 
    pass
290 
 
291 
  def getTrackLogById(self, id):
292 
    """
293 
    Parameters:
294 
     - id
295 
    """
296 
    pass
297 
 
3293 vikas 298 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 299 
    """
300 
    Parameters:
1996 vikas 301 
     - affiliateId
3293 vikas 302 
     - startDate
303 
     - endDate
1845 vikas 304 
    """
305 
    pass
306 
 
307 
  def getTrackLogsByUser(self, userId):
308 
    """
309 
    Parameters:
310 
     - userId
311 
    """
312 
    pass
313 
 
1996 vikas 314 
  def getTrackLogs(self, userId, event, url):
1845 vikas 315 
    """
316 
    Parameters:
317 
     - userId
318 
     - event
319 
     - url
320 
    """
321 
    pass
322 
 
559 chandransh 323 
  def createCart(self, userId):
94 ashish 324 
    """
325 
    Parameters:
559 chandransh 326 
     - userId
94 ashish 327 
    """
328 
    pass
329 
 
559 chandransh 330 
  def getCurrentCart(self, userId):
94 ashish 331 
    """
332 
    Parameters:
559 chandransh 333 
     - userId
94 ashish 334 
    """
335 
    pass
336 
 
559 chandransh 337 
  def getCart(self, cartId):
94 ashish 338 
    """
339 
    Parameters:
559 chandransh 340 
     - cartId
94 ashish 341 
    """
342 
    pass
343 
 
559 chandransh 344 
  def getCartsForUser(self, userId, status):
94 ashish 345 
    """
346 
    Parameters:
559 chandransh 347 
     - userId
348 
     - status
94 ashish 349 
    """
350 
    pass
351 
 
559 chandransh 352 
  def getCartsByStatus(self, status):
94 ashish 353 
    """
354 
    Parameters:
559 chandransh 355 
     - status
94 ashish 356 
    """
357 
    pass
358 
 
559 chandransh 359 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 360 
    """
361 
    Parameters:
559 chandransh 362 
     - from_time
363 
     - to_time
364 
     - status
94 ashish 365 
    """
366 
    pass
367 
 
559 chandransh 368 
  def changeCartStatus(self, cartId, status):
130 ashish 369 
    """
370 
    Parameters:
559 chandransh 371 
     - cartId
372 
     - status
130 ashish 373 
    """
374 
    pass
94 ashish 375 
 
559 chandransh 376 
  def addItemToCart(self, cartId, itemId, quantity):
130 ashish 377 
    """
378 
    Parameters:
559 chandransh 379 
     - cartId
380 
     - itemId
381 
     - quantity
130 ashish 382 
    """
383 
    pass
384 
 
559 chandransh 385 
  def deleteItemFromCart(self, cartId, itemId):
386 
    """
387 
    Parameters:
388 
     - cartId
389 
     - itemId
390 
    """
391 
    pass
130 ashish 392 
 
559 chandransh 393 
  def changeQuantity(self, cartId, itemId, quantity):
394 
    """
395 
    Parameters:
396 
     - cartId
397 
     - itemId
398 
     - quantity
399 
    """
400 
    pass
401 
 
402 
  def changeItemStatus(self, cartId, itemId, status):
403 
    """
404 
    Parameters:
405 
     - cartId
406 
     - itemId
407 
     - status
408 
    """
409 
    pass
410 
 
411 
  def addAddressToCart(self, cartId, addressId):
412 
    """
413 
    Parameters:
414 
     - cartId
415 
     - addressId
416 
    """
417 
    pass
418 
 
1976 varun.gupt 419 
  def applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
420 
    """
421 
    Parameters:
422 
     - cartId
423 
     - couponCode
424 
     - totalPrice
425 
     - discountedPrice
426 
    """
427 
    pass
428 
 
429 
  def removeCoupon(self, cartId):
430 
    """
431 
    Parameters:
432 
     - cartId
433 
    """
434 
    pass
435 
 
2815 vikas 436 
  def createOrders(self, cartId, sessionSource, sessionStartTime):
559 chandransh 437 
    """
690 chandransh 438 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
439 
 
559 chandransh 440 
    Parameters:
441 
     - cartId
2815 vikas 442 
     - sessionSource
443 
     - sessionStartTime
559 chandransh 444 
    """
445 
    pass
446 
 
447 
  def validateCart(self, cartId):
448 
    """
690 chandransh 449 
    Validates that:
450 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 451 
    2. All of the lines in the cart are active items.
690 chandransh 452 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 453 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 454 
 
559 chandransh 455 
    Parameters:
456 
     - cartId
457 
    """
458 
    pass
459 
 
690 chandransh 460 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 461 
    """
690 chandransh 462 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
463 
 
575 chandransh 464 
    Parameters:
690 chandransh 465 
     - fromCartId
466 
     - toCartId
467 
    """
468 
    pass
469 
 
470 
  def checkOut(self, cartId):
471 
    """
472 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
473 
 
474 
    Parameters:
575 chandransh 475 
     - cartId
476 
    """
477 
    pass
478 
 
690 chandransh 479 
  def resetCart(self, cartId, items):
559 chandransh 480 
    """
690 chandransh 481 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
482 
    This methods removes the specified quantiry of the specified item from the cart.
483 
 
559 chandransh 484 
    Parameters:
690 chandransh 485 
     - cartId
486 
     - items
559 chandransh 487 
    """
488 
    pass
489 
 
2981 rajveer 490 
  def getUserCount(self, userType):
559 chandransh 491 
    """
2981 rajveer 492 
    Returns number of registered users.
493 
    If userType = null, then it returns count of all users, including anonymous
494 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
495 
    If userType = UserType.USER, then it returns count of non-anonymous users only
772 rajveer 496 
 
559 chandransh 497 
    Parameters:
2981 rajveer 498 
     - userType
559 chandransh 499 
    """
500 
    pass
501 
 
2981 rajveer 502 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 503 
    """
2981 rajveer 504 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
505 
    If any of startDate or endDate is -1, then that filter is ignored.
506 
    If userType is null, then returns all the users, irrespective of anonymous flag
507 
 
508 
 
559 chandransh 509 
    Parameters:
2981 rajveer 510 
     - userType
511 
     - startDate
512 
     - endDate
559 chandransh 513 
    """
514 
    pass
515 
 
2981 rajveer 516 
  def putUserNote(self, user_id, entity_id, slide, note):
559 chandransh 517 
    """
518 
    Parameters:
2981 rajveer 519 
     - user_id
520 
     - entity_id
521 
     - slide
522 
     - note
559 chandransh 523 
    """
524 
    pass
525 
 
2981 rajveer 526 
  def getUserNotes(self, user_id, entity_id):
559 chandransh 527 
    """
528 
    Parameters:
2981 rajveer 529 
     - user_id
530 
     - entity_id
559 chandransh 531 
    """
532 
    pass
533 
 
2981 rajveer 534 
  def getMyResearchItems(self, userId):
559 chandransh 535 
    """
2981 rajveer 536 
    Returns list of item ids in myresearch for the user
537 
 
559 chandransh 538 
    Parameters:
539 
     - userId
540 
    """
541 
    pass
542 
 
2981 rajveer 543 
  def updateMyResearch(self, userId, itemId):
559 chandransh 544 
    """
2981 rajveer 545 
    add item to my research for a user
546 
 
559 chandransh 547 
    Parameters:
2981 rajveer 548 
     - userId
549 
     - itemId
559 chandransh 550 
    """
551 
    pass
552 
 
2981 rajveer 553 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 554 
    """
2981 rajveer 555 
    delete item from my research for a user
1596 ankur.sing 556 
 
557 
    Parameters:
2981 rajveer 558 
     - userId
559 
     - itemId
1596 ankur.sing 560 
    """
561 
    pass
559 chandransh 562 
 
2981 rajveer 563 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 564 
    """
2981 rajveer 565 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
1673 ankur.sing 566 
 
567 
    Parameters:
2981 rajveer 568 
     - userId
1673 ankur.sing 569 
    """
570 
    pass
1596 ankur.sing 571 
 
2981 rajveer 572 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 573 
    """
2981 rajveer 574 
    add item to browse history for a user
2642 varun.gupt 575 
 
576 
    Parameters:
2981 rajveer 577 
     - userId
578 
     - itemId
2642 varun.gupt 579 
    """
580 
    pass
1673 ankur.sing 581 
 
2642 varun.gupt 582 
 
94 ashish 583 
class Client(Iface):
584 
  """
585 
  service
586 
  """
587 
  def __init__(self, iprot, oprot=None):
588 
    self._iprot = self._oprot = iprot
589 
    if oprot != None:
590 
      self._oprot = oprot
591 
    self._seqid = 0
592 
 
765 rajveer 593 
  def closeSession(self, ):
594 
    """
595 
    For closing the open session in sqlalchemy
596 
    """
597 
    self.send_closeSession()
598 
    self.recv_closeSession()
599 
 
600 
  def send_closeSession(self, ):
601 
    self._oprot.writeMessageBegin('closeSession', TMessageType.CALL, self._seqid)
602 
    args = closeSession_args()
603 
    args.write(self._oprot)
604 
    self._oprot.writeMessageEnd()
605 
    self._oprot.trans.flush()
606 
 
607 
  def recv_closeSession(self, ):
608 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
609 
    if mtype == TMessageType.EXCEPTION:
610 
      x = TApplicationException()
611 
      x.read(self._iprot)
612 
      self._iprot.readMessageEnd()
613 
      raise x
614 
    result = closeSession_result()
615 
    result.read(self._iprot)
616 
    self._iprot.readMessageEnd()
617 
    return
618 
 
559 chandransh 619 
  def createAnonymousUser(self, jsessionId):
94 ashish 620 
    """
621 
    Parameters:
559 chandransh 622 
     - jsessionId
94 ashish 623 
    """
559 chandransh 624 
    self.send_createAnonymousUser(jsessionId)
625 
    return self.recv_createAnonymousUser()
94 ashish 626 
 
559 chandransh 627 
  def send_createAnonymousUser(self, jsessionId):
628 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
629 
    args = createAnonymousUser_args()
630 
    args.jsessionId = jsessionId
94 ashish 631 
    args.write(self._oprot)
632 
    self._oprot.writeMessageEnd()
633 
    self._oprot.trans.flush()
634 
 
559 chandransh 635 
  def recv_createAnonymousUser(self, ):
94 ashish 636 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
637 
    if mtype == TMessageType.EXCEPTION:
638 
      x = TApplicationException()
639 
      x.read(self._iprot)
640 
      self._iprot.readMessageEnd()
641 
      raise x
559 chandransh 642 
    result = createAnonymousUser_result()
94 ashish 643 
    result.read(self._iprot)
644 
    self._iprot.readMessageEnd()
645 
    if result.success != None:
646 
      return result.success
559 chandransh 647 
    if result.ucex != None:
648 
      raise result.ucex
649 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 650 
 
559 chandransh 651 
  def getUserById(self, userId):
94 ashish 652 
    """
653 
    Parameters:
654 
     - userId
655 
    """
559 chandransh 656 
    self.send_getUserById(userId)
657 
    return self.recv_getUserById()
94 ashish 658 
 
559 chandransh 659 
  def send_getUserById(self, userId):
660 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
661 
    args = getUserById_args()
94 ashish 662 
    args.userId = userId
663 
    args.write(self._oprot)
664 
    self._oprot.writeMessageEnd()
665 
    self._oprot.trans.flush()
666 
 
559 chandransh 667 
  def recv_getUserById(self, ):
94 ashish 668 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
669 
    if mtype == TMessageType.EXCEPTION:
670 
      x = TApplicationException()
671 
      x.read(self._iprot)
672 
      self._iprot.readMessageEnd()
673 
      raise x
559 chandransh 674 
    result = getUserById_result()
94 ashish 675 
    result.read(self._iprot)
676 
    self._iprot.readMessageEnd()
677 
    if result.success != None:
678 
      return result.success
559 chandransh 679 
    if result.ucex != None:
680 
      raise result.ucex
681 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 682 
 
1491 vikas 683 
  def getUserByEmail(self, email):
684 
    """
685 
    Parameters:
686 
     - email
687 
    """
688 
    self.send_getUserByEmail(email)
689 
    return self.recv_getUserByEmail()
690 
 
691 
  def send_getUserByEmail(self, email):
692 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
693 
    args = getUserByEmail_args()
694 
    args.email = email
695 
    args.write(self._oprot)
696 
    self._oprot.writeMessageEnd()
697 
    self._oprot.trans.flush()
698 
 
699 
  def recv_getUserByEmail(self, ):
700 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
701 
    if mtype == TMessageType.EXCEPTION:
702 
      x = TApplicationException()
703 
      x.read(self._iprot)
704 
      self._iprot.readMessageEnd()
705 
      raise x
706 
    result = getUserByEmail_result()
707 
    result.read(self._iprot)
708 
    self._iprot.readMessageEnd()
709 
    if result.success != None:
710 
      return result.success
711 
    if result.ucex != None:
712 
      raise result.ucex
713 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
714 
 
3032 mandeep.dh 715 
  def getUserByMobileNumber(self, mobileNumber):
716 
    """
717 
    Parameters:
718 
     - mobileNumber
719 
    """
720 
    self.send_getUserByMobileNumber(mobileNumber)
721 
    return self.recv_getUserByMobileNumber()
722 
 
723 
  def send_getUserByMobileNumber(self, mobileNumber):
724 
    self._oprot.writeMessageBegin('getUserByMobileNumber', TMessageType.CALL, self._seqid)
725 
    args = getUserByMobileNumber_args()
726 
    args.mobileNumber = mobileNumber
727 
    args.write(self._oprot)
728 
    self._oprot.writeMessageEnd()
729 
    self._oprot.trans.flush()
730 
 
731 
  def recv_getUserByMobileNumber(self, ):
732 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
733 
    if mtype == TMessageType.EXCEPTION:
734 
      x = TApplicationException()
735 
      x.read(self._iprot)
736 
      self._iprot.readMessageEnd()
737 
      raise x
738 
    result = getUserByMobileNumber_result()
739 
    result.read(self._iprot)
740 
    self._iprot.readMessageEnd()
741 
    if result.success != None:
742 
      return result.success
743 
    if result.ucex != None:
744 
      raise result.ucex
745 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByMobileNumber failed: unknown result");
746 
 
559 chandransh 747 
  def createUser(self, user):
94 ashish 748 
    """
749 
    Parameters:
559 chandransh 750 
     - user
94 ashish 751 
    """
559 chandransh 752 
    self.send_createUser(user)
753 
    return self.recv_createUser()
94 ashish 754 
 
559 chandransh 755 
  def send_createUser(self, user):
756 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
757 
    args = createUser_args()
758 
    args.user = user
94 ashish 759 
    args.write(self._oprot)
760 
    self._oprot.writeMessageEnd()
761 
    self._oprot.trans.flush()
762 
 
559 chandransh 763 
  def recv_createUser(self, ):
94 ashish 764 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
765 
    if mtype == TMessageType.EXCEPTION:
766 
      x = TApplicationException()
767 
      x.read(self._iprot)
768 
      self._iprot.readMessageEnd()
769 
      raise x
559 chandransh 770 
    result = createUser_result()
94 ashish 771 
    result.read(self._iprot)
772 
    self._iprot.readMessageEnd()
773 
    if result.success != None:
774 
      return result.success
559 chandransh 775 
    if result.ucex != None:
776 
      raise result.ucex
777 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 778 
 
559 chandransh 779 
  def updateUser(self, user):
94 ashish 780 
    """
781 
    Parameters:
559 chandransh 782 
     - user
94 ashish 783 
    """
559 chandransh 784 
    self.send_updateUser(user)
785 
    return self.recv_updateUser()
94 ashish 786 
 
559 chandransh 787 
  def send_updateUser(self, user):
788 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
789 
    args = updateUser_args()
790 
    args.user = user
94 ashish 791 
    args.write(self._oprot)
792 
    self._oprot.writeMessageEnd()
793 
    self._oprot.trans.flush()
794 
 
559 chandransh 795 
  def recv_updateUser(self, ):
94 ashish 796 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
797 
    if mtype == TMessageType.EXCEPTION:
798 
      x = TApplicationException()
799 
      x.read(self._iprot)
800 
      self._iprot.readMessageEnd()
801 
      raise x
559 chandransh 802 
    result = updateUser_result()
94 ashish 803 
    result.read(self._iprot)
804 
    self._iprot.readMessageEnd()
805 
    if result.success != None:
806 
      return result.success
559 chandransh 807 
    if result.ucex != None:
808 
      raise result.ucex
809 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 810 
 
559 chandransh 811 
  def deleteUser(self, userId):
94 ashish 812 
    """
813 
    Parameters:
814 
     - userId
815 
    """
559 chandransh 816 
    self.send_deleteUser(userId)
817 
    return self.recv_deleteUser()
94 ashish 818 
 
559 chandransh 819 
  def send_deleteUser(self, userId):
820 
    self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
821 
    args = deleteUser_args()
94 ashish 822 
    args.userId = userId
823 
    args.write(self._oprot)
824 
    self._oprot.writeMessageEnd()
825 
    self._oprot.trans.flush()
826 
 
559 chandransh 827 
  def recv_deleteUser(self, ):
94 ashish 828 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
829 
    if mtype == TMessageType.EXCEPTION:
830 
      x = TApplicationException()
831 
      x.read(self._iprot)
832 
      self._iprot.readMessageEnd()
833 
      raise x
559 chandransh 834 
    result = deleteUser_result()
94 ashish 835 
    result.read(self._iprot)
836 
    self._iprot.readMessageEnd()
837 
    if result.success != None:
838 
      return result.success
559 chandransh 839 
    if result.ucex != None:
840 
      raise result.ucex
841 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
94 ashish 842 
 
559 chandransh 843 
  def getUserState(self, userId):
94 ashish 844 
    """
845 
    Parameters:
846 
     - userId
847 
    """
559 chandransh 848 
    self.send_getUserState(userId)
849 
    return self.recv_getUserState()
94 ashish 850 
 
559 chandransh 851 
  def send_getUserState(self, userId):
852 
    self._oprot.writeMessageBegin('getUserState', TMessageType.CALL, self._seqid)
853 
    args = getUserState_args()
94 ashish 854 
    args.userId = userId
855 
    args.write(self._oprot)
856 
    self._oprot.writeMessageEnd()
857 
    self._oprot.trans.flush()
858 
 
559 chandransh 859 
  def recv_getUserState(self, ):
94 ashish 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
559 chandransh 866 
    result = getUserState_result()
94 ashish 867 
    result.read(self._iprot)
868 
    self._iprot.readMessageEnd()
869 
    if result.success != None:
870 
      return result.success
559 chandransh 871 
    if result.ucex != None:
872 
      raise result.ucex
873 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserState failed: unknown result");
94 ashish 874 
 
559 chandransh 875 
  def authenticateUser(self, email, password):
94 ashish 876 
    """
877 
    Parameters:
878 
     - email
879 
     - password
880 
    """
559 chandransh 881 
    self.send_authenticateUser(email, password)
122 ashish 882 
    return self.recv_authenticateUser()
883 
 
559 chandransh 884 
  def send_authenticateUser(self, email, password):
122 ashish 885 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
886 
    args = authenticateUser_args()
559 chandransh 887 
    args.email = email
122 ashish 888 
    args.password = password
889 
    args.write(self._oprot)
890 
    self._oprot.writeMessageEnd()
891 
    self._oprot.trans.flush()
892 
 
893 
  def recv_authenticateUser(self, ):
894 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
895 
    if mtype == TMessageType.EXCEPTION:
896 
      x = TApplicationException()
897 
      x.read(self._iprot)
898 
      self._iprot.readMessageEnd()
899 
      raise x
900 
    result = authenticateUser_result()
901 
    result.read(self._iprot)
902 
    self._iprot.readMessageEnd()
903 
    if result.success != None:
904 
      return result.success
559 chandransh 905 
    if result.auex != None:
906 
      raise result.auex
122 ashish 907 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
908 
 
94 ashish 909 
  def userExists(self, email):
910 
    """
911 
    Parameters:
912 
     - email
913 
    """
914 
    self.send_userExists(email)
915 
    return self.recv_userExists()
916 
 
917 
  def send_userExists(self, email):
918 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
919 
    args = userExists_args()
920 
    args.email = email
921 
    args.write(self._oprot)
922 
    self._oprot.writeMessageEnd()
923 
    self._oprot.trans.flush()
924 
 
925 
  def recv_userExists(self, ):
926 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
927 
    if mtype == TMessageType.EXCEPTION:
928 
      x = TApplicationException()
929 
      x.read(self._iprot)
930 
      self._iprot.readMessageEnd()
931 
      raise x
932 
    result = userExists_result()
933 
    result.read(self._iprot)
934 
    self._iprot.readMessageEnd()
935 
    if result.success != None:
936 
      return result.success
937 
    if result.ucx != None:
938 
      raise result.ucx
939 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
940 
 
567 rajveer 941 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 942 
    """
943 
    Parameters:
944 
     - userId
945 
     - address
513 rajveer 946 
     - setDefault
94 ashish 947 
    """
567 rajveer 948 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 949 
    return self.recv_addAddressForUser()
950 
 
567 rajveer 951 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 952 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
953 
    args = addAddressForUser_args()
559 chandransh 954 
    args.userId = userId
94 ashish 955 
    args.address = address
513 rajveer 956 
    args.setDefault = setDefault
94 ashish 957 
    args.write(self._oprot)
958 
    self._oprot.writeMessageEnd()
959 
    self._oprot.trans.flush()
960 
 
961 
  def recv_addAddressForUser(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 = addAddressForUser_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, "addAddressForUser failed: unknown result");
976 
 
977 
  def removeAddressForUser(self, userid, addressId):
978 
    """
979 
    Parameters:
980 
     - userid
981 
     - addressId
982 
    """
983 
    self.send_removeAddressForUser(userid, addressId)
984 
    return self.recv_removeAddressForUser()
985 
 
986 
  def send_removeAddressForUser(self, userid, addressId):
987 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
988 
    args = removeAddressForUser_args()
989 
    args.userid = userid
990 
    args.addressId = addressId
991 
    args.write(self._oprot)
992 
    self._oprot.writeMessageEnd()
993 
    self._oprot.trans.flush()
994 
 
995 
  def recv_removeAddressForUser(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 = removeAddressForUser_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, "removeAddressForUser failed: unknown result");
1010 
 
1011 
  def setUserAsLoggedIn(self, userId, timestamp):
1012 
    """
1013 
    Parameters:
1014 
     - userId
1015 
     - timestamp
1016 
    """
1017 
    self.send_setUserAsLoggedIn(userId, timestamp)
1018 
    return self.recv_setUserAsLoggedIn()
1019 
 
1020 
  def send_setUserAsLoggedIn(self, userId, timestamp):
1021 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
1022 
    args = setUserAsLoggedIn_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_setUserAsLoggedIn(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 = setUserAsLoggedIn_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, "setUserAsLoggedIn failed: unknown result");
1044 
 
1045 
  def setUserAsLoggedOut(self, userid, timestamp):
1046 
    """
1047 
    Parameters:
1048 
     - userid
1049 
     - timestamp
1050 
    """
1051 
    self.send_setUserAsLoggedOut(userid, timestamp)
1052 
    return self.recv_setUserAsLoggedOut()
1053 
 
1054 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1055 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1056 
    args = setUserAsLoggedOut_args()
1057 
    args.userid = userid
1058 
    args.timestamp = timestamp
1059 
    args.write(self._oprot)
1060 
    self._oprot.writeMessageEnd()
1061 
    self._oprot.trans.flush()
1062 
 
1063 
  def recv_setUserAsLoggedOut(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 = setUserAsLoggedOut_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, "setUserAsLoggedOut failed: unknown result");
1078 
 
504 rajveer 1079 
  def setDefaultAddress(self, userid, addressId):
1080 
    """
1081 
    Parameters:
1082 
     - userid
1083 
     - addressId
1084 
    """
1085 
    self.send_setDefaultAddress(userid, addressId)
1086 
    return self.recv_setDefaultAddress()
1087 
 
1088 
  def send_setDefaultAddress(self, userid, addressId):
1089 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1090 
    args = setDefaultAddress_args()
1091 
    args.userid = userid
1092 
    args.addressId = addressId
1093 
    args.write(self._oprot)
1094 
    self._oprot.writeMessageEnd()
1095 
    self._oprot.trans.flush()
1096 
 
1097 
  def recv_setDefaultAddress(self, ):
1098 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1099 
    if mtype == TMessageType.EXCEPTION:
1100 
      x = TApplicationException()
1101 
      x.read(self._iprot)
1102 
      self._iprot.readMessageEnd()
1103 
      raise x
1104 
    result = setDefaultAddress_result()
1105 
    result.read(self._iprot)
1106 
    self._iprot.readMessageEnd()
1107 
    if result.success != None:
1108 
      return result.success
1109 
    if result.ucx != None:
1110 
      raise result.ucx
1111 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1112 
 
594 rajveer 1113 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1114 
    """
1115 
    Parameters:
1116 
     - userid
594 rajveer 1117 
     - oldPassword
1118 
     - newPassword
94 ashish 1119 
    """
594 rajveer 1120 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1121 
    return self.recv_updatePassword()
1122 
 
594 rajveer 1123 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1124 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1125 
    args = updatePassword_args()
1126 
    args.userid = userid
594 rajveer 1127 
    args.oldPassword = oldPassword
1128 
    args.newPassword = newPassword
94 ashish 1129 
    args.write(self._oprot)
1130 
    self._oprot.writeMessageEnd()
1131 
    self._oprot.trans.flush()
1132 
 
1133 
  def recv_updatePassword(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 = updatePassword_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, "updatePassword failed: unknown result");
1148 
 
884 rajveer 1149 
  def forgotPassword(self, email, newPassword):
581 rajveer 1150 
    """
1151 
    Parameters:
1152 
     - email
884 rajveer 1153 
     - newPassword
581 rajveer 1154 
    """
884 rajveer 1155 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1156 
    return self.recv_forgotPassword()
1157 
 
884 rajveer 1158 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1159 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1160 
    args = forgotPassword_args()
1161 
    args.email = email
884 rajveer 1162 
    args.newPassword = newPassword
581 rajveer 1163 
    args.write(self._oprot)
1164 
    self._oprot.writeMessageEnd()
1165 
    self._oprot.trans.flush()
1166 
 
1167 
  def recv_forgotPassword(self, ):
1168 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1169 
    if mtype == TMessageType.EXCEPTION:
1170 
      x = TApplicationException()
1171 
      x.read(self._iprot)
1172 
      self._iprot.readMessageEnd()
1173 
      raise x
1174 
    result = forgotPassword_result()
1175 
    result.read(self._iprot)
1176 
    self._iprot.readMessageEnd()
1177 
    if result.success != None:
1178 
      return result.success
1179 
    if result.ucx != None:
1180 
      raise result.ucx
1181 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1182 
 
594 rajveer 1183 
  def getAllAddressesForUser(self, userId):
1184 
    """
1185 
    Parameters:
1186 
     - userId
1187 
    """
1188 
    self.send_getAllAddressesForUser(userId)
1189 
    return self.recv_getAllAddressesForUser()
1190 
 
1191 
  def send_getAllAddressesForUser(self, userId):
1192 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1193 
    args = getAllAddressesForUser_args()
1194 
    args.userId = userId
1195 
    args.write(self._oprot)
1196 
    self._oprot.writeMessageEnd()
1197 
    self._oprot.trans.flush()
1198 
 
1199 
  def recv_getAllAddressesForUser(self, ):
1200 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1201 
    if mtype == TMessageType.EXCEPTION:
1202 
      x = TApplicationException()
1203 
      x.read(self._iprot)
1204 
      self._iprot.readMessageEnd()
1205 
      raise x
1206 
    result = getAllAddressesForUser_result()
1207 
    result.read(self._iprot)
1208 
    self._iprot.readMessageEnd()
1209 
    if result.success != None:
1210 
      return result.success
1211 
    if result.ucx != None:
1212 
      raise result.ucx
1213 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1214 
 
1894 vikas 1215 
  def getAddressById(self, addressId):
1216 
    """
1217 
    Parameters:
1218 
     - addressId
1219 
    """
1220 
    self.send_getAddressById(addressId)
1221 
    return self.recv_getAddressById()
1222 
 
1223 
  def send_getAddressById(self, addressId):
1224 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1225 
    args = getAddressById_args()
1226 
    args.addressId = addressId
1227 
    args.write(self._oprot)
1228 
    self._oprot.writeMessageEnd()
1229 
    self._oprot.trans.flush()
1230 
 
1231 
  def recv_getAddressById(self, ):
1232 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1233 
    if mtype == TMessageType.EXCEPTION:
1234 
      x = TApplicationException()
1235 
      x.read(self._iprot)
1236 
      self._iprot.readMessageEnd()
1237 
      raise x
1238 
    result = getAddressById_result()
1239 
    result.read(self._iprot)
1240 
    self._iprot.readMessageEnd()
1241 
    if result.success != None:
1242 
      return result.success
1243 
    if result.ucx != None:
1244 
      raise result.ucx
1245 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1246 
 
594 rajveer 1247 
  def getDefaultAddressId(self, userId):
1248 
    """
1249 
    Parameters:
1250 
     - userId
1251 
    """
1252 
    self.send_getDefaultAddressId(userId)
1253 
    return self.recv_getDefaultAddressId()
1254 
 
1255 
  def send_getDefaultAddressId(self, userId):
1256 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1257 
    args = getDefaultAddressId_args()
1258 
    args.userId = userId
1259 
    args.write(self._oprot)
1260 
    self._oprot.writeMessageEnd()
1261 
    self._oprot.trans.flush()
1262 
 
1263 
  def recv_getDefaultAddressId(self, ):
1264 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1265 
    if mtype == TMessageType.EXCEPTION:
1266 
      x = TApplicationException()
1267 
      x.read(self._iprot)
1268 
      self._iprot.readMessageEnd()
1269 
      raise x
1270 
    result = getDefaultAddressId_result()
1271 
    result.read(self._iprot)
1272 
    self._iprot.readMessageEnd()
1273 
    if result.success != None:
1274 
      return result.success
1275 
    if result.ucx != None:
1276 
      raise result.ucx
1277 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1278 
 
785 rajveer 1279 
  def getDefaultPincode(self, userId):
1280 
    """
1281 
    Parameters:
1282 
     - userId
1283 
    """
1284 
    self.send_getDefaultPincode(userId)
1285 
    return self.recv_getDefaultPincode()
1286 
 
1287 
  def send_getDefaultPincode(self, userId):
1288 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1289 
    args = getDefaultPincode_args()
1290 
    args.userId = userId
1291 
    args.write(self._oprot)
1292 
    self._oprot.writeMessageEnd()
1293 
    self._oprot.trans.flush()
1294 
 
1295 
  def recv_getDefaultPincode(self, ):
1296 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1297 
    if mtype == TMessageType.EXCEPTION:
1298 
      x = TApplicationException()
1299 
      x.read(self._iprot)
1300 
      self._iprot.readMessageEnd()
1301 
      raise x
1302 
    result = getDefaultPincode_result()
1303 
    result.read(self._iprot)
1304 
    self._iprot.readMessageEnd()
1305 
    if result.success != None:
1306 
      return result.success
1307 
    if result.ucx != None:
1308 
      raise result.ucx
1309 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1310 
 
1274 varun.gupt 1311 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1312 
    """
1313 
    Parameters:
1314 
     - userId
1315 
     - replyTo
1316 
     - communicationType
1317 
     - orderId
1318 
     - airwaybillNo
1319 
     - productName
1320 
     - subject
1321 
     - message
1322 
    """
1323 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1324 
    return self.recv_saveUserCommunication()
1325 
 
1326 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1327 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1328 
    args = saveUserCommunication_args()
1329 
    args.userId = userId
1330 
    args.replyTo = replyTo
1331 
    args.communicationType = communicationType
1332 
    args.orderId = orderId
1333 
    args.airwaybillNo = airwaybillNo
1334 
    args.productName = productName
1335 
    args.subject = subject
1336 
    args.message = message
1337 
    args.write(self._oprot)
1338 
    self._oprot.writeMessageEnd()
1339 
    self._oprot.trans.flush()
1340 
 
1341 
  def recv_saveUserCommunication(self, ):
1342 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1343 
    if mtype == TMessageType.EXCEPTION:
1344 
      x = TApplicationException()
1345 
      x.read(self._iprot)
1346 
      self._iprot.readMessageEnd()
1347 
      raise x
1348 
    result = saveUserCommunication_result()
1349 
    result.read(self._iprot)
1350 
    self._iprot.readMessageEnd()
1351 
    if result.success != None:
1352 
      return result.success
1353 
    if result.ucx != None:
1354 
      raise result.ucx
1355 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1356 
 
1590 varun.gupt 1357 
  def getUserCommunicationById(self, id):
1358 
    """
1359 
    Parameters:
1360 
     - id
1361 
    """
1362 
    self.send_getUserCommunicationById(id)
1363 
    return self.recv_getUserCommunicationById()
1364 
 
1365 
  def send_getUserCommunicationById(self, id):
1366 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1367 
    args = getUserCommunicationById_args()
1368 
    args.id = id
1369 
    args.write(self._oprot)
1370 
    self._oprot.writeMessageEnd()
1371 
    self._oprot.trans.flush()
1372 
 
1373 
  def recv_getUserCommunicationById(self, ):
1374 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1375 
    if mtype == TMessageType.EXCEPTION:
1376 
      x = TApplicationException()
1377 
      x.read(self._iprot)
1378 
      self._iprot.readMessageEnd()
1379 
      raise x
1380 
    result = getUserCommunicationById_result()
1381 
    result.read(self._iprot)
1382 
    self._iprot.readMessageEnd()
1383 
    if result.success != None:
1384 
      return result.success
1385 
    if result.ucx != None:
1386 
      raise result.ucx
1387 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1388 
 
1389 
  def getUserCommunicationByUser(self, userId):
1390 
    """
1391 
    Parameters:
1392 
     - userId
1393 
    """
1394 
    self.send_getUserCommunicationByUser(userId)
1395 
    return self.recv_getUserCommunicationByUser()
1396 
 
1397 
  def send_getUserCommunicationByUser(self, userId):
1398 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1399 
    args = getUserCommunicationByUser_args()
1400 
    args.userId = userId
1401 
    args.write(self._oprot)
1402 
    self._oprot.writeMessageEnd()
1403 
    self._oprot.trans.flush()
1404 
 
1405 
  def recv_getUserCommunicationByUser(self, ):
1406 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1407 
    if mtype == TMessageType.EXCEPTION:
1408 
      x = TApplicationException()
1409 
      x.read(self._iprot)
1410 
      self._iprot.readMessageEnd()
1411 
      raise x
1412 
    result = getUserCommunicationByUser_result()
1413 
    result.read(self._iprot)
1414 
    self._iprot.readMessageEnd()
1415 
    if result.success != None:
1416 
      return result.success
1417 
    if result.ucx != None:
1418 
      raise result.ucx
1419 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1420 
 
1421 
  def getAllUserCommunications(self, ):
1422 
    self.send_getAllUserCommunications()
1423 
    return self.recv_getAllUserCommunications()
1424 
 
1425 
  def send_getAllUserCommunications(self, ):
1426 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1427 
    args = getAllUserCommunications_args()
1428 
    args.write(self._oprot)
1429 
    self._oprot.writeMessageEnd()
1430 
    self._oprot.trans.flush()
1431 
 
1432 
  def recv_getAllUserCommunications(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 = getAllUserCommunications_result()
1440 
    result.read(self._iprot)
1441 
    self._iprot.readMessageEnd()
1442 
    if result.success != None:
1443 
      return result.success
1444 
    if result.ucx != None:
1445 
      raise result.ucx
1446 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1447 
 
1859 vikas 1448 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1449 
    """
1450 
    Parameters:
1451 
     - name
1859 vikas 1452 
     - addedOn
1845 vikas 1453 
    """
1859 vikas 1454 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1455 
    return self.recv_createMasterAffiliate()
1456 
 
1859 vikas 1457 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1458 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1459 
    args = createMasterAffiliate_args()
1460 
    args.name = name
1859 vikas 1461 
    args.addedOn = addedOn
1845 vikas 1462 
    args.write(self._oprot)
1463 
    self._oprot.writeMessageEnd()
1464 
    self._oprot.trans.flush()
1465 
 
1466 
  def recv_createMasterAffiliate(self, ):
1467 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1468 
    if mtype == TMessageType.EXCEPTION:
1469 
      x = TApplicationException()
1470 
      x.read(self._iprot)
1471 
      self._iprot.readMessageEnd()
1472 
      raise x
1473 
    result = createMasterAffiliate_result()
1474 
    result.read(self._iprot)
1475 
    self._iprot.readMessageEnd()
1476 
    if result.success != None:
1477 
      return result.success
1478 
    if result.utx != None:
1479 
      raise result.utx
1480 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1481 
 
1899 vikas 1482 
  def getAllMasterAffiliates(self, ):
1483 
    self.send_getAllMasterAffiliates()
1484 
    return self.recv_getAllMasterAffiliates()
1485 
 
1486 
  def send_getAllMasterAffiliates(self, ):
1487 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1488 
    args = getAllMasterAffiliates_args()
1489 
    args.write(self._oprot)
1490 
    self._oprot.writeMessageEnd()
1491 
    self._oprot.trans.flush()
1492 
 
1493 
  def recv_getAllMasterAffiliates(self, ):
1494 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1495 
    if mtype == TMessageType.EXCEPTION:
1496 
      x = TApplicationException()
1497 
      x.read(self._iprot)
1498 
      self._iprot.readMessageEnd()
1499 
      raise x
1500 
    result = getAllMasterAffiliates_result()
1501 
    result.read(self._iprot)
1502 
    self._iprot.readMessageEnd()
1503 
    if result.success != None:
1504 
      return result.success
1505 
    if result.utx != None:
1506 
      raise result.utx
1507 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1508 
 
1845 vikas 1509 
  def getMasterAffiliateById(self, id):
1510 
    """
1511 
    Parameters:
1512 
     - id
1513 
    """
1514 
    self.send_getMasterAffiliateById(id)
1515 
    return self.recv_getMasterAffiliateById()
1516 
 
1517 
  def send_getMasterAffiliateById(self, id):
1518 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1519 
    args = getMasterAffiliateById_args()
1520 
    args.id = id
1521 
    args.write(self._oprot)
1522 
    self._oprot.writeMessageEnd()
1523 
    self._oprot.trans.flush()
1524 
 
1525 
  def recv_getMasterAffiliateById(self, ):
1526 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1527 
    if mtype == TMessageType.EXCEPTION:
1528 
      x = TApplicationException()
1529 
      x.read(self._iprot)
1530 
      self._iprot.readMessageEnd()
1531 
      raise x
1532 
    result = getMasterAffiliateById_result()
1533 
    result.read(self._iprot)
1534 
    self._iprot.readMessageEnd()
1535 
    if result.success != None:
1536 
      return result.success
1537 
    if result.utx != None:
1538 
      raise result.utx
1539 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1540 
 
1541 
  def getMasterAffiliateByName(self, name):
1542 
    """
1543 
    Parameters:
1544 
     - name
1545 
    """
1546 
    self.send_getMasterAffiliateByName(name)
1547 
    return self.recv_getMasterAffiliateByName()
1548 
 
1549 
  def send_getMasterAffiliateByName(self, name):
1550 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1551 
    args = getMasterAffiliateByName_args()
1552 
    args.name = name
1553 
    args.write(self._oprot)
1554 
    self._oprot.writeMessageEnd()
1555 
    self._oprot.trans.flush()
1556 
 
1557 
  def recv_getMasterAffiliateByName(self, ):
1558 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1559 
    if mtype == TMessageType.EXCEPTION:
1560 
      x = TApplicationException()
1561 
      x.read(self._iprot)
1562 
      self._iprot.readMessageEnd()
1563 
      raise x
1564 
    result = getMasterAffiliateByName_result()
1565 
    result.read(self._iprot)
1566 
    self._iprot.readMessageEnd()
1567 
    if result.success != None:
1568 
      return result.success
1569 
    if result.utx != None:
1570 
      raise result.utx
1571 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1572 
 
1859 vikas 1573 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1574 
    """
1575 
    Parameters:
1576 
     - name
1577 
     - url
1578 
     - masterAffiliateId
1859 vikas 1579 
     - addedOn
1845 vikas 1580 
    """
1859 vikas 1581 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1582 
    return self.recv_createAffiliate()
1583 
 
1859 vikas 1584 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1585 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1586 
    args = createAffiliate_args()
1587 
    args.name = name
1588 
    args.url = url
1589 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1590 
    args.addedOn = addedOn
1845 vikas 1591 
    args.write(self._oprot)
1592 
    self._oprot.writeMessageEnd()
1593 
    self._oprot.trans.flush()
1594 
 
1595 
  def recv_createAffiliate(self, ):
1596 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1597 
    if mtype == TMessageType.EXCEPTION:
1598 
      x = TApplicationException()
1599 
      x.read(self._iprot)
1600 
      self._iprot.readMessageEnd()
1601 
      raise x
1602 
    result = createAffiliate_result()
1603 
    result.read(self._iprot)
1604 
    self._iprot.readMessageEnd()
1605 
    if result.success != None:
1606 
      return result.success
1607 
    if result.utx != None:
1608 
      raise result.utx
1609 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1610 
 
1611 
  def getAffiliateById(self, id):
1612 
    """
1613 
    Parameters:
1614 
     - id
1615 
    """
1616 
    self.send_getAffiliateById(id)
1617 
    return self.recv_getAffiliateById()
1618 
 
1619 
  def send_getAffiliateById(self, id):
1620 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1621 
    args = getAffiliateById_args()
1622 
    args.id = id
1623 
    args.write(self._oprot)
1624 
    self._oprot.writeMessageEnd()
1625 
    self._oprot.trans.flush()
1626 
 
1627 
  def recv_getAffiliateById(self, ):
1628 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1629 
    if mtype == TMessageType.EXCEPTION:
1630 
      x = TApplicationException()
1631 
      x.read(self._iprot)
1632 
      self._iprot.readMessageEnd()
1633 
      raise x
1634 
    result = getAffiliateById_result()
1635 
    result.read(self._iprot)
1636 
    self._iprot.readMessageEnd()
1637 
    if result.success != None:
1638 
      return result.success
1639 
    if result.utx != None:
1640 
      raise result.utx
1641 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1642 
 
1643 
  def getAffiliateByName(self, name):
1644 
    """
1645 
    Parameters:
1646 
     - name
1647 
    """
1648 
    self.send_getAffiliateByName(name)
1649 
    return self.recv_getAffiliateByName()
1650 
 
1651 
  def send_getAffiliateByName(self, name):
1652 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1653 
    args = getAffiliateByName_args()
1654 
    args.name = name
1655 
    args.write(self._oprot)
1656 
    self._oprot.writeMessageEnd()
1657 
    self._oprot.trans.flush()
1658 
 
1659 
  def recv_getAffiliateByName(self, ):
1660 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1661 
    if mtype == TMessageType.EXCEPTION:
1662 
      x = TApplicationException()
1663 
      x.read(self._iprot)
1664 
      self._iprot.readMessageEnd()
1665 
      raise x
1666 
    result = getAffiliateByName_result()
1667 
    result.read(self._iprot)
1668 
    self._iprot.readMessageEnd()
1669 
    if result.success != None:
1670 
      return result.success
1671 
    if result.utx != None:
1672 
      raise result.utx
1673 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1674 
 
1996 vikas 1675 
  def getTrackerById(self, id):
1845 vikas 1676 
    """
1677 
    Parameters:
1678 
     - id
1679 
    """
1996 vikas 1680 
    self.send_getTrackerById(id)
1845 vikas 1681 
    return self.recv_getTrackerById()
1682 
 
1996 vikas 1683 
  def send_getTrackerById(self, id):
1845 vikas 1684 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1685 
    args = getTrackerById_args()
1996 vikas 1686 
    args.id = id
1845 vikas 1687 
    args.write(self._oprot)
1688 
    self._oprot.writeMessageEnd()
1689 
    self._oprot.trans.flush()
1690 
 
1691 
  def recv_getTrackerById(self, ):
1692 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1693 
    if mtype == TMessageType.EXCEPTION:
1694 
      x = TApplicationException()
1695 
      x.read(self._iprot)
1696 
      self._iprot.readMessageEnd()
1697 
      raise x
1698 
    result = getTrackerById_result()
1699 
    result.read(self._iprot)
1700 
    self._iprot.readMessageEnd()
1701 
    if result.success != None:
1702 
      return result.success
1703 
    if result.utx != None:
1704 
      raise result.utx
1705 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1706 
 
1996 vikas 1707 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1708 
    """
1709 
    Parameters:
1996 vikas 1710 
     - id
1845 vikas 1711 
    """
1996 vikas 1712 
    self.send_getAffiliatesByMasterAffiliate(id)
1713 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1714 
 
1996 vikas 1715 
  def send_getAffiliatesByMasterAffiliate(self, id):
1716 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1717 
    args = getAffiliatesByMasterAffiliate_args()
1718 
    args.id = id
1845 vikas 1719 
    args.write(self._oprot)
1720 
    self._oprot.writeMessageEnd()
1721 
    self._oprot.trans.flush()
1722 
 
1996 vikas 1723 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1724 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1725 
    if mtype == TMessageType.EXCEPTION:
1726 
      x = TApplicationException()
1727 
      x.read(self._iprot)
1728 
      self._iprot.readMessageEnd()
1729 
      raise x
1996 vikas 1730 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1731 
    result.read(self._iprot)
1732 
    self._iprot.readMessageEnd()
1733 
    if result.success != None:
1734 
      return result.success
1735 
    if result.utx != None:
1736 
      raise result.utx
1996 vikas 1737 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1738 
 
1996 vikas 1739 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1740 
    """
1741 
    Parameters:
1996 vikas 1742 
     - affiliateId
1845 vikas 1743 
     - userId
1744 
     - event
1745 
     - url
1746 
     - data
1859 vikas 1747 
     - addedOn
1845 vikas 1748 
    """
1996 vikas 1749 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1750 
    return self.recv_addTrackLog()
1751 
 
1996 vikas 1752 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1753 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1754 
    args = addTrackLog_args()
1996 vikas 1755 
    args.affiliateId = affiliateId
1845 vikas 1756 
    args.userId = userId
1757 
    args.event = event
1758 
    args.url = url
1759 
    args.data = data
1859 vikas 1760 
    args.addedOn = addedOn
1845 vikas 1761 
    args.write(self._oprot)
1762 
    self._oprot.writeMessageEnd()
1763 
    self._oprot.trans.flush()
1764 
 
1765 
  def recv_addTrackLog(self, ):
1766 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1767 
    if mtype == TMessageType.EXCEPTION:
1768 
      x = TApplicationException()
1769 
      x.read(self._iprot)
1770 
      self._iprot.readMessageEnd()
1771 
      raise x
1772 
    result = addTrackLog_result()
1773 
    result.read(self._iprot)
1774 
    self._iprot.readMessageEnd()
1775 
    if result.success != None:
1776 
      return result.success
1777 
    if result.utx != None:
1778 
      raise result.utx
1779 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1780 
 
1781 
  def getTrackLogById(self, id):
1782 
    """
1783 
    Parameters:
1784 
     - id
1785 
    """
1786 
    self.send_getTrackLogById(id)
1787 
    return self.recv_getTrackLogById()
1788 
 
1789 
  def send_getTrackLogById(self, id):
1790 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1791 
    args = getTrackLogById_args()
1792 
    args.id = id
1793 
    args.write(self._oprot)
1794 
    self._oprot.writeMessageEnd()
1795 
    self._oprot.trans.flush()
1796 
 
1797 
  def recv_getTrackLogById(self, ):
1798 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1799 
    if mtype == TMessageType.EXCEPTION:
1800 
      x = TApplicationException()
1801 
      x.read(self._iprot)
1802 
      self._iprot.readMessageEnd()
1803 
      raise x
1804 
    result = getTrackLogById_result()
1805 
    result.read(self._iprot)
1806 
    self._iprot.readMessageEnd()
1807 
    if result.success != None:
1808 
      return result.success
1809 
    if result.utx != None:
1810 
      raise result.utx
1811 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1812 
 
3293 vikas 1813 
  def getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1845 vikas 1814 
    """
1815 
    Parameters:
1996 vikas 1816 
     - affiliateId
3293 vikas 1817 
     - startDate
1818 
     - endDate
1845 vikas 1819 
    """
3293 vikas 1820 
    self.send_getTrackLogsByAffiliate(affiliateId, startDate, endDate)
1996 vikas 1821 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 1822 
 
3293 vikas 1823 
  def send_getTrackLogsByAffiliate(self, affiliateId, startDate, endDate):
1996 vikas 1824 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
1825 
    args = getTrackLogsByAffiliate_args()
1826 
    args.affiliateId = affiliateId
3293 vikas 1827 
    args.startDate = startDate
1828 
    args.endDate = endDate
1845 vikas 1829 
    args.write(self._oprot)
1830 
    self._oprot.writeMessageEnd()
1831 
    self._oprot.trans.flush()
1832 
 
1996 vikas 1833 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 1834 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1835 
    if mtype == TMessageType.EXCEPTION:
1836 
      x = TApplicationException()
1837 
      x.read(self._iprot)
1838 
      self._iprot.readMessageEnd()
1839 
      raise x
1996 vikas 1840 
    result = getTrackLogsByAffiliate_result()
1845 vikas 1841 
    result.read(self._iprot)
1842 
    self._iprot.readMessageEnd()
1843 
    if result.success != None:
1844 
      return result.success
1845 
    if result.utx != None:
1846 
      raise result.utx
1996 vikas 1847 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 1848 
 
1849 
  def getTrackLogsByUser(self, userId):
1850 
    """
1851 
    Parameters:
1852 
     - userId
1853 
    """
1854 
    self.send_getTrackLogsByUser(userId)
1855 
    return self.recv_getTrackLogsByUser()
1856 
 
1857 
  def send_getTrackLogsByUser(self, userId):
1858 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
1859 
    args = getTrackLogsByUser_args()
1860 
    args.userId = userId
1861 
    args.write(self._oprot)
1862 
    self._oprot.writeMessageEnd()
1863 
    self._oprot.trans.flush()
1864 
 
1865 
  def recv_getTrackLogsByUser(self, ):
1866 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1867 
    if mtype == TMessageType.EXCEPTION:
1868 
      x = TApplicationException()
1869 
      x.read(self._iprot)
1870 
      self._iprot.readMessageEnd()
1871 
      raise x
1872 
    result = getTrackLogsByUser_result()
1873 
    result.read(self._iprot)
1874 
    self._iprot.readMessageEnd()
1875 
    if result.success != None:
1876 
      return result.success
1877 
    if result.utx != None:
1878 
      raise result.utx
1879 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
1880 
 
1996 vikas 1881 
  def getTrackLogs(self, userId, event, url):
1845 vikas 1882 
    """
1883 
    Parameters:
1884 
     - userId
1885 
     - event
1886 
     - url
1887 
    """
1996 vikas 1888 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 1889 
    return self.recv_getTrackLogs()
1890 
 
1996 vikas 1891 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 1892 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
1893 
    args = getTrackLogs_args()
1894 
    args.userId = userId
1895 
    args.event = event
1896 
    args.url = url
1897 
    args.write(self._oprot)
1898 
    self._oprot.writeMessageEnd()
1899 
    self._oprot.trans.flush()
1900 
 
1901 
  def recv_getTrackLogs(self, ):
1902 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1903 
    if mtype == TMessageType.EXCEPTION:
1904 
      x = TApplicationException()
1905 
      x.read(self._iprot)
1906 
      self._iprot.readMessageEnd()
1907 
      raise x
1908 
    result = getTrackLogs_result()
1909 
    result.read(self._iprot)
1910 
    self._iprot.readMessageEnd()
1911 
    if result.success != None:
1912 
      return result.success
1913 
    if result.utx != None:
1914 
      raise result.utx
1915 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
1916 
 
559 chandransh 1917 
  def createCart(self, userId):
94 ashish 1918 
    """
1919 
    Parameters:
559 chandransh 1920 
     - userId
94 ashish 1921 
    """
559 chandransh 1922 
    self.send_createCart(userId)
1923 
    return self.recv_createCart()
94 ashish 1924 
 
559 chandransh 1925 
  def send_createCart(self, userId):
1926 
    self._oprot.writeMessageBegin('createCart', TMessageType.CALL, self._seqid)
1927 
    args = createCart_args()
1928 
    args.userId = userId
94 ashish 1929 
    args.write(self._oprot)
1930 
    self._oprot.writeMessageEnd()
1931 
    self._oprot.trans.flush()
1932 
 
559 chandransh 1933 
  def recv_createCart(self, ):
94 ashish 1934 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1935 
    if mtype == TMessageType.EXCEPTION:
1936 
      x = TApplicationException()
1937 
      x.read(self._iprot)
1938 
      self._iprot.readMessageEnd()
1939 
      raise x
559 chandransh 1940 
    result = createCart_result()
94 ashish 1941 
    result.read(self._iprot)
1942 
    self._iprot.readMessageEnd()
1943 
    if result.success != None:
1944 
      return result.success
559 chandransh 1945 
    if result.scx != None:
1946 
      raise result.scx
1947 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createCart failed: unknown result");
94 ashish 1948 
 
559 chandransh 1949 
  def getCurrentCart(self, userId):
94 ashish 1950 
    """
1951 
    Parameters:
559 chandransh 1952 
     - userId
94 ashish 1953 
    """
559 chandransh 1954 
    self.send_getCurrentCart(userId)
1955 
    return self.recv_getCurrentCart()
94 ashish 1956 
 
559 chandransh 1957 
  def send_getCurrentCart(self, userId):
1958 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
1959 
    args = getCurrentCart_args()
1960 
    args.userId = userId
94 ashish 1961 
    args.write(self._oprot)
1962 
    self._oprot.writeMessageEnd()
1963 
    self._oprot.trans.flush()
1964 
 
559 chandransh 1965 
  def recv_getCurrentCart(self, ):
94 ashish 1966 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1967 
    if mtype == TMessageType.EXCEPTION:
1968 
      x = TApplicationException()
1969 
      x.read(self._iprot)
1970 
      self._iprot.readMessageEnd()
1971 
      raise x
559 chandransh 1972 
    result = getCurrentCart_result()
94 ashish 1973 
    result.read(self._iprot)
1974 
    self._iprot.readMessageEnd()
1975 
    if result.success != None:
1976 
      return result.success
559 chandransh 1977 
    if result.scx != None:
1978 
      raise result.scx
1979 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 1980 
 
559 chandransh 1981 
  def getCart(self, cartId):
94 ashish 1982 
    """
1983 
    Parameters:
559 chandransh 1984 
     - cartId
94 ashish 1985 
    """
559 chandransh 1986 
    self.send_getCart(cartId)
1987 
    return self.recv_getCart()
94 ashish 1988 
 
559 chandransh 1989 
  def send_getCart(self, cartId):
1990 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
1991 
    args = getCart_args()
1992 
    args.cartId = cartId
94 ashish 1993 
    args.write(self._oprot)
1994 
    self._oprot.writeMessageEnd()
1995 
    self._oprot.trans.flush()
1996 
 
559 chandransh 1997 
  def recv_getCart(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 = getCart_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, "getCart failed: unknown result");
94 ashish 2012 
 
559 chandransh 2013 
  def getCartsForUser(self, userId, status):
94 ashish 2014 
    """
2015 
    Parameters:
559 chandransh 2016 
     - userId
2017 
     - status
94 ashish 2018 
    """
559 chandransh 2019 
    self.send_getCartsForUser(userId, status)
2020 
    return self.recv_getCartsForUser()
94 ashish 2021 
 
559 chandransh 2022 
  def send_getCartsForUser(self, userId, status):
2023 
    self._oprot.writeMessageBegin('getCartsForUser', TMessageType.CALL, self._seqid)
2024 
    args = getCartsForUser_args()
2025 
    args.userId = userId
2026 
    args.status = status
94 ashish 2027 
    args.write(self._oprot)
2028 
    self._oprot.writeMessageEnd()
2029 
    self._oprot.trans.flush()
2030 
 
559 chandransh 2031 
  def recv_getCartsForUser(self, ):
94 ashish 2032 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2033 
    if mtype == TMessageType.EXCEPTION:
2034 
      x = TApplicationException()
2035 
      x.read(self._iprot)
2036 
      self._iprot.readMessageEnd()
2037 
      raise x
559 chandransh 2038 
    result = getCartsForUser_result()
94 ashish 2039 
    result.read(self._iprot)
2040 
    self._iprot.readMessageEnd()
2041 
    if result.success != None:
2042 
      return result.success
559 chandransh 2043 
    if result.scx != None:
2044 
      raise result.scx
2045 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsForUser failed: unknown result");
94 ashish 2046 
 
559 chandransh 2047 
  def getCartsByStatus(self, status):
94 ashish 2048 
    """
2049 
    Parameters:
559 chandransh 2050 
     - status
94 ashish 2051 
    """
559 chandransh 2052 
    self.send_getCartsByStatus(status)
2053 
    return self.recv_getCartsByStatus()
94 ashish 2054 
 
559 chandransh 2055 
  def send_getCartsByStatus(self, status):
2056 
    self._oprot.writeMessageBegin('getCartsByStatus', TMessageType.CALL, self._seqid)
2057 
    args = getCartsByStatus_args()
2058 
    args.status = status
94 ashish 2059 
    args.write(self._oprot)
2060 
    self._oprot.writeMessageEnd()
2061 
    self._oprot.trans.flush()
2062 
 
559 chandransh 2063 
  def recv_getCartsByStatus(self, ):
94 ashish 2064 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2065 
    if mtype == TMessageType.EXCEPTION:
2066 
      x = TApplicationException()
2067 
      x.read(self._iprot)
2068 
      self._iprot.readMessageEnd()
2069 
      raise x
559 chandransh 2070 
    result = getCartsByStatus_result()
94 ashish 2071 
    result.read(self._iprot)
2072 
    self._iprot.readMessageEnd()
2073 
    if result.success != None:
2074 
      return result.success
559 chandransh 2075 
    if result.scx != None:
2076 
      raise result.scx
2077 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByStatus failed: unknown result");
94 ashish 2078 
 
559 chandransh 2079 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2080 
    """
2081 
    Parameters:
559 chandransh 2082 
     - from_time
2083 
     - to_time
2084 
     - status
94 ashish 2085 
    """
559 chandransh 2086 
    self.send_getCartsByTime(from_time, to_time, status)
2087 
    return self.recv_getCartsByTime()
94 ashish 2088 
 
559 chandransh 2089 
  def send_getCartsByTime(self, from_time, to_time, status):
2090 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2091 
    args = getCartsByTime_args()
2092 
    args.from_time = from_time
2093 
    args.to_time = to_time
2094 
    args.status = status
94 ashish 2095 
    args.write(self._oprot)
2096 
    self._oprot.writeMessageEnd()
2097 
    self._oprot.trans.flush()
2098 
 
559 chandransh 2099 
  def recv_getCartsByTime(self, ):
94 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 = getCartsByTime_result()
94 ashish 2107 
    result.read(self._iprot)
2108 
    self._iprot.readMessageEnd()
2109 
    if result.success != None:
2110 
      return result.success
559 chandransh 2111 
    if result.scx != None:
2112 
      raise result.scx
2113 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2114 
 
559 chandransh 2115 
  def changeCartStatus(self, cartId, status):
130 ashish 2116 
    """
2117 
    Parameters:
559 chandransh 2118 
     - cartId
2119 
     - status
130 ashish 2120 
    """
559 chandransh 2121 
    self.send_changeCartStatus(cartId, status)
2122 
    self.recv_changeCartStatus()
94 ashish 2123 
 
559 chandransh 2124 
  def send_changeCartStatus(self, cartId, status):
2125 
    self._oprot.writeMessageBegin('changeCartStatus', TMessageType.CALL, self._seqid)
2126 
    args = changeCartStatus_args()
2127 
    args.cartId = cartId
2128 
    args.status = status
130 ashish 2129 
    args.write(self._oprot)
2130 
    self._oprot.writeMessageEnd()
2131 
    self._oprot.trans.flush()
2132 
 
559 chandransh 2133 
  def recv_changeCartStatus(self, ):
130 ashish 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
559 chandransh 2140 
    result = changeCartStatus_result()
130 ashish 2141 
    result.read(self._iprot)
2142 
    self._iprot.readMessageEnd()
559 chandransh 2143 
    if result.scx != None:
2144 
      raise result.scx
2145 
    return
2146 
 
2147 
  def addItemToCart(self, cartId, itemId, quantity):
2148 
    """
2149 
    Parameters:
2150 
     - cartId
2151 
     - itemId
2152 
     - quantity
2153 
    """
2154 
    self.send_addItemToCart(cartId, itemId, quantity)
2035 rajveer 2155 
    return self.recv_addItemToCart()
559 chandransh 2156 
 
2157 
  def send_addItemToCart(self, cartId, itemId, quantity):
2158 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2159 
    args = addItemToCart_args()
2160 
    args.cartId = cartId
2161 
    args.itemId = itemId
2162 
    args.quantity = quantity
2163 
    args.write(self._oprot)
2164 
    self._oprot.writeMessageEnd()
2165 
    self._oprot.trans.flush()
2166 
 
2167 
  def recv_addItemToCart(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 = addItemToCart_result()
2175 
    result.read(self._iprot)
2176 
    self._iprot.readMessageEnd()
2035 rajveer 2177 
    if result.success != None:
2178 
      return result.success
559 chandransh 2179 
    if result.scx != None:
2180 
      raise result.scx
2035 rajveer 2181 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2182 
 
2183 
  def deleteItemFromCart(self, cartId, itemId):
2184 
    """
2185 
    Parameters:
2186 
     - cartId
2187 
     - itemId
2188 
    """
2189 
    self.send_deleteItemFromCart(cartId, itemId)
2190 
    self.recv_deleteItemFromCart()
2191 
 
2192 
  def send_deleteItemFromCart(self, cartId, itemId):
2193 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2194 
    args = deleteItemFromCart_args()
2195 
    args.cartId = cartId
2196 
    args.itemId = itemId
2197 
    args.write(self._oprot)
2198 
    self._oprot.writeMessageEnd()
2199 
    self._oprot.trans.flush()
2200 
 
2201 
  def recv_deleteItemFromCart(self, ):
2202 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2203 
    if mtype == TMessageType.EXCEPTION:
2204 
      x = TApplicationException()
2205 
      x.read(self._iprot)
2206 
      self._iprot.readMessageEnd()
2207 
      raise x
2208 
    result = deleteItemFromCart_result()
2209 
    result.read(self._iprot)
2210 
    self._iprot.readMessageEnd()
2211 
    if result.scx != None:
2212 
      raise result.scx
2213 
    return
2214 
 
2215 
  def changeQuantity(self, cartId, itemId, quantity):
2216 
    """
2217 
    Parameters:
2218 
     - cartId
2219 
     - itemId
2220 
     - quantity
2221 
    """
2222 
    self.send_changeQuantity(cartId, itemId, quantity)
2223 
    self.recv_changeQuantity()
2224 
 
2225 
  def send_changeQuantity(self, cartId, itemId, quantity):
2226 
    self._oprot.writeMessageBegin('changeQuantity', TMessageType.CALL, self._seqid)
2227 
    args = changeQuantity_args()
2228 
    args.cartId = cartId
2229 
    args.itemId = itemId
2230 
    args.quantity = quantity
2231 
    args.write(self._oprot)
2232 
    self._oprot.writeMessageEnd()
2233 
    self._oprot.trans.flush()
2234 
 
2235 
  def recv_changeQuantity(self, ):
2236 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2237 
    if mtype == TMessageType.EXCEPTION:
2238 
      x = TApplicationException()
2239 
      x.read(self._iprot)
2240 
      self._iprot.readMessageEnd()
2241 
      raise x
2242 
    result = changeQuantity_result()
2243 
    result.read(self._iprot)
2244 
    self._iprot.readMessageEnd()
2245 
    if result.scx != None:
2246 
      raise result.scx
2247 
    return
2248 
 
2249 
  def changeItemStatus(self, cartId, itemId, status):
2250 
    """
2251 
    Parameters:
2252 
     - cartId
2253 
     - itemId
2254 
     - status
2255 
    """
2256 
    self.send_changeItemStatus(cartId, itemId, status)
2257 
    self.recv_changeItemStatus()
2258 
 
2259 
  def send_changeItemStatus(self, cartId, itemId, status):
2260 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
2261 
    args = changeItemStatus_args()
2262 
    args.cartId = cartId
2263 
    args.itemId = itemId
2264 
    args.status = status
2265 
    args.write(self._oprot)
2266 
    self._oprot.writeMessageEnd()
2267 
    self._oprot.trans.flush()
2268 
 
2269 
  def recv_changeItemStatus(self, ):
2270 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2271 
    if mtype == TMessageType.EXCEPTION:
2272 
      x = TApplicationException()
2273 
      x.read(self._iprot)
2274 
      self._iprot.readMessageEnd()
2275 
      raise x
2276 
    result = changeItemStatus_result()
2277 
    result.read(self._iprot)
2278 
    self._iprot.readMessageEnd()
2279 
    if result.scx != None:
2280 
      raise result.scx
2281 
    return
2282 
 
2283 
  def addAddressToCart(self, cartId, addressId):
2284 
    """
2285 
    Parameters:
2286 
     - cartId
2287 
     - addressId
2288 
    """
2289 
    self.send_addAddressToCart(cartId, addressId)
2290 
    self.recv_addAddressToCart()
2291 
 
2292 
  def send_addAddressToCart(self, cartId, addressId):
2293 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2294 
    args = addAddressToCart_args()
2295 
    args.cartId = cartId
2296 
    args.addressId = addressId
2297 
    args.write(self._oprot)
2298 
    self._oprot.writeMessageEnd()
2299 
    self._oprot.trans.flush()
2300 
 
2301 
  def recv_addAddressToCart(self, ):
2302 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2303 
    if mtype == TMessageType.EXCEPTION:
2304 
      x = TApplicationException()
2305 
      x.read(self._iprot)
2306 
      self._iprot.readMessageEnd()
2307 
      raise x
2308 
    result = addAddressToCart_result()
2309 
    result.read(self._iprot)
2310 
    self._iprot.readMessageEnd()
575 chandransh 2311 
    if result.scx != None:
2312 
      raise result.scx
559 chandransh 2313 
    return
2314 
 
1976 varun.gupt 2315 
  def applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
2316 
    """
2317 
    Parameters:
2318 
     - cartId
2319 
     - couponCode
2320 
     - totalPrice
2321 
     - discountedPrice
2322 
    """
2323 
    self.send_applyCouponToCart(cartId, couponCode, totalPrice, discountedPrice)
2324 
    self.recv_applyCouponToCart()
2325 
 
2326 
  def send_applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
2327 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2328 
    args = applyCouponToCart_args()
2329 
    args.cartId = cartId
2330 
    args.couponCode = couponCode
2331 
    args.totalPrice = totalPrice
2332 
    args.discountedPrice = discountedPrice
2333 
    args.write(self._oprot)
2334 
    self._oprot.writeMessageEnd()
2335 
    self._oprot.trans.flush()
2336 
 
2337 
  def recv_applyCouponToCart(self, ):
2338 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2339 
    if mtype == TMessageType.EXCEPTION:
2340 
      x = TApplicationException()
2341 
      x.read(self._iprot)
2342 
      self._iprot.readMessageEnd()
2343 
      raise x
2344 
    result = applyCouponToCart_result()
2345 
    result.read(self._iprot)
2346 
    self._iprot.readMessageEnd()
2347 
    if result.scx != None:
2348 
      raise result.scx
2349 
    return
2350 
 
2351 
  def removeCoupon(self, cartId):
2352 
    """
2353 
    Parameters:
2354 
     - cartId
2355 
    """
2356 
    self.send_removeCoupon(cartId)
2357 
    self.recv_removeCoupon()
2358 
 
2359 
  def send_removeCoupon(self, cartId):
2360 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2361 
    args = removeCoupon_args()
2362 
    args.cartId = cartId
2363 
    args.write(self._oprot)
2364 
    self._oprot.writeMessageEnd()
2365 
    self._oprot.trans.flush()
2366 
 
2367 
  def recv_removeCoupon(self, ):
2368 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2369 
    if mtype == TMessageType.EXCEPTION:
2370 
      x = TApplicationException()
2371 
      x.read(self._iprot)
2372 
      self._iprot.readMessageEnd()
2373 
      raise x
2374 
    result = removeCoupon_result()
2375 
    result.read(self._iprot)
2376 
    self._iprot.readMessageEnd()
2377 
    if result.scx != None:
2378 
      raise result.scx
2379 
    return
2380 
 
2815 vikas 2381 
  def createOrders(self, cartId, sessionSource, sessionStartTime):
559 chandransh 2382 
    """
690 chandransh 2383 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
2384 
 
559 chandransh 2385 
    Parameters:
2386 
     - cartId
2815 vikas 2387 
     - sessionSource
2388 
     - sessionStartTime
559 chandransh 2389 
    """
2815 vikas 2390 
    self.send_createOrders(cartId, sessionSource, sessionStartTime)
690 chandransh 2391 
    return self.recv_createOrders()
559 chandransh 2392 
 
2815 vikas 2393 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime):
690 chandransh 2394 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2395 
    args = createOrders_args()
559 chandransh 2396 
    args.cartId = cartId
2815 vikas 2397 
    args.sessionSource = sessionSource
2398 
    args.sessionStartTime = sessionStartTime
559 chandransh 2399 
    args.write(self._oprot)
2400 
    self._oprot.writeMessageEnd()
2401 
    self._oprot.trans.flush()
2402 
 
690 chandransh 2403 
  def recv_createOrders(self, ):
559 chandransh 2404 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2405 
    if mtype == TMessageType.EXCEPTION:
2406 
      x = TApplicationException()
2407 
      x.read(self._iprot)
2408 
      self._iprot.readMessageEnd()
2409 
      raise x
690 chandransh 2410 
    result = createOrders_result()
559 chandransh 2411 
    result.read(self._iprot)
2412 
    self._iprot.readMessageEnd()
130 ashish 2413 
    if result.success != None:
2414 
      return result.success
559 chandransh 2415 
    if result.scx != None:
2416 
      raise result.scx
690 chandransh 2417 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2418 
 
559 chandransh 2419 
  def validateCart(self, cartId):
130 ashish 2420 
    """
690 chandransh 2421 
    Validates that:
2422 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2423 
    2. All of the lines in the cart are active items.
690 chandransh 2424 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2425 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 2426 
 
130 ashish 2427 
    Parameters:
559 chandransh 2428 
     - cartId
130 ashish 2429 
    """
559 chandransh 2430 
    self.send_validateCart(cartId)
2431 
    return self.recv_validateCart()
130 ashish 2432 
 
559 chandransh 2433 
  def send_validateCart(self, cartId):
2434 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2435 
    args = validateCart_args()
2436 
    args.cartId = cartId
130 ashish 2437 
    args.write(self._oprot)
2438 
    self._oprot.writeMessageEnd()
2439 
    self._oprot.trans.flush()
2440 
 
559 chandransh 2441 
  def recv_validateCart(self, ):
130 ashish 2442 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2443 
    if mtype == TMessageType.EXCEPTION:
2444 
      x = TApplicationException()
2445 
      x.read(self._iprot)
2446 
      self._iprot.readMessageEnd()
2447 
      raise x
559 chandransh 2448 
    result = validateCart_result()
130 ashish 2449 
    result.read(self._iprot)
2450 
    self._iprot.readMessageEnd()
2451 
    if result.success != None:
2452 
      return result.success
575 chandransh 2453 
    if result.scex != None:
2454 
      raise result.scex
559 chandransh 2455 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2456 
 
690 chandransh 2457 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2458 
    """
690 chandransh 2459 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
2460 
 
575 chandransh 2461 
    Parameters:
690 chandransh 2462 
     - fromCartId
2463 
     - toCartId
2464 
    """
2465 
    self.send_mergeCart(fromCartId, toCartId)
2466 
    self.recv_mergeCart()
2467 
 
2468 
  def send_mergeCart(self, fromCartId, toCartId):
2469 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2470 
    args = mergeCart_args()
2471 
    args.fromCartId = fromCartId
2472 
    args.toCartId = toCartId
2473 
    args.write(self._oprot)
2474 
    self._oprot.writeMessageEnd()
2475 
    self._oprot.trans.flush()
2476 
 
2477 
  def recv_mergeCart(self, ):
2478 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2479 
    if mtype == TMessageType.EXCEPTION:
2480 
      x = TApplicationException()
2481 
      x.read(self._iprot)
2482 
      self._iprot.readMessageEnd()
2483 
      raise x
2484 
    result = mergeCart_result()
2485 
    result.read(self._iprot)
2486 
    self._iprot.readMessageEnd()
2487 
    return
2488 
 
2489 
  def checkOut(self, cartId):
2490 
    """
2491 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
2492 
 
2493 
    Parameters:
575 chandransh 2494 
     - cartId
2495 
    """
690 chandransh 2496 
    self.send_checkOut(cartId)
2497 
    return self.recv_checkOut()
575 chandransh 2498 
 
690 chandransh 2499 
  def send_checkOut(self, cartId):
2500 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2501 
    args = checkOut_args()
575 chandransh 2502 
    args.cartId = cartId
2503 
    args.write(self._oprot)
2504 
    self._oprot.writeMessageEnd()
2505 
    self._oprot.trans.flush()
2506 
 
690 chandransh 2507 
  def recv_checkOut(self, ):
575 chandransh 2508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2509 
    if mtype == TMessageType.EXCEPTION:
2510 
      x = TApplicationException()
2511 
      x.read(self._iprot)
2512 
      self._iprot.readMessageEnd()
2513 
      raise x
690 chandransh 2514 
    result = checkOut_result()
575 chandransh 2515 
    result.read(self._iprot)
2516 
    self._iprot.readMessageEnd()
2517 
    if result.success != None:
2518 
      return result.success
2519 
    if result.scex != None:
2520 
      raise result.scex
690 chandransh 2521 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2522 
 
690 chandransh 2523 
  def resetCart(self, cartId, items):
559 chandransh 2524 
    """
690 chandransh 2525 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2526 
    This methods removes the specified quantiry of the specified item from the cart.
2527 
 
559 chandransh 2528 
    Parameters:
690 chandransh 2529 
     - cartId
2530 
     - items
559 chandransh 2531 
    """
690 chandransh 2532 
    self.send_resetCart(cartId, items)
2533 
    return self.recv_resetCart()
130 ashish 2534 
 
690 chandransh 2535 
  def send_resetCart(self, cartId, items):
2536 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2537 
    args = resetCart_args()
2538 
    args.cartId = cartId
2539 
    args.items = items
559 chandransh 2540 
    args.write(self._oprot)
2541 
    self._oprot.writeMessageEnd()
2542 
    self._oprot.trans.flush()
2543 
 
690 chandransh 2544 
  def recv_resetCart(self, ):
559 chandransh 2545 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2546 
    if mtype == TMessageType.EXCEPTION:
2547 
      x = TApplicationException()
2548 
      x.read(self._iprot)
2549 
      self._iprot.readMessageEnd()
2550 
      raise x
690 chandransh 2551 
    result = resetCart_result()
559 chandransh 2552 
    result.read(self._iprot)
2553 
    self._iprot.readMessageEnd()
690 chandransh 2554 
    if result.success != None:
2555 
      return result.success
2556 
    if result.scex != None:
2557 
      raise result.scex
2558 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2559 
 
2981 rajveer 2560 
  def getUserCount(self, userType):
559 chandransh 2561 
    """
2981 rajveer 2562 
    Returns number of registered users.
2563 
    If userType = null, then it returns count of all users, including anonymous
2564 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2565 
    If userType = UserType.USER, then it returns count of non-anonymous users only
772 rajveer 2566 
 
559 chandransh 2567 
    Parameters:
2981 rajveer 2568 
     - userType
559 chandransh 2569 
    """
2981 rajveer 2570 
    self.send_getUserCount(userType)
2571 
    return self.recv_getUserCount()
559 chandransh 2572 
 
2981 rajveer 2573 
  def send_getUserCount(self, userType):
2574 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2575 
    args = getUserCount_args()
2576 
    args.userType = userType
559 chandransh 2577 
    args.write(self._oprot)
2578 
    self._oprot.writeMessageEnd()
2579 
    self._oprot.trans.flush()
2580 
 
2981 rajveer 2581 
  def recv_getUserCount(self, ):
559 chandransh 2582 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2583 
    if mtype == TMessageType.EXCEPTION:
2584 
      x = TApplicationException()
2585 
      x.read(self._iprot)
2586 
      self._iprot.readMessageEnd()
2587 
      raise x
2981 rajveer 2588 
    result = getUserCount_result()
559 chandransh 2589 
    result.read(self._iprot)
2590 
    self._iprot.readMessageEnd()
2591 
    if result.success != None:
2592 
      return result.success
2981 rajveer 2593 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2594 
 
2981 rajveer 2595 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2596 
    """
2981 rajveer 2597 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2598 
    If any of startDate or endDate is -1, then that filter is ignored.
2599 
    If userType is null, then returns all the users, irrespective of anonymous flag
2600 
 
2601 
 
559 chandransh 2602 
    Parameters:
2981 rajveer 2603 
     - userType
2604 
     - startDate
2605 
     - endDate
559 chandransh 2606 
    """
2981 rajveer 2607 
    self.send_getAllUsers(userType, startDate, endDate)
2608 
    return self.recv_getAllUsers()
559 chandransh 2609 
 
2981 rajveer 2610 
  def send_getAllUsers(self, userType, startDate, endDate):
2611 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2612 
    args = getAllUsers_args()
2613 
    args.userType = userType
2614 
    args.startDate = startDate
2615 
    args.endDate = endDate
559 chandransh 2616 
    args.write(self._oprot)
2617 
    self._oprot.writeMessageEnd()
2618 
    self._oprot.trans.flush()
2619 
 
2981 rajveer 2620 
  def recv_getAllUsers(self, ):
559 chandransh 2621 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2622 
    if mtype == TMessageType.EXCEPTION:
2623 
      x = TApplicationException()
2624 
      x.read(self._iprot)
2625 
      self._iprot.readMessageEnd()
2626 
      raise x
2981 rajveer 2627 
    result = getAllUsers_result()
559 chandransh 2628 
    result.read(self._iprot)
2629 
    self._iprot.readMessageEnd()
2630 
    if result.success != None:
2631 
      return result.success
2981 rajveer 2632 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2633 
 
2981 rajveer 2634 
  def putUserNote(self, user_id, entity_id, slide, note):
559 chandransh 2635 
    """
2636 
    Parameters:
2981 rajveer 2637 
     - user_id
2638 
     - entity_id
2639 
     - slide
2640 
     - note
559 chandransh 2641 
    """
2981 rajveer 2642 
    self.send_putUserNote(user_id, entity_id, slide, note)
2643 
    self.recv_putUserNote()
559 chandransh 2644 
 
2981 rajveer 2645 
  def send_putUserNote(self, user_id, entity_id, slide, note):
2646 
    self._oprot.writeMessageBegin('putUserNote', TMessageType.CALL, self._seqid)
2647 
    args = putUserNote_args()
2648 
    args.user_id = user_id
2649 
    args.entity_id = entity_id
2650 
    args.slide = slide
2651 
    args.note = note
559 chandransh 2652 
    args.write(self._oprot)
2653 
    self._oprot.writeMessageEnd()
2654 
    self._oprot.trans.flush()
2655 
 
2981 rajveer 2656 
  def recv_putUserNote(self, ):
559 chandransh 2657 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2658 
    if mtype == TMessageType.EXCEPTION:
2659 
      x = TApplicationException()
2660 
      x.read(self._iprot)
2661 
      self._iprot.readMessageEnd()
2662 
      raise x
2981 rajveer 2663 
    result = putUserNote_result()
559 chandransh 2664 
    result.read(self._iprot)
2665 
    self._iprot.readMessageEnd()
2666 
    return
2667 
 
2981 rajveer 2668 
  def getUserNotes(self, user_id, entity_id):
559 chandransh 2669 
    """
2670 
    Parameters:
2981 rajveer 2671 
     - user_id
2672 
     - entity_id
559 chandransh 2673 
    """
2981 rajveer 2674 
    self.send_getUserNotes(user_id, entity_id)
2675 
    return self.recv_getUserNotes()
559 chandransh 2676 
 
2981 rajveer 2677 
  def send_getUserNotes(self, user_id, entity_id):
2678 
    self._oprot.writeMessageBegin('getUserNotes', TMessageType.CALL, self._seqid)
2679 
    args = getUserNotes_args()
2680 
    args.user_id = user_id
2681 
    args.entity_id = entity_id
559 chandransh 2682 
    args.write(self._oprot)
2683 
    self._oprot.writeMessageEnd()
2684 
    self._oprot.trans.flush()
2685 
 
2981 rajveer 2686 
  def recv_getUserNotes(self, ):
559 chandransh 2687 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2688 
    if mtype == TMessageType.EXCEPTION:
2689 
      x = TApplicationException()
2690 
      x.read(self._iprot)
2691 
      self._iprot.readMessageEnd()
2692 
      raise x
2981 rajveer 2693 
    result = getUserNotes_result()
559 chandransh 2694 
    result.read(self._iprot)
2695 
    self._iprot.readMessageEnd()
2981 rajveer 2696 
    if result.success != None:
2697 
      return result.success
2698 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserNotes failed: unknown result");
559 chandransh 2699 
 
2981 rajveer 2700 
  def getMyResearchItems(self, userId):
559 chandransh 2701 
    """
2981 rajveer 2702 
    Returns list of item ids in myresearch for the user
2703 
 
559 chandransh 2704 
    Parameters:
772 rajveer 2705 
     - userId
559 chandransh 2706 
    """
2981 rajveer 2707 
    self.send_getMyResearchItems(userId)
2708 
    return self.recv_getMyResearchItems()
559 chandransh 2709 
 
2981 rajveer 2710 
  def send_getMyResearchItems(self, userId):
2711 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2712 
    args = getMyResearchItems_args()
772 rajveer 2713 
    args.userId = userId
559 chandransh 2714 
    args.write(self._oprot)
2715 
    self._oprot.writeMessageEnd()
2716 
    self._oprot.trans.flush()
2717 
 
2981 rajveer 2718 
  def recv_getMyResearchItems(self, ):
559 chandransh 2719 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2720 
    if mtype == TMessageType.EXCEPTION:
2721 
      x = TApplicationException()
2722 
      x.read(self._iprot)
2723 
      self._iprot.readMessageEnd()
2724 
      raise x
2981 rajveer 2725 
    result = getMyResearchItems_result()
559 chandransh 2726 
    result.read(self._iprot)
2727 
    self._iprot.readMessageEnd()
2728 
    if result.success != None:
2729 
      return result.success
2730 
    if result.scx != None:
2731 
      raise result.scx
2981 rajveer 2732 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2733 
 
2981 rajveer 2734 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2735 
    """
2981 rajveer 2736 
    add item to my research for a user
2737 
 
559 chandransh 2738 
    Parameters:
2981 rajveer 2739 
     - userId
2740 
     - itemId
559 chandransh 2741 
    """
2981 rajveer 2742 
    self.send_updateMyResearch(userId, itemId)
2743 
    return self.recv_updateMyResearch()
559 chandransh 2744 
 
2981 rajveer 2745 
  def send_updateMyResearch(self, userId, itemId):
2746 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2747 
    args = updateMyResearch_args()
2748 
    args.userId = userId
2749 
    args.itemId = itemId
559 chandransh 2750 
    args.write(self._oprot)
2751 
    self._oprot.writeMessageEnd()
2752 
    self._oprot.trans.flush()
2753 
 
2981 rajveer 2754 
  def recv_updateMyResearch(self, ):
559 chandransh 2755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2756 
    if mtype == TMessageType.EXCEPTION:
2757 
      x = TApplicationException()
2758 
      x.read(self._iprot)
2759 
      self._iprot.readMessageEnd()
2760 
      raise x
2981 rajveer 2761 
    result = updateMyResearch_result()
559 chandransh 2762 
    result.read(self._iprot)
2763 
    self._iprot.readMessageEnd()
2981 rajveer 2764 
    if result.success != None:
2765 
      return result.success
2766 
    if result.scx != None:
2767 
      raise result.scx
2768 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
559 chandransh 2769 
 
2981 rajveer 2770 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2771 
    """
2981 rajveer 2772 
    delete item from my research for a user
1596 ankur.sing 2773 
 
2774 
    Parameters:
2981 rajveer 2775 
     - userId
2776 
     - itemId
1596 ankur.sing 2777 
    """
2981 rajveer 2778 
    self.send_deleteItemFromMyResearch(userId, itemId)
2779 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2780 
 
2981 rajveer 2781 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2782 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2783 
    args = deleteItemFromMyResearch_args()
2784 
    args.userId = userId
2785 
    args.itemId = itemId
1596 ankur.sing 2786 
    args.write(self._oprot)
2787 
    self._oprot.writeMessageEnd()
2788 
    self._oprot.trans.flush()
2789 
 
2981 rajveer 2790 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 2791 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2792 
    if mtype == TMessageType.EXCEPTION:
2793 
      x = TApplicationException()
2794 
      x.read(self._iprot)
2795 
      self._iprot.readMessageEnd()
2796 
      raise x
2981 rajveer 2797 
    result = deleteItemFromMyResearch_result()
1596 ankur.sing 2798 
    result.read(self._iprot)
2799 
    self._iprot.readMessageEnd()
2981 rajveer 2800 
    if result.scx != None:
2801 
      raise result.scx
2802 
    return
1596 ankur.sing 2803 
 
2981 rajveer 2804 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2805 
    """
2981 rajveer 2806 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
1673 ankur.sing 2807 
 
2808 
    Parameters:
2981 rajveer 2809 
     - userId
1673 ankur.sing 2810 
    """
2981 rajveer 2811 
    self.send_getBrowseHistoryItems(userId)
2812 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2813 
 
2981 rajveer 2814 
  def send_getBrowseHistoryItems(self, userId):
2815 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2816 
    args = getBrowseHistoryItems_args()
2817 
    args.userId = userId
1673 ankur.sing 2818 
    args.write(self._oprot)
2819 
    self._oprot.writeMessageEnd()
2820 
    self._oprot.trans.flush()
2821 
 
2981 rajveer 2822 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 2823 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2824 
    if mtype == TMessageType.EXCEPTION:
2825 
      x = TApplicationException()
2826 
      x.read(self._iprot)
2827 
      self._iprot.readMessageEnd()
2828 
      raise x
2981 rajveer 2829 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 2830 
    result.read(self._iprot)
2831 
    self._iprot.readMessageEnd()
2832 
    if result.success != None:
2833 
      return result.success
2981 rajveer 2834 
    if result.scx != None:
2835 
      raise result.scx
2836 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 2837 
 
2981 rajveer 2838 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 2839 
    """
2981 rajveer 2840 
    add item to browse history for a user
2642 varun.gupt 2841 
 
2842 
    Parameters:
2981 rajveer 2843 
     - userId
2844 
     - itemId
2642 varun.gupt 2845 
    """
2981 rajveer 2846 
    self.send_updateBrowseHistory(userId, itemId)
2847 
    self.recv_updateBrowseHistory()
1673 ankur.sing 2848 
 
2981 rajveer 2849 
  def send_updateBrowseHistory(self, userId, itemId):
2850 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2851 
    args = updateBrowseHistory_args()
2852 
    args.userId = userId
2853 
    args.itemId = itemId
2642 varun.gupt 2854 
    args.write(self._oprot)
2855 
    self._oprot.writeMessageEnd()
2856 
    self._oprot.trans.flush()
2857 
 
2981 rajveer 2858 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 2859 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2860 
    if mtype == TMessageType.EXCEPTION:
2861 
      x = TApplicationException()
2862 
      x.read(self._iprot)
2863 
      self._iprot.readMessageEnd()
2864 
      raise x
2981 rajveer 2865 
    result = updateBrowseHistory_result()
2642 varun.gupt 2866 
    result.read(self._iprot)
2867 
    self._iprot.readMessageEnd()
2868 
    return
2869 
 
2870 
 
94 ashish 2871 
class Processor(Iface, TProcessor):
2872 
  def __init__(self, handler):
2873 
    self._handler = handler
2874 
    self._processMap = {}
765 rajveer 2875 
    self._processMap["closeSession"] = Processor.process_closeSession
559 chandransh 2876 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
2877 
    self._processMap["getUserById"] = Processor.process_getUserById
1491 vikas 2878 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
3032 mandeep.dh 2879 
    self._processMap["getUserByMobileNumber"] = Processor.process_getUserByMobileNumber
559 chandransh 2880 
    self._processMap["createUser"] = Processor.process_createUser
2881 
    self._processMap["updateUser"] = Processor.process_updateUser
2882 
    self._processMap["deleteUser"] = Processor.process_deleteUser
2883 
    self._processMap["getUserState"] = Processor.process_getUserState
122 ashish 2884 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 2885 
    self._processMap["userExists"] = Processor.process_userExists
2886 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
2887 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
2888 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
2889 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 2890 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 2891 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 2892 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 2893 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 2894 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 2895 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 2896 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 2897 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 2898 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
2899 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
2900 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
1845 vikas 2901 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 2902 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 2903 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
2904 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
2905 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
2906 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
2907 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 2908 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 2909 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
2910 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
2911 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 2912 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 2913 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
2914 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 2915 
    self._processMap["createCart"] = Processor.process_createCart
2916 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
2917 
    self._processMap["getCart"] = Processor.process_getCart
2918 
    self._processMap["getCartsForUser"] = Processor.process_getCartsForUser
2919 
    self._processMap["getCartsByStatus"] = Processor.process_getCartsByStatus
2920 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
2921 
    self._processMap["changeCartStatus"] = Processor.process_changeCartStatus
2922 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
2923 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
2924 
    self._processMap["changeQuantity"] = Processor.process_changeQuantity
2925 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
2926 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
1976 varun.gupt 2927 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
2928 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
690 chandransh 2929 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 2930 
    self._processMap["validateCart"] = Processor.process_validateCart
2931 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 2932 
    self._processMap["checkOut"] = Processor.process_checkOut
2933 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 2934 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 2935 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2642 varun.gupt 2936 
    self._processMap["putUserNote"] = Processor.process_putUserNote
2937 
    self._processMap["getUserNotes"] = Processor.process_getUserNotes
2981 rajveer 2938 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
2939 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
2940 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
2941 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
2942 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
94 ashish 2943 
 
2944 
  def process(self, iprot, oprot):
2945 
    (name, type, seqid) = iprot.readMessageBegin()
2946 
    if name not in self._processMap:
2947 
      iprot.skip(TType.STRUCT)
2948 
      iprot.readMessageEnd()
2949 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
2950 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
2951 
      x.write(oprot)
2952 
      oprot.writeMessageEnd()
2953 
      oprot.trans.flush()
2954 
      return
2955 
    else:
2956 
      self._processMap[name](self, seqid, iprot, oprot)
2957 
    return True
2958 
 
765 rajveer 2959 
  def process_closeSession(self, seqid, iprot, oprot):
2960 
    args = closeSession_args()
2961 
    args.read(iprot)
2962 
    iprot.readMessageEnd()
2963 
    result = closeSession_result()
2964 
    self._handler.closeSession()
2965 
    oprot.writeMessageBegin("closeSession", TMessageType.REPLY, seqid)
2966 
    result.write(oprot)
2967 
    oprot.writeMessageEnd()
2968 
    oprot.trans.flush()
2969 
 
559 chandransh 2970 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
2971 
    args = createAnonymousUser_args()
94 ashish 2972 
    args.read(iprot)
2973 
    iprot.readMessageEnd()
559 chandransh 2974 
    result = createAnonymousUser_result()
94 ashish 2975 
    try:
559 chandransh 2976 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
2977 
    except UserContextException, ucex:
2978 
      result.ucex = ucex
2979 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 2980 
    result.write(oprot)
2981 
    oprot.writeMessageEnd()
2982 
    oprot.trans.flush()
2983 
 
559 chandransh 2984 
  def process_getUserById(self, seqid, iprot, oprot):
2985 
    args = getUserById_args()
94 ashish 2986 
    args.read(iprot)
2987 
    iprot.readMessageEnd()
559 chandransh 2988 
    result = getUserById_result()
94 ashish 2989 
    try:
559 chandransh 2990 
      result.success = self._handler.getUserById(args.userId)
2991 
    except UserContextException, ucex:
2992 
      result.ucex = ucex
2993 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 2994 
    result.write(oprot)
2995 
    oprot.writeMessageEnd()
2996 
    oprot.trans.flush()
2997 
 
1491 vikas 2998 
  def process_getUserByEmail(self, seqid, iprot, oprot):
2999 
    args = getUserByEmail_args()
3000 
    args.read(iprot)
3001 
    iprot.readMessageEnd()
3002 
    result = getUserByEmail_result()
3003 
    try:
3004 
      result.success = self._handler.getUserByEmail(args.email)
3005 
    except UserContextException, ucex:
3006 
      result.ucex = ucex
3007 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
3008 
    result.write(oprot)
3009 
    oprot.writeMessageEnd()
3010 
    oprot.trans.flush()
3011 
 
3032 mandeep.dh 3012 
  def process_getUserByMobileNumber(self, seqid, iprot, oprot):
3013 
    args = getUserByMobileNumber_args()
3014 
    args.read(iprot)
3015 
    iprot.readMessageEnd()
3016 
    result = getUserByMobileNumber_result()
3017 
    try:
3018 
      result.success = self._handler.getUserByMobileNumber(args.mobileNumber)
3019 
    except UserContextException, ucex:
3020 
      result.ucex = ucex
3021 
    oprot.writeMessageBegin("getUserByMobileNumber", TMessageType.REPLY, seqid)
3022 
    result.write(oprot)
3023 
    oprot.writeMessageEnd()
3024 
    oprot.trans.flush()
3025 
 
559 chandransh 3026 
  def process_createUser(self, seqid, iprot, oprot):
3027 
    args = createUser_args()
94 ashish 3028 
    args.read(iprot)
3029 
    iprot.readMessageEnd()
559 chandransh 3030 
    result = createUser_result()
94 ashish 3031 
    try:
559 chandransh 3032 
      result.success = self._handler.createUser(args.user)
3033 
    except UserContextException, ucex:
3034 
      result.ucex = ucex
3035 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 3036 
    result.write(oprot)
3037 
    oprot.writeMessageEnd()
3038 
    oprot.trans.flush()
3039 
 
559 chandransh 3040 
  def process_updateUser(self, seqid, iprot, oprot):
3041 
    args = updateUser_args()
94 ashish 3042 
    args.read(iprot)
3043 
    iprot.readMessageEnd()
559 chandransh 3044 
    result = updateUser_result()
94 ashish 3045 
    try:
559 chandransh 3046 
      result.success = self._handler.updateUser(args.user)
3047 
    except UserContextException, ucex:
3048 
      result.ucex = ucex
3049 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 3050 
    result.write(oprot)
3051 
    oprot.writeMessageEnd()
3052 
    oprot.trans.flush()
3053 
 
559 chandransh 3054 
  def process_deleteUser(self, seqid, iprot, oprot):
3055 
    args = deleteUser_args()
94 ashish 3056 
    args.read(iprot)
3057 
    iprot.readMessageEnd()
559 chandransh 3058 
    result = deleteUser_result()
94 ashish 3059 
    try:
559 chandransh 3060 
      result.success = self._handler.deleteUser(args.userId)
3061 
    except UserContextException, ucex:
3062 
      result.ucex = ucex
3063 
    oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
94 ashish 3064 
    result.write(oprot)
3065 
    oprot.writeMessageEnd()
3066 
    oprot.trans.flush()
3067 
 
559 chandransh 3068 
  def process_getUserState(self, seqid, iprot, oprot):
3069 
    args = getUserState_args()
94 ashish 3070 
    args.read(iprot)
3071 
    iprot.readMessageEnd()
559 chandransh 3072 
    result = getUserState_result()
94 ashish 3073 
    try:
559 chandransh 3074 
      result.success = self._handler.getUserState(args.userId)
3075 
    except UserContextException, ucex:
3076 
      result.ucex = ucex
3077 
    oprot.writeMessageBegin("getUserState", TMessageType.REPLY, seqid)
94 ashish 3078 
    result.write(oprot)
3079 
    oprot.writeMessageEnd()
3080 
    oprot.trans.flush()
3081 
 
122 ashish 3082 
  def process_authenticateUser(self, seqid, iprot, oprot):
3083 
    args = authenticateUser_args()
3084 
    args.read(iprot)
3085 
    iprot.readMessageEnd()
3086 
    result = authenticateUser_result()
3087 
    try:
559 chandransh 3088 
      result.success = self._handler.authenticateUser(args.email, args.password)
3089 
    except AuthenticationException, auex:
3090 
      result.auex = auex
122 ashish 3091 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
3092 
    result.write(oprot)
3093 
    oprot.writeMessageEnd()
3094 
    oprot.trans.flush()
3095 
 
94 ashish 3096 
  def process_userExists(self, seqid, iprot, oprot):
3097 
    args = userExists_args()
3098 
    args.read(iprot)
3099 
    iprot.readMessageEnd()
3100 
    result = userExists_result()
3101 
    try:
3102 
      result.success = self._handler.userExists(args.email)
3103 
    except UserContextException, ucx:
3104 
      result.ucx = ucx
3105 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
3106 
    result.write(oprot)
3107 
    oprot.writeMessageEnd()
3108 
    oprot.trans.flush()
3109 
 
3110 
  def process_addAddressForUser(self, seqid, iprot, oprot):
3111 
    args = addAddressForUser_args()
3112 
    args.read(iprot)
3113 
    iprot.readMessageEnd()
3114 
    result = addAddressForUser_result()
3115 
    try:
567 rajveer 3116 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 3117 
    except UserContextException, ucx:
3118 
      result.ucx = ucx
3119 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
3120 
    result.write(oprot)
3121 
    oprot.writeMessageEnd()
3122 
    oprot.trans.flush()
3123 
 
3124 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
3125 
    args = removeAddressForUser_args()
3126 
    args.read(iprot)
3127 
    iprot.readMessageEnd()
3128 
    result = removeAddressForUser_result()
3129 
    try:
3130 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
3131 
    except UserContextException, ucx:
3132 
      result.ucx = ucx
3133 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
3134 
    result.write(oprot)
3135 
    oprot.writeMessageEnd()
3136 
    oprot.trans.flush()
3137 
 
3138 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
3139 
    args = setUserAsLoggedIn_args()
3140 
    args.read(iprot)
3141 
    iprot.readMessageEnd()
3142 
    result = setUserAsLoggedIn_result()
3143 
    try:
3144 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
3145 
    except UserContextException, ucx:
3146 
      result.ucx = ucx
3147 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
3148 
    result.write(oprot)
3149 
    oprot.writeMessageEnd()
3150 
    oprot.trans.flush()
3151 
 
3152 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
3153 
    args = setUserAsLoggedOut_args()
3154 
    args.read(iprot)
3155 
    iprot.readMessageEnd()
3156 
    result = setUserAsLoggedOut_result()
3157 
    try:
3158 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
3159 
    except UserContextException, ucx:
3160 
      result.ucx = ucx
3161 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
3162 
    result.write(oprot)
3163 
    oprot.writeMessageEnd()
3164 
    oprot.trans.flush()
3165 
 
504 rajveer 3166 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
3167 
    args = setDefaultAddress_args()
3168 
    args.read(iprot)
3169 
    iprot.readMessageEnd()
3170 
    result = setDefaultAddress_result()
3171 
    try:
3172 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
3173 
    except UserContextException, ucx:
3174 
      result.ucx = ucx
3175 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
3176 
    result.write(oprot)
3177 
    oprot.writeMessageEnd()
3178 
    oprot.trans.flush()
3179 
 
94 ashish 3180 
  def process_updatePassword(self, seqid, iprot, oprot):
3181 
    args = updatePassword_args()
3182 
    args.read(iprot)
3183 
    iprot.readMessageEnd()
3184 
    result = updatePassword_result()
3185 
    try:
594 rajveer 3186 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 3187 
    except UserContextException, ucx:
3188 
      result.ucx = ucx
3189 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
3190 
    result.write(oprot)
3191 
    oprot.writeMessageEnd()
3192 
    oprot.trans.flush()
3193 
 
581 rajveer 3194 
  def process_forgotPassword(self, seqid, iprot, oprot):
3195 
    args = forgotPassword_args()
3196 
    args.read(iprot)
3197 
    iprot.readMessageEnd()
3198 
    result = forgotPassword_result()
3199 
    try:
884 rajveer 3200 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 3201 
    except UserContextException, ucx:
3202 
      result.ucx = ucx
3203 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
3204 
    result.write(oprot)
3205 
    oprot.writeMessageEnd()
3206 
    oprot.trans.flush()
3207 
 
594 rajveer 3208 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
3209 
    args = getAllAddressesForUser_args()
3210 
    args.read(iprot)
3211 
    iprot.readMessageEnd()
3212 
    result = getAllAddressesForUser_result()
3213 
    try:
3214 
      result.success = self._handler.getAllAddressesForUser(args.userId)
3215 
    except UserContextException, ucx:
3216 
      result.ucx = ucx
3217 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
3218 
    result.write(oprot)
3219 
    oprot.writeMessageEnd()
3220 
    oprot.trans.flush()
3221 
 
1894 vikas 3222 
  def process_getAddressById(self, seqid, iprot, oprot):
3223 
    args = getAddressById_args()
3224 
    args.read(iprot)
3225 
    iprot.readMessageEnd()
3226 
    result = getAddressById_result()
3227 
    try:
3228 
      result.success = self._handler.getAddressById(args.addressId)
3229 
    except UserContextException, ucx:
3230 
      result.ucx = ucx
3231 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
3232 
    result.write(oprot)
3233 
    oprot.writeMessageEnd()
3234 
    oprot.trans.flush()
3235 
 
594 rajveer 3236 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
3237 
    args = getDefaultAddressId_args()
3238 
    args.read(iprot)
3239 
    iprot.readMessageEnd()
3240 
    result = getDefaultAddressId_result()
3241 
    try:
3242 
      result.success = self._handler.getDefaultAddressId(args.userId)
3243 
    except UserContextException, ucx:
3244 
      result.ucx = ucx
3245 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
3246 
    result.write(oprot)
3247 
    oprot.writeMessageEnd()
3248 
    oprot.trans.flush()
3249 
 
785 rajveer 3250 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
3251 
    args = getDefaultPincode_args()
3252 
    args.read(iprot)
3253 
    iprot.readMessageEnd()
3254 
    result = getDefaultPincode_result()
3255 
    try:
3256 
      result.success = self._handler.getDefaultPincode(args.userId)
3257 
    except UserContextException, ucx:
3258 
      result.ucx = ucx
3259 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
3260 
    result.write(oprot)
3261 
    oprot.writeMessageEnd()
3262 
    oprot.trans.flush()
3263 
 
1274 varun.gupt 3264 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
3265 
    args = saveUserCommunication_args()
3266 
    args.read(iprot)
3267 
    iprot.readMessageEnd()
3268 
    result = saveUserCommunication_result()
3269 
    try:
3270 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
3271 
    except UserCommunicationException, ucx:
3272 
      result.ucx = ucx
3273 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
3274 
    result.write(oprot)
3275 
    oprot.writeMessageEnd()
3276 
    oprot.trans.flush()
3277 
 
1590 varun.gupt 3278 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
3279 
    args = getUserCommunicationById_args()
3280 
    args.read(iprot)
3281 
    iprot.readMessageEnd()
3282 
    result = getUserCommunicationById_result()
3283 
    try:
3284 
      result.success = self._handler.getUserCommunicationById(args.id)
3285 
    except UserCommunicationException, ucx:
3286 
      result.ucx = ucx
3287 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
3288 
    result.write(oprot)
3289 
    oprot.writeMessageEnd()
3290 
    oprot.trans.flush()
3291 
 
3292 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
3293 
    args = getUserCommunicationByUser_args()
3294 
    args.read(iprot)
3295 
    iprot.readMessageEnd()
3296 
    result = getUserCommunicationByUser_result()
3297 
    try:
3298 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
3299 
    except UserCommunicationException, ucx:
3300 
      result.ucx = ucx
3301 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
3302 
    result.write(oprot)
3303 
    oprot.writeMessageEnd()
3304 
    oprot.trans.flush()
3305 
 
3306 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
3307 
    args = getAllUserCommunications_args()
3308 
    args.read(iprot)
3309 
    iprot.readMessageEnd()
3310 
    result = getAllUserCommunications_result()
3311 
    try:
3312 
      result.success = self._handler.getAllUserCommunications()
3313 
    except UserCommunicationException, ucx:
3314 
      result.ucx = ucx
3315 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
3316 
    result.write(oprot)
3317 
    oprot.writeMessageEnd()
3318 
    oprot.trans.flush()
3319 
 
1845 vikas 3320 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
3321 
    args = createMasterAffiliate_args()
3322 
    args.read(iprot)
3323 
    iprot.readMessageEnd()
3324 
    result = createMasterAffiliate_result()
3325 
    try:
1859 vikas 3326 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 3327 
    except UserAffiliateException, utx:
1845 vikas 3328 
      result.utx = utx
3329 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
3330 
    result.write(oprot)
3331 
    oprot.writeMessageEnd()
3332 
    oprot.trans.flush()
3333 
 
1899 vikas 3334 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
3335 
    args = getAllMasterAffiliates_args()
3336 
    args.read(iprot)
3337 
    iprot.readMessageEnd()
3338 
    result = getAllMasterAffiliates_result()
3339 
    try:
3340 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 3341 
    except UserAffiliateException, utx:
1899 vikas 3342 
      result.utx = utx
3343 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
3344 
    result.write(oprot)
3345 
    oprot.writeMessageEnd()
3346 
    oprot.trans.flush()
3347 
 
1845 vikas 3348 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
3349 
    args = getMasterAffiliateById_args()
3350 
    args.read(iprot)
3351 
    iprot.readMessageEnd()
3352 
    result = getMasterAffiliateById_result()
3353 
    try:
3354 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 3355 
    except UserAffiliateException, utx:
1845 vikas 3356 
      result.utx = utx
3357 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
3358 
    result.write(oprot)
3359 
    oprot.writeMessageEnd()
3360 
    oprot.trans.flush()
3361 
 
3362 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
3363 
    args = getMasterAffiliateByName_args()
3364 
    args.read(iprot)
3365 
    iprot.readMessageEnd()
3366 
    result = getMasterAffiliateByName_result()
3367 
    try:
3368 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 3369 
    except UserAffiliateException, utx:
1845 vikas 3370 
      result.utx = utx
3371 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
3372 
    result.write(oprot)
3373 
    oprot.writeMessageEnd()
3374 
    oprot.trans.flush()
3375 
 
3376 
  def process_createAffiliate(self, seqid, iprot, oprot):
3377 
    args = createAffiliate_args()
3378 
    args.read(iprot)
3379 
    iprot.readMessageEnd()
3380 
    result = createAffiliate_result()
3381 
    try:
1859 vikas 3382 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 3383 
    except UserAffiliateException, utx:
1845 vikas 3384 
      result.utx = utx
3385 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
3386 
    result.write(oprot)
3387 
    oprot.writeMessageEnd()
3388 
    oprot.trans.flush()
3389 
 
3390 
  def process_getAffiliateById(self, seqid, iprot, oprot):
3391 
    args = getAffiliateById_args()
3392 
    args.read(iprot)
3393 
    iprot.readMessageEnd()
3394 
    result = getAffiliateById_result()
3395 
    try:
3396 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 3397 
    except UserAffiliateException, utx:
1845 vikas 3398 
      result.utx = utx
3399 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
3400 
    result.write(oprot)
3401 
    oprot.writeMessageEnd()
3402 
    oprot.trans.flush()
3403 
 
3404 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
3405 
    args = getAffiliateByName_args()
3406 
    args.read(iprot)
3407 
    iprot.readMessageEnd()
3408 
    result = getAffiliateByName_result()
3409 
    try:
3410 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 3411 
    except UserAffiliateException, utx:
1845 vikas 3412 
      result.utx = utx
3413 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
3414 
    result.write(oprot)
3415 
    oprot.writeMessageEnd()
3416 
    oprot.trans.flush()
3417 
 
3418 
  def process_getTrackerById(self, seqid, iprot, oprot):
3419 
    args = getTrackerById_args()
3420 
    args.read(iprot)
3421 
    iprot.readMessageEnd()
3422 
    result = getTrackerById_result()
3423 
    try:
1996 vikas 3424 
      result.success = self._handler.getTrackerById(args.id)
3425 
    except UserAffiliateException, utx:
1845 vikas 3426 
      result.utx = utx
3427 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
3428 
    result.write(oprot)
3429 
    oprot.writeMessageEnd()
3430 
    oprot.trans.flush()
3431 
 
1996 vikas 3432 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
3433 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 3434 
    args.read(iprot)
3435 
    iprot.readMessageEnd()
1996 vikas 3436 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 3437 
    try:
1996 vikas 3438 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
3439 
    except UserAffiliateException, utx:
1845 vikas 3440 
      result.utx = utx
1996 vikas 3441 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3442 
    result.write(oprot)
3443 
    oprot.writeMessageEnd()
3444 
    oprot.trans.flush()
3445 
 
3446 
  def process_addTrackLog(self, seqid, iprot, oprot):
3447 
    args = addTrackLog_args()
3448 
    args.read(iprot)
3449 
    iprot.readMessageEnd()
3450 
    result = addTrackLog_result()
3451 
    try:
1996 vikas 3452 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
3453 
    except UserAffiliateException, utx:
1845 vikas 3454 
      result.utx = utx
3455 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
3456 
    result.write(oprot)
3457 
    oprot.writeMessageEnd()
3458 
    oprot.trans.flush()
3459 
 
3460 
  def process_getTrackLogById(self, seqid, iprot, oprot):
3461 
    args = getTrackLogById_args()
3462 
    args.read(iprot)
3463 
    iprot.readMessageEnd()
3464 
    result = getTrackLogById_result()
3465 
    try:
3466 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 3467 
    except UserAffiliateException, utx:
1845 vikas 3468 
      result.utx = utx
3469 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
3470 
    result.write(oprot)
3471 
    oprot.writeMessageEnd()
3472 
    oprot.trans.flush()
3473 
 
1996 vikas 3474 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
3475 
    args = getTrackLogsByAffiliate_args()
1845 vikas 3476 
    args.read(iprot)
3477 
    iprot.readMessageEnd()
1996 vikas 3478 
    result = getTrackLogsByAffiliate_result()
1845 vikas 3479 
    try:
3293 vikas 3480 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId, args.startDate, args.endDate)
1996 vikas 3481 
    except UserAffiliateException, utx:
1845 vikas 3482 
      result.utx = utx
1996 vikas 3483 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3484 
    result.write(oprot)
3485 
    oprot.writeMessageEnd()
3486 
    oprot.trans.flush()
3487 
 
3488 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
3489 
    args = getTrackLogsByUser_args()
3490 
    args.read(iprot)
3491 
    iprot.readMessageEnd()
3492 
    result = getTrackLogsByUser_result()
3493 
    try:
3494 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 3495 
    except UserAffiliateException, utx:
1845 vikas 3496 
      result.utx = utx
3497 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
3498 
    result.write(oprot)
3499 
    oprot.writeMessageEnd()
3500 
    oprot.trans.flush()
3501 
 
3502 
  def process_getTrackLogs(self, seqid, iprot, oprot):
3503 
    args = getTrackLogs_args()
3504 
    args.read(iprot)
3505 
    iprot.readMessageEnd()
3506 
    result = getTrackLogs_result()
3507 
    try:
1996 vikas 3508 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
3509 
    except UserAffiliateException, utx:
1845 vikas 3510 
      result.utx = utx
3511 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
3512 
    result.write(oprot)
3513 
    oprot.writeMessageEnd()
3514 
    oprot.trans.flush()
3515 
 
559 chandransh 3516 
  def process_createCart(self, seqid, iprot, oprot):
3517 
    args = createCart_args()
94 ashish 3518 
    args.read(iprot)
3519 
    iprot.readMessageEnd()
559 chandransh 3520 
    result = createCart_result()
94 ashish 3521 
    try:
559 chandransh 3522 
      result.success = self._handler.createCart(args.userId)
3523 
    except ShoppingCartException, scx:
3524 
      result.scx = scx
3525 
    oprot.writeMessageBegin("createCart", TMessageType.REPLY, seqid)
94 ashish 3526 
    result.write(oprot)
3527 
    oprot.writeMessageEnd()
3528 
    oprot.trans.flush()
3529 
 
559 chandransh 3530 
  def process_getCurrentCart(self, seqid, iprot, oprot):
3531 
    args = getCurrentCart_args()
94 ashish 3532 
    args.read(iprot)
3533 
    iprot.readMessageEnd()
559 chandransh 3534 
    result = getCurrentCart_result()
94 ashish 3535 
    try:
559 chandransh 3536 
      result.success = self._handler.getCurrentCart(args.userId)
3537 
    except ShoppingCartException, scx:
3538 
      result.scx = scx
3539 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 3540 
    result.write(oprot)
3541 
    oprot.writeMessageEnd()
3542 
    oprot.trans.flush()
3543 
 
559 chandransh 3544 
  def process_getCart(self, seqid, iprot, oprot):
3545 
    args = getCart_args()
94 ashish 3546 
    args.read(iprot)
3547 
    iprot.readMessageEnd()
559 chandransh 3548 
    result = getCart_result()
94 ashish 3549 
    try:
559 chandransh 3550 
      result.success = self._handler.getCart(args.cartId)
3551 
    except ShoppingCartException, scx:
3552 
      result.scx = scx
3553 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 3554 
    result.write(oprot)
3555 
    oprot.writeMessageEnd()
3556 
    oprot.trans.flush()
3557 
 
559 chandransh 3558 
  def process_getCartsForUser(self, seqid, iprot, oprot):
3559 
    args = getCartsForUser_args()
94 ashish 3560 
    args.read(iprot)
3561 
    iprot.readMessageEnd()
559 chandransh 3562 
    result = getCartsForUser_result()
94 ashish 3563 
    try:
559 chandransh 3564 
      result.success = self._handler.getCartsForUser(args.userId, args.status)
3565 
    except ShoppingCartException, scx:
3566 
      result.scx = scx
3567 
    oprot.writeMessageBegin("getCartsForUser", TMessageType.REPLY, seqid)
94 ashish 3568 
    result.write(oprot)
3569 
    oprot.writeMessageEnd()
3570 
    oprot.trans.flush()
3571 
 
559 chandransh 3572 
  def process_getCartsByStatus(self, seqid, iprot, oprot):
3573 
    args = getCartsByStatus_args()
94 ashish 3574 
    args.read(iprot)
3575 
    iprot.readMessageEnd()
559 chandransh 3576 
    result = getCartsByStatus_result()
94 ashish 3577 
    try:
559 chandransh 3578 
      result.success = self._handler.getCartsByStatus(args.status)
3579 
    except ShoppingCartException, scx:
3580 
      result.scx = scx
3581 
    oprot.writeMessageBegin("getCartsByStatus", TMessageType.REPLY, seqid)
94 ashish 3582 
    result.write(oprot)
3583 
    oprot.writeMessageEnd()
3584 
    oprot.trans.flush()
3585 
 
559 chandransh 3586 
  def process_getCartsByTime(self, seqid, iprot, oprot):
3587 
    args = getCartsByTime_args()
94 ashish 3588 
    args.read(iprot)
3589 
    iprot.readMessageEnd()
559 chandransh 3590 
    result = getCartsByTime_result()
94 ashish 3591 
    try:
559 chandransh 3592 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
3593 
    except ShoppingCartException, scx:
3594 
      result.scx = scx
3595 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 3596 
    result.write(oprot)
3597 
    oprot.writeMessageEnd()
3598 
    oprot.trans.flush()
3599 
 
559 chandransh 3600 
  def process_changeCartStatus(self, seqid, iprot, oprot):
3601 
    args = changeCartStatus_args()
130 ashish 3602 
    args.read(iprot)
3603 
    iprot.readMessageEnd()
559 chandransh 3604 
    result = changeCartStatus_result()
130 ashish 3605 
    try:
559 chandransh 3606 
      self._handler.changeCartStatus(args.cartId, args.status)
3607 
    except ShoppingCartException, scx:
3608 
      result.scx = scx
3609 
    oprot.writeMessageBegin("changeCartStatus", TMessageType.REPLY, seqid)
130 ashish 3610 
    result.write(oprot)
3611 
    oprot.writeMessageEnd()
3612 
    oprot.trans.flush()
94 ashish 3613 
 
559 chandransh 3614 
  def process_addItemToCart(self, seqid, iprot, oprot):
3615 
    args = addItemToCart_args()
130 ashish 3616 
    args.read(iprot)
3617 
    iprot.readMessageEnd()
559 chandransh 3618 
    result = addItemToCart_result()
130 ashish 3619 
    try:
2035 rajveer 3620 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity)
559 chandransh 3621 
    except ShoppingCartException, scx:
3622 
      result.scx = scx
3623 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 3624 
    result.write(oprot)
3625 
    oprot.writeMessageEnd()
3626 
    oprot.trans.flush()
3627 
 
559 chandransh 3628 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
3629 
    args = deleteItemFromCart_args()
3630 
    args.read(iprot)
3631 
    iprot.readMessageEnd()
3632 
    result = deleteItemFromCart_result()
3633 
    try:
3634 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
3635 
    except ShoppingCartException, scx:
3636 
      result.scx = scx
3637 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
3638 
    result.write(oprot)
3639 
    oprot.writeMessageEnd()
3640 
    oprot.trans.flush()
130 ashish 3641 
 
559 chandransh 3642 
  def process_changeQuantity(self, seqid, iprot, oprot):
3643 
    args = changeQuantity_args()
3644 
    args.read(iprot)
3645 
    iprot.readMessageEnd()
3646 
    result = changeQuantity_result()
3647 
    try:
3648 
      self._handler.changeQuantity(args.cartId, args.itemId, args.quantity)
3649 
    except ShoppingCartException, scx:
3650 
      result.scx = scx
3651 
    oprot.writeMessageBegin("changeQuantity", TMessageType.REPLY, seqid)
3652 
    result.write(oprot)
3653 
    oprot.writeMessageEnd()
3654 
    oprot.trans.flush()
3655 
 
3656 
  def process_changeItemStatus(self, seqid, iprot, oprot):
3657 
    args = changeItemStatus_args()
3658 
    args.read(iprot)
3659 
    iprot.readMessageEnd()
3660 
    result = changeItemStatus_result()
3661 
    try:
3662 
      self._handler.changeItemStatus(args.cartId, args.itemId, args.status)
3663 
    except ShoppingCartException, scx:
3664 
      result.scx = scx
3665 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
3666 
    result.write(oprot)
3667 
    oprot.writeMessageEnd()
3668 
    oprot.trans.flush()
3669 
 
3670 
  def process_addAddressToCart(self, seqid, iprot, oprot):
3671 
    args = addAddressToCart_args()
3672 
    args.read(iprot)
3673 
    iprot.readMessageEnd()
3674 
    result = addAddressToCart_result()
575 chandransh 3675 
    try:
3676 
      self._handler.addAddressToCart(args.cartId, args.addressId)
3677 
    except ShoppingCartException, scx:
3678 
      result.scx = scx
559 chandransh 3679 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
3680 
    result.write(oprot)
3681 
    oprot.writeMessageEnd()
3682 
    oprot.trans.flush()
3683 
 
1976 varun.gupt 3684 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
3685 
    args = applyCouponToCart_args()
3686 
    args.read(iprot)
3687 
    iprot.readMessageEnd()
3688 
    result = applyCouponToCart_result()
3689 
    try:
3690 
      self._handler.applyCouponToCart(args.cartId, args.couponCode, args.totalPrice, args.discountedPrice)
3691 
    except ShoppingCartException, scx:
3692 
      result.scx = scx
3693 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
3694 
    result.write(oprot)
3695 
    oprot.writeMessageEnd()
3696 
    oprot.trans.flush()
3697 
 
3698 
  def process_removeCoupon(self, seqid, iprot, oprot):
3699 
    args = removeCoupon_args()
3700 
    args.read(iprot)
3701 
    iprot.readMessageEnd()
3702 
    result = removeCoupon_result()
3703 
    try:
3704 
      self._handler.removeCoupon(args.cartId)
3705 
    except ShoppingCartException, scx:
3706 
      result.scx = scx
3707 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
3708 
    result.write(oprot)
3709 
    oprot.writeMessageEnd()
3710 
    oprot.trans.flush()
3711 
 
690 chandransh 3712 
  def process_createOrders(self, seqid, iprot, oprot):
3713 
    args = createOrders_args()
559 chandransh 3714 
    args.read(iprot)
3715 
    iprot.readMessageEnd()
690 chandransh 3716 
    result = createOrders_result()
559 chandransh 3717 
    try:
2815 vikas 3718 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime)
559 chandransh 3719 
    except ShoppingCartException, scx:
3720 
      result.scx = scx
690 chandransh 3721 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 3722 
    result.write(oprot)
3723 
    oprot.writeMessageEnd()
3724 
    oprot.trans.flush()
3725 
 
3726 
  def process_validateCart(self, seqid, iprot, oprot):
3727 
    args = validateCart_args()
3728 
    args.read(iprot)
3729 
    iprot.readMessageEnd()
3730 
    result = validateCart_result()
575 chandransh 3731 
    try:
3732 
      result.success = self._handler.validateCart(args.cartId)
3733 
    except ShoppingCartException, scex:
3734 
      result.scex = scex
559 chandransh 3735 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
3736 
    result.write(oprot)
3737 
    oprot.writeMessageEnd()
3738 
    oprot.trans.flush()
3739 
 
690 chandransh 3740 
  def process_mergeCart(self, seqid, iprot, oprot):
3741 
    args = mergeCart_args()
575 chandransh 3742 
    args.read(iprot)
3743 
    iprot.readMessageEnd()
690 chandransh 3744 
    result = mergeCart_result()
3745 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
3746 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
3747 
    result.write(oprot)
3748 
    oprot.writeMessageEnd()
3749 
    oprot.trans.flush()
3750 
 
3751 
  def process_checkOut(self, seqid, iprot, oprot):
3752 
    args = checkOut_args()
3753 
    args.read(iprot)
3754 
    iprot.readMessageEnd()
3755 
    result = checkOut_result()
575 chandransh 3756 
    try:
690 chandransh 3757 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 3758 
    except ShoppingCartException, scex:
3759 
      result.scex = scex
690 chandransh 3760 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 3761 
    result.write(oprot)
3762 
    oprot.writeMessageEnd()
3763 
    oprot.trans.flush()
3764 
 
690 chandransh 3765 
  def process_resetCart(self, seqid, iprot, oprot):
3766 
    args = resetCart_args()
559 chandransh 3767 
    args.read(iprot)
3768 
    iprot.readMessageEnd()
690 chandransh 3769 
    result = resetCart_result()
3770 
    try:
3771 
      result.success = self._handler.resetCart(args.cartId, args.items)
3772 
    except ShoppingCartException, scex:
3773 
      result.scex = scex
3774 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 3775 
    result.write(oprot)
3776 
    oprot.writeMessageEnd()
3777 
    oprot.trans.flush()
3778 
 
2981 rajveer 3779 
  def process_getUserCount(self, seqid, iprot, oprot):
3780 
    args = getUserCount_args()
559 chandransh 3781 
    args.read(iprot)
3782 
    iprot.readMessageEnd()
2981 rajveer 3783 
    result = getUserCount_result()
3784 
    result.success = self._handler.getUserCount(args.userType)
3785 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 3786 
    result.write(oprot)
3787 
    oprot.writeMessageEnd()
3788 
    oprot.trans.flush()
3789 
 
2981 rajveer 3790 
  def process_getAllUsers(self, seqid, iprot, oprot):
3791 
    args = getAllUsers_args()
559 chandransh 3792 
    args.read(iprot)
3793 
    iprot.readMessageEnd()
2981 rajveer 3794 
    result = getAllUsers_result()
3795 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
3796 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 3797 
    result.write(oprot)
3798 
    oprot.writeMessageEnd()
3799 
    oprot.trans.flush()
3800 
 
2981 rajveer 3801 
  def process_putUserNote(self, seqid, iprot, oprot):
3802 
    args = putUserNote_args()
559 chandransh 3803 
    args.read(iprot)
3804 
    iprot.readMessageEnd()
2981 rajveer 3805 
    result = putUserNote_result()
3806 
    self._handler.putUserNote(args.user_id, args.entity_id, args.slide, args.note)
3807 
    oprot.writeMessageBegin("putUserNote", TMessageType.REPLY, seqid)
559 chandransh 3808 
    result.write(oprot)
3809 
    oprot.writeMessageEnd()
3810 
    oprot.trans.flush()
3811 
 
2981 rajveer 3812 
  def process_getUserNotes(self, seqid, iprot, oprot):
3813 
    args = getUserNotes_args()
559 chandransh 3814 
    args.read(iprot)
3815 
    iprot.readMessageEnd()
2981 rajveer 3816 
    result = getUserNotes_result()
3817 
    result.success = self._handler.getUserNotes(args.user_id, args.entity_id)
3818 
    oprot.writeMessageBegin("getUserNotes", TMessageType.REPLY, seqid)
559 chandransh 3819 
    result.write(oprot)
3820 
    oprot.writeMessageEnd()
3821 
    oprot.trans.flush()
3822 
 
2981 rajveer 3823 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
3824 
    args = getMyResearchItems_args()
559 chandransh 3825 
    args.read(iprot)
3826 
    iprot.readMessageEnd()
2981 rajveer 3827 
    result = getMyResearchItems_result()
559 chandransh 3828 
    try:
2981 rajveer 3829 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 3830 
    except WidgetException, scx:
3831 
      result.scx = scx
2981 rajveer 3832 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 3833 
    result.write(oprot)
3834 
    oprot.writeMessageEnd()
3835 
    oprot.trans.flush()
3836 
 
2981 rajveer 3837 
  def process_updateMyResearch(self, seqid, iprot, oprot):
3838 
    args = updateMyResearch_args()
772 rajveer 3839 
    args.read(iprot)
3840 
    iprot.readMessageEnd()
2981 rajveer 3841 
    result = updateMyResearch_result()
3842 
    try:
3843 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
3844 
    except WidgetException, scx:
3845 
      result.scx = scx
3846 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 3847 
    result.write(oprot)
3848 
    oprot.writeMessageEnd()
3849 
    oprot.trans.flush()
559 chandransh 3850 
 
2981 rajveer 3851 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
3852 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 3853 
    args.read(iprot)
3854 
    iprot.readMessageEnd()
2981 rajveer 3855 
    result = deleteItemFromMyResearch_result()
3856 
    try:
3857 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
3858 
    except WidgetException, scx:
3859 
      result.scx = scx
3860 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 3861 
    result.write(oprot)
3862 
    oprot.writeMessageEnd()
3863 
    oprot.trans.flush()
772 rajveer 3864 
 
2981 rajveer 3865 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
3866 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 3867 
    args.read(iprot)
3868 
    iprot.readMessageEnd()
2981 rajveer 3869 
    result = getBrowseHistoryItems_result()
3870 
    try:
3871 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
3872 
    except WidgetException, scx:
3873 
      result.scx = scx
3874 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 3875 
    result.write(oprot)
3876 
    oprot.writeMessageEnd()
3877 
    oprot.trans.flush()
1596 ankur.sing 3878 
 
2981 rajveer 3879 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
3880 
    args = updateBrowseHistory_args()
2642 varun.gupt 3881 
    args.read(iprot)
3882 
    iprot.readMessageEnd()
2981 rajveer 3883 
    result = updateBrowseHistory_result()
3884 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
3885 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 3886 
    result.write(oprot)
3887 
    oprot.writeMessageEnd()
3888 
    oprot.trans.flush()
1673 ankur.sing 3889 
 
2642 varun.gupt 3890 
 
94 ashish 3891 
# HELPER FUNCTIONS AND STRUCTURES
3892 
 
765 rajveer 3893 
class closeSession_args:
3894 
 
3895 
  thrift_spec = (
3896 
  )
3897 
 
3898 
  def read(self, iprot):
3899 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3900 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3901 
      return
3902 
    iprot.readStructBegin()
3903 
    while True:
3904 
      (fname, ftype, fid) = iprot.readFieldBegin()
3905 
      if ftype == TType.STOP:
3906 
        break
3907 
      else:
3908 
        iprot.skip(ftype)
3909 
      iprot.readFieldEnd()
3910 
    iprot.readStructEnd()
3911 
 
3912 
  def write(self, oprot):
3913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3915 
      return
3916 
    oprot.writeStructBegin('closeSession_args')
3917 
    oprot.writeFieldStop()
3918 
    oprot.writeStructEnd()
3919 
 
3920 
  def __repr__(self):
3921 
    L = ['%s=%r' % (key, value)
3922 
      for key, value in self.__dict__.iteritems()]
3923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3924 
 
3925 
  def __eq__(self, other):
3926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3927 
 
3928 
  def __ne__(self, other):
3929 
    return not (self == other)
3930 
 
3931 
class closeSession_result:
3932 
 
3933 
  thrift_spec = (
3934 
  )
3935 
 
3936 
  def read(self, iprot):
3937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3939 
      return
3940 
    iprot.readStructBegin()
3941 
    while True:
3942 
      (fname, ftype, fid) = iprot.readFieldBegin()
3943 
      if ftype == TType.STOP:
3944 
        break
3945 
      else:
3946 
        iprot.skip(ftype)
3947 
      iprot.readFieldEnd()
3948 
    iprot.readStructEnd()
3949 
 
3950 
  def write(self, oprot):
3951 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3952 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3953 
      return
3954 
    oprot.writeStructBegin('closeSession_result')
3955 
    oprot.writeFieldStop()
3956 
    oprot.writeStructEnd()
3957 
 
3958 
  def __repr__(self):
3959 
    L = ['%s=%r' % (key, value)
3960 
      for key, value in self.__dict__.iteritems()]
3961 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3962 
 
3963 
  def __eq__(self, other):
3964 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3965 
 
3966 
  def __ne__(self, other):
3967 
    return not (self == other)
3968 
 
559 chandransh 3969 
class createAnonymousUser_args:
94 ashish 3970 
  """
3971 
  Attributes:
559 chandransh 3972 
   - jsessionId
94 ashish 3973 
  """
3974 
 
3975 
  thrift_spec = (
3976 
    None, # 0
559 chandransh 3977 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 3978 
  )
3979 
 
559 chandransh 3980 
  def __init__(self, jsessionId=None,):
3981 
    self.jsessionId = jsessionId
94 ashish 3982 
 
3983 
  def read(self, iprot):
3984 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3985 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3986 
      return
3987 
    iprot.readStructBegin()
3988 
    while True:
3989 
      (fname, ftype, fid) = iprot.readFieldBegin()
3990 
      if ftype == TType.STOP:
3991 
        break
3992 
      if fid == 1:
559 chandransh 3993 
        if ftype == TType.STRING:
3994 
          self.jsessionId = iprot.readString();
94 ashish 3995 
        else:
3996 
          iprot.skip(ftype)
3997 
      else:
3998 
        iprot.skip(ftype)
3999 
      iprot.readFieldEnd()
4000 
    iprot.readStructEnd()
4001 
 
4002 
  def write(self, oprot):
4003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4005 
      return
559 chandransh 4006 
    oprot.writeStructBegin('createAnonymousUser_args')
4007 
    if self.jsessionId != None:
4008 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
4009 
      oprot.writeString(self.jsessionId)
94 ashish 4010 
      oprot.writeFieldEnd()
4011 
    oprot.writeFieldStop()
4012 
    oprot.writeStructEnd()
4013 
 
4014 
  def __repr__(self):
4015 
    L = ['%s=%r' % (key, value)
4016 
      for key, value in self.__dict__.iteritems()]
4017 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4018 
 
4019 
  def __eq__(self, other):
4020 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4021 
 
4022 
  def __ne__(self, other):
4023 
    return not (self == other)
4024 
 
559 chandransh 4025 
class createAnonymousUser_result:
94 ashish 4026 
  """
4027 
  Attributes:
4028 
   - success
559 chandransh 4029 
   - ucex
94 ashish 4030 
  """
4031 
 
4032 
  thrift_spec = (
559 chandransh 4033 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4034 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4035 
  )
4036 
 
559 chandransh 4037 
  def __init__(self, success=None, ucex=None,):
94 ashish 4038 
    self.success = success
559 chandransh 4039 
    self.ucex = ucex
94 ashish 4040 
 
4041 
  def read(self, iprot):
4042 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4043 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4044 
      return
4045 
    iprot.readStructBegin()
4046 
    while True:
4047 
      (fname, ftype, fid) = iprot.readFieldBegin()
4048 
      if ftype == TType.STOP:
4049 
        break
4050 
      if fid == 0:
4051 
        if ftype == TType.STRUCT:
559 chandransh 4052 
          self.success = User()
94 ashish 4053 
          self.success.read(iprot)
4054 
        else:
4055 
          iprot.skip(ftype)
4056 
      elif fid == 1:
4057 
        if ftype == TType.STRUCT:
559 chandransh 4058 
          self.ucex = UserContextException()
4059 
          self.ucex.read(iprot)
94 ashish 4060 
        else:
4061 
          iprot.skip(ftype)
4062 
      else:
4063 
        iprot.skip(ftype)
4064 
      iprot.readFieldEnd()
4065 
    iprot.readStructEnd()
4066 
 
4067 
  def write(self, oprot):
4068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4070 
      return
559 chandransh 4071 
    oprot.writeStructBegin('createAnonymousUser_result')
94 ashish 4072 
    if self.success != None:
4073 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4074 
      self.success.write(oprot)
4075 
      oprot.writeFieldEnd()
559 chandransh 4076 
    if self.ucex != None:
4077 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4078 
      self.ucex.write(oprot)
94 ashish 4079 
      oprot.writeFieldEnd()
4080 
    oprot.writeFieldStop()
4081 
    oprot.writeStructEnd()
4082 
 
4083 
  def __repr__(self):
4084 
    L = ['%s=%r' % (key, value)
4085 
      for key, value in self.__dict__.iteritems()]
4086 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4087 
 
4088 
  def __eq__(self, other):
4089 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4090 
 
4091 
  def __ne__(self, other):
4092 
    return not (self == other)
4093 
 
559 chandransh 4094 
class getUserById_args:
94 ashish 4095 
  """
4096 
  Attributes:
4097 
   - userId
4098 
  """
4099 
 
4100 
  thrift_spec = (
4101 
    None, # 0
4102 
    (1, TType.I64, 'userId', None, None, ), # 1
4103 
  )
4104 
 
559 chandransh 4105 
  def __init__(self, userId=None,):
94 ashish 4106 
    self.userId = userId
4107 
 
4108 
  def read(self, iprot):
4109 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4110 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4111 
      return
4112 
    iprot.readStructBegin()
4113 
    while True:
4114 
      (fname, ftype, fid) = iprot.readFieldBegin()
4115 
      if ftype == TType.STOP:
4116 
        break
4117 
      if fid == 1:
4118 
        if ftype == TType.I64:
4119 
          self.userId = iprot.readI64();
4120 
        else:
4121 
          iprot.skip(ftype)
4122 
      else:
4123 
        iprot.skip(ftype)
4124 
      iprot.readFieldEnd()
4125 
    iprot.readStructEnd()
4126 
 
4127 
  def write(self, oprot):
4128 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4129 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4130 
      return
559 chandransh 4131 
    oprot.writeStructBegin('getUserById_args')
94 ashish 4132 
    if self.userId != None:
4133 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4134 
      oprot.writeI64(self.userId)
4135 
      oprot.writeFieldEnd()
4136 
    oprot.writeFieldStop()
4137 
    oprot.writeStructEnd()
4138 
 
4139 
  def __repr__(self):
4140 
    L = ['%s=%r' % (key, value)
4141 
      for key, value in self.__dict__.iteritems()]
4142 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4143 
 
4144 
  def __eq__(self, other):
4145 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4146 
 
4147 
  def __ne__(self, other):
4148 
    return not (self == other)
4149 
 
559 chandransh 4150 
class getUserById_result:
94 ashish 4151 
  """
4152 
  Attributes:
4153 
   - success
559 chandransh 4154 
   - ucex
94 ashish 4155 
  """
4156 
 
4157 
  thrift_spec = (
559 chandransh 4158 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4159 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4160 
  )
4161 
 
559 chandransh 4162 
  def __init__(self, success=None, ucex=None,):
94 ashish 4163 
    self.success = success
559 chandransh 4164 
    self.ucex = ucex
94 ashish 4165 
 
4166 
  def read(self, iprot):
4167 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4168 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4169 
      return
4170 
    iprot.readStructBegin()
4171 
    while True:
4172 
      (fname, ftype, fid) = iprot.readFieldBegin()
4173 
      if ftype == TType.STOP:
4174 
        break
4175 
      if fid == 0:
4176 
        if ftype == TType.STRUCT:
559 chandransh 4177 
          self.success = User()
94 ashish 4178 
          self.success.read(iprot)
4179 
        else:
4180 
          iprot.skip(ftype)
4181 
      elif fid == 1:
4182 
        if ftype == TType.STRUCT:
559 chandransh 4183 
          self.ucex = UserContextException()
4184 
          self.ucex.read(iprot)
94 ashish 4185 
        else:
4186 
          iprot.skip(ftype)
4187 
      else:
4188 
        iprot.skip(ftype)
4189 
      iprot.readFieldEnd()
4190 
    iprot.readStructEnd()
4191 
 
4192 
  def write(self, oprot):
4193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4195 
      return
559 chandransh 4196 
    oprot.writeStructBegin('getUserById_result')
94 ashish 4197 
    if self.success != None:
4198 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4199 
      self.success.write(oprot)
4200 
      oprot.writeFieldEnd()
559 chandransh 4201 
    if self.ucex != None:
4202 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4203 
      self.ucex.write(oprot)
94 ashish 4204 
      oprot.writeFieldEnd()
4205 
    oprot.writeFieldStop()
4206 
    oprot.writeStructEnd()
4207 
 
4208 
  def __repr__(self):
4209 
    L = ['%s=%r' % (key, value)
4210 
      for key, value in self.__dict__.iteritems()]
4211 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4212 
 
4213 
  def __eq__(self, other):
4214 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4215 
 
4216 
  def __ne__(self, other):
4217 
    return not (self == other)
4218 
 
1491 vikas 4219 
class getUserByEmail_args:
4220 
  """
4221 
  Attributes:
4222 
   - email
4223 
  """
4224 
 
4225 
  thrift_spec = (
4226 
    None, # 0
4227 
    (1, TType.STRING, 'email', None, None, ), # 1
4228 
  )
4229 
 
4230 
  def __init__(self, email=None,):
4231 
    self.email = email
4232 
 
4233 
  def read(self, iprot):
4234 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4235 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4236 
      return
4237 
    iprot.readStructBegin()
4238 
    while True:
4239 
      (fname, ftype, fid) = iprot.readFieldBegin()
4240 
      if ftype == TType.STOP:
4241 
        break
4242 
      if fid == 1:
4243 
        if ftype == TType.STRING:
4244 
          self.email = iprot.readString();
4245 
        else:
4246 
          iprot.skip(ftype)
4247 
      else:
4248 
        iprot.skip(ftype)
4249 
      iprot.readFieldEnd()
4250 
    iprot.readStructEnd()
4251 
 
4252 
  def write(self, oprot):
4253 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4254 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4255 
      return
4256 
    oprot.writeStructBegin('getUserByEmail_args')
4257 
    if self.email != None:
4258 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4259 
      oprot.writeString(self.email)
4260 
      oprot.writeFieldEnd()
4261 
    oprot.writeFieldStop()
4262 
    oprot.writeStructEnd()
4263 
 
4264 
  def __repr__(self):
4265 
    L = ['%s=%r' % (key, value)
4266 
      for key, value in self.__dict__.iteritems()]
4267 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4268 
 
4269 
  def __eq__(self, other):
4270 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4271 
 
4272 
  def __ne__(self, other):
4273 
    return not (self == other)
4274 
 
4275 
class getUserByEmail_result:
4276 
  """
4277 
  Attributes:
4278 
   - success
4279 
   - ucex
4280 
  """
4281 
 
4282 
  thrift_spec = (
4283 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4284 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4285 
  )
4286 
 
4287 
  def __init__(self, success=None, ucex=None,):
4288 
    self.success = success
4289 
    self.ucex = ucex
4290 
 
4291 
  def read(self, iprot):
4292 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4293 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4294 
      return
4295 
    iprot.readStructBegin()
4296 
    while True:
4297 
      (fname, ftype, fid) = iprot.readFieldBegin()
4298 
      if ftype == TType.STOP:
4299 
        break
4300 
      if fid == 0:
4301 
        if ftype == TType.STRUCT:
4302 
          self.success = User()
4303 
          self.success.read(iprot)
4304 
        else:
4305 
          iprot.skip(ftype)
4306 
      elif fid == 1:
4307 
        if ftype == TType.STRUCT:
4308 
          self.ucex = UserContextException()
4309 
          self.ucex.read(iprot)
4310 
        else:
4311 
          iprot.skip(ftype)
4312 
      else:
4313 
        iprot.skip(ftype)
4314 
      iprot.readFieldEnd()
4315 
    iprot.readStructEnd()
4316 
 
4317 
  def write(self, oprot):
4318 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4319 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4320 
      return
4321 
    oprot.writeStructBegin('getUserByEmail_result')
4322 
    if self.success != None:
4323 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4324 
      self.success.write(oprot)
4325 
      oprot.writeFieldEnd()
4326 
    if self.ucex != None:
4327 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4328 
      self.ucex.write(oprot)
4329 
      oprot.writeFieldEnd()
4330 
    oprot.writeFieldStop()
4331 
    oprot.writeStructEnd()
4332 
 
4333 
  def __repr__(self):
4334 
    L = ['%s=%r' % (key, value)
4335 
      for key, value in self.__dict__.iteritems()]
4336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4337 
 
4338 
  def __eq__(self, other):
4339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4340 
 
4341 
  def __ne__(self, other):
4342 
    return not (self == other)
4343 
 
3032 mandeep.dh 4344 
class getUserByMobileNumber_args:
4345 
  """
4346 
  Attributes:
4347 
   - mobileNumber
4348 
  """
4349 
 
4350 
  thrift_spec = (
4351 
    None, # 0
4352 
    (1, TType.I64, 'mobileNumber', None, None, ), # 1
4353 
  )
4354 
 
4355 
  def __init__(self, mobileNumber=None,):
4356 
    self.mobileNumber = mobileNumber
4357 
 
4358 
  def read(self, iprot):
4359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4361 
      return
4362 
    iprot.readStructBegin()
4363 
    while True:
4364 
      (fname, ftype, fid) = iprot.readFieldBegin()
4365 
      if ftype == TType.STOP:
4366 
        break
4367 
      if fid == 1:
4368 
        if ftype == TType.I64:
4369 
          self.mobileNumber = iprot.readI64();
4370 
        else:
4371 
          iprot.skip(ftype)
4372 
      else:
4373 
        iprot.skip(ftype)
4374 
      iprot.readFieldEnd()
4375 
    iprot.readStructEnd()
4376 
 
4377 
  def write(self, oprot):
4378 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4379 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4380 
      return
4381 
    oprot.writeStructBegin('getUserByMobileNumber_args')
4382 
    if self.mobileNumber != None:
4383 
      oprot.writeFieldBegin('mobileNumber', TType.I64, 1)
4384 
      oprot.writeI64(self.mobileNumber)
4385 
      oprot.writeFieldEnd()
4386 
    oprot.writeFieldStop()
4387 
    oprot.writeStructEnd()
4388 
 
4389 
  def __repr__(self):
4390 
    L = ['%s=%r' % (key, value)
4391 
      for key, value in self.__dict__.iteritems()]
4392 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4393 
 
4394 
  def __eq__(self, other):
4395 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4396 
 
4397 
  def __ne__(self, other):
4398 
    return not (self == other)
4399 
 
4400 
class getUserByMobileNumber_result:
4401 
  """
4402 
  Attributes:
4403 
   - success
4404 
   - ucex
4405 
  """
4406 
 
4407 
  thrift_spec = (
4408 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4409 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4410 
  )
4411 
 
4412 
  def __init__(self, success=None, ucex=None,):
4413 
    self.success = success
4414 
    self.ucex = ucex
4415 
 
4416 
  def read(self, iprot):
4417 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4418 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4419 
      return
4420 
    iprot.readStructBegin()
4421 
    while True:
4422 
      (fname, ftype, fid) = iprot.readFieldBegin()
4423 
      if ftype == TType.STOP:
4424 
        break
4425 
      if fid == 0:
4426 
        if ftype == TType.STRUCT:
4427 
          self.success = User()
4428 
          self.success.read(iprot)
4429 
        else:
4430 
          iprot.skip(ftype)
4431 
      elif fid == 1:
4432 
        if ftype == TType.STRUCT:
4433 
          self.ucex = UserContextException()
4434 
          self.ucex.read(iprot)
4435 
        else:
4436 
          iprot.skip(ftype)
4437 
      else:
4438 
        iprot.skip(ftype)
4439 
      iprot.readFieldEnd()
4440 
    iprot.readStructEnd()
4441 
 
4442 
  def write(self, oprot):
4443 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4444 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4445 
      return
4446 
    oprot.writeStructBegin('getUserByMobileNumber_result')
4447 
    if self.success != None:
4448 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4449 
      self.success.write(oprot)
4450 
      oprot.writeFieldEnd()
4451 
    if self.ucex != None:
4452 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4453 
      self.ucex.write(oprot)
4454 
      oprot.writeFieldEnd()
4455 
    oprot.writeFieldStop()
4456 
    oprot.writeStructEnd()
4457 
 
4458 
  def __repr__(self):
4459 
    L = ['%s=%r' % (key, value)
4460 
      for key, value in self.__dict__.iteritems()]
4461 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4462 
 
4463 
  def __eq__(self, other):
4464 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4465 
 
4466 
  def __ne__(self, other):
4467 
    return not (self == other)
4468 
 
559 chandransh 4469 
class createUser_args:
94 ashish 4470 
  """
4471 
  Attributes:
559 chandransh 4472 
   - user
94 ashish 4473 
  """
4474 
 
4475 
  thrift_spec = (
4476 
    None, # 0
559 chandransh 4477 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4478 
  )
4479 
 
559 chandransh 4480 
  def __init__(self, user=None,):
4481 
    self.user = user
94 ashish 4482 
 
4483 
  def read(self, iprot):
4484 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4485 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4486 
      return
4487 
    iprot.readStructBegin()
4488 
    while True:
4489 
      (fname, ftype, fid) = iprot.readFieldBegin()
4490 
      if ftype == TType.STOP:
4491 
        break
4492 
      if fid == 1:
559 chandransh 4493 
        if ftype == TType.STRUCT:
4494 
          self.user = User()
4495 
          self.user.read(iprot)
94 ashish 4496 
        else:
4497 
          iprot.skip(ftype)
4498 
      else:
4499 
        iprot.skip(ftype)
4500 
      iprot.readFieldEnd()
4501 
    iprot.readStructEnd()
4502 
 
4503 
  def write(self, oprot):
4504 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4505 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4506 
      return
559 chandransh 4507 
    oprot.writeStructBegin('createUser_args')
4508 
    if self.user != None:
4509 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4510 
      self.user.write(oprot)
94 ashish 4511 
      oprot.writeFieldEnd()
4512 
    oprot.writeFieldStop()
4513 
    oprot.writeStructEnd()
4514 
 
4515 
  def __repr__(self):
4516 
    L = ['%s=%r' % (key, value)
4517 
      for key, value in self.__dict__.iteritems()]
4518 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4519 
 
4520 
  def __eq__(self, other):
4521 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4522 
 
4523 
  def __ne__(self, other):
4524 
    return not (self == other)
4525 
 
559 chandransh 4526 
class createUser_result:
94 ashish 4527 
  """
4528 
  Attributes:
4529 
   - success
559 chandransh 4530 
   - ucex
94 ashish 4531 
  """
4532 
 
4533 
  thrift_spec = (
559 chandransh 4534 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4535 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4536 
  )
4537 
 
559 chandransh 4538 
  def __init__(self, success=None, ucex=None,):
94 ashish 4539 
    self.success = success
559 chandransh 4540 
    self.ucex = ucex
94 ashish 4541 
 
4542 
  def read(self, iprot):
4543 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4544 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4545 
      return
4546 
    iprot.readStructBegin()
4547 
    while True:
4548 
      (fname, ftype, fid) = iprot.readFieldBegin()
4549 
      if ftype == TType.STOP:
4550 
        break
4551 
      if fid == 0:
4552 
        if ftype == TType.STRUCT:
559 chandransh 4553 
          self.success = User()
94 ashish 4554 
          self.success.read(iprot)
4555 
        else:
4556 
          iprot.skip(ftype)
4557 
      elif fid == 1:
4558 
        if ftype == TType.STRUCT:
559 chandransh 4559 
          self.ucex = UserContextException()
4560 
          self.ucex.read(iprot)
94 ashish 4561 
        else:
4562 
          iprot.skip(ftype)
4563 
      else:
4564 
        iprot.skip(ftype)
4565 
      iprot.readFieldEnd()
4566 
    iprot.readStructEnd()
4567 
 
4568 
  def write(self, oprot):
4569 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4570 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4571 
      return
559 chandransh 4572 
    oprot.writeStructBegin('createUser_result')
94 ashish 4573 
    if self.success != None:
4574 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4575 
      self.success.write(oprot)
4576 
      oprot.writeFieldEnd()
559 chandransh 4577 
    if self.ucex != None:
4578 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4579 
      self.ucex.write(oprot)
94 ashish 4580 
      oprot.writeFieldEnd()
4581 
    oprot.writeFieldStop()
4582 
    oprot.writeStructEnd()
4583 
 
4584 
  def __repr__(self):
4585 
    L = ['%s=%r' % (key, value)
4586 
      for key, value in self.__dict__.iteritems()]
4587 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4588 
 
4589 
  def __eq__(self, other):
4590 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4591 
 
4592 
  def __ne__(self, other):
4593 
    return not (self == other)
4594 
 
559 chandransh 4595 
class updateUser_args:
94 ashish 4596 
  """
4597 
  Attributes:
559 chandransh 4598 
   - user
94 ashish 4599 
  """
4600 
 
4601 
  thrift_spec = (
4602 
    None, # 0
559 chandransh 4603 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4604 
  )
4605 
 
559 chandransh 4606 
  def __init__(self, user=None,):
4607 
    self.user = user
94 ashish 4608 
 
4609 
  def read(self, iprot):
4610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4612 
      return
4613 
    iprot.readStructBegin()
4614 
    while True:
4615 
      (fname, ftype, fid) = iprot.readFieldBegin()
4616 
      if ftype == TType.STOP:
4617 
        break
4618 
      if fid == 1:
559 chandransh 4619 
        if ftype == TType.STRUCT:
4620 
          self.user = User()
4621 
          self.user.read(iprot)
94 ashish 4622 
        else:
4623 
          iprot.skip(ftype)
4624 
      else:
4625 
        iprot.skip(ftype)
4626 
      iprot.readFieldEnd()
4627 
    iprot.readStructEnd()
4628 
 
4629 
  def write(self, oprot):
4630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4632 
      return
559 chandransh 4633 
    oprot.writeStructBegin('updateUser_args')
4634 
    if self.user != None:
4635 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4636 
      self.user.write(oprot)
94 ashish 4637 
      oprot.writeFieldEnd()
4638 
    oprot.writeFieldStop()
4639 
    oprot.writeStructEnd()
4640 
 
4641 
  def __repr__(self):
4642 
    L = ['%s=%r' % (key, value)
4643 
      for key, value in self.__dict__.iteritems()]
4644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4645 
 
4646 
  def __eq__(self, other):
4647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4648 
 
4649 
  def __ne__(self, other):
4650 
    return not (self == other)
4651 
 
559 chandransh 4652 
class updateUser_result:
94 ashish 4653 
  """
4654 
  Attributes:
4655 
   - success
559 chandransh 4656 
   - ucex
94 ashish 4657 
  """
4658 
 
4659 
  thrift_spec = (
559 chandransh 4660 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4661 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4662 
  )
4663 
 
559 chandransh 4664 
  def __init__(self, success=None, ucex=None,):
94 ashish 4665 
    self.success = success
559 chandransh 4666 
    self.ucex = ucex
94 ashish 4667 
 
4668 
  def read(self, iprot):
4669 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4670 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4671 
      return
4672 
    iprot.readStructBegin()
4673 
    while True:
4674 
      (fname, ftype, fid) = iprot.readFieldBegin()
4675 
      if ftype == TType.STOP:
4676 
        break
4677 
      if fid == 0:
4678 
        if ftype == TType.STRUCT:
559 chandransh 4679 
          self.success = User()
94 ashish 4680 
          self.success.read(iprot)
4681 
        else:
4682 
          iprot.skip(ftype)
4683 
      elif fid == 1:
4684 
        if ftype == TType.STRUCT:
559 chandransh 4685 
          self.ucex = UserContextException()
4686 
          self.ucex.read(iprot)
94 ashish 4687 
        else:
4688 
          iprot.skip(ftype)
4689 
      else:
4690 
        iprot.skip(ftype)
4691 
      iprot.readFieldEnd()
4692 
    iprot.readStructEnd()
4693 
 
4694 
  def write(self, oprot):
4695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4697 
      return
559 chandransh 4698 
    oprot.writeStructBegin('updateUser_result')
94 ashish 4699 
    if self.success != None:
4700 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4701 
      self.success.write(oprot)
4702 
      oprot.writeFieldEnd()
559 chandransh 4703 
    if self.ucex != None:
4704 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4705 
      self.ucex.write(oprot)
94 ashish 4706 
      oprot.writeFieldEnd()
4707 
    oprot.writeFieldStop()
4708 
    oprot.writeStructEnd()
4709 
 
4710 
  def __repr__(self):
4711 
    L = ['%s=%r' % (key, value)
4712 
      for key, value in self.__dict__.iteritems()]
4713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4714 
 
4715 
  def __eq__(self, other):
4716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4717 
 
4718 
  def __ne__(self, other):
4719 
    return not (self == other)
4720 
 
559 chandransh 4721 
class deleteUser_args:
94 ashish 4722 
  """
4723 
  Attributes:
4724 
   - userId
4725 
  """
4726 
 
4727 
  thrift_spec = (
4728 
    None, # 0
4729 
    (1, TType.I64, 'userId', None, None, ), # 1
4730 
  )
4731 
 
559 chandransh 4732 
  def __init__(self, userId=None,):
94 ashish 4733 
    self.userId = userId
4734 
 
4735 
  def read(self, iprot):
4736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4738 
      return
4739 
    iprot.readStructBegin()
4740 
    while True:
4741 
      (fname, ftype, fid) = iprot.readFieldBegin()
4742 
      if ftype == TType.STOP:
4743 
        break
4744 
      if fid == 1:
4745 
        if ftype == TType.I64:
4746 
          self.userId = iprot.readI64();
4747 
        else:
4748 
          iprot.skip(ftype)
4749 
      else:
4750 
        iprot.skip(ftype)
4751 
      iprot.readFieldEnd()
4752 
    iprot.readStructEnd()
4753 
 
4754 
  def write(self, oprot):
4755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4757 
      return
559 chandransh 4758 
    oprot.writeStructBegin('deleteUser_args')
94 ashish 4759 
    if self.userId != None:
4760 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4761 
      oprot.writeI64(self.userId)
4762 
      oprot.writeFieldEnd()
4763 
    oprot.writeFieldStop()
4764 
    oprot.writeStructEnd()
4765 
 
4766 
  def __repr__(self):
4767 
    L = ['%s=%r' % (key, value)
4768 
      for key, value in self.__dict__.iteritems()]
4769 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4770 
 
4771 
  def __eq__(self, other):
4772 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4773 
 
4774 
  def __ne__(self, other):
4775 
    return not (self == other)
4776 
 
559 chandransh 4777 
class deleteUser_result:
94 ashish 4778 
  """
4779 
  Attributes:
4780 
   - success
559 chandransh 4781 
   - ucex
94 ashish 4782 
  """
4783 
 
4784 
  thrift_spec = (
559 chandransh 4785 
    (0, TType.BOOL, 'success', None, None, ), # 0
4786 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4787 
  )
4788 
 
559 chandransh 4789 
  def __init__(self, success=None, ucex=None,):
94 ashish 4790 
    self.success = success
559 chandransh 4791 
    self.ucex = ucex
94 ashish 4792 
 
4793 
  def read(self, iprot):
4794 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4795 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4796 
      return
4797 
    iprot.readStructBegin()
4798 
    while True:
4799 
      (fname, ftype, fid) = iprot.readFieldBegin()
4800 
      if ftype == TType.STOP:
4801 
        break
4802 
      if fid == 0:
559 chandransh 4803 
        if ftype == TType.BOOL:
4804 
          self.success = iprot.readBool();
94 ashish 4805 
        else:
4806 
          iprot.skip(ftype)
4807 
      elif fid == 1:
4808 
        if ftype == TType.STRUCT:
559 chandransh 4809 
          self.ucex = UserContextException()
4810 
          self.ucex.read(iprot)
94 ashish 4811 
        else:
4812 
          iprot.skip(ftype)
4813 
      else:
4814 
        iprot.skip(ftype)
4815 
      iprot.readFieldEnd()
4816 
    iprot.readStructEnd()
4817 
 
4818 
  def write(self, oprot):
4819 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4820 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4821 
      return
559 chandransh 4822 
    oprot.writeStructBegin('deleteUser_result')
94 ashish 4823 
    if self.success != None:
559 chandransh 4824 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4825 
      oprot.writeBool(self.success)
94 ashish 4826 
      oprot.writeFieldEnd()
559 chandransh 4827 
    if self.ucex != None:
4828 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4829 
      self.ucex.write(oprot)
94 ashish 4830 
      oprot.writeFieldEnd()
4831 
    oprot.writeFieldStop()
4832 
    oprot.writeStructEnd()
4833 
 
4834 
  def __repr__(self):
4835 
    L = ['%s=%r' % (key, value)
4836 
      for key, value in self.__dict__.iteritems()]
4837 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4838 
 
4839 
  def __eq__(self, other):
4840 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4841 
 
4842 
  def __ne__(self, other):
4843 
    return not (self == other)
4844 
 
559 chandransh 4845 
class getUserState_args:
94 ashish 4846 
  """
4847 
  Attributes:
4848 
   - userId
4849 
  """
4850 
 
4851 
  thrift_spec = (
4852 
    None, # 0
4853 
    (1, TType.I64, 'userId', None, None, ), # 1
4854 
  )
4855 
 
559 chandransh 4856 
  def __init__(self, userId=None,):
94 ashish 4857 
    self.userId = userId
4858 
 
4859 
  def read(self, iprot):
4860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4862 
      return
4863 
    iprot.readStructBegin()
4864 
    while True:
4865 
      (fname, ftype, fid) = iprot.readFieldBegin()
4866 
      if ftype == TType.STOP:
4867 
        break
4868 
      if fid == 1:
4869 
        if ftype == TType.I64:
4870 
          self.userId = iprot.readI64();
4871 
        else:
4872 
          iprot.skip(ftype)
4873 
      else:
4874 
        iprot.skip(ftype)
4875 
      iprot.readFieldEnd()
4876 
    iprot.readStructEnd()
4877 
 
4878 
  def write(self, oprot):
4879 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4880 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4881 
      return
559 chandransh 4882 
    oprot.writeStructBegin('getUserState_args')
94 ashish 4883 
    if self.userId != None:
4884 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4885 
      oprot.writeI64(self.userId)
4886 
      oprot.writeFieldEnd()
4887 
    oprot.writeFieldStop()
4888 
    oprot.writeStructEnd()
4889 
 
4890 
  def __repr__(self):
4891 
    L = ['%s=%r' % (key, value)
4892 
      for key, value in self.__dict__.iteritems()]
4893 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4894 
 
4895 
  def __eq__(self, other):
4896 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4897 
 
4898 
  def __ne__(self, other):
4899 
    return not (self == other)
4900 
 
559 chandransh 4901 
class getUserState_result:
94 ashish 4902 
  """
4903 
  Attributes:
4904 
   - success
559 chandransh 4905 
   - ucex
94 ashish 4906 
  """
4907 
 
4908 
  thrift_spec = (
559 chandransh 4909 
    (0, TType.STRUCT, 'success', (UserState, UserState.thrift_spec), None, ), # 0
4910 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4911 
  )
4912 
 
559 chandransh 4913 
  def __init__(self, success=None, ucex=None,):
94 ashish 4914 
    self.success = success
559 chandransh 4915 
    self.ucex = ucex
94 ashish 4916 
 
4917 
  def read(self, iprot):
4918 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4919 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4920 
      return
4921 
    iprot.readStructBegin()
4922 
    while True:
4923 
      (fname, ftype, fid) = iprot.readFieldBegin()
4924 
      if ftype == TType.STOP:
4925 
        break
4926 
      if fid == 0:
4927 
        if ftype == TType.STRUCT:
559 chandransh 4928 
          self.success = UserState()
94 ashish 4929 
          self.success.read(iprot)
4930 
        else:
4931 
          iprot.skip(ftype)
4932 
      elif fid == 1:
4933 
        if ftype == TType.STRUCT:
559 chandransh 4934 
          self.ucex = UserContextException()
4935 
          self.ucex.read(iprot)
94 ashish 4936 
        else:
4937 
          iprot.skip(ftype)
4938 
      else:
4939 
        iprot.skip(ftype)
4940 
      iprot.readFieldEnd()
4941 
    iprot.readStructEnd()
4942 
 
4943 
  def write(self, oprot):
4944 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4945 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4946 
      return
559 chandransh 4947 
    oprot.writeStructBegin('getUserState_result')
94 ashish 4948 
    if self.success != None:
4949 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4950 
      self.success.write(oprot)
4951 
      oprot.writeFieldEnd()
559 chandransh 4952 
    if self.ucex != None:
4953 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4954 
      self.ucex.write(oprot)
94 ashish 4955 
      oprot.writeFieldEnd()
4956 
    oprot.writeFieldStop()
4957 
    oprot.writeStructEnd()
4958 
 
4959 
  def __repr__(self):
4960 
    L = ['%s=%r' % (key, value)
4961 
      for key, value in self.__dict__.iteritems()]
4962 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4963 
 
4964 
  def __eq__(self, other):
4965 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4966 
 
4967 
  def __ne__(self, other):
4968 
    return not (self == other)
4969 
 
559 chandransh 4970 
class authenticateUser_args:
94 ashish 4971 
  """
4972 
  Attributes:
4973 
   - email
4974 
   - password
4975 
  """
4976 
 
4977 
  thrift_spec = (
4978 
    None, # 0
4979 
    (1, TType.STRING, 'email', None, None, ), # 1
4980 
    (2, TType.STRING, 'password', None, None, ), # 2
4981 
  )
4982 
 
4983 
  def __init__(self, email=None, password=None,):
4984 
    self.email = email
4985 
    self.password = password
4986 
 
4987 
  def read(self, iprot):
4988 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4989 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4990 
      return
4991 
    iprot.readStructBegin()
4992 
    while True:
4993 
      (fname, ftype, fid) = iprot.readFieldBegin()
4994 
      if ftype == TType.STOP:
4995 
        break
4996 
      if fid == 1:
4997 
        if ftype == TType.STRING:
4998 
          self.email = iprot.readString();
4999 
        else:
5000 
          iprot.skip(ftype)
5001 
      elif fid == 2:
5002 
        if ftype == TType.STRING:
5003 
          self.password = iprot.readString();
5004 
        else:
5005 
          iprot.skip(ftype)
5006 
      else:
5007 
        iprot.skip(ftype)
5008 
      iprot.readFieldEnd()
5009 
    iprot.readStructEnd()
5010 
 
5011 
  def write(self, oprot):
5012 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5013 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5014 
      return
559 chandransh 5015 
    oprot.writeStructBegin('authenticateUser_args')
94 ashish 5016 
    if self.email != None:
5017 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5018 
      oprot.writeString(self.email)
5019 
      oprot.writeFieldEnd()
5020 
    if self.password != None:
5021 
      oprot.writeFieldBegin('password', TType.STRING, 2)
5022 
      oprot.writeString(self.password)
5023 
      oprot.writeFieldEnd()
5024 
    oprot.writeFieldStop()
5025 
    oprot.writeStructEnd()
5026 
 
5027 
  def __repr__(self):
5028 
    L = ['%s=%r' % (key, value)
5029 
      for key, value in self.__dict__.iteritems()]
5030 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5031 
 
5032 
  def __eq__(self, other):
5033 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5034 
 
5035 
  def __ne__(self, other):
5036 
    return not (self == other)
5037 
 
559 chandransh 5038 
class authenticateUser_result:
94 ashish 5039 
  """
5040 
  Attributes:
5041 
   - success
559 chandransh 5042 
   - auex
94 ashish 5043 
  """
5044 
 
5045 
  thrift_spec = (
559 chandransh 5046 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
5047 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 5048 
  )
5049 
 
559 chandransh 5050 
  def __init__(self, success=None, auex=None,):
94 ashish 5051 
    self.success = success
559 chandransh 5052 
    self.auex = auex
94 ashish 5053 
 
5054 
  def read(self, iprot):
5055 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5056 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5057 
      return
5058 
    iprot.readStructBegin()
5059 
    while True:
5060 
      (fname, ftype, fid) = iprot.readFieldBegin()
5061 
      if ftype == TType.STOP:
5062 
        break
5063 
      if fid == 0:
5064 
        if ftype == TType.STRUCT:
559 chandransh 5065 
          self.success = User()
94 ashish 5066 
          self.success.read(iprot)
5067 
        else:
5068 
          iprot.skip(ftype)
5069 
      elif fid == 1:
5070 
        if ftype == TType.STRUCT:
559 chandransh 5071 
          self.auex = AuthenticationException()
5072 
          self.auex.read(iprot)
94 ashish 5073 
        else:
5074 
          iprot.skip(ftype)
5075 
      else:
5076 
        iprot.skip(ftype)
5077 
      iprot.readFieldEnd()
5078 
    iprot.readStructEnd()
5079 
 
5080 
  def write(self, oprot):
5081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5083 
      return
559 chandransh 5084 
    oprot.writeStructBegin('authenticateUser_result')
94 ashish 5085 
    if self.success != None:
5086 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
5087 
      self.success.write(oprot)
5088 
      oprot.writeFieldEnd()
559 chandransh 5089 
    if self.auex != None:
5090 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
5091 
      self.auex.write(oprot)
94 ashish 5092 
      oprot.writeFieldEnd()
5093 
    oprot.writeFieldStop()
5094 
    oprot.writeStructEnd()
5095 
 
5096 
  def __repr__(self):
5097 
    L = ['%s=%r' % (key, value)
5098 
      for key, value in self.__dict__.iteritems()]
5099 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5100 
 
5101 
  def __eq__(self, other):
5102 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5103 
 
5104 
  def __ne__(self, other):
5105 
    return not (self == other)
5106 
 
559 chandransh 5107 
class userExists_args:
122 ashish 5108 
  """
5109 
  Attributes:
559 chandransh 5110 
   - email
122 ashish 5111 
  """
5112 
 
5113 
  thrift_spec = (
5114 
    None, # 0
559 chandransh 5115 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 5116 
  )
5117 
 
559 chandransh 5118 
  def __init__(self, email=None,):
5119 
    self.email = email
122 ashish 5120 
 
5121 
  def read(self, iprot):
5122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5124 
      return
5125 
    iprot.readStructBegin()
5126 
    while True:
5127 
      (fname, ftype, fid) = iprot.readFieldBegin()
5128 
      if ftype == TType.STOP:
5129 
        break
5130 
      if fid == 1:
5131 
        if ftype == TType.STRING:
559 chandransh 5132 
          self.email = iprot.readString();
122 ashish 5133 
        else:
5134 
          iprot.skip(ftype)
559 chandransh 5135 
      else:
5136 
        iprot.skip(ftype)
5137 
      iprot.readFieldEnd()
5138 
    iprot.readStructEnd()
5139 
 
5140 
  def write(self, oprot):
5141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5143 
      return
5144 
    oprot.writeStructBegin('userExists_args')
5145 
    if self.email != None:
5146 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5147 
      oprot.writeString(self.email)
5148 
      oprot.writeFieldEnd()
5149 
    oprot.writeFieldStop()
5150 
    oprot.writeStructEnd()
5151 
 
5152 
  def __repr__(self):
5153 
    L = ['%s=%r' % (key, value)
5154 
      for key, value in self.__dict__.iteritems()]
5155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5156 
 
5157 
  def __eq__(self, other):
5158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5159 
 
5160 
  def __ne__(self, other):
5161 
    return not (self == other)
5162 
 
5163 
class userExists_result:
5164 
  """
5165 
  Attributes:
5166 
   - success
5167 
   - ucx
5168 
  """
5169 
 
5170 
  thrift_spec = (
5171 
    (0, TType.BOOL, 'success', None, None, ), # 0
5172 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5173 
  )
5174 
 
5175 
  def __init__(self, success=None, ucx=None,):
5176 
    self.success = success
5177 
    self.ucx = ucx
5178 
 
5179 
  def read(self, iprot):
5180 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5181 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5182 
      return
5183 
    iprot.readStructBegin()
5184 
    while True:
5185 
      (fname, ftype, fid) = iprot.readFieldBegin()
5186 
      if ftype == TType.STOP:
5187 
        break
5188 
      if fid == 0:
5189 
        if ftype == TType.BOOL:
5190 
          self.success = iprot.readBool();
5191 
        else:
5192 
          iprot.skip(ftype)
5193 
      elif fid == 1:
5194 
        if ftype == TType.STRUCT:
5195 
          self.ucx = UserContextException()
5196 
          self.ucx.read(iprot)
5197 
        else:
5198 
          iprot.skip(ftype)
5199 
      else:
5200 
        iprot.skip(ftype)
5201 
      iprot.readFieldEnd()
5202 
    iprot.readStructEnd()
5203 
 
5204 
  def write(self, oprot):
5205 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5206 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5207 
      return
5208 
    oprot.writeStructBegin('userExists_result')
5209 
    if self.success != None:
5210 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5211 
      oprot.writeBool(self.success)
5212 
      oprot.writeFieldEnd()
5213 
    if self.ucx != None:
5214 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5215 
      self.ucx.write(oprot)
5216 
      oprot.writeFieldEnd()
5217 
    oprot.writeFieldStop()
5218 
    oprot.writeStructEnd()
5219 
 
5220 
  def __repr__(self):
5221 
    L = ['%s=%r' % (key, value)
5222 
      for key, value in self.__dict__.iteritems()]
5223 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5224 
 
5225 
  def __eq__(self, other):
5226 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5227 
 
5228 
  def __ne__(self, other):
5229 
    return not (self == other)
5230 
 
5231 
class addAddressForUser_args:
5232 
  """
5233 
  Attributes:
5234 
   - userId
5235 
   - address
5236 
   - setDefault
5237 
  """
5238 
 
5239 
  thrift_spec = (
5240 
    None, # 0
5241 
    (1, TType.I64, 'userId', None, None, ), # 1
5242 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 5243 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 5244 
  )
5245 
 
567 rajveer 5246 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 5247 
    self.userId = userId
5248 
    self.address = address
5249 
    self.setDefault = setDefault
5250 
 
5251 
  def read(self, iprot):
5252 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5253 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5254 
      return
5255 
    iprot.readStructBegin()
5256 
    while True:
5257 
      (fname, ftype, fid) = iprot.readFieldBegin()
5258 
      if ftype == TType.STOP:
5259 
        break
5260 
      if fid == 1:
5261 
        if ftype == TType.I64:
5262 
          self.userId = iprot.readI64();
5263 
        else:
5264 
          iprot.skip(ftype)
122 ashish 5265 
      elif fid == 2:
559 chandransh 5266 
        if ftype == TType.STRUCT:
5267 
          self.address = Address()
5268 
          self.address.read(iprot)
122 ashish 5269 
        else:
5270 
          iprot.skip(ftype)
5271 
      elif fid == 3:
5272 
        if ftype == TType.BOOL:
559 chandransh 5273 
          self.setDefault = iprot.readBool();
122 ashish 5274 
        else:
5275 
          iprot.skip(ftype)
5276 
      else:
5277 
        iprot.skip(ftype)
5278 
      iprot.readFieldEnd()
5279 
    iprot.readStructEnd()
5280 
 
5281 
  def write(self, oprot):
5282 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5283 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5284 
      return
559 chandransh 5285 
    oprot.writeStructBegin('addAddressForUser_args')
5286 
    if self.userId != None:
5287 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5288 
      oprot.writeI64(self.userId)
122 ashish 5289 
      oprot.writeFieldEnd()
559 chandransh 5290 
    if self.address != None:
5291 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
5292 
      self.address.write(oprot)
122 ashish 5293 
      oprot.writeFieldEnd()
559 chandransh 5294 
    if self.setDefault != None:
567 rajveer 5295 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 5296 
      oprot.writeBool(self.setDefault)
5297 
      oprot.writeFieldEnd()
122 ashish 5298 
    oprot.writeFieldStop()
5299 
    oprot.writeStructEnd()
5300 
 
5301 
  def __repr__(self):
5302 
    L = ['%s=%r' % (key, value)
5303 
      for key, value in self.__dict__.iteritems()]
5304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5305 
 
5306 
  def __eq__(self, other):
5307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5308 
 
5309 
  def __ne__(self, other):
5310 
    return not (self == other)
5311 
 
559 chandransh 5312 
class addAddressForUser_result:
122 ashish 5313 
  """
5314 
  Attributes:
5315 
   - success
559 chandransh 5316 
   - ucx
122 ashish 5317 
  """
5318 
 
5319 
  thrift_spec = (
567 rajveer 5320 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 5321 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 5322 
  )
5323 
 
559 chandransh 5324 
  def __init__(self, success=None, ucx=None,):
122 ashish 5325 
    self.success = success
559 chandransh 5326 
    self.ucx = ucx
122 ashish 5327 
 
5328 
  def read(self, iprot):
5329 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5330 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5331 
      return
5332 
    iprot.readStructBegin()
5333 
    while True:
5334 
      (fname, ftype, fid) = iprot.readFieldBegin()
5335 
      if ftype == TType.STOP:
5336 
        break
5337 
      if fid == 0:
567 rajveer 5338 
        if ftype == TType.I64:
5339 
          self.success = iprot.readI64();
122 ashish 5340 
        else:
5341 
          iprot.skip(ftype)
5342 
      elif fid == 1:
5343 
        if ftype == TType.STRUCT:
559 chandransh 5344 
          self.ucx = UserContextException()
5345 
          self.ucx.read(iprot)
122 ashish 5346 
        else:
5347 
          iprot.skip(ftype)
5348 
      else:
5349 
        iprot.skip(ftype)
5350 
      iprot.readFieldEnd()
5351 
    iprot.readStructEnd()
5352 
 
5353 
  def write(self, oprot):
5354 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5355 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5356 
      return
559 chandransh 5357 
    oprot.writeStructBegin('addAddressForUser_result')
122 ashish 5358 
    if self.success != None:
567 rajveer 5359 
      oprot.writeFieldBegin('success', TType.I64, 0)
5360 
      oprot.writeI64(self.success)
122 ashish 5361 
      oprot.writeFieldEnd()
559 chandransh 5362 
    if self.ucx != None:
5363 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5364 
      self.ucx.write(oprot)
122 ashish 5365 
      oprot.writeFieldEnd()
5366 
    oprot.writeFieldStop()
5367 
    oprot.writeStructEnd()
5368 
 
5369 
  def __repr__(self):
5370 
    L = ['%s=%r' % (key, value)
5371 
      for key, value in self.__dict__.iteritems()]
5372 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5373 
 
5374 
  def __eq__(self, other):
5375 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5376 
 
5377 
  def __ne__(self, other):
5378 
    return not (self == other)
5379 
 
559 chandransh 5380 
class removeAddressForUser_args:
94 ashish 5381 
  """
5382 
  Attributes:
559 chandransh 5383 
   - userid
5384 
   - addressId
94 ashish 5385 
  """
5386 
 
5387 
  thrift_spec = (
5388 
    None, # 0
559 chandransh 5389 
    (1, TType.I64, 'userid', None, None, ), # 1
5390 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 5391 
  )
5392 
 
559 chandransh 5393 
  def __init__(self, userid=None, addressId=None,):
5394 
    self.userid = userid
5395 
    self.addressId = addressId
94 ashish 5396 
 
5397 
  def read(self, iprot):
5398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5400 
      return
5401 
    iprot.readStructBegin()
5402 
    while True:
5403 
      (fname, ftype, fid) = iprot.readFieldBegin()
5404 
      if ftype == TType.STOP:
5405 
        break
5406 
      if fid == 1:
559 chandransh 5407 
        if ftype == TType.I64:
5408 
          self.userid = iprot.readI64();
94 ashish 5409 
        else:
5410 
          iprot.skip(ftype)
559 chandransh 5411 
      elif fid == 2:
5412 
        if ftype == TType.I64:
5413 
          self.addressId = iprot.readI64();
5414 
        else:
5415 
          iprot.skip(ftype)
94 ashish 5416 
      else:
5417 
        iprot.skip(ftype)
5418 
      iprot.readFieldEnd()
5419 
    iprot.readStructEnd()
5420 
 
5421 
  def write(self, oprot):
5422 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5423 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5424 
      return
559 chandransh 5425 
    oprot.writeStructBegin('removeAddressForUser_args')
5426 
    if self.userid != None:
5427 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5428 
      oprot.writeI64(self.userid)
94 ashish 5429 
      oprot.writeFieldEnd()
559 chandransh 5430 
    if self.addressId != None:
5431 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5432 
      oprot.writeI64(self.addressId)
5433 
      oprot.writeFieldEnd()
94 ashish 5434 
    oprot.writeFieldStop()
5435 
    oprot.writeStructEnd()
5436 
 
5437 
  def __repr__(self):
5438 
    L = ['%s=%r' % (key, value)
5439 
      for key, value in self.__dict__.iteritems()]
5440 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5441 
 
5442 
  def __eq__(self, other):
5443 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5444 
 
5445 
  def __ne__(self, other):
5446 
    return not (self == other)
5447 
 
559 chandransh 5448 
class removeAddressForUser_result:
94 ashish 5449 
  """
5450 
  Attributes:
5451 
   - success
5452 
   - ucx
5453 
  """
5454 
 
5455 
  thrift_spec = (
5456 
    (0, TType.BOOL, 'success', None, None, ), # 0
5457 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5458 
  )
5459 
 
5460 
  def __init__(self, success=None, ucx=None,):
5461 
    self.success = success
5462 
    self.ucx = ucx
5463 
 
5464 
  def read(self, iprot):
5465 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5466 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5467 
      return
5468 
    iprot.readStructBegin()
5469 
    while True:
5470 
      (fname, ftype, fid) = iprot.readFieldBegin()
5471 
      if ftype == TType.STOP:
5472 
        break
5473 
      if fid == 0:
5474 
        if ftype == TType.BOOL:
5475 
          self.success = iprot.readBool();
5476 
        else:
5477 
          iprot.skip(ftype)
5478 
      elif fid == 1:
5479 
        if ftype == TType.STRUCT:
5480 
          self.ucx = UserContextException()
5481 
          self.ucx.read(iprot)
5482 
        else:
5483 
          iprot.skip(ftype)
5484 
      else:
5485 
        iprot.skip(ftype)
5486 
      iprot.readFieldEnd()
5487 
    iprot.readStructEnd()
5488 
 
5489 
  def write(self, oprot):
5490 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5491 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5492 
      return
559 chandransh 5493 
    oprot.writeStructBegin('removeAddressForUser_result')
94 ashish 5494 
    if self.success != None:
5495 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5496 
      oprot.writeBool(self.success)
5497 
      oprot.writeFieldEnd()
5498 
    if self.ucx != None:
5499 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5500 
      self.ucx.write(oprot)
5501 
      oprot.writeFieldEnd()
5502 
    oprot.writeFieldStop()
5503 
    oprot.writeStructEnd()
5504 
 
5505 
  def __repr__(self):
5506 
    L = ['%s=%r' % (key, value)
5507 
      for key, value in self.__dict__.iteritems()]
5508 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5509 
 
5510 
  def __eq__(self, other):
5511 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5512 
 
5513 
  def __ne__(self, other):
5514 
    return not (self == other)
5515 
 
559 chandransh 5516 
class setUserAsLoggedIn_args:
94 ashish 5517 
  """
5518 
  Attributes:
559 chandransh 5519 
   - userId
94 ashish 5520 
   - timestamp
5521 
  """
5522 
 
5523 
  thrift_spec = (
5524 
    None, # 0
559 chandransh 5525 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 5526 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5527 
  )
5528 
 
559 chandransh 5529 
  def __init__(self, userId=None, timestamp=None,):
5530 
    self.userId = userId
94 ashish 5531 
    self.timestamp = timestamp
5532 
 
5533 
  def read(self, iprot):
5534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5536 
      return
5537 
    iprot.readStructBegin()
5538 
    while True:
5539 
      (fname, ftype, fid) = iprot.readFieldBegin()
5540 
      if ftype == TType.STOP:
5541 
        break
5542 
      if fid == 1:
559 chandransh 5543 
        if ftype == TType.I64:
5544 
          self.userId = iprot.readI64();
94 ashish 5545 
        else:
5546 
          iprot.skip(ftype)
5547 
      elif fid == 2:
5548 
        if ftype == TType.I64:
5549 
          self.timestamp = iprot.readI64();
5550 
        else:
5551 
          iprot.skip(ftype)
5552 
      else:
5553 
        iprot.skip(ftype)
5554 
      iprot.readFieldEnd()
5555 
    iprot.readStructEnd()
5556 
 
5557 
  def write(self, oprot):
5558 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5559 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5560 
      return
559 chandransh 5561 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
5562 
    if self.userId != None:
5563 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5564 
      oprot.writeI64(self.userId)
94 ashish 5565 
      oprot.writeFieldEnd()
5566 
    if self.timestamp != None:
5567 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5568 
      oprot.writeI64(self.timestamp)
5569 
      oprot.writeFieldEnd()
5570 
    oprot.writeFieldStop()
5571 
    oprot.writeStructEnd()
5572 
 
5573 
  def __repr__(self):
5574 
    L = ['%s=%r' % (key, value)
5575 
      for key, value in self.__dict__.iteritems()]
5576 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5577 
 
5578 
  def __eq__(self, other):
5579 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5580 
 
5581 
  def __ne__(self, other):
5582 
    return not (self == other)
5583 
 
559 chandransh 5584 
class setUserAsLoggedIn_result:
94 ashish 5585 
  """
5586 
  Attributes:
5587 
   - success
5588 
   - ucx
5589 
  """
5590 
 
5591 
  thrift_spec = (
5592 
    (0, TType.BOOL, 'success', None, None, ), # 0
5593 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5594 
  )
5595 
 
5596 
  def __init__(self, success=None, ucx=None,):
5597 
    self.success = success
5598 
    self.ucx = ucx
5599 
 
5600 
  def read(self, iprot):
5601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5603 
      return
5604 
    iprot.readStructBegin()
5605 
    while True:
5606 
      (fname, ftype, fid) = iprot.readFieldBegin()
5607 
      if ftype == TType.STOP:
5608 
        break
5609 
      if fid == 0:
5610 
        if ftype == TType.BOOL:
5611 
          self.success = iprot.readBool();
5612 
        else:
5613 
          iprot.skip(ftype)
5614 
      elif fid == 1:
5615 
        if ftype == TType.STRUCT:
5616 
          self.ucx = UserContextException()
5617 
          self.ucx.read(iprot)
5618 
        else:
5619 
          iprot.skip(ftype)
5620 
      else:
5621 
        iprot.skip(ftype)
5622 
      iprot.readFieldEnd()
5623 
    iprot.readStructEnd()
5624 
 
5625 
  def write(self, oprot):
5626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5628 
      return
559 chandransh 5629 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
94 ashish 5630 
    if self.success != None:
5631 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5632 
      oprot.writeBool(self.success)
5633 
      oprot.writeFieldEnd()
5634 
    if self.ucx != None:
5635 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5636 
      self.ucx.write(oprot)
5637 
      oprot.writeFieldEnd()
5638 
    oprot.writeFieldStop()
5639 
    oprot.writeStructEnd()
5640 
 
5641 
  def __repr__(self):
5642 
    L = ['%s=%r' % (key, value)
5643 
      for key, value in self.__dict__.iteritems()]
5644 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5645 
 
5646 
  def __eq__(self, other):
5647 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5648 
 
5649 
  def __ne__(self, other):
5650 
    return not (self == other)
5651 
 
559 chandransh 5652 
class setUserAsLoggedOut_args:
94 ashish 5653 
  """
5654 
  Attributes:
5655 
   - userid
5656 
   - timestamp
5657 
  """
5658 
 
5659 
  thrift_spec = (
5660 
    None, # 0
559 chandransh 5661 
    (1, TType.I64, 'userid', None, None, ), # 1
5662 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 5663 
  )
5664 
 
559 chandransh 5665 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 5666 
    self.userid = userid
5667 
    self.timestamp = timestamp
5668 
 
5669 
  def read(self, iprot):
5670 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5671 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5672 
      return
5673 
    iprot.readStructBegin()
5674 
    while True:
5675 
      (fname, ftype, fid) = iprot.readFieldBegin()
5676 
      if ftype == TType.STOP:
5677 
        break
5678 
      if fid == 1:
5679 
        if ftype == TType.I64:
5680 
          self.userid = iprot.readI64();
5681 
        else:
5682 
          iprot.skip(ftype)
559 chandransh 5683 
      elif fid == 2:
94 ashish 5684 
        if ftype == TType.I64:
5685 
          self.timestamp = iprot.readI64();
5686 
        else:
5687 
          iprot.skip(ftype)
5688 
      else:
5689 
        iprot.skip(ftype)
5690 
      iprot.readFieldEnd()
5691 
    iprot.readStructEnd()
5692 
 
5693 
  def write(self, oprot):
5694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5696 
      return
559 chandransh 5697 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
94 ashish 5698 
    if self.userid != None:
559 chandransh 5699 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 5700 
      oprot.writeI64(self.userid)
5701 
      oprot.writeFieldEnd()
5702 
    if self.timestamp != None:
559 chandransh 5703 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 5704 
      oprot.writeI64(self.timestamp)
5705 
      oprot.writeFieldEnd()
5706 
    oprot.writeFieldStop()
5707 
    oprot.writeStructEnd()
5708 
 
5709 
  def __repr__(self):
5710 
    L = ['%s=%r' % (key, value)
5711 
      for key, value in self.__dict__.iteritems()]
5712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5713 
 
5714 
  def __eq__(self, other):
5715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5716 
 
5717 
  def __ne__(self, other):
5718 
    return not (self == other)
5719 
 
559 chandransh 5720 
class setUserAsLoggedOut_result:
94 ashish 5721 
  """
5722 
  Attributes:
5723 
   - success
5724 
   - ucx
5725 
  """
5726 
 
5727 
  thrift_spec = (
5728 
    (0, TType.BOOL, 'success', None, None, ), # 0
5729 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5730 
  )
5731 
 
5732 
  def __init__(self, success=None, ucx=None,):
5733 
    self.success = success
5734 
    self.ucx = ucx
5735 
 
5736 
  def read(self, iprot):
5737 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5738 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5739 
      return
5740 
    iprot.readStructBegin()
5741 
    while True:
5742 
      (fname, ftype, fid) = iprot.readFieldBegin()
5743 
      if ftype == TType.STOP:
5744 
        break
5745 
      if fid == 0:
5746 
        if ftype == TType.BOOL:
5747 
          self.success = iprot.readBool();
5748 
        else:
5749 
          iprot.skip(ftype)
5750 
      elif fid == 1:
5751 
        if ftype == TType.STRUCT:
5752 
          self.ucx = UserContextException()
5753 
          self.ucx.read(iprot)
5754 
        else:
5755 
          iprot.skip(ftype)
5756 
      else:
5757 
        iprot.skip(ftype)
5758 
      iprot.readFieldEnd()
5759 
    iprot.readStructEnd()
5760 
 
5761 
  def write(self, oprot):
5762 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5763 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5764 
      return
559 chandransh 5765 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
94 ashish 5766 
    if self.success != None:
5767 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5768 
      oprot.writeBool(self.success)
5769 
      oprot.writeFieldEnd()
5770 
    if self.ucx != None:
5771 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5772 
      self.ucx.write(oprot)
5773 
      oprot.writeFieldEnd()
5774 
    oprot.writeFieldStop()
5775 
    oprot.writeStructEnd()
5776 
 
5777 
  def __repr__(self):
5778 
    L = ['%s=%r' % (key, value)
5779 
      for key, value in self.__dict__.iteritems()]
5780 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5781 
 
5782 
  def __eq__(self, other):
5783 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5784 
 
5785 
  def __ne__(self, other):
5786 
    return not (self == other)
5787 
 
559 chandransh 5788 
class setDefaultAddress_args:
94 ashish 5789 
  """
5790 
  Attributes:
5791 
   - userid
5792 
   - addressId
5793 
  """
5794 
 
5795 
  thrift_spec = (
5796 
    None, # 0
5797 
    (1, TType.I64, 'userid', None, None, ), # 1
5798 
    (2, TType.I64, 'addressId', None, None, ), # 2
5799 
  )
5800 
 
5801 
  def __init__(self, userid=None, addressId=None,):
5802 
    self.userid = userid
5803 
    self.addressId = addressId
5804 
 
5805 
  def read(self, iprot):
5806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5808 
      return
5809 
    iprot.readStructBegin()
5810 
    while True:
5811 
      (fname, ftype, fid) = iprot.readFieldBegin()
5812 
      if ftype == TType.STOP:
5813 
        break
5814 
      if fid == 1:
5815 
        if ftype == TType.I64:
5816 
          self.userid = iprot.readI64();
5817 
        else:
5818 
          iprot.skip(ftype)
5819 
      elif fid == 2:
5820 
        if ftype == TType.I64:
5821 
          self.addressId = iprot.readI64();
5822 
        else:
5823 
          iprot.skip(ftype)
5824 
      else:
5825 
        iprot.skip(ftype)
5826 
      iprot.readFieldEnd()
5827 
    iprot.readStructEnd()
5828 
 
5829 
  def write(self, oprot):
5830 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5831 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5832 
      return
559 chandransh 5833 
    oprot.writeStructBegin('setDefaultAddress_args')
94 ashish 5834 
    if self.userid != None:
5835 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5836 
      oprot.writeI64(self.userid)
5837 
      oprot.writeFieldEnd()
5838 
    if self.addressId != None:
5839 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5840 
      oprot.writeI64(self.addressId)
5841 
      oprot.writeFieldEnd()
5842 
    oprot.writeFieldStop()
5843 
    oprot.writeStructEnd()
5844 
 
5845 
  def __repr__(self):
5846 
    L = ['%s=%r' % (key, value)
5847 
      for key, value in self.__dict__.iteritems()]
5848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5849 
 
5850 
  def __eq__(self, other):
5851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5852 
 
5853 
  def __ne__(self, other):
5854 
    return not (self == other)
5855 
 
559 chandransh 5856 
class setDefaultAddress_result:
94 ashish 5857 
  """
5858 
  Attributes:
5859 
   - success
5860 
   - ucx
5861 
  """
5862 
 
5863 
  thrift_spec = (
5864 
    (0, TType.BOOL, 'success', None, None, ), # 0
5865 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5866 
  )
5867 
 
5868 
  def __init__(self, success=None, ucx=None,):
5869 
    self.success = success
5870 
    self.ucx = ucx
5871 
 
5872 
  def read(self, iprot):
5873 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5874 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5875 
      return
5876 
    iprot.readStructBegin()
5877 
    while True:
5878 
      (fname, ftype, fid) = iprot.readFieldBegin()
5879 
      if ftype == TType.STOP:
5880 
        break
5881 
      if fid == 0:
5882 
        if ftype == TType.BOOL:
5883 
          self.success = iprot.readBool();
5884 
        else:
5885 
          iprot.skip(ftype)
5886 
      elif fid == 1:
5887 
        if ftype == TType.STRUCT:
5888 
          self.ucx = UserContextException()
5889 
          self.ucx.read(iprot)
5890 
        else:
5891 
          iprot.skip(ftype)
5892 
      else:
5893 
        iprot.skip(ftype)
5894 
      iprot.readFieldEnd()
5895 
    iprot.readStructEnd()
5896 
 
5897 
  def write(self, oprot):
5898 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5899 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5900 
      return
559 chandransh 5901 
    oprot.writeStructBegin('setDefaultAddress_result')
94 ashish 5902 
    if self.success != None:
5903 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5904 
      oprot.writeBool(self.success)
5905 
      oprot.writeFieldEnd()
5906 
    if self.ucx != None:
5907 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5908 
      self.ucx.write(oprot)
5909 
      oprot.writeFieldEnd()
5910 
    oprot.writeFieldStop()
5911 
    oprot.writeStructEnd()
5912 
 
5913 
  def __repr__(self):
5914 
    L = ['%s=%r' % (key, value)
5915 
      for key, value in self.__dict__.iteritems()]
5916 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5917 
 
5918 
  def __eq__(self, other):
5919 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5920 
 
5921 
  def __ne__(self, other):
5922 
    return not (self == other)
5923 
 
559 chandransh 5924 
class updatePassword_args:
94 ashish 5925 
  """
5926 
  Attributes:
559 chandransh 5927 
   - userid
594 rajveer 5928 
   - oldPassword
5929 
   - newPassword
94 ashish 5930 
  """
5931 
 
5932 
  thrift_spec = (
5933 
    None, # 0
559 chandransh 5934 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 5935 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
5936 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 5937 
  )
5938 
 
594 rajveer 5939 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 5940 
    self.userid = userid
594 rajveer 5941 
    self.oldPassword = oldPassword
5942 
    self.newPassword = newPassword
94 ashish 5943 
 
5944 
  def read(self, iprot):
5945 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5946 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5947 
      return
5948 
    iprot.readStructBegin()
5949 
    while True:
5950 
      (fname, ftype, fid) = iprot.readFieldBegin()
5951 
      if ftype == TType.STOP:
5952 
        break
5953 
      if fid == 1:
5954 
        if ftype == TType.I64:
559 chandransh 5955 
          self.userid = iprot.readI64();
94 ashish 5956 
        else:
5957 
          iprot.skip(ftype)
5958 
      elif fid == 2:
559 chandransh 5959 
        if ftype == TType.STRING:
594 rajveer 5960 
          self.oldPassword = iprot.readString();
94 ashish 5961 
        else:
5962 
          iprot.skip(ftype)
594 rajveer 5963 
      elif fid == 3:
5964 
        if ftype == TType.STRING:
5965 
          self.newPassword = iprot.readString();
5966 
        else:
5967 
          iprot.skip(ftype)
94 ashish 5968 
      else:
5969 
        iprot.skip(ftype)
5970 
      iprot.readFieldEnd()
5971 
    iprot.readStructEnd()
5972 
 
5973 
  def write(self, oprot):
5974 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5975 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5976 
      return
559 chandransh 5977 
    oprot.writeStructBegin('updatePassword_args')
5978 
    if self.userid != None:
5979 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5980 
      oprot.writeI64(self.userid)
94 ashish 5981 
      oprot.writeFieldEnd()
594 rajveer 5982 
    if self.oldPassword != None:
5983 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
5984 
      oprot.writeString(self.oldPassword)
94 ashish 5985 
      oprot.writeFieldEnd()
594 rajveer 5986 
    if self.newPassword != None:
5987 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
5988 
      oprot.writeString(self.newPassword)
5989 
      oprot.writeFieldEnd()
94 ashish 5990 
    oprot.writeFieldStop()
5991 
    oprot.writeStructEnd()
5992 
 
5993 
  def __repr__(self):
5994 
    L = ['%s=%r' % (key, value)
5995 
      for key, value in self.__dict__.iteritems()]
5996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5997 
 
5998 
  def __eq__(self, other):
5999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6000 
 
6001 
  def __ne__(self, other):
6002 
    return not (self == other)
6003 
 
559 chandransh 6004 
class updatePassword_result:
94 ashish 6005 
  """
6006 
  Attributes:
6007 
   - success
6008 
   - ucx
6009 
  """
6010 
 
6011 
  thrift_spec = (
6012 
    (0, TType.BOOL, 'success', None, None, ), # 0
6013 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6014 
  )
6015 
 
6016 
  def __init__(self, success=None, ucx=None,):
6017 
    self.success = success
6018 
    self.ucx = ucx
6019 
 
6020 
  def read(self, iprot):
6021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6023 
      return
6024 
    iprot.readStructBegin()
6025 
    while True:
6026 
      (fname, ftype, fid) = iprot.readFieldBegin()
6027 
      if ftype == TType.STOP:
6028 
        break
6029 
      if fid == 0:
6030 
        if ftype == TType.BOOL:
6031 
          self.success = iprot.readBool();
6032 
        else:
6033 
          iprot.skip(ftype)
6034 
      elif fid == 1:
6035 
        if ftype == TType.STRUCT:
6036 
          self.ucx = UserContextException()
6037 
          self.ucx.read(iprot)
6038 
        else:
6039 
          iprot.skip(ftype)
6040 
      else:
6041 
        iprot.skip(ftype)
6042 
      iprot.readFieldEnd()
6043 
    iprot.readStructEnd()
6044 
 
6045 
  def write(self, oprot):
6046 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6047 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6048 
      return
559 chandransh 6049 
    oprot.writeStructBegin('updatePassword_result')
94 ashish 6050 
    if self.success != None:
6051 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6052 
      oprot.writeBool(self.success)
6053 
      oprot.writeFieldEnd()
6054 
    if self.ucx != None:
6055 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6056 
      self.ucx.write(oprot)
6057 
      oprot.writeFieldEnd()
6058 
    oprot.writeFieldStop()
6059 
    oprot.writeStructEnd()
6060 
 
6061 
  def __repr__(self):
6062 
    L = ['%s=%r' % (key, value)
6063 
      for key, value in self.__dict__.iteritems()]
6064 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6065 
 
6066 
  def __eq__(self, other):
6067 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6068 
 
6069 
  def __ne__(self, other):
6070 
    return not (self == other)
6071 
 
581 rajveer 6072 
class forgotPassword_args:
6073 
  """
6074 
  Attributes:
6075 
   - email
884 rajveer 6076 
   - newPassword
581 rajveer 6077 
  """
6078 
 
6079 
  thrift_spec = (
6080 
    None, # 0
6081 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 6082 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 6083 
  )
6084 
 
884 rajveer 6085 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 6086 
    self.email = email
884 rajveer 6087 
    self.newPassword = newPassword
581 rajveer 6088 
 
6089 
  def read(self, iprot):
6090 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6091 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6092 
      return
6093 
    iprot.readStructBegin()
6094 
    while True:
6095 
      (fname, ftype, fid) = iprot.readFieldBegin()
6096 
      if ftype == TType.STOP:
6097 
        break
6098 
      if fid == 1:
6099 
        if ftype == TType.STRING:
6100 
          self.email = iprot.readString();
6101 
        else:
6102 
          iprot.skip(ftype)
884 rajveer 6103 
      elif fid == 2:
6104 
        if ftype == TType.STRING:
6105 
          self.newPassword = iprot.readString();
6106 
        else:
6107 
          iprot.skip(ftype)
581 rajveer 6108 
      else:
6109 
        iprot.skip(ftype)
6110 
      iprot.readFieldEnd()
6111 
    iprot.readStructEnd()
6112 
 
6113 
  def write(self, oprot):
6114 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6115 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6116 
      return
6117 
    oprot.writeStructBegin('forgotPassword_args')
6118 
    if self.email != None:
6119 
      oprot.writeFieldBegin('email', TType.STRING, 1)
6120 
      oprot.writeString(self.email)
6121 
      oprot.writeFieldEnd()
884 rajveer 6122 
    if self.newPassword != None:
6123 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
6124 
      oprot.writeString(self.newPassword)
6125 
      oprot.writeFieldEnd()
581 rajveer 6126 
    oprot.writeFieldStop()
6127 
    oprot.writeStructEnd()
6128 
 
6129 
  def __repr__(self):
6130 
    L = ['%s=%r' % (key, value)
6131 
      for key, value in self.__dict__.iteritems()]
6132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6133 
 
6134 
  def __eq__(self, other):
6135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6136 
 
6137 
  def __ne__(self, other):
6138 
    return not (self == other)
6139 
 
6140 
class forgotPassword_result:
6141 
  """
6142 
  Attributes:
6143 
   - success
6144 
   - ucx
6145 
  """
6146 
 
6147 
  thrift_spec = (
6148 
    (0, TType.BOOL, 'success', None, None, ), # 0
6149 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6150 
  )
6151 
 
6152 
  def __init__(self, success=None, ucx=None,):
6153 
    self.success = success
6154 
    self.ucx = ucx
6155 
 
6156 
  def read(self, iprot):
6157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6159 
      return
6160 
    iprot.readStructBegin()
6161 
    while True:
6162 
      (fname, ftype, fid) = iprot.readFieldBegin()
6163 
      if ftype == TType.STOP:
6164 
        break
6165 
      if fid == 0:
6166 
        if ftype == TType.BOOL:
6167 
          self.success = iprot.readBool();
6168 
        else:
6169 
          iprot.skip(ftype)
6170 
      elif fid == 1:
6171 
        if ftype == TType.STRUCT:
6172 
          self.ucx = UserContextException()
6173 
          self.ucx.read(iprot)
6174 
        else:
6175 
          iprot.skip(ftype)
6176 
      else:
6177 
        iprot.skip(ftype)
6178 
      iprot.readFieldEnd()
6179 
    iprot.readStructEnd()
6180 
 
6181 
  def write(self, oprot):
6182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6184 
      return
6185 
    oprot.writeStructBegin('forgotPassword_result')
6186 
    if self.success != None:
6187 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6188 
      oprot.writeBool(self.success)
6189 
      oprot.writeFieldEnd()
6190 
    if self.ucx != None:
6191 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6192 
      self.ucx.write(oprot)
6193 
      oprot.writeFieldEnd()
6194 
    oprot.writeFieldStop()
6195 
    oprot.writeStructEnd()
6196 
 
6197 
  def __repr__(self):
6198 
    L = ['%s=%r' % (key, value)
6199 
      for key, value in self.__dict__.iteritems()]
6200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6201 
 
6202 
  def __eq__(self, other):
6203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6204 
 
6205 
  def __ne__(self, other):
6206 
    return not (self == other)
6207 
 
594 rajveer 6208 
class getAllAddressesForUser_args:
6209 
  """
6210 
  Attributes:
6211 
   - userId
6212 
  """
6213 
 
6214 
  thrift_spec = (
6215 
    None, # 0
6216 
    (1, TType.I64, 'userId', None, None, ), # 1
6217 
  )
6218 
 
6219 
  def __init__(self, userId=None,):
6220 
    self.userId = userId
6221 
 
6222 
  def read(self, iprot):
6223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6225 
      return
6226 
    iprot.readStructBegin()
6227 
    while True:
6228 
      (fname, ftype, fid) = iprot.readFieldBegin()
6229 
      if ftype == TType.STOP:
6230 
        break
6231 
      if fid == 1:
6232 
        if ftype == TType.I64:
6233 
          self.userId = iprot.readI64();
6234 
        else:
6235 
          iprot.skip(ftype)
6236 
      else:
6237 
        iprot.skip(ftype)
6238 
      iprot.readFieldEnd()
6239 
    iprot.readStructEnd()
6240 
 
6241 
  def write(self, oprot):
6242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6244 
      return
6245 
    oprot.writeStructBegin('getAllAddressesForUser_args')
6246 
    if self.userId != None:
6247 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6248 
      oprot.writeI64(self.userId)
6249 
      oprot.writeFieldEnd()
6250 
    oprot.writeFieldStop()
6251 
    oprot.writeStructEnd()
6252 
 
6253 
  def __repr__(self):
6254 
    L = ['%s=%r' % (key, value)
6255 
      for key, value in self.__dict__.iteritems()]
6256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6257 
 
6258 
  def __eq__(self, other):
6259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6260 
 
6261 
  def __ne__(self, other):
6262 
    return not (self == other)
6263 
 
6264 
class getAllAddressesForUser_result:
6265 
  """
6266 
  Attributes:
6267 
   - success
6268 
   - ucx
6269 
  """
6270 
 
6271 
  thrift_spec = (
6272 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
6273 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6274 
  )
6275 
 
6276 
  def __init__(self, success=None, ucx=None,):
6277 
    self.success = success
6278 
    self.ucx = ucx
6279 
 
6280 
  def read(self, iprot):
6281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6283 
      return
6284 
    iprot.readStructBegin()
6285 
    while True:
6286 
      (fname, ftype, fid) = iprot.readFieldBegin()
6287 
      if ftype == TType.STOP:
6288 
        break
6289 
      if fid == 0:
6290 
        if ftype == TType.LIST:
6291 
          self.success = []
2981 rajveer 6292 
          (_etype31, _size28) = iprot.readListBegin()
6293 
          for _i32 in xrange(_size28):
6294 
            _elem33 = Address()
6295 
            _elem33.read(iprot)
6296 
            self.success.append(_elem33)
594 rajveer 6297 
          iprot.readListEnd()
6298 
        else:
6299 
          iprot.skip(ftype)
6300 
      elif fid == 1:
6301 
        if ftype == TType.STRUCT:
6302 
          self.ucx = UserContextException()
6303 
          self.ucx.read(iprot)
6304 
        else:
6305 
          iprot.skip(ftype)
6306 
      else:
6307 
        iprot.skip(ftype)
6308 
      iprot.readFieldEnd()
6309 
    iprot.readStructEnd()
6310 
 
6311 
  def write(self, oprot):
6312 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6313 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6314 
      return
6315 
    oprot.writeStructBegin('getAllAddressesForUser_result')
6316 
    if self.success != None:
6317 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6318 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 6319 
      for iter34 in self.success:
6320 
        iter34.write(oprot)
594 rajveer 6321 
      oprot.writeListEnd()
6322 
      oprot.writeFieldEnd()
6323 
    if self.ucx != None:
6324 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6325 
      self.ucx.write(oprot)
6326 
      oprot.writeFieldEnd()
6327 
    oprot.writeFieldStop()
6328 
    oprot.writeStructEnd()
6329 
 
6330 
  def __repr__(self):
6331 
    L = ['%s=%r' % (key, value)
6332 
      for key, value in self.__dict__.iteritems()]
6333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6334 
 
6335 
  def __eq__(self, other):
6336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6337 
 
6338 
  def __ne__(self, other):
6339 
    return not (self == other)
6340 
 
1894 vikas 6341 
class getAddressById_args:
6342 
  """
6343 
  Attributes:
6344 
   - addressId
6345 
  """
6346 
 
6347 
  thrift_spec = (
6348 
    None, # 0
6349 
    (1, TType.I64, 'addressId', None, None, ), # 1
6350 
  )
6351 
 
6352 
  def __init__(self, addressId=None,):
6353 
    self.addressId = addressId
6354 
 
6355 
  def read(self, iprot):
6356 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6357 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6358 
      return
6359 
    iprot.readStructBegin()
6360 
    while True:
6361 
      (fname, ftype, fid) = iprot.readFieldBegin()
6362 
      if ftype == TType.STOP:
6363 
        break
6364 
      if fid == 1:
6365 
        if ftype == TType.I64:
6366 
          self.addressId = iprot.readI64();
6367 
        else:
6368 
          iprot.skip(ftype)
6369 
      else:
6370 
        iprot.skip(ftype)
6371 
      iprot.readFieldEnd()
6372 
    iprot.readStructEnd()
6373 
 
6374 
  def write(self, oprot):
6375 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6376 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6377 
      return
6378 
    oprot.writeStructBegin('getAddressById_args')
6379 
    if self.addressId != None:
6380 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
6381 
      oprot.writeI64(self.addressId)
6382 
      oprot.writeFieldEnd()
6383 
    oprot.writeFieldStop()
6384 
    oprot.writeStructEnd()
6385 
 
6386 
  def __repr__(self):
6387 
    L = ['%s=%r' % (key, value)
6388 
      for key, value in self.__dict__.iteritems()]
6389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6390 
 
6391 
  def __eq__(self, other):
6392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6393 
 
6394 
  def __ne__(self, other):
6395 
    return not (self == other)
6396 
 
6397 
class getAddressById_result:
6398 
  """
6399 
  Attributes:
6400 
   - success
6401 
   - ucx
6402 
  """
6403 
 
6404 
  thrift_spec = (
6405 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
6406 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6407 
  )
6408 
 
6409 
  def __init__(self, success=None, ucx=None,):
6410 
    self.success = success
6411 
    self.ucx = ucx
6412 
 
6413 
  def read(self, iprot):
6414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6416 
      return
6417 
    iprot.readStructBegin()
6418 
    while True:
6419 
      (fname, ftype, fid) = iprot.readFieldBegin()
6420 
      if ftype == TType.STOP:
6421 
        break
6422 
      if fid == 0:
6423 
        if ftype == TType.STRUCT:
6424 
          self.success = Address()
6425 
          self.success.read(iprot)
6426 
        else:
6427 
          iprot.skip(ftype)
6428 
      elif fid == 1:
6429 
        if ftype == TType.STRUCT:
6430 
          self.ucx = UserContextException()
6431 
          self.ucx.read(iprot)
6432 
        else:
6433 
          iprot.skip(ftype)
6434 
      else:
6435 
        iprot.skip(ftype)
6436 
      iprot.readFieldEnd()
6437 
    iprot.readStructEnd()
6438 
 
6439 
  def write(self, oprot):
6440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6442 
      return
6443 
    oprot.writeStructBegin('getAddressById_result')
6444 
    if self.success != None:
6445 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6446 
      self.success.write(oprot)
6447 
      oprot.writeFieldEnd()
6448 
    if self.ucx != None:
6449 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6450 
      self.ucx.write(oprot)
6451 
      oprot.writeFieldEnd()
6452 
    oprot.writeFieldStop()
6453 
    oprot.writeStructEnd()
6454 
 
6455 
  def __repr__(self):
6456 
    L = ['%s=%r' % (key, value)
6457 
      for key, value in self.__dict__.iteritems()]
6458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6459 
 
6460 
  def __eq__(self, other):
6461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6462 
 
6463 
  def __ne__(self, other):
6464 
    return not (self == other)
6465 
 
594 rajveer 6466 
class getDefaultAddressId_args:
6467 
  """
6468 
  Attributes:
6469 
   - userId
6470 
  """
6471 
 
6472 
  thrift_spec = (
6473 
    None, # 0
6474 
    (1, TType.I64, 'userId', None, None, ), # 1
6475 
  )
6476 
 
6477 
  def __init__(self, userId=None,):
6478 
    self.userId = userId
6479 
 
6480 
  def read(self, iprot):
6481 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6482 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6483 
      return
6484 
    iprot.readStructBegin()
6485 
    while True:
6486 
      (fname, ftype, fid) = iprot.readFieldBegin()
6487 
      if ftype == TType.STOP:
6488 
        break
6489 
      if fid == 1:
6490 
        if ftype == TType.I64:
6491 
          self.userId = iprot.readI64();
6492 
        else:
6493 
          iprot.skip(ftype)
6494 
      else:
6495 
        iprot.skip(ftype)
6496 
      iprot.readFieldEnd()
6497 
    iprot.readStructEnd()
6498 
 
6499 
  def write(self, oprot):
6500 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6501 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6502 
      return
6503 
    oprot.writeStructBegin('getDefaultAddressId_args')
6504 
    if self.userId != None:
6505 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6506 
      oprot.writeI64(self.userId)
6507 
      oprot.writeFieldEnd()
6508 
    oprot.writeFieldStop()
6509 
    oprot.writeStructEnd()
6510 
 
6511 
  def __repr__(self):
6512 
    L = ['%s=%r' % (key, value)
6513 
      for key, value in self.__dict__.iteritems()]
6514 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6515 
 
6516 
  def __eq__(self, other):
6517 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6518 
 
6519 
  def __ne__(self, other):
6520 
    return not (self == other)
6521 
 
6522 
class getDefaultAddressId_result:
6523 
  """
6524 
  Attributes:
6525 
   - success
6526 
   - ucx
6527 
  """
6528 
 
6529 
  thrift_spec = (
6530 
    (0, TType.I64, 'success', None, None, ), # 0
6531 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6532 
  )
6533 
 
6534 
  def __init__(self, success=None, ucx=None,):
6535 
    self.success = success
6536 
    self.ucx = ucx
6537 
 
6538 
  def read(self, iprot):
6539 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6540 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6541 
      return
6542 
    iprot.readStructBegin()
6543 
    while True:
6544 
      (fname, ftype, fid) = iprot.readFieldBegin()
6545 
      if ftype == TType.STOP:
6546 
        break
6547 
      if fid == 0:
6548 
        if ftype == TType.I64:
6549 
          self.success = iprot.readI64();
6550 
        else:
6551 
          iprot.skip(ftype)
6552 
      elif fid == 1:
6553 
        if ftype == TType.STRUCT:
6554 
          self.ucx = UserContextException()
6555 
          self.ucx.read(iprot)
6556 
        else:
6557 
          iprot.skip(ftype)
6558 
      else:
6559 
        iprot.skip(ftype)
6560 
      iprot.readFieldEnd()
6561 
    iprot.readStructEnd()
6562 
 
6563 
  def write(self, oprot):
6564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6566 
      return
6567 
    oprot.writeStructBegin('getDefaultAddressId_result')
6568 
    if self.success != None:
6569 
      oprot.writeFieldBegin('success', TType.I64, 0)
6570 
      oprot.writeI64(self.success)
6571 
      oprot.writeFieldEnd()
6572 
    if self.ucx != None:
6573 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6574 
      self.ucx.write(oprot)
6575 
      oprot.writeFieldEnd()
6576 
    oprot.writeFieldStop()
6577 
    oprot.writeStructEnd()
6578 
 
6579 
  def __repr__(self):
6580 
    L = ['%s=%r' % (key, value)
6581 
      for key, value in self.__dict__.iteritems()]
6582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6583 
 
6584 
  def __eq__(self, other):
6585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6586 
 
6587 
  def __ne__(self, other):
6588 
    return not (self == other)
6589 
 
785 rajveer 6590 
class getDefaultPincode_args:
6591 
  """
6592 
  Attributes:
6593 
   - userId
6594 
  """
6595 
 
6596 
  thrift_spec = (
6597 
    None, # 0
6598 
    (1, TType.I64, 'userId', None, None, ), # 1
6599 
  )
6600 
 
6601 
  def __init__(self, userId=None,):
6602 
    self.userId = userId
6603 
 
6604 
  def read(self, iprot):
6605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6607 
      return
6608 
    iprot.readStructBegin()
6609 
    while True:
6610 
      (fname, ftype, fid) = iprot.readFieldBegin()
6611 
      if ftype == TType.STOP:
6612 
        break
6613 
      if fid == 1:
6614 
        if ftype == TType.I64:
6615 
          self.userId = iprot.readI64();
6616 
        else:
6617 
          iprot.skip(ftype)
6618 
      else:
6619 
        iprot.skip(ftype)
6620 
      iprot.readFieldEnd()
6621 
    iprot.readStructEnd()
6622 
 
6623 
  def write(self, oprot):
6624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6626 
      return
6627 
    oprot.writeStructBegin('getDefaultPincode_args')
6628 
    if self.userId != None:
6629 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6630 
      oprot.writeI64(self.userId)
6631 
      oprot.writeFieldEnd()
6632 
    oprot.writeFieldStop()
6633 
    oprot.writeStructEnd()
6634 
 
6635 
  def __repr__(self):
6636 
    L = ['%s=%r' % (key, value)
6637 
      for key, value in self.__dict__.iteritems()]
6638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6639 
 
6640 
  def __eq__(self, other):
6641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6642 
 
6643 
  def __ne__(self, other):
6644 
    return not (self == other)
6645 
 
6646 
class getDefaultPincode_result:
6647 
  """
6648 
  Attributes:
6649 
   - success
6650 
   - ucx
6651 
  """
6652 
 
6653 
  thrift_spec = (
6654 
    (0, TType.STRING, 'success', None, None, ), # 0
6655 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6656 
  )
6657 
 
6658 
  def __init__(self, success=None, ucx=None,):
6659 
    self.success = success
6660 
    self.ucx = ucx
6661 
 
6662 
  def read(self, iprot):
6663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6665 
      return
6666 
    iprot.readStructBegin()
6667 
    while True:
6668 
      (fname, ftype, fid) = iprot.readFieldBegin()
6669 
      if ftype == TType.STOP:
6670 
        break
6671 
      if fid == 0:
6672 
        if ftype == TType.STRING:
6673 
          self.success = iprot.readString();
6674 
        else:
6675 
          iprot.skip(ftype)
6676 
      elif fid == 1:
6677 
        if ftype == TType.STRUCT:
6678 
          self.ucx = UserContextException()
6679 
          self.ucx.read(iprot)
6680 
        else:
6681 
          iprot.skip(ftype)
6682 
      else:
6683 
        iprot.skip(ftype)
6684 
      iprot.readFieldEnd()
6685 
    iprot.readStructEnd()
6686 
 
6687 
  def write(self, oprot):
6688 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6689 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6690 
      return
6691 
    oprot.writeStructBegin('getDefaultPincode_result')
6692 
    if self.success != None:
6693 
      oprot.writeFieldBegin('success', TType.STRING, 0)
6694 
      oprot.writeString(self.success)
6695 
      oprot.writeFieldEnd()
6696 
    if self.ucx != None:
6697 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6698 
      self.ucx.write(oprot)
6699 
      oprot.writeFieldEnd()
6700 
    oprot.writeFieldStop()
6701 
    oprot.writeStructEnd()
6702 
 
6703 
  def __repr__(self):
6704 
    L = ['%s=%r' % (key, value)
6705 
      for key, value in self.__dict__.iteritems()]
6706 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6707 
 
6708 
  def __eq__(self, other):
6709 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6710 
 
6711 
  def __ne__(self, other):
6712 
    return not (self == other)
6713 
 
1274 varun.gupt 6714 
class saveUserCommunication_args:
6715 
  """
6716 
  Attributes:
6717 
   - userId
6718 
   - replyTo
6719 
   - communicationType
6720 
   - orderId
6721 
   - airwaybillNo
6722 
   - productName
6723 
   - subject
6724 
   - message
6725 
  """
6726 
 
6727 
  thrift_spec = (
6728 
    None, # 0
6729 
    (1, TType.I64, 'userId', None, None, ), # 1
6730 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
6731 
    (3, TType.I64, 'communicationType', None, None, ), # 3
6732 
    (4, TType.I64, 'orderId', None, None, ), # 4
6733 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
6734 
    (6, TType.STRING, 'productName', None, None, ), # 6
6735 
    (7, TType.STRING, 'subject', None, None, ), # 7
6736 
    (8, TType.STRING, 'message', None, None, ), # 8
6737 
  )
6738 
 
6739 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
6740 
    self.userId = userId
6741 
    self.replyTo = replyTo
6742 
    self.communicationType = communicationType
6743 
    self.orderId = orderId
6744 
    self.airwaybillNo = airwaybillNo
6745 
    self.productName = productName
6746 
    self.subject = subject
6747 
    self.message = message
6748 
 
6749 
  def read(self, iprot):
6750 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6751 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6752 
      return
6753 
    iprot.readStructBegin()
6754 
    while True:
6755 
      (fname, ftype, fid) = iprot.readFieldBegin()
6756 
      if ftype == TType.STOP:
6757 
        break
6758 
      if fid == 1:
6759 
        if ftype == TType.I64:
6760 
          self.userId = iprot.readI64();
6761 
        else:
6762 
          iprot.skip(ftype)
6763 
      elif fid == 2:
6764 
        if ftype == TType.STRING:
6765 
          self.replyTo = iprot.readString();
6766 
        else:
6767 
          iprot.skip(ftype)
6768 
      elif fid == 3:
6769 
        if ftype == TType.I64:
6770 
          self.communicationType = iprot.readI64();
6771 
        else:
6772 
          iprot.skip(ftype)
6773 
      elif fid == 4:
6774 
        if ftype == TType.I64:
6775 
          self.orderId = iprot.readI64();
6776 
        else:
6777 
          iprot.skip(ftype)
6778 
      elif fid == 5:
6779 
        if ftype == TType.STRING:
6780 
          self.airwaybillNo = iprot.readString();
6781 
        else:
6782 
          iprot.skip(ftype)
6783 
      elif fid == 6:
6784 
        if ftype == TType.STRING:
6785 
          self.productName = iprot.readString();
6786 
        else:
6787 
          iprot.skip(ftype)
6788 
      elif fid == 7:
6789 
        if ftype == TType.STRING:
6790 
          self.subject = iprot.readString();
6791 
        else:
6792 
          iprot.skip(ftype)
6793 
      elif fid == 8:
6794 
        if ftype == TType.STRING:
6795 
          self.message = iprot.readString();
6796 
        else:
6797 
          iprot.skip(ftype)
6798 
      else:
6799 
        iprot.skip(ftype)
6800 
      iprot.readFieldEnd()
6801 
    iprot.readStructEnd()
6802 
 
6803 
  def write(self, oprot):
6804 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6805 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6806 
      return
6807 
    oprot.writeStructBegin('saveUserCommunication_args')
6808 
    if self.userId != None:
6809 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6810 
      oprot.writeI64(self.userId)
6811 
      oprot.writeFieldEnd()
6812 
    if self.replyTo != None:
6813 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
6814 
      oprot.writeString(self.replyTo)
6815 
      oprot.writeFieldEnd()
6816 
    if self.communicationType != None:
6817 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
6818 
      oprot.writeI64(self.communicationType)
6819 
      oprot.writeFieldEnd()
6820 
    if self.orderId != None:
6821 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
6822 
      oprot.writeI64(self.orderId)
6823 
      oprot.writeFieldEnd()
6824 
    if self.airwaybillNo != None:
6825 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
6826 
      oprot.writeString(self.airwaybillNo)
6827 
      oprot.writeFieldEnd()
6828 
    if self.productName != None:
6829 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
6830 
      oprot.writeString(self.productName)
6831 
      oprot.writeFieldEnd()
6832 
    if self.subject != None:
6833 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
6834 
      oprot.writeString(self.subject)
6835 
      oprot.writeFieldEnd()
6836 
    if self.message != None:
6837 
      oprot.writeFieldBegin('message', TType.STRING, 8)
6838 
      oprot.writeString(self.message)
6839 
      oprot.writeFieldEnd()
6840 
    oprot.writeFieldStop()
6841 
    oprot.writeStructEnd()
6842 
 
6843 
  def __repr__(self):
6844 
    L = ['%s=%r' % (key, value)
6845 
      for key, value in self.__dict__.iteritems()]
6846 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6847 
 
6848 
  def __eq__(self, other):
6849 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6850 
 
6851 
  def __ne__(self, other):
6852 
    return not (self == other)
6853 
 
6854 
class saveUserCommunication_result:
6855 
  """
6856 
  Attributes:
6857 
   - success
6858 
   - ucx
6859 
  """
6860 
 
6861 
  thrift_spec = (
6862 
    (0, TType.BOOL, 'success', None, None, ), # 0
6863 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6864 
  )
6865 
 
6866 
  def __init__(self, success=None, ucx=None,):
6867 
    self.success = success
6868 
    self.ucx = ucx
6869 
 
6870 
  def read(self, iprot):
6871 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6872 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6873 
      return
6874 
    iprot.readStructBegin()
6875 
    while True:
6876 
      (fname, ftype, fid) = iprot.readFieldBegin()
6877 
      if ftype == TType.STOP:
6878 
        break
6879 
      if fid == 0:
6880 
        if ftype == TType.BOOL:
6881 
          self.success = iprot.readBool();
6882 
        else:
6883 
          iprot.skip(ftype)
6884 
      elif fid == 1:
6885 
        if ftype == TType.STRUCT:
6886 
          self.ucx = UserCommunicationException()
6887 
          self.ucx.read(iprot)
6888 
        else:
6889 
          iprot.skip(ftype)
6890 
      else:
6891 
        iprot.skip(ftype)
6892 
      iprot.readFieldEnd()
6893 
    iprot.readStructEnd()
6894 
 
6895 
  def write(self, oprot):
6896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6898 
      return
6899 
    oprot.writeStructBegin('saveUserCommunication_result')
6900 
    if self.success != None:
6901 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6902 
      oprot.writeBool(self.success)
6903 
      oprot.writeFieldEnd()
6904 
    if self.ucx != None:
6905 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6906 
      self.ucx.write(oprot)
6907 
      oprot.writeFieldEnd()
6908 
    oprot.writeFieldStop()
6909 
    oprot.writeStructEnd()
6910 
 
6911 
  def __repr__(self):
6912 
    L = ['%s=%r' % (key, value)
6913 
      for key, value in self.__dict__.iteritems()]
6914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6915 
 
6916 
  def __eq__(self, other):
6917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6918 
 
6919 
  def __ne__(self, other):
6920 
    return not (self == other)
6921 
 
1590 varun.gupt 6922 
class getUserCommunicationById_args:
6923 
  """
6924 
  Attributes:
6925 
   - id
6926 
  """
6927 
 
6928 
  thrift_spec = (
6929 
    None, # 0
6930 
    (1, TType.I64, 'id', None, None, ), # 1
6931 
  )
6932 
 
6933 
  def __init__(self, id=None,):
6934 
    self.id = id
6935 
 
6936 
  def read(self, iprot):
6937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6939 
      return
6940 
    iprot.readStructBegin()
6941 
    while True:
6942 
      (fname, ftype, fid) = iprot.readFieldBegin()
6943 
      if ftype == TType.STOP:
6944 
        break
6945 
      if fid == 1:
6946 
        if ftype == TType.I64:
6947 
          self.id = iprot.readI64();
6948 
        else:
6949 
          iprot.skip(ftype)
6950 
      else:
6951 
        iprot.skip(ftype)
6952 
      iprot.readFieldEnd()
6953 
    iprot.readStructEnd()
6954 
 
6955 
  def write(self, oprot):
6956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6958 
      return
6959 
    oprot.writeStructBegin('getUserCommunicationById_args')
6960 
    if self.id != None:
6961 
      oprot.writeFieldBegin('id', TType.I64, 1)
6962 
      oprot.writeI64(self.id)
6963 
      oprot.writeFieldEnd()
6964 
    oprot.writeFieldStop()
6965 
    oprot.writeStructEnd()
6966 
 
6967 
  def __repr__(self):
6968 
    L = ['%s=%r' % (key, value)
6969 
      for key, value in self.__dict__.iteritems()]
6970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6971 
 
6972 
  def __eq__(self, other):
6973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6974 
 
6975 
  def __ne__(self, other):
6976 
    return not (self == other)
6977 
 
6978 
class getUserCommunicationById_result:
6979 
  """
6980 
  Attributes:
6981 
   - success
6982 
   - ucx
6983 
  """
6984 
 
6985 
  thrift_spec = (
6986 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
6987 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6988 
  )
6989 
 
6990 
  def __init__(self, success=None, ucx=None,):
6991 
    self.success = success
6992 
    self.ucx = ucx
6993 
 
6994 
  def read(self, iprot):
6995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6997 
      return
6998 
    iprot.readStructBegin()
6999 
    while True:
7000 
      (fname, ftype, fid) = iprot.readFieldBegin()
7001 
      if ftype == TType.STOP:
7002 
        break
7003 
      if fid == 0:
7004 
        if ftype == TType.STRUCT:
7005 
          self.success = UserCommunication()
7006 
          self.success.read(iprot)
7007 
        else:
7008 
          iprot.skip(ftype)
7009 
      elif fid == 1:
7010 
        if ftype == TType.STRUCT:
7011 
          self.ucx = UserCommunicationException()
7012 
          self.ucx.read(iprot)
7013 
        else:
7014 
          iprot.skip(ftype)
7015 
      else:
7016 
        iprot.skip(ftype)
7017 
      iprot.readFieldEnd()
7018 
    iprot.readStructEnd()
7019 
 
7020 
  def write(self, oprot):
7021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7023 
      return
7024 
    oprot.writeStructBegin('getUserCommunicationById_result')
7025 
    if self.success != None:
7026 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7027 
      self.success.write(oprot)
7028 
      oprot.writeFieldEnd()
7029 
    if self.ucx != None:
7030 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7031 
      self.ucx.write(oprot)
7032 
      oprot.writeFieldEnd()
7033 
    oprot.writeFieldStop()
7034 
    oprot.writeStructEnd()
7035 
 
7036 
  def __repr__(self):
7037 
    L = ['%s=%r' % (key, value)
7038 
      for key, value in self.__dict__.iteritems()]
7039 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7040 
 
7041 
  def __eq__(self, other):
7042 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7043 
 
7044 
  def __ne__(self, other):
7045 
    return not (self == other)
7046 
 
7047 
class getUserCommunicationByUser_args:
7048 
  """
7049 
  Attributes:
7050 
   - userId
7051 
  """
7052 
 
7053 
  thrift_spec = (
7054 
    None, # 0
7055 
    (1, TType.I64, 'userId', None, None, ), # 1
7056 
  )
7057 
 
7058 
  def __init__(self, userId=None,):
7059 
    self.userId = userId
7060 
 
7061 
  def read(self, iprot):
7062 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7063 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7064 
      return
7065 
    iprot.readStructBegin()
7066 
    while True:
7067 
      (fname, ftype, fid) = iprot.readFieldBegin()
7068 
      if ftype == TType.STOP:
7069 
        break
7070 
      if fid == 1:
7071 
        if ftype == TType.I64:
7072 
          self.userId = iprot.readI64();
7073 
        else:
7074 
          iprot.skip(ftype)
7075 
      else:
7076 
        iprot.skip(ftype)
7077 
      iprot.readFieldEnd()
7078 
    iprot.readStructEnd()
7079 
 
7080 
  def write(self, oprot):
7081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7083 
      return
7084 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
7085 
    if self.userId != None:
7086 
      oprot.writeFieldBegin('userId', TType.I64, 1)
7087 
      oprot.writeI64(self.userId)
7088 
      oprot.writeFieldEnd()
7089 
    oprot.writeFieldStop()
7090 
    oprot.writeStructEnd()
7091 
 
7092 
  def __repr__(self):
7093 
    L = ['%s=%r' % (key, value)
7094 
      for key, value in self.__dict__.iteritems()]
7095 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7096 
 
7097 
  def __eq__(self, other):
7098 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7099 
 
7100 
  def __ne__(self, other):
7101 
    return not (self == other)
7102 
 
7103 
class getUserCommunicationByUser_result:
7104 
  """
7105 
  Attributes:
7106 
   - success
7107 
   - ucx
7108 
  """
7109 
 
7110 
  thrift_spec = (
7111 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
7112 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7113 
  )
7114 
 
7115 
  def __init__(self, success=None, ucx=None,):
7116 
    self.success = success
7117 
    self.ucx = ucx
7118 
 
7119 
  def read(self, iprot):
7120 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7121 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7122 
      return
7123 
    iprot.readStructBegin()
7124 
    while True:
7125 
      (fname, ftype, fid) = iprot.readFieldBegin()
7126 
      if ftype == TType.STOP:
7127 
        break
7128 
      if fid == 0:
7129 
        if ftype == TType.LIST:
7130 
          self.success = []
2981 rajveer 7131 
          (_etype38, _size35) = iprot.readListBegin()
7132 
          for _i39 in xrange(_size35):
7133 
            _elem40 = UserCommunication()
7134 
            _elem40.read(iprot)
7135 
            self.success.append(_elem40)
1590 varun.gupt 7136 
          iprot.readListEnd()
7137 
        else:
7138 
          iprot.skip(ftype)
7139 
      elif fid == 1:
7140 
        if ftype == TType.STRUCT:
7141 
          self.ucx = UserCommunicationException()
7142 
          self.ucx.read(iprot)
7143 
        else:
7144 
          iprot.skip(ftype)
7145 
      else:
7146 
        iprot.skip(ftype)
7147 
      iprot.readFieldEnd()
7148 
    iprot.readStructEnd()
7149 
 
7150 
  def write(self, oprot):
7151 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7152 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7153 
      return
7154 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
7155 
    if self.success != None:
7156 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7157 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 7158 
      for iter41 in self.success:
7159 
        iter41.write(oprot)
1590 varun.gupt 7160 
      oprot.writeListEnd()
7161 
      oprot.writeFieldEnd()
7162 
    if self.ucx != None:
7163 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7164 
      self.ucx.write(oprot)
7165 
      oprot.writeFieldEnd()
7166 
    oprot.writeFieldStop()
7167 
    oprot.writeStructEnd()
7168 
 
7169 
  def __repr__(self):
7170 
    L = ['%s=%r' % (key, value)
7171 
      for key, value in self.__dict__.iteritems()]
7172 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7173 
 
7174 
  def __eq__(self, other):
7175 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7176 
 
7177 
  def __ne__(self, other):
7178 
    return not (self == other)
7179 
 
7180 
class getAllUserCommunications_args:
7181 
 
7182 
  thrift_spec = (
7183 
  )
7184 
 
7185 
  def read(self, iprot):
7186 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7187 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7188 
      return
7189 
    iprot.readStructBegin()
7190 
    while True:
7191 
      (fname, ftype, fid) = iprot.readFieldBegin()
7192 
      if ftype == TType.STOP:
7193 
        break
7194 
      else:
7195 
        iprot.skip(ftype)
7196 
      iprot.readFieldEnd()
7197 
    iprot.readStructEnd()
7198 
 
7199 
  def write(self, oprot):
7200 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7201 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7202 
      return
7203 
    oprot.writeStructBegin('getAllUserCommunications_args')
7204 
    oprot.writeFieldStop()
7205 
    oprot.writeStructEnd()
7206 
 
7207 
  def __repr__(self):
7208 
    L = ['%s=%r' % (key, value)
7209 
      for key, value in self.__dict__.iteritems()]
7210 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7211 
 
7212 
  def __eq__(self, other):
7213 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7214 
 
7215 
  def __ne__(self, other):
7216 
    return not (self == other)
7217 
 
7218 
class getAllUserCommunications_result:
7219 
  """
7220 
  Attributes:
7221 
   - success
7222 
   - ucx
7223 
  """
7224 
 
7225 
  thrift_spec = (
7226 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
7227 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7228 
  )
7229 
 
7230 
  def __init__(self, success=None, ucx=None,):
7231 
    self.success = success
7232 
    self.ucx = ucx
7233 
 
7234 
  def read(self, iprot):
7235 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7236 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7237 
      return
7238 
    iprot.readStructBegin()
7239 
    while True:
7240 
      (fname, ftype, fid) = iprot.readFieldBegin()
7241 
      if ftype == TType.STOP:
7242 
        break
7243 
      if fid == 0:
7244 
        if ftype == TType.LIST:
7245 
          self.success = []
2981 rajveer 7246 
          (_etype45, _size42) = iprot.readListBegin()
7247 
          for _i46 in xrange(_size42):
7248 
            _elem47 = UserCommunication()
7249 
            _elem47.read(iprot)
7250 
            self.success.append(_elem47)
1590 varun.gupt 7251 
          iprot.readListEnd()
7252 
        else:
7253 
          iprot.skip(ftype)
7254 
      elif fid == 1:
7255 
        if ftype == TType.STRUCT:
7256 
          self.ucx = UserCommunicationException()
7257 
          self.ucx.read(iprot)
7258 
        else:
7259 
          iprot.skip(ftype)
7260 
      else:
7261 
        iprot.skip(ftype)
7262 
      iprot.readFieldEnd()
7263 
    iprot.readStructEnd()
7264 
 
7265 
  def write(self, oprot):
7266 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7267 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7268 
      return
7269 
    oprot.writeStructBegin('getAllUserCommunications_result')
7270 
    if self.success != None:
7271 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7272 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 7273 
      for iter48 in self.success:
7274 
        iter48.write(oprot)
1590 varun.gupt 7275 
      oprot.writeListEnd()
7276 
      oprot.writeFieldEnd()
7277 
    if self.ucx != None:
7278 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7279 
      self.ucx.write(oprot)
7280 
      oprot.writeFieldEnd()
7281 
    oprot.writeFieldStop()
7282 
    oprot.writeStructEnd()
7283 
 
7284 
  def __repr__(self):
7285 
    L = ['%s=%r' % (key, value)
7286 
      for key, value in self.__dict__.iteritems()]
7287 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7288 
 
7289 
  def __eq__(self, other):
7290 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7291 
 
7292 
  def __ne__(self, other):
7293 
    return not (self == other)
7294 
 
1845 vikas 7295 
class createMasterAffiliate_args:
7296 
  """
7297 
  Attributes:
7298 
   - name
1859 vikas 7299 
   - addedOn
1845 vikas 7300 
  """
7301 
 
7302 
  thrift_spec = (
7303 
    None, # 0
7304 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 7305 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 7306 
  )
7307 
 
1859 vikas 7308 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 7309 
    self.name = name
1859 vikas 7310 
    self.addedOn = addedOn
1845 vikas 7311 
 
7312 
  def read(self, iprot):
7313 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7314 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7315 
      return
7316 
    iprot.readStructBegin()
7317 
    while True:
7318 
      (fname, ftype, fid) = iprot.readFieldBegin()
7319 
      if ftype == TType.STOP:
7320 
        break
7321 
      if fid == 1:
7322 
        if ftype == TType.STRING:
7323 
          self.name = iprot.readString();
7324 
        else:
7325 
          iprot.skip(ftype)
1859 vikas 7326 
      elif fid == 2:
7327 
        if ftype == TType.I64:
7328 
          self.addedOn = iprot.readI64();
7329 
        else:
7330 
          iprot.skip(ftype)
1845 vikas 7331 
      else:
7332 
        iprot.skip(ftype)
7333 
      iprot.readFieldEnd()
7334 
    iprot.readStructEnd()
7335 
 
7336 
  def write(self, oprot):
7337 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7338 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7339 
      return
7340 
    oprot.writeStructBegin('createMasterAffiliate_args')
7341 
    if self.name != None:
7342 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7343 
      oprot.writeString(self.name)
7344 
      oprot.writeFieldEnd()
1859 vikas 7345 
    if self.addedOn != None:
7346 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
7347 
      oprot.writeI64(self.addedOn)
7348 
      oprot.writeFieldEnd()
1845 vikas 7349 
    oprot.writeFieldStop()
7350 
    oprot.writeStructEnd()
7351 
 
7352 
  def __repr__(self):
7353 
    L = ['%s=%r' % (key, value)
7354 
      for key, value in self.__dict__.iteritems()]
7355 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7356 
 
7357 
  def __eq__(self, other):
7358 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7359 
 
7360 
  def __ne__(self, other):
7361 
    return not (self == other)
7362 
 
7363 
class createMasterAffiliate_result:
7364 
  """
7365 
  Attributes:
7366 
   - success
7367 
   - utx
7368 
  """
7369 
 
7370 
  thrift_spec = (
7371 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7372 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7373 
  )
7374 
 
7375 
  def __init__(self, success=None, utx=None,):
7376 
    self.success = success
7377 
    self.utx = utx
7378 
 
7379 
  def read(self, iprot):
7380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7382 
      return
7383 
    iprot.readStructBegin()
7384 
    while True:
7385 
      (fname, ftype, fid) = iprot.readFieldBegin()
7386 
      if ftype == TType.STOP:
7387 
        break
7388 
      if fid == 0:
7389 
        if ftype == TType.STRUCT:
7390 
          self.success = MasterAffiliate()
7391 
          self.success.read(iprot)
7392 
        else:
7393 
          iprot.skip(ftype)
7394 
      elif fid == 1:
7395 
        if ftype == TType.STRUCT:
1996 vikas 7396 
          self.utx = UserAffiliateException()
1845 vikas 7397 
          self.utx.read(iprot)
7398 
        else:
7399 
          iprot.skip(ftype)
7400 
      else:
7401 
        iprot.skip(ftype)
7402 
      iprot.readFieldEnd()
7403 
    iprot.readStructEnd()
7404 
 
7405 
  def write(self, oprot):
7406 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7407 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7408 
      return
7409 
    oprot.writeStructBegin('createMasterAffiliate_result')
7410 
    if self.success != None:
7411 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7412 
      self.success.write(oprot)
7413 
      oprot.writeFieldEnd()
7414 
    if self.utx != None:
7415 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7416 
      self.utx.write(oprot)
7417 
      oprot.writeFieldEnd()
7418 
    oprot.writeFieldStop()
7419 
    oprot.writeStructEnd()
7420 
 
7421 
  def __repr__(self):
7422 
    L = ['%s=%r' % (key, value)
7423 
      for key, value in self.__dict__.iteritems()]
7424 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7425 
 
7426 
  def __eq__(self, other):
7427 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7428 
 
7429 
  def __ne__(self, other):
7430 
    return not (self == other)
7431 
 
1899 vikas 7432 
class getAllMasterAffiliates_args:
7433 
 
7434 
  thrift_spec = (
7435 
  )
7436 
 
7437 
  def read(self, iprot):
7438 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7439 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7440 
      return
7441 
    iprot.readStructBegin()
7442 
    while True:
7443 
      (fname, ftype, fid) = iprot.readFieldBegin()
7444 
      if ftype == TType.STOP:
7445 
        break
7446 
      else:
7447 
        iprot.skip(ftype)
7448 
      iprot.readFieldEnd()
7449 
    iprot.readStructEnd()
7450 
 
7451 
  def write(self, oprot):
7452 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7453 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7454 
      return
7455 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
7456 
    oprot.writeFieldStop()
7457 
    oprot.writeStructEnd()
7458 
 
7459 
  def __repr__(self):
7460 
    L = ['%s=%r' % (key, value)
7461 
      for key, value in self.__dict__.iteritems()]
7462 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7463 
 
7464 
  def __eq__(self, other):
7465 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7466 
 
7467 
  def __ne__(self, other):
7468 
    return not (self == other)
7469 
 
7470 
class getAllMasterAffiliates_result:
7471 
  """
7472 
  Attributes:
7473 
   - success
7474 
   - utx
7475 
  """
7476 
 
7477 
  thrift_spec = (
7478 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 7479 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 7480 
  )
7481 
 
7482 
  def __init__(self, success=None, utx=None,):
7483 
    self.success = success
7484 
    self.utx = utx
7485 
 
7486 
  def read(self, iprot):
7487 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7488 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7489 
      return
7490 
    iprot.readStructBegin()
7491 
    while True:
7492 
      (fname, ftype, fid) = iprot.readFieldBegin()
7493 
      if ftype == TType.STOP:
7494 
        break
7495 
      if fid == 0:
7496 
        if ftype == TType.LIST:
7497 
          self.success = []
2981 rajveer 7498 
          (_etype52, _size49) = iprot.readListBegin()
7499 
          for _i53 in xrange(_size49):
7500 
            _elem54 = MasterAffiliate()
7501 
            _elem54.read(iprot)
7502 
            self.success.append(_elem54)
1899 vikas 7503 
          iprot.readListEnd()
7504 
        else:
7505 
          iprot.skip(ftype)
7506 
      elif fid == 1:
7507 
        if ftype == TType.STRUCT:
1996 vikas 7508 
          self.utx = UserAffiliateException()
1899 vikas 7509 
          self.utx.read(iprot)
7510 
        else:
7511 
          iprot.skip(ftype)
7512 
      else:
7513 
        iprot.skip(ftype)
7514 
      iprot.readFieldEnd()
7515 
    iprot.readStructEnd()
7516 
 
7517 
  def write(self, oprot):
7518 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7519 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7520 
      return
7521 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
7522 
    if self.success != None:
7523 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7524 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 7525 
      for iter55 in self.success:
7526 
        iter55.write(oprot)
1899 vikas 7527 
      oprot.writeListEnd()
7528 
      oprot.writeFieldEnd()
7529 
    if self.utx != None:
7530 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7531 
      self.utx.write(oprot)
7532 
      oprot.writeFieldEnd()
7533 
    oprot.writeFieldStop()
7534 
    oprot.writeStructEnd()
7535 
 
7536 
  def __repr__(self):
7537 
    L = ['%s=%r' % (key, value)
7538 
      for key, value in self.__dict__.iteritems()]
7539 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7540 
 
7541 
  def __eq__(self, other):
7542 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7543 
 
7544 
  def __ne__(self, other):
7545 
    return not (self == other)
7546 
 
1845 vikas 7547 
class getMasterAffiliateById_args:
7548 
  """
7549 
  Attributes:
7550 
   - id
7551 
  """
7552 
 
7553 
  thrift_spec = (
7554 
    None, # 0
7555 
    (1, TType.I64, 'id', None, None, ), # 1
7556 
  )
7557 
 
7558 
  def __init__(self, id=None,):
7559 
    self.id = id
7560 
 
7561 
  def read(self, iprot):
7562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7564 
      return
7565 
    iprot.readStructBegin()
7566 
    while True:
7567 
      (fname, ftype, fid) = iprot.readFieldBegin()
7568 
      if ftype == TType.STOP:
7569 
        break
7570 
      if fid == 1:
7571 
        if ftype == TType.I64:
7572 
          self.id = iprot.readI64();
7573 
        else:
7574 
          iprot.skip(ftype)
7575 
      else:
7576 
        iprot.skip(ftype)
7577 
      iprot.readFieldEnd()
7578 
    iprot.readStructEnd()
7579 
 
7580 
  def write(self, oprot):
7581 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7582 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7583 
      return
7584 
    oprot.writeStructBegin('getMasterAffiliateById_args')
7585 
    if self.id != None:
7586 
      oprot.writeFieldBegin('id', TType.I64, 1)
7587 
      oprot.writeI64(self.id)
7588 
      oprot.writeFieldEnd()
7589 
    oprot.writeFieldStop()
7590 
    oprot.writeStructEnd()
7591 
 
7592 
  def __repr__(self):
7593 
    L = ['%s=%r' % (key, value)
7594 
      for key, value in self.__dict__.iteritems()]
7595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7596 
 
7597 
  def __eq__(self, other):
7598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7599 
 
7600 
  def __ne__(self, other):
7601 
    return not (self == other)
7602 
 
7603 
class getMasterAffiliateById_result:
7604 
  """
7605 
  Attributes:
7606 
   - success
7607 
   - utx
7608 
  """
7609 
 
7610 
  thrift_spec = (
7611 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7612 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7613 
  )
7614 
 
7615 
  def __init__(self, success=None, utx=None,):
7616 
    self.success = success
7617 
    self.utx = utx
7618 
 
7619 
  def read(self, iprot):
7620 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7621 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7622 
      return
7623 
    iprot.readStructBegin()
7624 
    while True:
7625 
      (fname, ftype, fid) = iprot.readFieldBegin()
7626 
      if ftype == TType.STOP:
7627 
        break
7628 
      if fid == 0:
7629 
        if ftype == TType.STRUCT:
7630 
          self.success = MasterAffiliate()
7631 
          self.success.read(iprot)
7632 
        else:
7633 
          iprot.skip(ftype)
7634 
      elif fid == 1:
7635 
        if ftype == TType.STRUCT:
1996 vikas 7636 
          self.utx = UserAffiliateException()
1845 vikas 7637 
          self.utx.read(iprot)
7638 
        else:
7639 
          iprot.skip(ftype)
7640 
      else:
7641 
        iprot.skip(ftype)
7642 
      iprot.readFieldEnd()
7643 
    iprot.readStructEnd()
7644 
 
7645 
  def write(self, oprot):
7646 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7647 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7648 
      return
7649 
    oprot.writeStructBegin('getMasterAffiliateById_result')
7650 
    if self.success != None:
7651 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7652 
      self.success.write(oprot)
7653 
      oprot.writeFieldEnd()
7654 
    if self.utx != None:
7655 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7656 
      self.utx.write(oprot)
7657 
      oprot.writeFieldEnd()
7658 
    oprot.writeFieldStop()
7659 
    oprot.writeStructEnd()
7660 
 
7661 
  def __repr__(self):
7662 
    L = ['%s=%r' % (key, value)
7663 
      for key, value in self.__dict__.iteritems()]
7664 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7665 
 
7666 
  def __eq__(self, other):
7667 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7668 
 
7669 
  def __ne__(self, other):
7670 
    return not (self == other)
7671 
 
7672 
class getMasterAffiliateByName_args:
7673 
  """
7674 
  Attributes:
7675 
   - name
7676 
  """
7677 
 
7678 
  thrift_spec = (
7679 
    None, # 0
7680 
    (1, TType.STRING, 'name', None, None, ), # 1
7681 
  )
7682 
 
7683 
  def __init__(self, name=None,):
7684 
    self.name = name
7685 
 
7686 
  def read(self, iprot):
7687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7689 
      return
7690 
    iprot.readStructBegin()
7691 
    while True:
7692 
      (fname, ftype, fid) = iprot.readFieldBegin()
7693 
      if ftype == TType.STOP:
7694 
        break
7695 
      if fid == 1:
7696 
        if ftype == TType.STRING:
7697 
          self.name = iprot.readString();
7698 
        else:
7699 
          iprot.skip(ftype)
7700 
      else:
7701 
        iprot.skip(ftype)
7702 
      iprot.readFieldEnd()
7703 
    iprot.readStructEnd()
7704 
 
7705 
  def write(self, oprot):
7706 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7707 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7708 
      return
7709 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
7710 
    if self.name != None:
7711 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7712 
      oprot.writeString(self.name)
7713 
      oprot.writeFieldEnd()
7714 
    oprot.writeFieldStop()
7715 
    oprot.writeStructEnd()
7716 
 
7717 
  def __repr__(self):
7718 
    L = ['%s=%r' % (key, value)
7719 
      for key, value in self.__dict__.iteritems()]
7720 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7721 
 
7722 
  def __eq__(self, other):
7723 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7724 
 
7725 
  def __ne__(self, other):
7726 
    return not (self == other)
7727 
 
7728 
class getMasterAffiliateByName_result:
7729 
  """
7730 
  Attributes:
7731 
   - success
7732 
   - utx
7733 
  """
7734 
 
7735 
  thrift_spec = (
7736 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7737 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7738 
  )
7739 
 
7740 
  def __init__(self, success=None, utx=None,):
7741 
    self.success = success
7742 
    self.utx = utx
7743 
 
7744 
  def read(self, iprot):
7745 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7746 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7747 
      return
7748 
    iprot.readStructBegin()
7749 
    while True:
7750 
      (fname, ftype, fid) = iprot.readFieldBegin()
7751 
      if ftype == TType.STOP:
7752 
        break
7753 
      if fid == 0:
7754 
        if ftype == TType.STRUCT:
7755 
          self.success = MasterAffiliate()
7756 
          self.success.read(iprot)
7757 
        else:
7758 
          iprot.skip(ftype)
7759 
      elif fid == 1:
7760 
        if ftype == TType.STRUCT:
1996 vikas 7761 
          self.utx = UserAffiliateException()
1845 vikas 7762 
          self.utx.read(iprot)
7763 
        else:
7764 
          iprot.skip(ftype)
7765 
      else:
7766 
        iprot.skip(ftype)
7767 
      iprot.readFieldEnd()
7768 
    iprot.readStructEnd()
7769 
 
7770 
  def write(self, oprot):
7771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7773 
      return
7774 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
7775 
    if self.success != None:
7776 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7777 
      self.success.write(oprot)
7778 
      oprot.writeFieldEnd()
7779 
    if self.utx != None:
7780 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7781 
      self.utx.write(oprot)
7782 
      oprot.writeFieldEnd()
7783 
    oprot.writeFieldStop()
7784 
    oprot.writeStructEnd()
7785 
 
7786 
  def __repr__(self):
7787 
    L = ['%s=%r' % (key, value)
7788 
      for key, value in self.__dict__.iteritems()]
7789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7790 
 
7791 
  def __eq__(self, other):
7792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7793 
 
7794 
  def __ne__(self, other):
7795 
    return not (self == other)
7796 
 
7797 
class createAffiliate_args:
7798 
  """
7799 
  Attributes:
7800 
   - name
7801 
   - url
7802 
   - masterAffiliateId
1859 vikas 7803 
   - addedOn
1845 vikas 7804 
  """
7805 
 
7806 
  thrift_spec = (
7807 
    None, # 0
7808 
    (1, TType.STRING, 'name', None, None, ), # 1
7809 
    (2, TType.STRING, 'url', None, None, ), # 2
7810 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 7811 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 7812 
  )
7813 
 
1859 vikas 7814 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 7815 
    self.name = name
7816 
    self.url = url
7817 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 7818 
    self.addedOn = addedOn
1845 vikas 7819 
 
7820 
  def read(self, iprot):
7821 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7822 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7823 
      return
7824 
    iprot.readStructBegin()
7825 
    while True:
7826 
      (fname, ftype, fid) = iprot.readFieldBegin()
7827 
      if ftype == TType.STOP:
7828 
        break
7829 
      if fid == 1:
7830 
        if ftype == TType.STRING:
7831 
          self.name = iprot.readString();
7832 
        else:
7833 
          iprot.skip(ftype)
7834 
      elif fid == 2:
7835 
        if ftype == TType.STRING:
7836 
          self.url = iprot.readString();
7837 
        else:
7838 
          iprot.skip(ftype)
7839 
      elif fid == 3:
7840 
        if ftype == TType.I64:
7841 
          self.masterAffiliateId = iprot.readI64();
7842 
        else:
7843 
          iprot.skip(ftype)
1859 vikas 7844 
      elif fid == 4:
7845 
        if ftype == TType.I64:
7846 
          self.addedOn = iprot.readI64();
7847 
        else:
7848 
          iprot.skip(ftype)
1845 vikas 7849 
      else:
7850 
        iprot.skip(ftype)
7851 
      iprot.readFieldEnd()
7852 
    iprot.readStructEnd()
7853 
 
7854 
  def write(self, oprot):
7855 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7856 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7857 
      return
7858 
    oprot.writeStructBegin('createAffiliate_args')
7859 
    if self.name != None:
7860 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7861 
      oprot.writeString(self.name)
7862 
      oprot.writeFieldEnd()
7863 
    if self.url != None:
7864 
      oprot.writeFieldBegin('url', TType.STRING, 2)
7865 
      oprot.writeString(self.url)
7866 
      oprot.writeFieldEnd()
7867 
    if self.masterAffiliateId != None:
7868 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
7869 
      oprot.writeI64(self.masterAffiliateId)
7870 
      oprot.writeFieldEnd()
1859 vikas 7871 
    if self.addedOn != None:
7872 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
7873 
      oprot.writeI64(self.addedOn)
7874 
      oprot.writeFieldEnd()
1845 vikas 7875 
    oprot.writeFieldStop()
7876 
    oprot.writeStructEnd()
7877 
 
7878 
  def __repr__(self):
7879 
    L = ['%s=%r' % (key, value)
7880 
      for key, value in self.__dict__.iteritems()]
7881 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7882 
 
7883 
  def __eq__(self, other):
7884 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7885 
 
7886 
  def __ne__(self, other):
7887 
    return not (self == other)
7888 
 
7889 
class createAffiliate_result:
7890 
  """
7891 
  Attributes:
7892 
   - success
7893 
   - utx
7894 
  """
7895 
 
7896 
  thrift_spec = (
7897 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 7898 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7899 
  )
7900 
 
7901 
  def __init__(self, success=None, utx=None,):
7902 
    self.success = success
7903 
    self.utx = utx
7904 
 
7905 
  def read(self, iprot):
7906 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7907 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7908 
      return
7909 
    iprot.readStructBegin()
7910 
    while True:
7911 
      (fname, ftype, fid) = iprot.readFieldBegin()
7912 
      if ftype == TType.STOP:
7913 
        break
7914 
      if fid == 0:
7915 
        if ftype == TType.STRUCT:
7916 
          self.success = Affiliate()
7917 
          self.success.read(iprot)
7918 
        else:
7919 
          iprot.skip(ftype)
7920 
      elif fid == 1:
7921 
        if ftype == TType.STRUCT:
1996 vikas 7922 
          self.utx = UserAffiliateException()
1845 vikas 7923 
          self.utx.read(iprot)
7924 
        else:
7925 
          iprot.skip(ftype)
7926 
      else:
7927 
        iprot.skip(ftype)
7928 
      iprot.readFieldEnd()
7929 
    iprot.readStructEnd()
7930 
 
7931 
  def write(self, oprot):
7932 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7933 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7934 
      return
7935 
    oprot.writeStructBegin('createAffiliate_result')
7936 
    if self.success != None:
7937 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7938 
      self.success.write(oprot)
7939 
      oprot.writeFieldEnd()
7940 
    if self.utx != None:
7941 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7942 
      self.utx.write(oprot)
7943 
      oprot.writeFieldEnd()
7944 
    oprot.writeFieldStop()
7945 
    oprot.writeStructEnd()
7946 
 
7947 
  def __repr__(self):
7948 
    L = ['%s=%r' % (key, value)
7949 
      for key, value in self.__dict__.iteritems()]
7950 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7951 
 
7952 
  def __eq__(self, other):
7953 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7954 
 
7955 
  def __ne__(self, other):
7956 
    return not (self == other)
7957 
 
7958 
class getAffiliateById_args:
7959 
  """
7960 
  Attributes:
7961 
   - id
7962 
  """
7963 
 
7964 
  thrift_spec = (
7965 
    None, # 0
7966 
    (1, TType.I64, 'id', None, None, ), # 1
7967 
  )
7968 
 
7969 
  def __init__(self, id=None,):
7970 
    self.id = id
7971 
 
7972 
  def read(self, iprot):
7973 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7974 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7975 
      return
7976 
    iprot.readStructBegin()
7977 
    while True:
7978 
      (fname, ftype, fid) = iprot.readFieldBegin()
7979 
      if ftype == TType.STOP:
7980 
        break
7981 
      if fid == 1:
7982 
        if ftype == TType.I64:
7983 
          self.id = iprot.readI64();
7984 
        else:
7985 
          iprot.skip(ftype)
7986 
      else:
7987 
        iprot.skip(ftype)
7988 
      iprot.readFieldEnd()
7989 
    iprot.readStructEnd()
7990 
 
7991 
  def write(self, oprot):
7992 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7993 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7994 
      return
7995 
    oprot.writeStructBegin('getAffiliateById_args')
7996 
    if self.id != None:
7997 
      oprot.writeFieldBegin('id', TType.I64, 1)
7998 
      oprot.writeI64(self.id)
7999 
      oprot.writeFieldEnd()
8000 
    oprot.writeFieldStop()
8001 
    oprot.writeStructEnd()
8002 
 
8003 
  def __repr__(self):
8004 
    L = ['%s=%r' % (key, value)
8005 
      for key, value in self.__dict__.iteritems()]
8006 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8007 
 
8008 
  def __eq__(self, other):
8009 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8010 
 
8011 
  def __ne__(self, other):
8012 
    return not (self == other)
8013 
 
8014 
class getAffiliateById_result:
8015 
  """
8016 
  Attributes:
8017 
   - success
8018 
   - utx
8019 
  """
8020 
 
8021 
  thrift_spec = (
8022 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8023 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8024 
  )
8025 
 
8026 
  def __init__(self, success=None, utx=None,):
8027 
    self.success = success
8028 
    self.utx = utx
8029 
 
8030 
  def read(self, iprot):
8031 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8032 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8033 
      return
8034 
    iprot.readStructBegin()
8035 
    while True:
8036 
      (fname, ftype, fid) = iprot.readFieldBegin()
8037 
      if ftype == TType.STOP:
8038 
        break
8039 
      if fid == 0:
8040 
        if ftype == TType.STRUCT:
8041 
          self.success = Affiliate()
8042 
          self.success.read(iprot)
8043 
        else:
8044 
          iprot.skip(ftype)
8045 
      elif fid == 1:
8046 
        if ftype == TType.STRUCT:
1996 vikas 8047 
          self.utx = UserAffiliateException()
1845 vikas 8048 
          self.utx.read(iprot)
8049 
        else:
8050 
          iprot.skip(ftype)
8051 
      else:
8052 
        iprot.skip(ftype)
8053 
      iprot.readFieldEnd()
8054 
    iprot.readStructEnd()
8055 
 
8056 
  def write(self, oprot):
8057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8059 
      return
8060 
    oprot.writeStructBegin('getAffiliateById_result')
8061 
    if self.success != None:
8062 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8063 
      self.success.write(oprot)
8064 
      oprot.writeFieldEnd()
8065 
    if self.utx != None:
8066 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8067 
      self.utx.write(oprot)
8068 
      oprot.writeFieldEnd()
8069 
    oprot.writeFieldStop()
8070 
    oprot.writeStructEnd()
8071 
 
8072 
  def __repr__(self):
8073 
    L = ['%s=%r' % (key, value)
8074 
      for key, value in self.__dict__.iteritems()]
8075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8076 
 
8077 
  def __eq__(self, other):
8078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8079 
 
8080 
  def __ne__(self, other):
8081 
    return not (self == other)
8082 
 
8083 
class getAffiliateByName_args:
8084 
  """
8085 
  Attributes:
8086 
   - name
8087 
  """
8088 
 
8089 
  thrift_spec = (
8090 
    None, # 0
8091 
    (1, TType.STRING, 'name', None, None, ), # 1
8092 
  )
8093 
 
8094 
  def __init__(self, name=None,):
8095 
    self.name = name
8096 
 
8097 
  def read(self, iprot):
8098 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8099 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8100 
      return
8101 
    iprot.readStructBegin()
8102 
    while True:
8103 
      (fname, ftype, fid) = iprot.readFieldBegin()
8104 
      if ftype == TType.STOP:
8105 
        break
8106 
      if fid == 1:
8107 
        if ftype == TType.STRING:
8108 
          self.name = iprot.readString();
8109 
        else:
8110 
          iprot.skip(ftype)
8111 
      else:
8112 
        iprot.skip(ftype)
8113 
      iprot.readFieldEnd()
8114 
    iprot.readStructEnd()
8115 
 
8116 
  def write(self, oprot):
8117 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8118 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8119 
      return
8120 
    oprot.writeStructBegin('getAffiliateByName_args')
8121 
    if self.name != None:
8122 
      oprot.writeFieldBegin('name', TType.STRING, 1)
8123 
      oprot.writeString(self.name)
8124 
      oprot.writeFieldEnd()
8125 
    oprot.writeFieldStop()
8126 
    oprot.writeStructEnd()
8127 
 
8128 
  def __repr__(self):
8129 
    L = ['%s=%r' % (key, value)
8130 
      for key, value in self.__dict__.iteritems()]
8131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8132 
 
8133 
  def __eq__(self, other):
8134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8135 
 
8136 
  def __ne__(self, other):
8137 
    return not (self == other)
8138 
 
8139 
class getAffiliateByName_result:
8140 
  """
8141 
  Attributes:
8142 
   - success
8143 
   - utx
8144 
  """
8145 
 
8146 
  thrift_spec = (
8147 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8148 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8149 
  )
8150 
 
8151 
  def __init__(self, success=None, utx=None,):
8152 
    self.success = success
8153 
    self.utx = utx
8154 
 
8155 
  def read(self, iprot):
8156 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8157 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8158 
      return
8159 
    iprot.readStructBegin()
8160 
    while True:
8161 
      (fname, ftype, fid) = iprot.readFieldBegin()
8162 
      if ftype == TType.STOP:
8163 
        break
8164 
      if fid == 0:
8165 
        if ftype == TType.STRUCT:
8166 
          self.success = Affiliate()
8167 
          self.success.read(iprot)
8168 
        else:
8169 
          iprot.skip(ftype)
8170 
      elif fid == 1:
8171 
        if ftype == TType.STRUCT:
1996 vikas 8172 
          self.utx = UserAffiliateException()
1845 vikas 8173 
          self.utx.read(iprot)
8174 
        else:
8175 
          iprot.skip(ftype)
8176 
      else:
8177 
        iprot.skip(ftype)
8178 
      iprot.readFieldEnd()
8179 
    iprot.readStructEnd()
8180 
 
8181 
  def write(self, oprot):
8182 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8183 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8184 
      return
8185 
    oprot.writeStructBegin('getAffiliateByName_result')
8186 
    if self.success != None:
8187 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8188 
      self.success.write(oprot)
8189 
      oprot.writeFieldEnd()
8190 
    if self.utx != None:
8191 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8192 
      self.utx.write(oprot)
8193 
      oprot.writeFieldEnd()
8194 
    oprot.writeFieldStop()
8195 
    oprot.writeStructEnd()
8196 
 
8197 
  def __repr__(self):
8198 
    L = ['%s=%r' % (key, value)
8199 
      for key, value in self.__dict__.iteritems()]
8200 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8201 
 
8202 
  def __eq__(self, other):
8203 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8204 
 
8205 
  def __ne__(self, other):
8206 
    return not (self == other)
8207 
 
1996 vikas 8208 
class getTrackerById_args:
1845 vikas 8209 
  """
8210 
  Attributes:
8211 
   - id
8212 
  """
8213 
 
8214 
  thrift_spec = (
8215 
    None, # 0
8216 
    (1, TType.I64, 'id', None, None, ), # 1
8217 
  )
8218 
 
8219 
  def __init__(self, id=None,):
8220 
    self.id = id
8221 
 
8222 
  def read(self, iprot):
8223 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8224 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8225 
      return
8226 
    iprot.readStructBegin()
8227 
    while True:
8228 
      (fname, ftype, fid) = iprot.readFieldBegin()
8229 
      if ftype == TType.STOP:
8230 
        break
8231 
      if fid == 1:
8232 
        if ftype == TType.I64:
8233 
          self.id = iprot.readI64();
8234 
        else:
8235 
          iprot.skip(ftype)
8236 
      else:
8237 
        iprot.skip(ftype)
8238 
      iprot.readFieldEnd()
8239 
    iprot.readStructEnd()
8240 
 
8241 
  def write(self, oprot):
8242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8244 
      return
1996 vikas 8245 
    oprot.writeStructBegin('getTrackerById_args')
1845 vikas 8246 
    if self.id != None:
8247 
      oprot.writeFieldBegin('id', TType.I64, 1)
8248 
      oprot.writeI64(self.id)
8249 
      oprot.writeFieldEnd()
8250 
    oprot.writeFieldStop()
8251 
    oprot.writeStructEnd()
8252 
 
8253 
  def __repr__(self):
8254 
    L = ['%s=%r' % (key, value)
8255 
      for key, value in self.__dict__.iteritems()]
8256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8257 
 
8258 
  def __eq__(self, other):
8259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8260 
 
8261 
  def __ne__(self, other):
8262 
    return not (self == other)
8263 
 
8264 
class getTrackerById_result:
8265 
  """
8266 
  Attributes:
8267 
   - success
8268 
   - utx
8269 
  """
8270 
 
8271 
  thrift_spec = (
8272 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 8273 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8274 
  )
8275 
 
8276 
  def __init__(self, success=None, utx=None,):
8277 
    self.success = success
8278 
    self.utx = utx
8279 
 
8280 
  def read(self, iprot):
8281 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8282 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8283 
      return
8284 
    iprot.readStructBegin()
8285 
    while True:
8286 
      (fname, ftype, fid) = iprot.readFieldBegin()
8287 
      if ftype == TType.STOP:
8288 
        break
8289 
      if fid == 0:
8290 
        if ftype == TType.STRUCT:
8291 
          self.success = Tracker()
8292 
          self.success.read(iprot)
8293 
        else:
8294 
          iprot.skip(ftype)
8295 
      elif fid == 1:
8296 
        if ftype == TType.STRUCT:
1996 vikas 8297 
          self.utx = UserAffiliateException()
1845 vikas 8298 
          self.utx.read(iprot)
8299 
        else:
8300 
          iprot.skip(ftype)
8301 
      else:
8302 
        iprot.skip(ftype)
8303 
      iprot.readFieldEnd()
8304 
    iprot.readStructEnd()
8305 
 
8306 
  def write(self, oprot):
8307 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8308 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8309 
      return
8310 
    oprot.writeStructBegin('getTrackerById_result')
8311 
    if self.success != None:
8312 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8313 
      self.success.write(oprot)
8314 
      oprot.writeFieldEnd()
8315 
    if self.utx != None:
8316 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8317 
      self.utx.write(oprot)
8318 
      oprot.writeFieldEnd()
8319 
    oprot.writeFieldStop()
8320 
    oprot.writeStructEnd()
8321 
 
8322 
  def __repr__(self):
8323 
    L = ['%s=%r' % (key, value)
8324 
      for key, value in self.__dict__.iteritems()]
8325 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8326 
 
8327 
  def __eq__(self, other):
8328 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8329 
 
8330 
  def __ne__(self, other):
8331 
    return not (self == other)
8332 
 
1996 vikas 8333 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 8334 
  """
8335 
  Attributes:
1996 vikas 8336 
   - id
1845 vikas 8337 
  """
8338 
 
8339 
  thrift_spec = (
8340 
    None, # 0
1996 vikas 8341 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 8342 
  )
8343 
 
1996 vikas 8344 
  def __init__(self, id=None,):
8345 
    self.id = id
1845 vikas 8346 
 
8347 
  def read(self, iprot):
8348 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8349 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8350 
      return
8351 
    iprot.readStructBegin()
8352 
    while True:
8353 
      (fname, ftype, fid) = iprot.readFieldBegin()
8354 
      if ftype == TType.STOP:
8355 
        break
8356 
      if fid == 1:
8357 
        if ftype == TType.I64:
1996 vikas 8358 
          self.id = iprot.readI64();
1845 vikas 8359 
        else:
8360 
          iprot.skip(ftype)
8361 
      else:
8362 
        iprot.skip(ftype)
8363 
      iprot.readFieldEnd()
8364 
    iprot.readStructEnd()
8365 
 
8366 
  def write(self, oprot):
8367 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8368 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8369 
      return
1996 vikas 8370 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
8371 
    if self.id != None:
8372 
      oprot.writeFieldBegin('id', TType.I64, 1)
8373 
      oprot.writeI64(self.id)
1845 vikas 8374 
      oprot.writeFieldEnd()
8375 
    oprot.writeFieldStop()
8376 
    oprot.writeStructEnd()
8377 
 
8378 
  def __repr__(self):
8379 
    L = ['%s=%r' % (key, value)
8380 
      for key, value in self.__dict__.iteritems()]
8381 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8382 
 
8383 
  def __eq__(self, other):
8384 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8385 
 
8386 
  def __ne__(self, other):
8387 
    return not (self == other)
8388 
 
1996 vikas 8389 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 8390 
  """
8391 
  Attributes:
8392 
   - success
8393 
   - utx
8394 
  """
8395 
 
8396 
  thrift_spec = (
1996 vikas 8397 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
8398 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8399 
  )
8400 
 
8401 
  def __init__(self, success=None, utx=None,):
8402 
    self.success = success
8403 
    self.utx = utx
8404 
 
8405 
  def read(self, iprot):
8406 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8407 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8408 
      return
8409 
    iprot.readStructBegin()
8410 
    while True:
8411 
      (fname, ftype, fid) = iprot.readFieldBegin()
8412 
      if ftype == TType.STOP:
8413 
        break
8414 
      if fid == 0:
8415 
        if ftype == TType.LIST:
8416 
          self.success = []
2981 rajveer 8417 
          (_etype59, _size56) = iprot.readListBegin()
8418 
          for _i60 in xrange(_size56):
8419 
            _elem61 = Affiliate()
8420 
            _elem61.read(iprot)
8421 
            self.success.append(_elem61)
1845 vikas 8422 
          iprot.readListEnd()
8423 
        else:
8424 
          iprot.skip(ftype)
8425 
      elif fid == 1:
8426 
        if ftype == TType.STRUCT:
1996 vikas 8427 
          self.utx = UserAffiliateException()
1845 vikas 8428 
          self.utx.read(iprot)
8429 
        else:
8430 
          iprot.skip(ftype)
8431 
      else:
8432 
        iprot.skip(ftype)
8433 
      iprot.readFieldEnd()
8434 
    iprot.readStructEnd()
8435 
 
8436 
  def write(self, oprot):
8437 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8438 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8439 
      return
1996 vikas 8440 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
1845 vikas 8441 
    if self.success != None:
8442 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8443 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 8444 
      for iter62 in self.success:
8445 
        iter62.write(oprot)
1845 vikas 8446 
      oprot.writeListEnd()
8447 
      oprot.writeFieldEnd()
8448 
    if self.utx != None:
8449 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8450 
      self.utx.write(oprot)
8451 
      oprot.writeFieldEnd()
8452 
    oprot.writeFieldStop()
8453 
    oprot.writeStructEnd()
8454 
 
8455 
  def __repr__(self):
8456 
    L = ['%s=%r' % (key, value)
8457 
      for key, value in self.__dict__.iteritems()]
8458 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8459 
 
8460 
  def __eq__(self, other):
8461 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8462 
 
8463 
  def __ne__(self, other):
8464 
    return not (self == other)
8465 
 
8466 
class addTrackLog_args:
8467 
  """
8468 
  Attributes:
1996 vikas 8469 
   - affiliateId
1845 vikas 8470 
   - userId
8471 
   - event
8472 
   - url
8473 
   - data
1859 vikas 8474 
   - addedOn
1845 vikas 8475 
  """
8476 
 
8477 
  thrift_spec = (
8478 
    None, # 0
1996 vikas 8479 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 8480 
    (2, TType.I64, 'userId', None, None, ), # 2
8481 
    (3, TType.STRING, 'event', None, None, ), # 3
8482 
    (4, TType.STRING, 'url', None, None, ), # 4
8483 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 8484 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 8485 
  )
8486 
 
1996 vikas 8487 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
8488 
    self.affiliateId = affiliateId
1845 vikas 8489 
    self.userId = userId
8490 
    self.event = event
8491 
    self.url = url
8492 
    self.data = data
1859 vikas 8493 
    self.addedOn = addedOn
1845 vikas 8494 
 
8495 
  def read(self, iprot):
8496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8498 
      return
8499 
    iprot.readStructBegin()
8500 
    while True:
8501 
      (fname, ftype, fid) = iprot.readFieldBegin()
8502 
      if ftype == TType.STOP:
8503 
        break
8504 
      if fid == 1:
8505 
        if ftype == TType.I64:
1996 vikas 8506 
          self.affiliateId = iprot.readI64();
1845 vikas 8507 
        else:
8508 
          iprot.skip(ftype)
8509 
      elif fid == 2:
8510 
        if ftype == TType.I64:
8511 
          self.userId = iprot.readI64();
8512 
        else:
8513 
          iprot.skip(ftype)
8514 
      elif fid == 3:
8515 
        if ftype == TType.STRING:
8516 
          self.event = iprot.readString();
8517 
        else:
8518 
          iprot.skip(ftype)
8519 
      elif fid == 4:
8520 
        if ftype == TType.STRING:
8521 
          self.url = iprot.readString();
8522 
        else:
8523 
          iprot.skip(ftype)
8524 
      elif fid == 5:
8525 
        if ftype == TType.STRING:
8526 
          self.data = iprot.readString();
8527 
        else:
8528 
          iprot.skip(ftype)
1859 vikas 8529 
      elif fid == 6:
8530 
        if ftype == TType.I64:
8531 
          self.addedOn = iprot.readI64();
8532 
        else:
8533 
          iprot.skip(ftype)
1845 vikas 8534 
      else:
8535 
        iprot.skip(ftype)
8536 
      iprot.readFieldEnd()
8537 
    iprot.readStructEnd()
8538 
 
8539 
  def write(self, oprot):
8540 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8541 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8542 
      return
8543 
    oprot.writeStructBegin('addTrackLog_args')
1996 vikas 8544 
    if self.affiliateId != None:
8545 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
8546 
      oprot.writeI64(self.affiliateId)
1845 vikas 8547 
      oprot.writeFieldEnd()
8548 
    if self.userId != None:
8549 
      oprot.writeFieldBegin('userId', TType.I64, 2)
8550 
      oprot.writeI64(self.userId)
8551 
      oprot.writeFieldEnd()
8552 
    if self.event != None:
8553 
      oprot.writeFieldBegin('event', TType.STRING, 3)
8554 
      oprot.writeString(self.event)
8555 
      oprot.writeFieldEnd()
8556 
    if self.url != None:
8557 
      oprot.writeFieldBegin('url', TType.STRING, 4)
8558 
      oprot.writeString(self.url)
8559 
      oprot.writeFieldEnd()
8560 
    if self.data != None:
8561 
      oprot.writeFieldBegin('data', TType.STRING, 5)
8562 
      oprot.writeString(self.data)
8563 
      oprot.writeFieldEnd()
1859 vikas 8564 
    if self.addedOn != None:
8565 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
8566 
      oprot.writeI64(self.addedOn)
8567 
      oprot.writeFieldEnd()
1845 vikas 8568 
    oprot.writeFieldStop()
8569 
    oprot.writeStructEnd()
8570 
 
8571 
  def __repr__(self):
8572 
    L = ['%s=%r' % (key, value)
8573 
      for key, value in self.__dict__.iteritems()]
8574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8575 
 
8576 
  def __eq__(self, other):
8577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8578 
 
8579 
  def __ne__(self, other):
8580 
    return not (self == other)
8581 
 
8582 
class addTrackLog_result:
8583 
  """
8584 
  Attributes:
8585 
   - success
8586 
   - utx
8587 
  """
8588 
 
8589 
  thrift_spec = (
8590 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 8591 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8592 
  )
8593 
 
8594 
  def __init__(self, success=None, utx=None,):
8595 
    self.success = success
8596 
    self.utx = utx
8597 
 
8598 
  def read(self, iprot):
8599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8601 
      return
8602 
    iprot.readStructBegin()
8603 
    while True:
8604 
      (fname, ftype, fid) = iprot.readFieldBegin()
8605 
      if ftype == TType.STOP:
8606 
        break
8607 
      if fid == 0:
8608 
        if ftype == TType.I64:
8609 
          self.success = iprot.readI64();
8610 
        else:
8611 
          iprot.skip(ftype)
8612 
      elif fid == 1:
8613 
        if ftype == TType.STRUCT:
1996 vikas 8614 
          self.utx = UserAffiliateException()
1845 vikas 8615 
          self.utx.read(iprot)
8616 
        else:
8617 
          iprot.skip(ftype)
8618 
      else:
8619 
        iprot.skip(ftype)
8620 
      iprot.readFieldEnd()
8621 
    iprot.readStructEnd()
8622 
 
8623 
  def write(self, oprot):
8624 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8625 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8626 
      return
8627 
    oprot.writeStructBegin('addTrackLog_result')
8628 
    if self.success != None:
8629 
      oprot.writeFieldBegin('success', TType.I64, 0)
8630 
      oprot.writeI64(self.success)
8631 
      oprot.writeFieldEnd()
8632 
    if self.utx != None:
8633 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8634 
      self.utx.write(oprot)
8635 
      oprot.writeFieldEnd()
8636 
    oprot.writeFieldStop()
8637 
    oprot.writeStructEnd()
8638 
 
8639 
  def __repr__(self):
8640 
    L = ['%s=%r' % (key, value)
8641 
      for key, value in self.__dict__.iteritems()]
8642 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8643 
 
8644 
  def __eq__(self, other):
8645 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8646 
 
8647 
  def __ne__(self, other):
8648 
    return not (self == other)
8649 
 
8650 
class getTrackLogById_args:
8651 
  """
8652 
  Attributes:
8653 
   - id
8654 
  """
8655 
 
8656 
  thrift_spec = (
8657 
    None, # 0
8658 
    (1, TType.I64, 'id', None, None, ), # 1
8659 
  )
8660 
 
8661 
  def __init__(self, id=None,):
8662 
    self.id = id
8663 
 
8664 
  def read(self, iprot):
8665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8667 
      return
8668 
    iprot.readStructBegin()
8669 
    while True:
8670 
      (fname, ftype, fid) = iprot.readFieldBegin()
8671 
      if ftype == TType.STOP:
8672 
        break
8673 
      if fid == 1:
8674 
        if ftype == TType.I64:
8675 
          self.id = iprot.readI64();
8676 
        else:
8677 
          iprot.skip(ftype)
8678 
      else:
8679 
        iprot.skip(ftype)
8680 
      iprot.readFieldEnd()
8681 
    iprot.readStructEnd()
8682 
 
8683 
  def write(self, oprot):
8684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8686 
      return
8687 
    oprot.writeStructBegin('getTrackLogById_args')
8688 
    if self.id != None:
8689 
      oprot.writeFieldBegin('id', TType.I64, 1)
8690 
      oprot.writeI64(self.id)
8691 
      oprot.writeFieldEnd()
8692 
    oprot.writeFieldStop()
8693 
    oprot.writeStructEnd()
8694 
 
8695 
  def __repr__(self):
8696 
    L = ['%s=%r' % (key, value)
8697 
      for key, value in self.__dict__.iteritems()]
8698 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8699 
 
8700 
  def __eq__(self, other):
8701 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8702 
 
8703 
  def __ne__(self, other):
8704 
    return not (self == other)
8705 
 
8706 
class getTrackLogById_result:
8707 
  """
8708 
  Attributes:
8709 
   - success
8710 
   - utx
8711 
  """
8712 
 
8713 
  thrift_spec = (
8714 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 8715 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8716 
  )
8717 
 
8718 
  def __init__(self, success=None, utx=None,):
8719 
    self.success = success
8720 
    self.utx = utx
8721 
 
8722 
  def read(self, iprot):
8723 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8724 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8725 
      return
8726 
    iprot.readStructBegin()
8727 
    while True:
8728 
      (fname, ftype, fid) = iprot.readFieldBegin()
8729 
      if ftype == TType.STOP:
8730 
        break
8731 
      if fid == 0:
8732 
        if ftype == TType.STRUCT:
8733 
          self.success = TrackLog()
8734 
          self.success.read(iprot)
8735 
        else:
8736 
          iprot.skip(ftype)
8737 
      elif fid == 1:
8738 
        if ftype == TType.STRUCT:
1996 vikas 8739 
          self.utx = UserAffiliateException()
1845 vikas 8740 
          self.utx.read(iprot)
8741 
        else:
8742 
          iprot.skip(ftype)
8743 
      else:
8744 
        iprot.skip(ftype)
8745 
      iprot.readFieldEnd()
8746 
    iprot.readStructEnd()
8747 
 
8748 
  def write(self, oprot):
8749 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8750 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8751 
      return
8752 
    oprot.writeStructBegin('getTrackLogById_result')
8753 
    if self.success != None:
8754 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8755 
      self.success.write(oprot)
8756 
      oprot.writeFieldEnd()
8757 
    if self.utx != None:
8758 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8759 
      self.utx.write(oprot)
8760 
      oprot.writeFieldEnd()
8761 
    oprot.writeFieldStop()
8762 
    oprot.writeStructEnd()
8763 
 
8764 
  def __repr__(self):
8765 
    L = ['%s=%r' % (key, value)
8766 
      for key, value in self.__dict__.iteritems()]
8767 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8768 
 
8769 
  def __eq__(self, other):
8770 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8771 
 
8772 
  def __ne__(self, other):
8773 
    return not (self == other)
8774 
 
1996 vikas 8775 
class getTrackLogsByAffiliate_args:
1845 vikas 8776 
  """
8777 
  Attributes:
1996 vikas 8778 
   - affiliateId
3293 vikas 8779 
   - startDate
8780 
   - endDate
1845 vikas 8781 
  """
8782 
 
8783 
  thrift_spec = (
8784 
    None, # 0
1996 vikas 8785 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
3293 vikas 8786 
    (2, TType.I64, 'startDate', None, None, ), # 2
8787 
    (3, TType.I64, 'endDate', None, None, ), # 3
1845 vikas 8788 
  )
8789 
 
3293 vikas 8790 
  def __init__(self, affiliateId=None, startDate=None, endDate=None,):
1996 vikas 8791 
    self.affiliateId = affiliateId
3293 vikas 8792 
    self.startDate = startDate
8793 
    self.endDate = endDate
1845 vikas 8794 
 
8795 
  def read(self, iprot):
8796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8798 
      return
8799 
    iprot.readStructBegin()
8800 
    while True:
8801 
      (fname, ftype, fid) = iprot.readFieldBegin()
8802 
      if ftype == TType.STOP:
8803 
        break
8804 
      if fid == 1:
8805 
        if ftype == TType.I64:
1996 vikas 8806 
          self.affiliateId = iprot.readI64();
1845 vikas 8807 
        else:
8808 
          iprot.skip(ftype)
3293 vikas 8809 
      elif fid == 2:
8810 
        if ftype == TType.I64:
8811 
          self.startDate = iprot.readI64();
8812 
        else:
8813 
          iprot.skip(ftype)
8814 
      elif fid == 3:
8815 
        if ftype == TType.I64:
8816 
          self.endDate = iprot.readI64();
8817 
        else:
8818 
          iprot.skip(ftype)
1845 vikas 8819 
      else:
8820 
        iprot.skip(ftype)
8821 
      iprot.readFieldEnd()
8822 
    iprot.readStructEnd()
8823 
 
8824 
  def write(self, oprot):
8825 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8826 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8827 
      return
1996 vikas 8828 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
8829 
    if self.affiliateId != None:
8830 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
8831 
      oprot.writeI64(self.affiliateId)
1845 vikas 8832 
      oprot.writeFieldEnd()
3293 vikas 8833 
    if self.startDate != None:
8834 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
8835 
      oprot.writeI64(self.startDate)
8836 
      oprot.writeFieldEnd()
8837 
    if self.endDate != None:
8838 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
8839 
      oprot.writeI64(self.endDate)
8840 
      oprot.writeFieldEnd()
1845 vikas 8841 
    oprot.writeFieldStop()
8842 
    oprot.writeStructEnd()
8843 
 
8844 
  def __repr__(self):
8845 
    L = ['%s=%r' % (key, value)
8846 
      for key, value in self.__dict__.iteritems()]
8847 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8848 
 
8849 
  def __eq__(self, other):
8850 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8851 
 
8852 
  def __ne__(self, other):
8853 
    return not (self == other)
8854 
 
1996 vikas 8855 
class getTrackLogsByAffiliate_result:
1845 vikas 8856 
  """
8857 
  Attributes:
8858 
   - success
8859 
   - utx
8860 
  """
8861 
 
8862 
  thrift_spec = (
8863 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 8864 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8865 
  )
8866 
 
8867 
  def __init__(self, success=None, utx=None,):
8868 
    self.success = success
8869 
    self.utx = utx
8870 
 
8871 
  def read(self, iprot):
8872 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8873 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8874 
      return
8875 
    iprot.readStructBegin()
8876 
    while True:
8877 
      (fname, ftype, fid) = iprot.readFieldBegin()
8878 
      if ftype == TType.STOP:
8879 
        break
8880 
      if fid == 0:
8881 
        if ftype == TType.LIST:
8882 
          self.success = []
2981 rajveer 8883 
          (_etype66, _size63) = iprot.readListBegin()
8884 
          for _i67 in xrange(_size63):
8885 
            _elem68 = TrackLog()
8886 
            _elem68.read(iprot)
8887 
            self.success.append(_elem68)
1845 vikas 8888 
          iprot.readListEnd()
8889 
        else:
8890 
          iprot.skip(ftype)
8891 
      elif fid == 1:
8892 
        if ftype == TType.STRUCT:
1996 vikas 8893 
          self.utx = UserAffiliateException()
1845 vikas 8894 
          self.utx.read(iprot)
8895 
        else:
8896 
          iprot.skip(ftype)
8897 
      else:
8898 
        iprot.skip(ftype)
8899 
      iprot.readFieldEnd()
8900 
    iprot.readStructEnd()
8901 
 
8902 
  def write(self, oprot):
8903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8905 
      return
1996 vikas 8906 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
1845 vikas 8907 
    if self.success != None:
8908 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8909 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 8910 
      for iter69 in self.success:
8911 
        iter69.write(oprot)
1845 vikas 8912 
      oprot.writeListEnd()
8913 
      oprot.writeFieldEnd()
8914 
    if self.utx != None:
8915 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8916 
      self.utx.write(oprot)
8917 
      oprot.writeFieldEnd()
8918 
    oprot.writeFieldStop()
8919 
    oprot.writeStructEnd()
8920 
 
8921 
  def __repr__(self):
8922 
    L = ['%s=%r' % (key, value)
8923 
      for key, value in self.__dict__.iteritems()]
8924 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8925 
 
8926 
  def __eq__(self, other):
8927 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8928 
 
8929 
  def __ne__(self, other):
8930 
    return not (self == other)
8931 
 
8932 
class getTrackLogsByUser_args:
8933 
  """
8934 
  Attributes:
8935 
   - userId
8936 
  """
8937 
 
8938 
  thrift_spec = (
8939 
    None, # 0
8940 
    (1, TType.I64, 'userId', None, None, ), # 1
8941 
  )
8942 
 
8943 
  def __init__(self, userId=None,):
8944 
    self.userId = userId
8945 
 
8946 
  def read(self, iprot):
8947 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8948 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8949 
      return
8950 
    iprot.readStructBegin()
8951 
    while True:
8952 
      (fname, ftype, fid) = iprot.readFieldBegin()
8953 
      if ftype == TType.STOP:
8954 
        break
8955 
      if fid == 1:
8956 
        if ftype == TType.I64:
8957 
          self.userId = iprot.readI64();
8958 
        else:
8959 
          iprot.skip(ftype)
8960 
      else:
8961 
        iprot.skip(ftype)
8962 
      iprot.readFieldEnd()
8963 
    iprot.readStructEnd()
8964 
 
8965 
  def write(self, oprot):
8966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8968 
      return
8969 
    oprot.writeStructBegin('getTrackLogsByUser_args')
8970 
    if self.userId != None:
8971 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8972 
      oprot.writeI64(self.userId)
8973 
      oprot.writeFieldEnd()
8974 
    oprot.writeFieldStop()
8975 
    oprot.writeStructEnd()
8976 
 
8977 
  def __repr__(self):
8978 
    L = ['%s=%r' % (key, value)
8979 
      for key, value in self.__dict__.iteritems()]
8980 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8981 
 
8982 
  def __eq__(self, other):
8983 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8984 
 
8985 
  def __ne__(self, other):
8986 
    return not (self == other)
8987 
 
8988 
class getTrackLogsByUser_result:
8989 
  """
8990 
  Attributes:
8991 
   - success
8992 
   - utx
8993 
  """
8994 
 
8995 
  thrift_spec = (
8996 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 8997 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8998 
  )
8999 
 
9000 
  def __init__(self, success=None, utx=None,):
9001 
    self.success = success
9002 
    self.utx = utx
9003 
 
9004 
  def read(self, iprot):
9005 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9006 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9007 
      return
9008 
    iprot.readStructBegin()
9009 
    while True:
9010 
      (fname, ftype, fid) = iprot.readFieldBegin()
9011 
      if ftype == TType.STOP:
9012 
        break
9013 
      if fid == 0:
9014 
        if ftype == TType.LIST:
9015 
          self.success = []
2981 rajveer 9016 
          (_etype73, _size70) = iprot.readListBegin()
9017 
          for _i74 in xrange(_size70):
9018 
            _elem75 = TrackLog()
9019 
            _elem75.read(iprot)
9020 
            self.success.append(_elem75)
1845 vikas 9021 
          iprot.readListEnd()
9022 
        else:
9023 
          iprot.skip(ftype)
9024 
      elif fid == 1:
9025 
        if ftype == TType.STRUCT:
1996 vikas 9026 
          self.utx = UserAffiliateException()
1845 vikas 9027 
          self.utx.read(iprot)
9028 
        else:
9029 
          iprot.skip(ftype)
9030 
      else:
9031 
        iprot.skip(ftype)
9032 
      iprot.readFieldEnd()
9033 
    iprot.readStructEnd()
9034 
 
9035 
  def write(self, oprot):
9036 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9037 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9038 
      return
9039 
    oprot.writeStructBegin('getTrackLogsByUser_result')
9040 
    if self.success != None:
9041 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9042 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 9043 
      for iter76 in self.success:
9044 
        iter76.write(oprot)
1845 vikas 9045 
      oprot.writeListEnd()
9046 
      oprot.writeFieldEnd()
9047 
    if self.utx != None:
9048 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9049 
      self.utx.write(oprot)
9050 
      oprot.writeFieldEnd()
9051 
    oprot.writeFieldStop()
9052 
    oprot.writeStructEnd()
9053 
 
9054 
  def __repr__(self):
9055 
    L = ['%s=%r' % (key, value)
9056 
      for key, value in self.__dict__.iteritems()]
9057 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9058 
 
9059 
  def __eq__(self, other):
9060 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9061 
 
9062 
  def __ne__(self, other):
9063 
    return not (self == other)
9064 
 
9065 
class getTrackLogs_args:
9066 
  """
9067 
  Attributes:
9068 
   - userId
9069 
   - event
9070 
   - url
9071 
  """
9072 
 
9073 
  thrift_spec = (
9074 
    None, # 0
1996 vikas 9075 
    (1, TType.I64, 'userId', None, None, ), # 1
9076 
    (2, TType.STRING, 'event', None, None, ), # 2
9077 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 9078 
  )
9079 
 
1996 vikas 9080 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 9081 
    self.userId = userId
9082 
    self.event = event
9083 
    self.url = url
9084 
 
9085 
  def read(self, iprot):
9086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9088 
      return
9089 
    iprot.readStructBegin()
9090 
    while True:
9091 
      (fname, ftype, fid) = iprot.readFieldBegin()
9092 
      if ftype == TType.STOP:
9093 
        break
9094 
      if fid == 1:
9095 
        if ftype == TType.I64:
1996 vikas 9096 
          self.userId = iprot.readI64();
1845 vikas 9097 
        else:
9098 
          iprot.skip(ftype)
9099 
      elif fid == 2:
9100 
        if ftype == TType.STRING:
9101 
          self.event = iprot.readString();
9102 
        else:
9103 
          iprot.skip(ftype)
1996 vikas 9104 
      elif fid == 3:
1845 vikas 9105 
        if ftype == TType.STRING:
9106 
          self.url = iprot.readString();
9107 
        else:
9108 
          iprot.skip(ftype)
9109 
      else:
9110 
        iprot.skip(ftype)
9111 
      iprot.readFieldEnd()
9112 
    iprot.readStructEnd()
9113 
 
9114 
  def write(self, oprot):
9115 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9116 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9117 
      return
9118 
    oprot.writeStructBegin('getTrackLogs_args')
9119 
    if self.userId != None:
1996 vikas 9120 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 9121 
      oprot.writeI64(self.userId)
9122 
      oprot.writeFieldEnd()
9123 
    if self.event != None:
1996 vikas 9124 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 9125 
      oprot.writeString(self.event)
9126 
      oprot.writeFieldEnd()
9127 
    if self.url != None:
1996 vikas 9128 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 9129 
      oprot.writeString(self.url)
9130 
      oprot.writeFieldEnd()
9131 
    oprot.writeFieldStop()
9132 
    oprot.writeStructEnd()
9133 
 
9134 
  def __repr__(self):
9135 
    L = ['%s=%r' % (key, value)
9136 
      for key, value in self.__dict__.iteritems()]
9137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9138 
 
9139 
  def __eq__(self, other):
9140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9141 
 
9142 
  def __ne__(self, other):
9143 
    return not (self == other)
9144 
 
9145 
class getTrackLogs_result:
9146 
  """
9147 
  Attributes:
9148 
   - success
9149 
   - utx
9150 
  """
9151 
 
9152 
  thrift_spec = (
9153 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 9154 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 9155 
  )
9156 
 
9157 
  def __init__(self, success=None, utx=None,):
9158 
    self.success = success
9159 
    self.utx = utx
9160 
 
9161 
  def read(self, iprot):
9162 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9163 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9164 
      return
9165 
    iprot.readStructBegin()
9166 
    while True:
9167 
      (fname, ftype, fid) = iprot.readFieldBegin()
9168 
      if ftype == TType.STOP:
9169 
        break
9170 
      if fid == 0:
9171 
        if ftype == TType.LIST:
9172 
          self.success = []
2981 rajveer 9173 
          (_etype80, _size77) = iprot.readListBegin()
9174 
          for _i81 in xrange(_size77):
9175 
            _elem82 = TrackLog()
9176 
            _elem82.read(iprot)
9177 
            self.success.append(_elem82)
1845 vikas 9178 
          iprot.readListEnd()
9179 
        else:
9180 
          iprot.skip(ftype)
9181 
      elif fid == 1:
9182 
        if ftype == TType.STRUCT:
1996 vikas 9183 
          self.utx = UserAffiliateException()
1845 vikas 9184 
          self.utx.read(iprot)
9185 
        else:
9186 
          iprot.skip(ftype)
9187 
      else:
9188 
        iprot.skip(ftype)
9189 
      iprot.readFieldEnd()
9190 
    iprot.readStructEnd()
9191 
 
9192 
  def write(self, oprot):
9193 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9194 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9195 
      return
9196 
    oprot.writeStructBegin('getTrackLogs_result')
9197 
    if self.success != None:
9198 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9199 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 9200 
      for iter83 in self.success:
9201 
        iter83.write(oprot)
1845 vikas 9202 
      oprot.writeListEnd()
9203 
      oprot.writeFieldEnd()
9204 
    if self.utx != None:
9205 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9206 
      self.utx.write(oprot)
9207 
      oprot.writeFieldEnd()
9208 
    oprot.writeFieldStop()
9209 
    oprot.writeStructEnd()
9210 
 
9211 
  def __repr__(self):
9212 
    L = ['%s=%r' % (key, value)
9213 
      for key, value in self.__dict__.iteritems()]
9214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9215 
 
9216 
  def __eq__(self, other):
9217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9218 
 
9219 
  def __ne__(self, other):
9220 
    return not (self == other)
9221 
 
559 chandransh 9222 
class createCart_args:
94 ashish 9223 
  """
9224 
  Attributes:
559 chandransh 9225 
   - userId
94 ashish 9226 
  """
9227 
 
9228 
  thrift_spec = (
9229 
    None, # 0
559 chandransh 9230 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 9231 
  )
9232 
 
559 chandransh 9233 
  def __init__(self, userId=None,):
9234 
    self.userId = userId
94 ashish 9235 
 
9236 
  def read(self, iprot):
9237 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9238 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9239 
      return
9240 
    iprot.readStructBegin()
9241 
    while True:
9242 
      (fname, ftype, fid) = iprot.readFieldBegin()
9243 
      if ftype == TType.STOP:
9244 
        break
9245 
      if fid == 1:
9246 
        if ftype == TType.I64:
559 chandransh 9247 
          self.userId = iprot.readI64();
94 ashish 9248 
        else:
9249 
          iprot.skip(ftype)
559 chandransh 9250 
      else:
9251 
        iprot.skip(ftype)
9252 
      iprot.readFieldEnd()
9253 
    iprot.readStructEnd()
9254 
 
9255 
  def write(self, oprot):
9256 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9257 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9258 
      return
9259 
    oprot.writeStructBegin('createCart_args')
9260 
    if self.userId != None:
9261 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9262 
      oprot.writeI64(self.userId)
9263 
      oprot.writeFieldEnd()
9264 
    oprot.writeFieldStop()
9265 
    oprot.writeStructEnd()
9266 
 
9267 
  def __repr__(self):
9268 
    L = ['%s=%r' % (key, value)
9269 
      for key, value in self.__dict__.iteritems()]
9270 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9271 
 
9272 
  def __eq__(self, other):
9273 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9274 
 
9275 
  def __ne__(self, other):
9276 
    return not (self == other)
9277 
 
9278 
class createCart_result:
9279 
  """
9280 
  Attributes:
9281 
   - success
9282 
   - scx
9283 
  """
9284 
 
9285 
  thrift_spec = (
9286 
    (0, TType.I64, 'success', None, None, ), # 0
9287 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9288 
  )
9289 
 
9290 
  def __init__(self, success=None, scx=None,):
9291 
    self.success = success
9292 
    self.scx = scx
9293 
 
9294 
  def read(self, iprot):
9295 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9296 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9297 
      return
9298 
    iprot.readStructBegin()
9299 
    while True:
9300 
      (fname, ftype, fid) = iprot.readFieldBegin()
9301 
      if ftype == TType.STOP:
9302 
        break
9303 
      if fid == 0:
94 ashish 9304 
        if ftype == TType.I64:
559 chandransh 9305 
          self.success = iprot.readI64();
94 ashish 9306 
        else:
9307 
          iprot.skip(ftype)
559 chandransh 9308 
      elif fid == 1:
9309 
        if ftype == TType.STRUCT:
9310 
          self.scx = ShoppingCartException()
9311 
          self.scx.read(iprot)
9312 
        else:
9313 
          iprot.skip(ftype)
94 ashish 9314 
      else:
9315 
        iprot.skip(ftype)
9316 
      iprot.readFieldEnd()
9317 
    iprot.readStructEnd()
9318 
 
9319 
  def write(self, oprot):
9320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9322 
      return
559 chandransh 9323 
    oprot.writeStructBegin('createCart_result')
9324 
    if self.success != None:
9325 
      oprot.writeFieldBegin('success', TType.I64, 0)
9326 
      oprot.writeI64(self.success)
94 ashish 9327 
      oprot.writeFieldEnd()
559 chandransh 9328 
    if self.scx != None:
9329 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9330 
      self.scx.write(oprot)
94 ashish 9331 
      oprot.writeFieldEnd()
9332 
    oprot.writeFieldStop()
9333 
    oprot.writeStructEnd()
9334 
 
9335 
  def __repr__(self):
9336 
    L = ['%s=%r' % (key, value)
9337 
      for key, value in self.__dict__.iteritems()]
9338 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9339 
 
9340 
  def __eq__(self, other):
9341 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9342 
 
9343 
  def __ne__(self, other):
9344 
    return not (self == other)
9345 
 
559 chandransh 9346 
class getCurrentCart_args:
94 ashish 9347 
  """
9348 
  Attributes:
559 chandransh 9349 
   - userId
9350 
  """
9351 
 
9352 
  thrift_spec = (
9353 
    None, # 0
9354 
    (1, TType.I64, 'userId', None, None, ), # 1
9355 
  )
9356 
 
9357 
  def __init__(self, userId=None,):
9358 
    self.userId = userId
9359 
 
9360 
  def read(self, iprot):
9361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9363 
      return
9364 
    iprot.readStructBegin()
9365 
    while True:
9366 
      (fname, ftype, fid) = iprot.readFieldBegin()
9367 
      if ftype == TType.STOP:
9368 
        break
9369 
      if fid == 1:
9370 
        if ftype == TType.I64:
9371 
          self.userId = iprot.readI64();
9372 
        else:
9373 
          iprot.skip(ftype)
9374 
      else:
9375 
        iprot.skip(ftype)
9376 
      iprot.readFieldEnd()
9377 
    iprot.readStructEnd()
9378 
 
9379 
  def write(self, oprot):
9380 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9381 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9382 
      return
9383 
    oprot.writeStructBegin('getCurrentCart_args')
9384 
    if self.userId != None:
9385 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9386 
      oprot.writeI64(self.userId)
9387 
      oprot.writeFieldEnd()
9388 
    oprot.writeFieldStop()
9389 
    oprot.writeStructEnd()
9390 
 
9391 
  def __repr__(self):
9392 
    L = ['%s=%r' % (key, value)
9393 
      for key, value in self.__dict__.iteritems()]
9394 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9395 
 
9396 
  def __eq__(self, other):
9397 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9398 
 
9399 
  def __ne__(self, other):
9400 
    return not (self == other)
9401 
 
9402 
class getCurrentCart_result:
9403 
  """
9404 
  Attributes:
94 ashish 9405 
   - success
559 chandransh 9406 
   - scx
94 ashish 9407 
  """
9408 
 
9409 
  thrift_spec = (
559 chandransh 9410 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9411 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9412 
  )
9413 
 
559 chandransh 9414 
  def __init__(self, success=None, scx=None,):
94 ashish 9415 
    self.success = success
559 chandransh 9416 
    self.scx = scx
94 ashish 9417 
 
9418 
  def read(self, iprot):
9419 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9420 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9421 
      return
9422 
    iprot.readStructBegin()
9423 
    while True:
9424 
      (fname, ftype, fid) = iprot.readFieldBegin()
9425 
      if ftype == TType.STOP:
9426 
        break
9427 
      if fid == 0:
559 chandransh 9428 
        if ftype == TType.STRUCT:
9429 
          self.success = Cart()
9430 
          self.success.read(iprot)
94 ashish 9431 
        else:
9432 
          iprot.skip(ftype)
9433 
      elif fid == 1:
9434 
        if ftype == TType.STRUCT:
559 chandransh 9435 
          self.scx = ShoppingCartException()
9436 
          self.scx.read(iprot)
94 ashish 9437 
        else:
9438 
          iprot.skip(ftype)
9439 
      else:
9440 
        iprot.skip(ftype)
9441 
      iprot.readFieldEnd()
9442 
    iprot.readStructEnd()
9443 
 
9444 
  def write(self, oprot):
9445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9447 
      return
559 chandransh 9448 
    oprot.writeStructBegin('getCurrentCart_result')
94 ashish 9449 
    if self.success != None:
559 chandransh 9450 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9451 
      self.success.write(oprot)
94 ashish 9452 
      oprot.writeFieldEnd()
559 chandransh 9453 
    if self.scx != None:
9454 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9455 
      self.scx.write(oprot)
94 ashish 9456 
      oprot.writeFieldEnd()
9457 
    oprot.writeFieldStop()
9458 
    oprot.writeStructEnd()
9459 
 
9460 
  def __repr__(self):
9461 
    L = ['%s=%r' % (key, value)
9462 
      for key, value in self.__dict__.iteritems()]
9463 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9464 
 
9465 
  def __eq__(self, other):
9466 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9467 
 
9468 
  def __ne__(self, other):
9469 
    return not (self == other)
9470 
 
559 chandransh 9471 
class getCart_args:
504 rajveer 9472 
  """
9473 
  Attributes:
559 chandransh 9474 
   - cartId
504 rajveer 9475 
  """
9476 
 
9477 
  thrift_spec = (
9478 
    None, # 0
559 chandransh 9479 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 9480 
  )
9481 
 
559 chandransh 9482 
  def __init__(self, cartId=None,):
9483 
    self.cartId = cartId
504 rajveer 9484 
 
9485 
  def read(self, iprot):
9486 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9487 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9488 
      return
9489 
    iprot.readStructBegin()
9490 
    while True:
9491 
      (fname, ftype, fid) = iprot.readFieldBegin()
9492 
      if ftype == TType.STOP:
9493 
        break
9494 
      if fid == 1:
9495 
        if ftype == TType.I64:
559 chandransh 9496 
          self.cartId = iprot.readI64();
504 rajveer 9497 
        else:
9498 
          iprot.skip(ftype)
9499 
      else:
9500 
        iprot.skip(ftype)
9501 
      iprot.readFieldEnd()
9502 
    iprot.readStructEnd()
9503 
 
9504 
  def write(self, oprot):
9505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9507 
      return
559 chandransh 9508 
    oprot.writeStructBegin('getCart_args')
9509 
    if self.cartId != None:
9510 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9511 
      oprot.writeI64(self.cartId)
504 rajveer 9512 
      oprot.writeFieldEnd()
9513 
    oprot.writeFieldStop()
9514 
    oprot.writeStructEnd()
9515 
 
9516 
  def __repr__(self):
9517 
    L = ['%s=%r' % (key, value)
9518 
      for key, value in self.__dict__.iteritems()]
9519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9520 
 
9521 
  def __eq__(self, other):
9522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9523 
 
9524 
  def __ne__(self, other):
9525 
    return not (self == other)
9526 
 
559 chandransh 9527 
class getCart_result:
504 rajveer 9528 
  """
9529 
  Attributes:
9530 
   - success
559 chandransh 9531 
   - scx
504 rajveer 9532 
  """
9533 
 
9534 
  thrift_spec = (
559 chandransh 9535 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9536 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 9537 
  )
9538 
 
559 chandransh 9539 
  def __init__(self, success=None, scx=None,):
504 rajveer 9540 
    self.success = success
559 chandransh 9541 
    self.scx = scx
504 rajveer 9542 
 
9543 
  def read(self, iprot):
9544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9546 
      return
9547 
    iprot.readStructBegin()
9548 
    while True:
9549 
      (fname, ftype, fid) = iprot.readFieldBegin()
9550 
      if ftype == TType.STOP:
9551 
        break
9552 
      if fid == 0:
559 chandransh 9553 
        if ftype == TType.STRUCT:
9554 
          self.success = Cart()
9555 
          self.success.read(iprot)
504 rajveer 9556 
        else:
9557 
          iprot.skip(ftype)
9558 
      elif fid == 1:
9559 
        if ftype == TType.STRUCT:
559 chandransh 9560 
          self.scx = ShoppingCartException()
9561 
          self.scx.read(iprot)
504 rajveer 9562 
        else:
9563 
          iprot.skip(ftype)
9564 
      else:
9565 
        iprot.skip(ftype)
9566 
      iprot.readFieldEnd()
9567 
    iprot.readStructEnd()
9568 
 
9569 
  def write(self, oprot):
9570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9572 
      return
559 chandransh 9573 
    oprot.writeStructBegin('getCart_result')
504 rajveer 9574 
    if self.success != None:
559 chandransh 9575 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9576 
      self.success.write(oprot)
504 rajveer 9577 
      oprot.writeFieldEnd()
559 chandransh 9578 
    if self.scx != None:
9579 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9580 
      self.scx.write(oprot)
504 rajveer 9581 
      oprot.writeFieldEnd()
9582 
    oprot.writeFieldStop()
9583 
    oprot.writeStructEnd()
9584 
 
9585 
  def __repr__(self):
9586 
    L = ['%s=%r' % (key, value)
9587 
      for key, value in self.__dict__.iteritems()]
9588 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9589 
 
9590 
  def __eq__(self, other):
9591 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9592 
 
9593 
  def __ne__(self, other):
9594 
    return not (self == other)
9595 
 
559 chandransh 9596 
class getCartsForUser_args:
94 ashish 9597 
  """
9598 
  Attributes:
559 chandransh 9599 
   - userId
9600 
   - status
94 ashish 9601 
  """
9602 
 
9603 
  thrift_spec = (
9604 
    None, # 0
559 chandransh 9605 
    (1, TType.I64, 'userId', None, None, ), # 1
9606 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 9607 
  )
9608 
 
559 chandransh 9609 
  def __init__(self, userId=None, status=None,):
9610 
    self.userId = userId
9611 
    self.status = status
94 ashish 9612 
 
9613 
  def read(self, iprot):
9614 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9615 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9616 
      return
9617 
    iprot.readStructBegin()
9618 
    while True:
9619 
      (fname, ftype, fid) = iprot.readFieldBegin()
9620 
      if ftype == TType.STOP:
9621 
        break
9622 
      if fid == 1:
9623 
        if ftype == TType.I64:
559 chandransh 9624 
          self.userId = iprot.readI64();
94 ashish 9625 
        else:
9626 
          iprot.skip(ftype)
9627 
      elif fid == 2:
559 chandransh 9628 
        if ftype == TType.I32:
9629 
          self.status = iprot.readI32();
94 ashish 9630 
        else:
9631 
          iprot.skip(ftype)
9632 
      else:
9633 
        iprot.skip(ftype)
9634 
      iprot.readFieldEnd()
9635 
    iprot.readStructEnd()
9636 
 
9637 
  def write(self, oprot):
9638 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9639 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9640 
      return
559 chandransh 9641 
    oprot.writeStructBegin('getCartsForUser_args')
9642 
    if self.userId != None:
9643 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9644 
      oprot.writeI64(self.userId)
94 ashish 9645 
      oprot.writeFieldEnd()
559 chandransh 9646 
    if self.status != None:
9647 
      oprot.writeFieldBegin('status', TType.I32, 2)
9648 
      oprot.writeI32(self.status)
94 ashish 9649 
      oprot.writeFieldEnd()
9650 
    oprot.writeFieldStop()
9651 
    oprot.writeStructEnd()
9652 
 
9653 
  def __repr__(self):
9654 
    L = ['%s=%r' % (key, value)
9655 
      for key, value in self.__dict__.iteritems()]
9656 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9657 
 
9658 
  def __eq__(self, other):
9659 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9660 
 
9661 
  def __ne__(self, other):
9662 
    return not (self == other)
9663 
 
559 chandransh 9664 
class getCartsForUser_result:
94 ashish 9665 
  """
9666 
  Attributes:
9667 
   - success
559 chandransh 9668 
   - scx
94 ashish 9669 
  """
9670 
 
9671 
  thrift_spec = (
559 chandransh 9672 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9673 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9674 
  )
9675 
 
559 chandransh 9676 
  def __init__(self, success=None, scx=None,):
94 ashish 9677 
    self.success = success
559 chandransh 9678 
    self.scx = scx
94 ashish 9679 
 
9680 
  def read(self, iprot):
9681 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9682 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9683 
      return
9684 
    iprot.readStructBegin()
9685 
    while True:
9686 
      (fname, ftype, fid) = iprot.readFieldBegin()
9687 
      if ftype == TType.STOP:
9688 
        break
9689 
      if fid == 0:
559 chandransh 9690 
        if ftype == TType.LIST:
9691 
          self.success = []
2981 rajveer 9692 
          (_etype87, _size84) = iprot.readListBegin()
9693 
          for _i88 in xrange(_size84):
9694 
            _elem89 = Cart()
9695 
            _elem89.read(iprot)
9696 
            self.success.append(_elem89)
559 chandransh 9697 
          iprot.readListEnd()
94 ashish 9698 
        else:
9699 
          iprot.skip(ftype)
9700 
      elif fid == 1:
9701 
        if ftype == TType.STRUCT:
559 chandransh 9702 
          self.scx = ShoppingCartException()
9703 
          self.scx.read(iprot)
94 ashish 9704 
        else:
9705 
          iprot.skip(ftype)
9706 
      else:
9707 
        iprot.skip(ftype)
9708 
      iprot.readFieldEnd()
9709 
    iprot.readStructEnd()
9710 
 
9711 
  def write(self, oprot):
9712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9714 
      return
559 chandransh 9715 
    oprot.writeStructBegin('getCartsForUser_result')
94 ashish 9716 
    if self.success != None:
559 chandransh 9717 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9718 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 9719 
      for iter90 in self.success:
9720 
        iter90.write(oprot)
559 chandransh 9721 
      oprot.writeListEnd()
94 ashish 9722 
      oprot.writeFieldEnd()
559 chandransh 9723 
    if self.scx != None:
9724 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9725 
      self.scx.write(oprot)
94 ashish 9726 
      oprot.writeFieldEnd()
9727 
    oprot.writeFieldStop()
9728 
    oprot.writeStructEnd()
9729 
 
9730 
  def __repr__(self):
9731 
    L = ['%s=%r' % (key, value)
9732 
      for key, value in self.__dict__.iteritems()]
9733 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9734 
 
9735 
  def __eq__(self, other):
9736 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9737 
 
9738 
  def __ne__(self, other):
9739 
    return not (self == other)
9740 
 
559 chandransh 9741 
class getCartsByStatus_args:
94 ashish 9742 
  """
9743 
  Attributes:
559 chandransh 9744 
   - status
94 ashish 9745 
  """
9746 
 
9747 
  thrift_spec = (
9748 
    None, # 0
559 chandransh 9749 
    (1, TType.I32, 'status', None, None, ), # 1
94 ashish 9750 
  )
9751 
 
559 chandransh 9752 
  def __init__(self, status=None,):
9753 
    self.status = status
94 ashish 9754 
 
9755 
  def read(self, iprot):
9756 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9757 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9758 
      return
9759 
    iprot.readStructBegin()
9760 
    while True:
9761 
      (fname, ftype, fid) = iprot.readFieldBegin()
9762 
      if ftype == TType.STOP:
9763 
        break
9764 
      if fid == 1:
559 chandransh 9765 
        if ftype == TType.I32:
9766 
          self.status = iprot.readI32();
9767 
        else:
9768 
          iprot.skip(ftype)
9769 
      else:
9770 
        iprot.skip(ftype)
9771 
      iprot.readFieldEnd()
9772 
    iprot.readStructEnd()
9773 
 
9774 
  def write(self, oprot):
9775 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9776 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9777 
      return
9778 
    oprot.writeStructBegin('getCartsByStatus_args')
9779 
    if self.status != None:
9780 
      oprot.writeFieldBegin('status', TType.I32, 1)
9781 
      oprot.writeI32(self.status)
9782 
      oprot.writeFieldEnd()
9783 
    oprot.writeFieldStop()
9784 
    oprot.writeStructEnd()
9785 
 
9786 
  def __repr__(self):
9787 
    L = ['%s=%r' % (key, value)
9788 
      for key, value in self.__dict__.iteritems()]
9789 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9790 
 
9791 
  def __eq__(self, other):
9792 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9793 
 
9794 
  def __ne__(self, other):
9795 
    return not (self == other)
9796 
 
9797 
class getCartsByStatus_result:
9798 
  """
9799 
  Attributes:
9800 
   - success
9801 
   - scx
9802 
  """
9803 
 
9804 
  thrift_spec = (
9805 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9806 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9807 
  )
9808 
 
9809 
  def __init__(self, success=None, scx=None,):
9810 
    self.success = success
9811 
    self.scx = scx
9812 
 
9813 
  def read(self, iprot):
9814 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9815 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9816 
      return
9817 
    iprot.readStructBegin()
9818 
    while True:
9819 
      (fname, ftype, fid) = iprot.readFieldBegin()
9820 
      if ftype == TType.STOP:
9821 
        break
9822 
      if fid == 0:
9823 
        if ftype == TType.LIST:
9824 
          self.success = []
2981 rajveer 9825 
          (_etype94, _size91) = iprot.readListBegin()
9826 
          for _i95 in xrange(_size91):
9827 
            _elem96 = Cart()
9828 
            _elem96.read(iprot)
9829 
            self.success.append(_elem96)
559 chandransh 9830 
          iprot.readListEnd()
9831 
        else:
9832 
          iprot.skip(ftype)
9833 
      elif fid == 1:
9834 
        if ftype == TType.STRUCT:
9835 
          self.scx = ShoppingCartException()
9836 
          self.scx.read(iprot)
9837 
        else:
9838 
          iprot.skip(ftype)
9839 
      else:
9840 
        iprot.skip(ftype)
9841 
      iprot.readFieldEnd()
9842 
    iprot.readStructEnd()
9843 
 
9844 
  def write(self, oprot):
9845 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9846 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9847 
      return
9848 
    oprot.writeStructBegin('getCartsByStatus_result')
9849 
    if self.success != None:
9850 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9851 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 9852 
      for iter97 in self.success:
9853 
        iter97.write(oprot)
559 chandransh 9854 
      oprot.writeListEnd()
9855 
      oprot.writeFieldEnd()
9856 
    if self.scx != None:
9857 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9858 
      self.scx.write(oprot)
9859 
      oprot.writeFieldEnd()
9860 
    oprot.writeFieldStop()
9861 
    oprot.writeStructEnd()
9862 
 
9863 
  def __repr__(self):
9864 
    L = ['%s=%r' % (key, value)
9865 
      for key, value in self.__dict__.iteritems()]
9866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9867 
 
9868 
  def __eq__(self, other):
9869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9870 
 
9871 
  def __ne__(self, other):
9872 
    return not (self == other)
9873 
 
9874 
class getCartsByTime_args:
9875 
  """
9876 
  Attributes:
9877 
   - from_time
9878 
   - to_time
9879 
   - status
9880 
  """
9881 
 
9882 
  thrift_spec = (
9883 
    None, # 0
9884 
    (1, TType.I64, 'from_time', None, None, ), # 1
9885 
    (2, TType.I64, 'to_time', None, None, ), # 2
9886 
    (3, TType.I32, 'status', None, None, ), # 3
9887 
  )
9888 
 
9889 
  def __init__(self, from_time=None, to_time=None, status=None,):
9890 
    self.from_time = from_time
9891 
    self.to_time = to_time
9892 
    self.status = status
9893 
 
9894 
  def read(self, iprot):
9895 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9896 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9897 
      return
9898 
    iprot.readStructBegin()
9899 
    while True:
9900 
      (fname, ftype, fid) = iprot.readFieldBegin()
9901 
      if ftype == TType.STOP:
9902 
        break
9903 
      if fid == 1:
94 ashish 9904 
        if ftype == TType.I64:
559 chandransh 9905 
          self.from_time = iprot.readI64();
94 ashish 9906 
        else:
9907 
          iprot.skip(ftype)
122 ashish 9908 
      elif fid == 2:
559 chandransh 9909 
        if ftype == TType.I64:
9910 
          self.to_time = iprot.readI64();
122 ashish 9911 
        else:
9912 
          iprot.skip(ftype)
559 chandransh 9913 
      elif fid == 3:
9914 
        if ftype == TType.I32:
9915 
          self.status = iprot.readI32();
9916 
        else:
9917 
          iprot.skip(ftype)
94 ashish 9918 
      else:
9919 
        iprot.skip(ftype)
9920 
      iprot.readFieldEnd()
9921 
    iprot.readStructEnd()
9922 
 
9923 
  def write(self, oprot):
9924 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9925 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9926 
      return
559 chandransh 9927 
    oprot.writeStructBegin('getCartsByTime_args')
9928 
    if self.from_time != None:
9929 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
9930 
      oprot.writeI64(self.from_time)
94 ashish 9931 
      oprot.writeFieldEnd()
559 chandransh 9932 
    if self.to_time != None:
9933 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
9934 
      oprot.writeI64(self.to_time)
122 ashish 9935 
      oprot.writeFieldEnd()
559 chandransh 9936 
    if self.status != None:
9937 
      oprot.writeFieldBegin('status', TType.I32, 3)
9938 
      oprot.writeI32(self.status)
9939 
      oprot.writeFieldEnd()
94 ashish 9940 
    oprot.writeFieldStop()
9941 
    oprot.writeStructEnd()
9942 
 
9943 
  def __repr__(self):
9944 
    L = ['%s=%r' % (key, value)
9945 
      for key, value in self.__dict__.iteritems()]
9946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9947 
 
9948 
  def __eq__(self, other):
9949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9950 
 
9951 
  def __ne__(self, other):
9952 
    return not (self == other)
9953 
 
559 chandransh 9954 
class getCartsByTime_result:
94 ashish 9955 
  """
9956 
  Attributes:
9957 
   - success
559 chandransh 9958 
   - scx
94 ashish 9959 
  """
9960 
 
9961 
  thrift_spec = (
559 chandransh 9962 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9963 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9964 
  )
9965 
 
559 chandransh 9966 
  def __init__(self, success=None, scx=None,):
94 ashish 9967 
    self.success = success
559 chandransh 9968 
    self.scx = scx
94 ashish 9969 
 
9970 
  def read(self, iprot):
9971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9973 
      return
9974 
    iprot.readStructBegin()
9975 
    while True:
9976 
      (fname, ftype, fid) = iprot.readFieldBegin()
9977 
      if ftype == TType.STOP:
9978 
        break
9979 
      if fid == 0:
559 chandransh 9980 
        if ftype == TType.LIST:
9981 
          self.success = []
2981 rajveer 9982 
          (_etype101, _size98) = iprot.readListBegin()
9983 
          for _i102 in xrange(_size98):
9984 
            _elem103 = Cart()
9985 
            _elem103.read(iprot)
9986 
            self.success.append(_elem103)
559 chandransh 9987 
          iprot.readListEnd()
94 ashish 9988 
        else:
9989 
          iprot.skip(ftype)
9990 
      elif fid == 1:
9991 
        if ftype == TType.STRUCT:
559 chandransh 9992 
          self.scx = ShoppingCartException()
9993 
          self.scx.read(iprot)
94 ashish 9994 
        else:
9995 
          iprot.skip(ftype)
9996 
      else:
9997 
        iprot.skip(ftype)
9998 
      iprot.readFieldEnd()
9999 
    iprot.readStructEnd()
10000 
 
10001 
  def write(self, oprot):
10002 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10003 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10004 
      return
559 chandransh 10005 
    oprot.writeStructBegin('getCartsByTime_result')
94 ashish 10006 
    if self.success != None:
559 chandransh 10007 
      oprot.writeFieldBegin('success', TType.LIST, 0)
10008 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 10009 
      for iter104 in self.success:
10010 
        iter104.write(oprot)
559 chandransh 10011 
      oprot.writeListEnd()
94 ashish 10012 
      oprot.writeFieldEnd()
559 chandransh 10013 
    if self.scx != None:
10014 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10015 
      self.scx.write(oprot)
94 ashish 10016 
      oprot.writeFieldEnd()
10017 
    oprot.writeFieldStop()
10018 
    oprot.writeStructEnd()
10019 
 
10020 
  def __repr__(self):
10021 
    L = ['%s=%r' % (key, value)
10022 
      for key, value in self.__dict__.iteritems()]
10023 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10024 
 
10025 
  def __eq__(self, other):
10026 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10027 
 
10028 
  def __ne__(self, other):
10029 
    return not (self == other)
10030 
 
559 chandransh 10031 
class changeCartStatus_args:
94 ashish 10032 
  """
10033 
  Attributes:
559 chandransh 10034 
   - cartId
10035 
   - status
94 ashish 10036 
  """
10037 
 
10038 
  thrift_spec = (
10039 
    None, # 0
559 chandransh 10040 
    (1, TType.I64, 'cartId', None, None, ), # 1
10041 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 10042 
  )
10043 
 
559 chandransh 10044 
  def __init__(self, cartId=None, status=None,):
10045 
    self.cartId = cartId
10046 
    self.status = status
94 ashish 10047 
 
10048 
  def read(self, iprot):
10049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10051 
      return
10052 
    iprot.readStructBegin()
10053 
    while True:
10054 
      (fname, ftype, fid) = iprot.readFieldBegin()
10055 
      if ftype == TType.STOP:
10056 
        break
10057 
      if fid == 1:
10058 
        if ftype == TType.I64:
559 chandransh 10059 
          self.cartId = iprot.readI64();
94 ashish 10060 
        else:
10061 
          iprot.skip(ftype)
559 chandransh 10062 
      elif fid == 2:
10063 
        if ftype == TType.I32:
10064 
          self.status = iprot.readI32();
10065 
        else:
10066 
          iprot.skip(ftype)
94 ashish 10067 
      else:
10068 
        iprot.skip(ftype)
10069 
      iprot.readFieldEnd()
10070 
    iprot.readStructEnd()
10071 
 
10072 
  def write(self, oprot):
10073 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10074 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10075 
      return
559 chandransh 10076 
    oprot.writeStructBegin('changeCartStatus_args')
10077 
    if self.cartId != None:
10078 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10079 
      oprot.writeI64(self.cartId)
94 ashish 10080 
      oprot.writeFieldEnd()
559 chandransh 10081 
    if self.status != None:
10082 
      oprot.writeFieldBegin('status', TType.I32, 2)
10083 
      oprot.writeI32(self.status)
10084 
      oprot.writeFieldEnd()
94 ashish 10085 
    oprot.writeFieldStop()
10086 
    oprot.writeStructEnd()
10087 
 
10088 
  def __repr__(self):
10089 
    L = ['%s=%r' % (key, value)
10090 
      for key, value in self.__dict__.iteritems()]
10091 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10092 
 
10093 
  def __eq__(self, other):
10094 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10095 
 
10096 
  def __ne__(self, other):
10097 
    return not (self == other)
10098 
 
559 chandransh 10099 
class changeCartStatus_result:
94 ashish 10100 
  """
10101 
  Attributes:
559 chandransh 10102 
   - scx
10103 
  """
10104 
 
10105 
  thrift_spec = (
10106 
    None, # 0
10107 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10108 
  )
10109 
 
10110 
  def __init__(self, scx=None,):
10111 
    self.scx = scx
10112 
 
10113 
  def read(self, iprot):
10114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10116 
      return
10117 
    iprot.readStructBegin()
10118 
    while True:
10119 
      (fname, ftype, fid) = iprot.readFieldBegin()
10120 
      if ftype == TType.STOP:
10121 
        break
10122 
      if fid == 1:
10123 
        if ftype == TType.STRUCT:
10124 
          self.scx = ShoppingCartException()
10125 
          self.scx.read(iprot)
10126 
        else:
10127 
          iprot.skip(ftype)
10128 
      else:
10129 
        iprot.skip(ftype)
10130 
      iprot.readFieldEnd()
10131 
    iprot.readStructEnd()
10132 
 
10133 
  def write(self, oprot):
10134 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10135 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10136 
      return
10137 
    oprot.writeStructBegin('changeCartStatus_result')
10138 
    if self.scx != None:
10139 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10140 
      self.scx.write(oprot)
10141 
      oprot.writeFieldEnd()
10142 
    oprot.writeFieldStop()
10143 
    oprot.writeStructEnd()
10144 
 
10145 
  def __repr__(self):
10146 
    L = ['%s=%r' % (key, value)
10147 
      for key, value in self.__dict__.iteritems()]
10148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10149 
 
10150 
  def __eq__(self, other):
10151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10152 
 
10153 
  def __ne__(self, other):
10154 
    return not (self == other)
10155 
 
10156 
class addItemToCart_args:
10157 
  """
10158 
  Attributes:
10159 
   - cartId
10160 
   - itemId
10161 
   - quantity
10162 
  """
10163 
 
10164 
  thrift_spec = (
10165 
    None, # 0
10166 
    (1, TType.I64, 'cartId', None, None, ), # 1
10167 
    (2, TType.I64, 'itemId', None, None, ), # 2
10168 
    (3, TType.I64, 'quantity', None, None, ), # 3
10169 
  )
10170 
 
10171 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
10172 
    self.cartId = cartId
10173 
    self.itemId = itemId
10174 
    self.quantity = quantity
10175 
 
10176 
  def read(self, iprot):
10177 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10178 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10179 
      return
10180 
    iprot.readStructBegin()
10181 
    while True:
10182 
      (fname, ftype, fid) = iprot.readFieldBegin()
10183 
      if ftype == TType.STOP:
10184 
        break
10185 
      if fid == 1:
10186 
        if ftype == TType.I64:
10187 
          self.cartId = iprot.readI64();
10188 
        else:
10189 
          iprot.skip(ftype)
10190 
      elif fid == 2:
10191 
        if ftype == TType.I64:
10192 
          self.itemId = iprot.readI64();
10193 
        else:
10194 
          iprot.skip(ftype)
10195 
      elif fid == 3:
10196 
        if ftype == TType.I64:
10197 
          self.quantity = iprot.readI64();
10198 
        else:
10199 
          iprot.skip(ftype)
10200 
      else:
10201 
        iprot.skip(ftype)
10202 
      iprot.readFieldEnd()
10203 
    iprot.readStructEnd()
10204 
 
10205 
  def write(self, oprot):
10206 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10207 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10208 
      return
10209 
    oprot.writeStructBegin('addItemToCart_args')
10210 
    if self.cartId != None:
10211 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10212 
      oprot.writeI64(self.cartId)
10213 
      oprot.writeFieldEnd()
10214 
    if self.itemId != None:
10215 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10216 
      oprot.writeI64(self.itemId)
10217 
      oprot.writeFieldEnd()
10218 
    if self.quantity != None:
10219 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10220 
      oprot.writeI64(self.quantity)
10221 
      oprot.writeFieldEnd()
10222 
    oprot.writeFieldStop()
10223 
    oprot.writeStructEnd()
10224 
 
10225 
  def __repr__(self):
10226 
    L = ['%s=%r' % (key, value)
10227 
      for key, value in self.__dict__.iteritems()]
10228 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10229 
 
10230 
  def __eq__(self, other):
10231 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10232 
 
10233 
  def __ne__(self, other):
10234 
    return not (self == other)
10235 
 
10236 
class addItemToCart_result:
10237 
  """
10238 
  Attributes:
2035 rajveer 10239 
   - success
559 chandransh 10240 
   - scx
10241 
  """
10242 
 
10243 
  thrift_spec = (
2035 rajveer 10244 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 10245 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10246 
  )
10247 
 
2035 rajveer 10248 
  def __init__(self, success=None, scx=None,):
10249 
    self.success = success
559 chandransh 10250 
    self.scx = scx
10251 
 
10252 
  def read(self, iprot):
10253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10255 
      return
10256 
    iprot.readStructBegin()
10257 
    while True:
10258 
      (fname, ftype, fid) = iprot.readFieldBegin()
10259 
      if ftype == TType.STOP:
10260 
        break
2035 rajveer 10261 
      if fid == 0:
10262 
        if ftype == TType.STRING:
10263 
          self.success = iprot.readString();
10264 
        else:
10265 
          iprot.skip(ftype)
10266 
      elif fid == 1:
559 chandransh 10267 
        if ftype == TType.STRUCT:
10268 
          self.scx = ShoppingCartException()
10269 
          self.scx.read(iprot)
10270 
        else:
10271 
          iprot.skip(ftype)
10272 
      else:
10273 
        iprot.skip(ftype)
10274 
      iprot.readFieldEnd()
10275 
    iprot.readStructEnd()
10276 
 
10277 
  def write(self, oprot):
10278 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10279 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10280 
      return
10281 
    oprot.writeStructBegin('addItemToCart_result')
2035 rajveer 10282 
    if self.success != None:
10283 
      oprot.writeFieldBegin('success', TType.STRING, 0)
10284 
      oprot.writeString(self.success)
10285 
      oprot.writeFieldEnd()
559 chandransh 10286 
    if self.scx != None:
10287 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10288 
      self.scx.write(oprot)
10289 
      oprot.writeFieldEnd()
10290 
    oprot.writeFieldStop()
10291 
    oprot.writeStructEnd()
10292 
 
10293 
  def __repr__(self):
10294 
    L = ['%s=%r' % (key, value)
10295 
      for key, value in self.__dict__.iteritems()]
10296 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10297 
 
10298 
  def __eq__(self, other):
10299 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10300 
 
10301 
  def __ne__(self, other):
10302 
    return not (self == other)
10303 
 
10304 
class deleteItemFromCart_args:
10305 
  """
10306 
  Attributes:
10307 
   - cartId
10308 
   - itemId
10309 
  """
10310 
 
10311 
  thrift_spec = (
10312 
    None, # 0
10313 
    (1, TType.I64, 'cartId', None, None, ), # 1
10314 
    (2, TType.I64, 'itemId', None, None, ), # 2
10315 
  )
10316 
 
10317 
  def __init__(self, cartId=None, itemId=None,):
10318 
    self.cartId = cartId
10319 
    self.itemId = itemId
10320 
 
10321 
  def read(self, iprot):
10322 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10323 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10324 
      return
10325 
    iprot.readStructBegin()
10326 
    while True:
10327 
      (fname, ftype, fid) = iprot.readFieldBegin()
10328 
      if ftype == TType.STOP:
10329 
        break
10330 
      if fid == 1:
10331 
        if ftype == TType.I64:
10332 
          self.cartId = iprot.readI64();
10333 
        else:
10334 
          iprot.skip(ftype)
10335 
      elif fid == 2:
10336 
        if ftype == TType.I64:
10337 
          self.itemId = iprot.readI64();
10338 
        else:
10339 
          iprot.skip(ftype)
10340 
      else:
10341 
        iprot.skip(ftype)
10342 
      iprot.readFieldEnd()
10343 
    iprot.readStructEnd()
10344 
 
10345 
  def write(self, oprot):
10346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10348 
      return
10349 
    oprot.writeStructBegin('deleteItemFromCart_args')
10350 
    if self.cartId != None:
10351 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10352 
      oprot.writeI64(self.cartId)
10353 
      oprot.writeFieldEnd()
10354 
    if self.itemId != None:
10355 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10356 
      oprot.writeI64(self.itemId)
10357 
      oprot.writeFieldEnd()
10358 
    oprot.writeFieldStop()
10359 
    oprot.writeStructEnd()
10360 
 
10361 
  def __repr__(self):
10362 
    L = ['%s=%r' % (key, value)
10363 
      for key, value in self.__dict__.iteritems()]
10364 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10365 
 
10366 
  def __eq__(self, other):
10367 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10368 
 
10369 
  def __ne__(self, other):
10370 
    return not (self == other)
10371 
 
10372 
class deleteItemFromCart_result:
10373 
  """
10374 
  Attributes:
10375 
   - scx
10376 
  """
10377 
 
10378 
  thrift_spec = (
10379 
    None, # 0
10380 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10381 
  )
10382 
 
10383 
  def __init__(self, scx=None,):
10384 
    self.scx = scx
10385 
 
10386 
  def read(self, iprot):
10387 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10388 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10389 
      return
10390 
    iprot.readStructBegin()
10391 
    while True:
10392 
      (fname, ftype, fid) = iprot.readFieldBegin()
10393 
      if ftype == TType.STOP:
10394 
        break
10395 
      if fid == 1:
10396 
        if ftype == TType.STRUCT:
10397 
          self.scx = ShoppingCartException()
10398 
          self.scx.read(iprot)
10399 
        else:
10400 
          iprot.skip(ftype)
10401 
      else:
10402 
        iprot.skip(ftype)
10403 
      iprot.readFieldEnd()
10404 
    iprot.readStructEnd()
10405 
 
10406 
  def write(self, oprot):
10407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10409 
      return
10410 
    oprot.writeStructBegin('deleteItemFromCart_result')
10411 
    if self.scx != None:
10412 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10413 
      self.scx.write(oprot)
10414 
      oprot.writeFieldEnd()
10415 
    oprot.writeFieldStop()
10416 
    oprot.writeStructEnd()
10417 
 
10418 
  def __repr__(self):
10419 
    L = ['%s=%r' % (key, value)
10420 
      for key, value in self.__dict__.iteritems()]
10421 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10422 
 
10423 
  def __eq__(self, other):
10424 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10425 
 
10426 
  def __ne__(self, other):
10427 
    return not (self == other)
10428 
 
10429 
class changeQuantity_args:
10430 
  """
10431 
  Attributes:
10432 
   - cartId
10433 
   - itemId
10434 
   - quantity
10435 
  """
10436 
 
10437 
  thrift_spec = (
10438 
    None, # 0
10439 
    (1, TType.I64, 'cartId', None, None, ), # 1
10440 
    (2, TType.I64, 'itemId', None, None, ), # 2
10441 
    (3, TType.I64, 'quantity', None, None, ), # 3
10442 
  )
10443 
 
10444 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
10445 
    self.cartId = cartId
10446 
    self.itemId = itemId
10447 
    self.quantity = quantity
10448 
 
10449 
  def read(self, iprot):
10450 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10451 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10452 
      return
10453 
    iprot.readStructBegin()
10454 
    while True:
10455 
      (fname, ftype, fid) = iprot.readFieldBegin()
10456 
      if ftype == TType.STOP:
10457 
        break
10458 
      if fid == 1:
10459 
        if ftype == TType.I64:
10460 
          self.cartId = iprot.readI64();
10461 
        else:
10462 
          iprot.skip(ftype)
10463 
      elif fid == 2:
10464 
        if ftype == TType.I64:
10465 
          self.itemId = iprot.readI64();
10466 
        else:
10467 
          iprot.skip(ftype)
10468 
      elif fid == 3:
10469 
        if ftype == TType.I64:
10470 
          self.quantity = iprot.readI64();
10471 
        else:
10472 
          iprot.skip(ftype)
10473 
      else:
10474 
        iprot.skip(ftype)
10475 
      iprot.readFieldEnd()
10476 
    iprot.readStructEnd()
10477 
 
10478 
  def write(self, oprot):
10479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10481 
      return
10482 
    oprot.writeStructBegin('changeQuantity_args')
10483 
    if self.cartId != None:
10484 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10485 
      oprot.writeI64(self.cartId)
10486 
      oprot.writeFieldEnd()
10487 
    if self.itemId != None:
10488 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10489 
      oprot.writeI64(self.itemId)
10490 
      oprot.writeFieldEnd()
10491 
    if self.quantity != None:
10492 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10493 
      oprot.writeI64(self.quantity)
10494 
      oprot.writeFieldEnd()
10495 
    oprot.writeFieldStop()
10496 
    oprot.writeStructEnd()
10497 
 
10498 
  def __repr__(self):
10499 
    L = ['%s=%r' % (key, value)
10500 
      for key, value in self.__dict__.iteritems()]
10501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10502 
 
10503 
  def __eq__(self, other):
10504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10505 
 
10506 
  def __ne__(self, other):
10507 
    return not (self == other)
10508 
 
10509 
class changeQuantity_result:
10510 
  """
10511 
  Attributes:
10512 
   - scx
10513 
  """
10514 
 
10515 
  thrift_spec = (
10516 
    None, # 0
10517 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10518 
  )
10519 
 
10520 
  def __init__(self, scx=None,):
10521 
    self.scx = scx
10522 
 
10523 
  def read(self, iprot):
10524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10526 
      return
10527 
    iprot.readStructBegin()
10528 
    while True:
10529 
      (fname, ftype, fid) = iprot.readFieldBegin()
10530 
      if ftype == TType.STOP:
10531 
        break
10532 
      if fid == 1:
10533 
        if ftype == TType.STRUCT:
10534 
          self.scx = ShoppingCartException()
10535 
          self.scx.read(iprot)
10536 
        else:
10537 
          iprot.skip(ftype)
10538 
      else:
10539 
        iprot.skip(ftype)
10540 
      iprot.readFieldEnd()
10541 
    iprot.readStructEnd()
10542 
 
10543 
  def write(self, oprot):
10544 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10545 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10546 
      return
10547 
    oprot.writeStructBegin('changeQuantity_result')
10548 
    if self.scx != None:
10549 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10550 
      self.scx.write(oprot)
10551 
      oprot.writeFieldEnd()
10552 
    oprot.writeFieldStop()
10553 
    oprot.writeStructEnd()
10554 
 
10555 
  def __repr__(self):
10556 
    L = ['%s=%r' % (key, value)
10557 
      for key, value in self.__dict__.iteritems()]
10558 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10559 
 
10560 
  def __eq__(self, other):
10561 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10562 
 
10563 
  def __ne__(self, other):
10564 
    return not (self == other)
10565 
 
10566 
class changeItemStatus_args:
10567 
  """
10568 
  Attributes:
10569 
   - cartId
10570 
   - itemId
10571 
   - status
10572 
  """
10573 
 
10574 
  thrift_spec = (
10575 
    None, # 0
10576 
    (1, TType.I64, 'cartId', None, None, ), # 1
10577 
    (2, TType.I64, 'itemId', None, None, ), # 2
10578 
    (3, TType.I32, 'status', None, None, ), # 3
10579 
  )
10580 
 
10581 
  def __init__(self, cartId=None, itemId=None, status=None,):
10582 
    self.cartId = cartId
10583 
    self.itemId = itemId
10584 
    self.status = status
10585 
 
10586 
  def read(self, iprot):
10587 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10588 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10589 
      return
10590 
    iprot.readStructBegin()
10591 
    while True:
10592 
      (fname, ftype, fid) = iprot.readFieldBegin()
10593 
      if ftype == TType.STOP:
10594 
        break
10595 
      if fid == 1:
10596 
        if ftype == TType.I64:
10597 
          self.cartId = iprot.readI64();
10598 
        else:
10599 
          iprot.skip(ftype)
10600 
      elif fid == 2:
10601 
        if ftype == TType.I64:
10602 
          self.itemId = iprot.readI64();
10603 
        else:
10604 
          iprot.skip(ftype)
10605 
      elif fid == 3:
10606 
        if ftype == TType.I32:
10607 
          self.status = iprot.readI32();
10608 
        else:
10609 
          iprot.skip(ftype)
10610 
      else:
10611 
        iprot.skip(ftype)
10612 
      iprot.readFieldEnd()
10613 
    iprot.readStructEnd()
10614 
 
10615 
  def write(self, oprot):
10616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10618 
      return
10619 
    oprot.writeStructBegin('changeItemStatus_args')
10620 
    if self.cartId != None:
10621 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10622 
      oprot.writeI64(self.cartId)
10623 
      oprot.writeFieldEnd()
10624 
    if self.itemId != None:
10625 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10626 
      oprot.writeI64(self.itemId)
10627 
      oprot.writeFieldEnd()
10628 
    if self.status != None:
10629 
      oprot.writeFieldBegin('status', TType.I32, 3)
10630 
      oprot.writeI32(self.status)
10631 
      oprot.writeFieldEnd()
10632 
    oprot.writeFieldStop()
10633 
    oprot.writeStructEnd()
10634 
 
10635 
  def __repr__(self):
10636 
    L = ['%s=%r' % (key, value)
10637 
      for key, value in self.__dict__.iteritems()]
10638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10639 
 
10640 
  def __eq__(self, other):
10641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10642 
 
10643 
  def __ne__(self, other):
10644 
    return not (self == other)
10645 
 
10646 
class changeItemStatus_result:
10647 
  """
10648 
  Attributes:
10649 
   - scx
10650 
  """
10651 
 
10652 
  thrift_spec = (
10653 
    None, # 0
10654 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10655 
  )
10656 
 
10657 
  def __init__(self, scx=None,):
10658 
    self.scx = scx
10659 
 
10660 
  def read(self, iprot):
10661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10663 
      return
10664 
    iprot.readStructBegin()
10665 
    while True:
10666 
      (fname, ftype, fid) = iprot.readFieldBegin()
10667 
      if ftype == TType.STOP:
10668 
        break
10669 
      if fid == 1:
10670 
        if ftype == TType.STRUCT:
10671 
          self.scx = ShoppingCartException()
10672 
          self.scx.read(iprot)
10673 
        else:
10674 
          iprot.skip(ftype)
10675 
      else:
10676 
        iprot.skip(ftype)
10677 
      iprot.readFieldEnd()
10678 
    iprot.readStructEnd()
10679 
 
10680 
  def write(self, oprot):
10681 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10682 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10683 
      return
10684 
    oprot.writeStructBegin('changeItemStatus_result')
10685 
    if self.scx != None:
10686 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10687 
      self.scx.write(oprot)
10688 
      oprot.writeFieldEnd()
10689 
    oprot.writeFieldStop()
10690 
    oprot.writeStructEnd()
10691 
 
10692 
  def __repr__(self):
10693 
    L = ['%s=%r' % (key, value)
10694 
      for key, value in self.__dict__.iteritems()]
10695 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10696 
 
10697 
  def __eq__(self, other):
10698 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10699 
 
10700 
  def __ne__(self, other):
10701 
    return not (self == other)
10702 
 
10703 
class addAddressToCart_args:
10704 
  """
10705 
  Attributes:
10706 
   - cartId
10707 
   - addressId
10708 
  """
10709 
 
10710 
  thrift_spec = (
10711 
    None, # 0
10712 
    (1, TType.I64, 'cartId', None, None, ), # 1
10713 
    (2, TType.I64, 'addressId', None, None, ), # 2
10714 
  )
10715 
 
10716 
  def __init__(self, cartId=None, addressId=None,):
10717 
    self.cartId = cartId
10718 
    self.addressId = addressId
10719 
 
10720 
  def read(self, iprot):
10721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10723 
      return
10724 
    iprot.readStructBegin()
10725 
    while True:
10726 
      (fname, ftype, fid) = iprot.readFieldBegin()
10727 
      if ftype == TType.STOP:
10728 
        break
10729 
      if fid == 1:
10730 
        if ftype == TType.I64:
10731 
          self.cartId = iprot.readI64();
10732 
        else:
10733 
          iprot.skip(ftype)
10734 
      elif fid == 2:
10735 
        if ftype == TType.I64:
10736 
          self.addressId = iprot.readI64();
10737 
        else:
10738 
          iprot.skip(ftype)
10739 
      else:
10740 
        iprot.skip(ftype)
10741 
      iprot.readFieldEnd()
10742 
    iprot.readStructEnd()
10743 
 
10744 
  def write(self, oprot):
10745 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10746 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10747 
      return
10748 
    oprot.writeStructBegin('addAddressToCart_args')
10749 
    if self.cartId != None:
10750 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10751 
      oprot.writeI64(self.cartId)
10752 
      oprot.writeFieldEnd()
10753 
    if self.addressId != None:
10754 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
10755 
      oprot.writeI64(self.addressId)
10756 
      oprot.writeFieldEnd()
10757 
    oprot.writeFieldStop()
10758 
    oprot.writeStructEnd()
10759 
 
10760 
  def __repr__(self):
10761 
    L = ['%s=%r' % (key, value)
10762 
      for key, value in self.__dict__.iteritems()]
10763 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10764 
 
10765 
  def __eq__(self, other):
10766 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10767 
 
10768 
  def __ne__(self, other):
10769 
    return not (self == other)
10770 
 
10771 
class addAddressToCart_result:
575 chandransh 10772 
  """
10773 
  Attributes:
10774 
   - scx
10775 
  """
559 chandransh 10776 
 
10777 
  thrift_spec = (
575 chandransh 10778 
    None, # 0
10779 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 10780 
  )
10781 
 
575 chandransh 10782 
  def __init__(self, scx=None,):
10783 
    self.scx = scx
10784 
 
559 chandransh 10785 
  def read(self, iprot):
10786 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10787 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10788 
      return
10789 
    iprot.readStructBegin()
10790 
    while True:
10791 
      (fname, ftype, fid) = iprot.readFieldBegin()
10792 
      if ftype == TType.STOP:
10793 
        break
575 chandransh 10794 
      if fid == 1:
10795 
        if ftype == TType.STRUCT:
10796 
          self.scx = ShoppingCartException()
10797 
          self.scx.read(iprot)
10798 
        else:
10799 
          iprot.skip(ftype)
559 chandransh 10800 
      else:
10801 
        iprot.skip(ftype)
10802 
      iprot.readFieldEnd()
10803 
    iprot.readStructEnd()
10804 
 
10805 
  def write(self, oprot):
10806 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10807 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10808 
      return
10809 
    oprot.writeStructBegin('addAddressToCart_result')
575 chandransh 10810 
    if self.scx != None:
10811 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10812 
      self.scx.write(oprot)
10813 
      oprot.writeFieldEnd()
559 chandransh 10814 
    oprot.writeFieldStop()
10815 
    oprot.writeStructEnd()
10816 
 
10817 
  def __repr__(self):
10818 
    L = ['%s=%r' % (key, value)
10819 
      for key, value in self.__dict__.iteritems()]
10820 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10821 
 
10822 
  def __eq__(self, other):
10823 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10824 
 
10825 
  def __ne__(self, other):
10826 
    return not (self == other)
10827 
 
1976 varun.gupt 10828 
class applyCouponToCart_args:
10829 
  """
10830 
  Attributes:
10831 
   - cartId
10832 
   - couponCode
10833 
   - totalPrice
10834 
   - discountedPrice
10835 
  """
10836 
 
10837 
  thrift_spec = (
10838 
    None, # 0
10839 
    (1, TType.I64, 'cartId', None, None, ), # 1
10840 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
10841 
    (3, TType.DOUBLE, 'totalPrice', None, None, ), # 3
10842 
    (4, TType.DOUBLE, 'discountedPrice', None, None, ), # 4
10843 
  )
10844 
 
10845 
  def __init__(self, cartId=None, couponCode=None, totalPrice=None, discountedPrice=None,):
10846 
    self.cartId = cartId
10847 
    self.couponCode = couponCode
10848 
    self.totalPrice = totalPrice
10849 
    self.discountedPrice = discountedPrice
10850 
 
10851 
  def read(self, iprot):
10852 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10853 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10854 
      return
10855 
    iprot.readStructBegin()
10856 
    while True:
10857 
      (fname, ftype, fid) = iprot.readFieldBegin()
10858 
      if ftype == TType.STOP:
10859 
        break
10860 
      if fid == 1:
10861 
        if ftype == TType.I64:
10862 
          self.cartId = iprot.readI64();
10863 
        else:
10864 
          iprot.skip(ftype)
10865 
      elif fid == 2:
10866 
        if ftype == TType.STRING:
10867 
          self.couponCode = iprot.readString();
10868 
        else:
10869 
          iprot.skip(ftype)
10870 
      elif fid == 3:
10871 
        if ftype == TType.DOUBLE:
10872 
          self.totalPrice = iprot.readDouble();
10873 
        else:
10874 
          iprot.skip(ftype)
10875 
      elif fid == 4:
10876 
        if ftype == TType.DOUBLE:
10877 
          self.discountedPrice = iprot.readDouble();
10878 
        else:
10879 
          iprot.skip(ftype)
10880 
      else:
10881 
        iprot.skip(ftype)
10882 
      iprot.readFieldEnd()
10883 
    iprot.readStructEnd()
10884 
 
10885 
  def write(self, oprot):
10886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10888 
      return
10889 
    oprot.writeStructBegin('applyCouponToCart_args')
10890 
    if self.cartId != None:
10891 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10892 
      oprot.writeI64(self.cartId)
10893 
      oprot.writeFieldEnd()
10894 
    if self.couponCode != None:
10895 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
10896 
      oprot.writeString(self.couponCode)
10897 
      oprot.writeFieldEnd()
10898 
    if self.totalPrice != None:
10899 
      oprot.writeFieldBegin('totalPrice', TType.DOUBLE, 3)
10900 
      oprot.writeDouble(self.totalPrice)
10901 
      oprot.writeFieldEnd()
10902 
    if self.discountedPrice != None:
10903 
      oprot.writeFieldBegin('discountedPrice', TType.DOUBLE, 4)
10904 
      oprot.writeDouble(self.discountedPrice)
10905 
      oprot.writeFieldEnd()
10906 
    oprot.writeFieldStop()
10907 
    oprot.writeStructEnd()
10908 
 
10909 
  def __repr__(self):
10910 
    L = ['%s=%r' % (key, value)
10911 
      for key, value in self.__dict__.iteritems()]
10912 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10913 
 
10914 
  def __eq__(self, other):
10915 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10916 
 
10917 
  def __ne__(self, other):
10918 
    return not (self == other)
10919 
 
10920 
class applyCouponToCart_result:
10921 
  """
10922 
  Attributes:
10923 
   - scx
10924 
  """
10925 
 
10926 
  thrift_spec = (
10927 
    None, # 0
10928 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10929 
  )
10930 
 
10931 
  def __init__(self, scx=None,):
10932 
    self.scx = scx
10933 
 
10934 
  def read(self, iprot):
10935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10937 
      return
10938 
    iprot.readStructBegin()
10939 
    while True:
10940 
      (fname, ftype, fid) = iprot.readFieldBegin()
10941 
      if ftype == TType.STOP:
10942 
        break
10943 
      if fid == 1:
10944 
        if ftype == TType.STRUCT:
10945 
          self.scx = ShoppingCartException()
10946 
          self.scx.read(iprot)
10947 
        else:
10948 
          iprot.skip(ftype)
10949 
      else:
10950 
        iprot.skip(ftype)
10951 
      iprot.readFieldEnd()
10952 
    iprot.readStructEnd()
10953 
 
10954 
  def write(self, oprot):
10955 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10956 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10957 
      return
10958 
    oprot.writeStructBegin('applyCouponToCart_result')
10959 
    if self.scx != None:
10960 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10961 
      self.scx.write(oprot)
10962 
      oprot.writeFieldEnd()
10963 
    oprot.writeFieldStop()
10964 
    oprot.writeStructEnd()
10965 
 
10966 
  def __repr__(self):
10967 
    L = ['%s=%r' % (key, value)
10968 
      for key, value in self.__dict__.iteritems()]
10969 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10970 
 
10971 
  def __eq__(self, other):
10972 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10973 
 
10974 
  def __ne__(self, other):
10975 
    return not (self == other)
10976 
 
10977 
class removeCoupon_args:
10978 
  """
10979 
  Attributes:
10980 
   - cartId
10981 
  """
10982 
 
10983 
  thrift_spec = (
10984 
    None, # 0
10985 
    (1, TType.I64, 'cartId', None, None, ), # 1
10986 
  )
10987 
 
10988 
  def __init__(self, cartId=None,):
10989 
    self.cartId = cartId
10990 
 
10991 
  def read(self, iprot):
10992 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10993 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10994 
      return
10995 
    iprot.readStructBegin()
10996 
    while True:
10997 
      (fname, ftype, fid) = iprot.readFieldBegin()
10998 
      if ftype == TType.STOP:
10999 
        break
11000 
      if fid == 1:
11001 
        if ftype == TType.I64:
11002 
          self.cartId = iprot.readI64();
11003 
        else:
11004 
          iprot.skip(ftype)
11005 
      else:
11006 
        iprot.skip(ftype)
11007 
      iprot.readFieldEnd()
11008 
    iprot.readStructEnd()
11009 
 
11010 
  def write(self, oprot):
11011 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11012 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11013 
      return
11014 
    oprot.writeStructBegin('removeCoupon_args')
11015 
    if self.cartId != None:
11016 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11017 
      oprot.writeI64(self.cartId)
11018 
      oprot.writeFieldEnd()
11019 
    oprot.writeFieldStop()
11020 
    oprot.writeStructEnd()
11021 
 
11022 
  def __repr__(self):
11023 
    L = ['%s=%r' % (key, value)
11024 
      for key, value in self.__dict__.iteritems()]
11025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11026 
 
11027 
  def __eq__(self, other):
11028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11029 
 
11030 
  def __ne__(self, other):
11031 
    return not (self == other)
11032 
 
11033 
class removeCoupon_result:
11034 
  """
11035 
  Attributes:
11036 
   - scx
11037 
  """
11038 
 
11039 
  thrift_spec = (
11040 
    None, # 0
11041 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11042 
  )
11043 
 
11044 
  def __init__(self, scx=None,):
11045 
    self.scx = scx
11046 
 
11047 
  def read(self, iprot):
11048 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11049 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11050 
      return
11051 
    iprot.readStructBegin()
11052 
    while True:
11053 
      (fname, ftype, fid) = iprot.readFieldBegin()
11054 
      if ftype == TType.STOP:
11055 
        break
11056 
      if fid == 1:
11057 
        if ftype == TType.STRUCT:
11058 
          self.scx = ShoppingCartException()
11059 
          self.scx.read(iprot)
11060 
        else:
11061 
          iprot.skip(ftype)
11062 
      else:
11063 
        iprot.skip(ftype)
11064 
      iprot.readFieldEnd()
11065 
    iprot.readStructEnd()
11066 
 
11067 
  def write(self, oprot):
11068 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11069 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11070 
      return
11071 
    oprot.writeStructBegin('removeCoupon_result')
11072 
    if self.scx != None:
11073 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11074 
      self.scx.write(oprot)
11075 
      oprot.writeFieldEnd()
11076 
    oprot.writeFieldStop()
11077 
    oprot.writeStructEnd()
11078 
 
11079 
  def __repr__(self):
11080 
    L = ['%s=%r' % (key, value)
11081 
      for key, value in self.__dict__.iteritems()]
11082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11083 
 
11084 
  def __eq__(self, other):
11085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11086 
 
11087 
  def __ne__(self, other):
11088 
    return not (self == other)
11089 
 
690 chandransh 11090 
class createOrders_args:
559 chandransh 11091 
  """
11092 
  Attributes:
11093 
   - cartId
2815 vikas 11094 
   - sessionSource
11095 
   - sessionStartTime
559 chandransh 11096 
  """
11097 
 
11098 
  thrift_spec = (
11099 
    None, # 0
11100 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 11101 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
11102 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
559 chandransh 11103 
  )
11104 
 
2815 vikas 11105 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None,):
559 chandransh 11106 
    self.cartId = cartId
2815 vikas 11107 
    self.sessionSource = sessionSource
11108 
    self.sessionStartTime = sessionStartTime
559 chandransh 11109 
 
11110 
  def read(self, iprot):
11111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11113 
      return
11114 
    iprot.readStructBegin()
11115 
    while True:
11116 
      (fname, ftype, fid) = iprot.readFieldBegin()
11117 
      if ftype == TType.STOP:
11118 
        break
11119 
      if fid == 1:
11120 
        if ftype == TType.I64:
11121 
          self.cartId = iprot.readI64();
11122 
        else:
11123 
          iprot.skip(ftype)
2815 vikas 11124 
      elif fid == 2:
11125 
        if ftype == TType.STRING:
11126 
          self.sessionSource = iprot.readString();
11127 
        else:
11128 
          iprot.skip(ftype)
11129 
      elif fid == 3:
11130 
        if ftype == TType.I64:
11131 
          self.sessionStartTime = iprot.readI64();
11132 
        else:
11133 
          iprot.skip(ftype)
559 chandransh 11134 
      else:
11135 
        iprot.skip(ftype)
11136 
      iprot.readFieldEnd()
11137 
    iprot.readStructEnd()
11138 
 
11139 
  def write(self, oprot):
11140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11142 
      return
690 chandransh 11143 
    oprot.writeStructBegin('createOrders_args')
559 chandransh 11144 
    if self.cartId != None:
11145 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11146 
      oprot.writeI64(self.cartId)
11147 
      oprot.writeFieldEnd()
2815 vikas 11148 
    if self.sessionSource != None:
11149 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
11150 
      oprot.writeString(self.sessionSource)
11151 
      oprot.writeFieldEnd()
11152 
    if self.sessionStartTime != None:
11153 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
11154 
      oprot.writeI64(self.sessionStartTime)
11155 
      oprot.writeFieldEnd()
559 chandransh 11156 
    oprot.writeFieldStop()
11157 
    oprot.writeStructEnd()
11158 
 
11159 
  def __repr__(self):
11160 
    L = ['%s=%r' % (key, value)
11161 
      for key, value in self.__dict__.iteritems()]
11162 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11163 
 
11164 
  def __eq__(self, other):
11165 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11166 
 
11167 
  def __ne__(self, other):
11168 
    return not (self == other)
11169 
 
690 chandransh 11170 
class createOrders_result:
559 chandransh 11171 
  """
11172 
  Attributes:
94 ashish 11173 
   - success
559 chandransh 11174 
   - scx
94 ashish 11175 
  """
11176 
 
11177 
  thrift_spec = (
575 chandransh 11178 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 11179 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11180 
  )
11181 
 
559 chandransh 11182 
  def __init__(self, success=None, scx=None,):
94 ashish 11183 
    self.success = success
559 chandransh 11184 
    self.scx = scx
94 ashish 11185 
 
11186 
  def read(self, iprot):
11187 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11188 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11189 
      return
11190 
    iprot.readStructBegin()
11191 
    while True:
11192 
      (fname, ftype, fid) = iprot.readFieldBegin()
11193 
      if ftype == TType.STOP:
11194 
        break
11195 
      if fid == 0:
575 chandransh 11196 
        if ftype == TType.I64:
11197 
          self.success = iprot.readI64();
94 ashish 11198 
        else:
11199 
          iprot.skip(ftype)
11200 
      elif fid == 1:
11201 
        if ftype == TType.STRUCT:
559 chandransh 11202 
          self.scx = ShoppingCartException()
11203 
          self.scx.read(iprot)
94 ashish 11204 
        else:
11205 
          iprot.skip(ftype)
11206 
      else:
11207 
        iprot.skip(ftype)
11208 
      iprot.readFieldEnd()
11209 
    iprot.readStructEnd()
11210 
 
11211 
  def write(self, oprot):
11212 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11213 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11214 
      return
690 chandransh 11215 
    oprot.writeStructBegin('createOrders_result')
94 ashish 11216 
    if self.success != None:
575 chandransh 11217 
      oprot.writeFieldBegin('success', TType.I64, 0)
11218 
      oprot.writeI64(self.success)
94 ashish 11219 
      oprot.writeFieldEnd()
559 chandransh 11220 
    if self.scx != None:
11221 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11222 
      self.scx.write(oprot)
94 ashish 11223 
      oprot.writeFieldEnd()
11224 
    oprot.writeFieldStop()
11225 
    oprot.writeStructEnd()
11226 
 
11227 
  def __repr__(self):
11228 
    L = ['%s=%r' % (key, value)
11229 
      for key, value in self.__dict__.iteritems()]
11230 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11231 
 
11232 
  def __eq__(self, other):
11233 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11234 
 
11235 
  def __ne__(self, other):
11236 
    return not (self == other)
11237 
 
559 chandransh 11238 
class validateCart_args:
94 ashish 11239 
  """
11240 
  Attributes:
559 chandransh 11241 
   - cartId
94 ashish 11242 
  """
11243 
 
11244 
  thrift_spec = (
11245 
    None, # 0
559 chandransh 11246 
    (1, TType.I64, 'cartId', None, None, ), # 1
94 ashish 11247 
  )
11248 
 
559 chandransh 11249 
  def __init__(self, cartId=None,):
11250 
    self.cartId = cartId
94 ashish 11251 
 
11252 
  def read(self, iprot):
11253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11255 
      return
11256 
    iprot.readStructBegin()
11257 
    while True:
11258 
      (fname, ftype, fid) = iprot.readFieldBegin()
11259 
      if ftype == TType.STOP:
11260 
        break
11261 
      if fid == 1:
11262 
        if ftype == TType.I64:
559 chandransh 11263 
          self.cartId = iprot.readI64();
94 ashish 11264 
        else:
11265 
          iprot.skip(ftype)
11266 
      else:
11267 
        iprot.skip(ftype)
11268 
      iprot.readFieldEnd()
11269 
    iprot.readStructEnd()
11270 
 
11271 
  def write(self, oprot):
11272 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11273 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11274 
      return
559 chandransh 11275 
    oprot.writeStructBegin('validateCart_args')
11276 
    if self.cartId != None:
11277 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11278 
      oprot.writeI64(self.cartId)
94 ashish 11279 
      oprot.writeFieldEnd()
11280 
    oprot.writeFieldStop()
11281 
    oprot.writeStructEnd()
11282 
 
11283 
  def __repr__(self):
11284 
    L = ['%s=%r' % (key, value)
11285 
      for key, value in self.__dict__.iteritems()]
11286 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11287 
 
11288 
  def __eq__(self, other):
11289 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11290 
 
11291 
  def __ne__(self, other):
11292 
    return not (self == other)
11293 
 
559 chandransh 11294 
class validateCart_result:
94 ashish 11295 
  """
11296 
  Attributes:
11297 
   - success
575 chandransh 11298 
   - scex
94 ashish 11299 
  """
11300 
 
11301 
  thrift_spec = (
1466 ankur.sing 11302 
    (0, TType.STRING, 'success', None, None, ), # 0
575 chandransh 11303 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11304 
  )
11305 
 
575 chandransh 11306 
  def __init__(self, success=None, scex=None,):
94 ashish 11307 
    self.success = success
575 chandransh 11308 
    self.scex = scex
94 ashish 11309 
 
11310 
  def read(self, iprot):
11311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11313 
      return
11314 
    iprot.readStructBegin()
11315 
    while True:
11316 
      (fname, ftype, fid) = iprot.readFieldBegin()
11317 
      if ftype == TType.STOP:
11318 
        break
11319 
      if fid == 0:
1466 ankur.sing 11320 
        if ftype == TType.STRING:
11321 
          self.success = iprot.readString();
94 ashish 11322 
        else:
11323 
          iprot.skip(ftype)
575 chandransh 11324 
      elif fid == 1:
11325 
        if ftype == TType.STRUCT:
11326 
          self.scex = ShoppingCartException()
11327 
          self.scex.read(iprot)
11328 
        else:
11329 
          iprot.skip(ftype)
94 ashish 11330 
      else:
11331 
        iprot.skip(ftype)
11332 
      iprot.readFieldEnd()
11333 
    iprot.readStructEnd()
11334 
 
11335 
  def write(self, oprot):
11336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11338 
      return
559 chandransh 11339 
    oprot.writeStructBegin('validateCart_result')
94 ashish 11340 
    if self.success != None:
1466 ankur.sing 11341 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11342 
      oprot.writeString(self.success)
94 ashish 11343 
      oprot.writeFieldEnd()
575 chandransh 11344 
    if self.scex != None:
11345 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11346 
      self.scex.write(oprot)
11347 
      oprot.writeFieldEnd()
559 chandransh 11348 
    oprot.writeFieldStop()
11349 
    oprot.writeStructEnd()
11350 
 
11351 
  def __repr__(self):
11352 
    L = ['%s=%r' % (key, value)
11353 
      for key, value in self.__dict__.iteritems()]
11354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11355 
 
11356 
  def __eq__(self, other):
11357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11358 
 
11359 
  def __ne__(self, other):
11360 
    return not (self == other)
11361 
 
690 chandransh 11362 
class mergeCart_args:
575 chandransh 11363 
  """
11364 
  Attributes:
690 chandransh 11365 
   - fromCartId
11366 
   - toCartId
11367 
  """
11368 
 
11369 
  thrift_spec = (
11370 
    None, # 0
11371 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
11372 
    (2, TType.I64, 'toCartId', None, None, ), # 2
11373 
  )
11374 
 
11375 
  def __init__(self, fromCartId=None, toCartId=None,):
11376 
    self.fromCartId = fromCartId
11377 
    self.toCartId = toCartId
11378 
 
11379 
  def read(self, iprot):
11380 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11381 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11382 
      return
11383 
    iprot.readStructBegin()
11384 
    while True:
11385 
      (fname, ftype, fid) = iprot.readFieldBegin()
11386 
      if ftype == TType.STOP:
11387 
        break
11388 
      if fid == 1:
11389 
        if ftype == TType.I64:
11390 
          self.fromCartId = iprot.readI64();
11391 
        else:
11392 
          iprot.skip(ftype)
11393 
      elif fid == 2:
11394 
        if ftype == TType.I64:
11395 
          self.toCartId = iprot.readI64();
11396 
        else:
11397 
          iprot.skip(ftype)
11398 
      else:
11399 
        iprot.skip(ftype)
11400 
      iprot.readFieldEnd()
11401 
    iprot.readStructEnd()
11402 
 
11403 
  def write(self, oprot):
11404 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11405 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11406 
      return
11407 
    oprot.writeStructBegin('mergeCart_args')
11408 
    if self.fromCartId != None:
11409 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
11410 
      oprot.writeI64(self.fromCartId)
11411 
      oprot.writeFieldEnd()
11412 
    if self.toCartId != None:
11413 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
11414 
      oprot.writeI64(self.toCartId)
11415 
      oprot.writeFieldEnd()
11416 
    oprot.writeFieldStop()
11417 
    oprot.writeStructEnd()
11418 
 
11419 
  def __repr__(self):
11420 
    L = ['%s=%r' % (key, value)
11421 
      for key, value in self.__dict__.iteritems()]
11422 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11423 
 
11424 
  def __eq__(self, other):
11425 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11426 
 
11427 
  def __ne__(self, other):
11428 
    return not (self == other)
11429 
 
11430 
class mergeCart_result:
11431 
 
11432 
  thrift_spec = (
11433 
  )
11434 
 
11435 
  def read(self, iprot):
11436 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11437 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11438 
      return
11439 
    iprot.readStructBegin()
11440 
    while True:
11441 
      (fname, ftype, fid) = iprot.readFieldBegin()
11442 
      if ftype == TType.STOP:
11443 
        break
11444 
      else:
11445 
        iprot.skip(ftype)
11446 
      iprot.readFieldEnd()
11447 
    iprot.readStructEnd()
11448 
 
11449 
  def write(self, oprot):
11450 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11451 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11452 
      return
11453 
    oprot.writeStructBegin('mergeCart_result')
11454 
    oprot.writeFieldStop()
11455 
    oprot.writeStructEnd()
11456 
 
11457 
  def __repr__(self):
11458 
    L = ['%s=%r' % (key, value)
11459 
      for key, value in self.__dict__.iteritems()]
11460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11461 
 
11462 
  def __eq__(self, other):
11463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11464 
 
11465 
  def __ne__(self, other):
11466 
    return not (self == other)
11467 
 
11468 
class checkOut_args:
11469 
  """
11470 
  Attributes:
575 chandransh 11471 
   - cartId
11472 
  """
11473 
 
11474 
  thrift_spec = (
11475 
    None, # 0
11476 
    (1, TType.I64, 'cartId', None, None, ), # 1
11477 
  )
11478 
 
11479 
  def __init__(self, cartId=None,):
11480 
    self.cartId = cartId
11481 
 
11482 
  def read(self, iprot):
11483 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11484 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11485 
      return
11486 
    iprot.readStructBegin()
11487 
    while True:
11488 
      (fname, ftype, fid) = iprot.readFieldBegin()
11489 
      if ftype == TType.STOP:
11490 
        break
11491 
      if fid == 1:
11492 
        if ftype == TType.I64:
11493 
          self.cartId = iprot.readI64();
11494 
        else:
11495 
          iprot.skip(ftype)
11496 
      else:
11497 
        iprot.skip(ftype)
11498 
      iprot.readFieldEnd()
11499 
    iprot.readStructEnd()
11500 
 
11501 
  def write(self, oprot):
11502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11504 
      return
690 chandransh 11505 
    oprot.writeStructBegin('checkOut_args')
575 chandransh 11506 
    if self.cartId != None:
11507 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11508 
      oprot.writeI64(self.cartId)
11509 
      oprot.writeFieldEnd()
11510 
    oprot.writeFieldStop()
11511 
    oprot.writeStructEnd()
11512 
 
11513 
  def __repr__(self):
11514 
    L = ['%s=%r' % (key, value)
11515 
      for key, value in self.__dict__.iteritems()]
11516 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11517 
 
11518 
  def __eq__(self, other):
11519 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11520 
 
11521 
  def __ne__(self, other):
11522 
    return not (self == other)
11523 
 
690 chandransh 11524 
class checkOut_result:
575 chandransh 11525 
  """
11526 
  Attributes:
11527 
   - success
11528 
   - scex
11529 
  """
11530 
 
11531 
  thrift_spec = (
11532 
    (0, TType.BOOL, 'success', None, None, ), # 0
11533 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11534 
  )
11535 
 
11536 
  def __init__(self, success=None, scex=None,):
11537 
    self.success = success
11538 
    self.scex = scex
11539 
 
11540 
  def read(self, iprot):
11541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11543 
      return
11544 
    iprot.readStructBegin()
11545 
    while True:
11546 
      (fname, ftype, fid) = iprot.readFieldBegin()
11547 
      if ftype == TType.STOP:
11548 
        break
11549 
      if fid == 0:
11550 
        if ftype == TType.BOOL:
11551 
          self.success = iprot.readBool();
11552 
        else:
11553 
          iprot.skip(ftype)
11554 
      elif fid == 1:
11555 
        if ftype == TType.STRUCT:
11556 
          self.scex = ShoppingCartException()
11557 
          self.scex.read(iprot)
11558 
        else:
11559 
          iprot.skip(ftype)
11560 
      else:
11561 
        iprot.skip(ftype)
11562 
      iprot.readFieldEnd()
11563 
    iprot.readStructEnd()
11564 
 
11565 
  def write(self, oprot):
11566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11568 
      return
690 chandransh 11569 
    oprot.writeStructBegin('checkOut_result')
575 chandransh 11570 
    if self.success != None:
11571 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11572 
      oprot.writeBool(self.success)
11573 
      oprot.writeFieldEnd()
11574 
    if self.scex != None:
11575 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11576 
      self.scex.write(oprot)
11577 
      oprot.writeFieldEnd()
11578 
    oprot.writeFieldStop()
11579 
    oprot.writeStructEnd()
11580 
 
11581 
  def __repr__(self):
11582 
    L = ['%s=%r' % (key, value)
11583 
      for key, value in self.__dict__.iteritems()]
11584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11585 
 
11586 
  def __eq__(self, other):
11587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11588 
 
11589 
  def __ne__(self, other):
11590 
    return not (self == other)
11591 
 
690 chandransh 11592 
class resetCart_args:
559 chandransh 11593 
  """
11594 
  Attributes:
690 chandransh 11595 
   - cartId
11596 
   - items
559 chandransh 11597 
  """
11598 
 
11599 
  thrift_spec = (
11600 
    None, # 0
690 chandransh 11601 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 11602 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 11603 
  )
11604 
 
690 chandransh 11605 
  def __init__(self, cartId=None, items=None,):
11606 
    self.cartId = cartId
11607 
    self.items = items
559 chandransh 11608 
 
11609 
  def read(self, iprot):
11610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11612 
      return
11613 
    iprot.readStructBegin()
11614 
    while True:
11615 
      (fname, ftype, fid) = iprot.readFieldBegin()
11616 
      if ftype == TType.STOP:
11617 
        break
11618 
      if fid == 1:
11619 
        if ftype == TType.I64:
690 chandransh 11620 
          self.cartId = iprot.readI64();
559 chandransh 11621 
        else:
11622 
          iprot.skip(ftype)
11623 
      elif fid == 2:
690 chandransh 11624 
        if ftype == TType.MAP:
11625 
          self.items = {}
2981 rajveer 11626 
          (_ktype106, _vtype107, _size105 ) = iprot.readMapBegin()
11627 
          for _i109 in xrange(_size105):
11628 
            _key110 = iprot.readI64();
11629 
            _val111 = iprot.readDouble();
11630 
            self.items[_key110] = _val111
690 chandransh 11631 
          iprot.readMapEnd()
559 chandransh 11632 
        else:
11633 
          iprot.skip(ftype)
11634 
      else:
11635 
        iprot.skip(ftype)
11636 
      iprot.readFieldEnd()
11637 
    iprot.readStructEnd()
11638 
 
11639 
  def write(self, oprot):
11640 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11641 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11642 
      return
690 chandransh 11643 
    oprot.writeStructBegin('resetCart_args')
11644 
    if self.cartId != None:
11645 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11646 
      oprot.writeI64(self.cartId)
94 ashish 11647 
      oprot.writeFieldEnd()
690 chandransh 11648 
    if self.items != None:
11649 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 11650 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
2981 rajveer 11651 
      for kiter112,viter113 in self.items.items():
11652 
        oprot.writeI64(kiter112)
11653 
        oprot.writeDouble(viter113)
690 chandransh 11654 
      oprot.writeMapEnd()
559 chandransh 11655 
      oprot.writeFieldEnd()
94 ashish 11656 
    oprot.writeFieldStop()
11657 
    oprot.writeStructEnd()
11658 
 
11659 
  def __repr__(self):
11660 
    L = ['%s=%r' % (key, value)
11661 
      for key, value in self.__dict__.iteritems()]
11662 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11663 
 
11664 
  def __eq__(self, other):
11665 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11666 
 
11667 
  def __ne__(self, other):
11668 
    return not (self == other)
11669 
 
690 chandransh 11670 
class resetCart_result:
11671 
  """
11672 
  Attributes:
11673 
   - success
11674 
   - scex
11675 
  """
559 chandransh 11676 
 
11677 
  thrift_spec = (
690 chandransh 11678 
    (0, TType.BOOL, 'success', None, None, ), # 0
11679 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11680 
  )
11681 
 
690 chandransh 11682 
  def __init__(self, success=None, scex=None,):
11683 
    self.success = success
11684 
    self.scex = scex
11685 
 
559 chandransh 11686 
  def read(self, iprot):
11687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11689 
      return
11690 
    iprot.readStructBegin()
11691 
    while True:
11692 
      (fname, ftype, fid) = iprot.readFieldBegin()
11693 
      if ftype == TType.STOP:
11694 
        break
690 chandransh 11695 
      if fid == 0:
11696 
        if ftype == TType.BOOL:
11697 
          self.success = iprot.readBool();
11698 
        else:
11699 
          iprot.skip(ftype)
11700 
      elif fid == 1:
11701 
        if ftype == TType.STRUCT:
11702 
          self.scex = ShoppingCartException()
11703 
          self.scex.read(iprot)
11704 
        else:
11705 
          iprot.skip(ftype)
559 chandransh 11706 
      else:
11707 
        iprot.skip(ftype)
11708 
      iprot.readFieldEnd()
11709 
    iprot.readStructEnd()
11710 
 
11711 
  def write(self, oprot):
11712 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11713 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11714 
      return
690 chandransh 11715 
    oprot.writeStructBegin('resetCart_result')
11716 
    if self.success != None:
11717 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11718 
      oprot.writeBool(self.success)
11719 
      oprot.writeFieldEnd()
11720 
    if self.scex != None:
11721 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11722 
      self.scex.write(oprot)
11723 
      oprot.writeFieldEnd()
559 chandransh 11724 
    oprot.writeFieldStop()
11725 
    oprot.writeStructEnd()
11726 
 
11727 
  def __repr__(self):
11728 
    L = ['%s=%r' % (key, value)
11729 
      for key, value in self.__dict__.iteritems()]
11730 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11731 
 
11732 
  def __eq__(self, other):
11733 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11734 
 
11735 
  def __ne__(self, other):
11736 
    return not (self == other)
11737 
 
2981 rajveer 11738 
class getUserCount_args:
94 ashish 11739 
  """
11740 
  Attributes:
2981 rajveer 11741 
   - userType
559 chandransh 11742 
  """
11743 
 
11744 
  thrift_spec = (
11745 
    None, # 0
2981 rajveer 11746 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 11747 
  )
11748 
 
2981 rajveer 11749 
  def __init__(self, userType=None,):
11750 
    self.userType = userType
559 chandransh 11751 
 
11752 
  def read(self, iprot):
11753 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11754 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11755 
      return
11756 
    iprot.readStructBegin()
11757 
    while True:
11758 
      (fname, ftype, fid) = iprot.readFieldBegin()
11759 
      if ftype == TType.STOP:
11760 
        break
11761 
      if fid == 1:
2981 rajveer 11762 
        if ftype == TType.I32:
11763 
          self.userType = iprot.readI32();
559 chandransh 11764 
        else:
11765 
          iprot.skip(ftype)
11766 
      else:
11767 
        iprot.skip(ftype)
11768 
      iprot.readFieldEnd()
11769 
    iprot.readStructEnd()
11770 
 
11771 
  def write(self, oprot):
11772 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11773 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11774 
      return
2981 rajveer 11775 
    oprot.writeStructBegin('getUserCount_args')
11776 
    if self.userType != None:
11777 
      oprot.writeFieldBegin('userType', TType.I32, 1)
11778 
      oprot.writeI32(self.userType)
559 chandransh 11779 
      oprot.writeFieldEnd()
11780 
    oprot.writeFieldStop()
11781 
    oprot.writeStructEnd()
11782 
 
11783 
  def __repr__(self):
11784 
    L = ['%s=%r' % (key, value)
11785 
      for key, value in self.__dict__.iteritems()]
11786 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11787 
 
11788 
  def __eq__(self, other):
11789 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11790 
 
11791 
  def __ne__(self, other):
11792 
    return not (self == other)
11793 
 
2981 rajveer 11794 
class getUserCount_result:
94 ashish 11795 
  """
11796 
  Attributes:
11797 
   - success
11798 
  """
11799 
 
11800 
  thrift_spec = (
2981 rajveer 11801 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 11802 
  )
11803 
 
2981 rajveer 11804 
  def __init__(self, success=None,):
94 ashish 11805 
    self.success = success
11806 
 
11807 
  def read(self, iprot):
11808 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11809 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11810 
      return
11811 
    iprot.readStructBegin()
11812 
    while True:
11813 
      (fname, ftype, fid) = iprot.readFieldBegin()
11814 
      if ftype == TType.STOP:
11815 
        break
11816 
      if fid == 0:
2981 rajveer 11817 
        if ftype == TType.I64:
11818 
          self.success = iprot.readI64();
94 ashish 11819 
        else:
11820 
          iprot.skip(ftype)
11821 
      else:
11822 
        iprot.skip(ftype)
11823 
      iprot.readFieldEnd()
11824 
    iprot.readStructEnd()
11825 
 
11826 
  def write(self, oprot):
11827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11829 
      return
2981 rajveer 11830 
    oprot.writeStructBegin('getUserCount_result')
94 ashish 11831 
    if self.success != None:
2981 rajveer 11832 
      oprot.writeFieldBegin('success', TType.I64, 0)
11833 
      oprot.writeI64(self.success)
94 ashish 11834 
      oprot.writeFieldEnd()
11835 
    oprot.writeFieldStop()
11836 
    oprot.writeStructEnd()
11837 
 
11838 
  def __repr__(self):
11839 
    L = ['%s=%r' % (key, value)
11840 
      for key, value in self.__dict__.iteritems()]
11841 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11842 
 
11843 
  def __eq__(self, other):
11844 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11845 
 
11846 
  def __ne__(self, other):
11847 
    return not (self == other)
11848 
 
2981 rajveer 11849 
class getAllUsers_args:
94 ashish 11850 
  """
11851 
  Attributes:
2981 rajveer 11852 
   - userType
11853 
   - startDate
11854 
   - endDate
94 ashish 11855 
  """
11856 
 
11857 
  thrift_spec = (
11858 
    None, # 0
2981 rajveer 11859 
    (1, TType.I32, 'userType', None, None, ), # 1
11860 
    (2, TType.I64, 'startDate', None, None, ), # 2
11861 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 11862 
  )
11863 
 
2981 rajveer 11864 
  def __init__(self, userType=None, startDate=None, endDate=None,):
11865 
    self.userType = userType
11866 
    self.startDate = startDate
11867 
    self.endDate = endDate
94 ashish 11868 
 
11869 
  def read(self, iprot):
11870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11872 
      return
11873 
    iprot.readStructBegin()
11874 
    while True:
11875 
      (fname, ftype, fid) = iprot.readFieldBegin()
11876 
      if ftype == TType.STOP:
11877 
        break
11878 
      if fid == 1:
2981 rajveer 11879 
        if ftype == TType.I32:
11880 
          self.userType = iprot.readI32();
94 ashish 11881 
        else:
11882 
          iprot.skip(ftype)
11883 
      elif fid == 2:
559 chandransh 11884 
        if ftype == TType.I64:
2981 rajveer 11885 
          self.startDate = iprot.readI64();
94 ashish 11886 
        else:
11887 
          iprot.skip(ftype)
2981 rajveer 11888 
      elif fid == 3:
11889 
        if ftype == TType.I64:
11890 
          self.endDate = iprot.readI64();
11891 
        else:
11892 
          iprot.skip(ftype)
94 ashish 11893 
      else:
11894 
        iprot.skip(ftype)
11895 
      iprot.readFieldEnd()
11896 
    iprot.readStructEnd()
11897 
 
11898 
  def write(self, oprot):
11899 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11900 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11901 
      return
2981 rajveer 11902 
    oprot.writeStructBegin('getAllUsers_args')
11903 
    if self.userType != None:
11904 
      oprot.writeFieldBegin('userType', TType.I32, 1)
11905 
      oprot.writeI32(self.userType)
94 ashish 11906 
      oprot.writeFieldEnd()
2981 rajveer 11907 
    if self.startDate != None:
11908 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
11909 
      oprot.writeI64(self.startDate)
94 ashish 11910 
      oprot.writeFieldEnd()
2981 rajveer 11911 
    if self.endDate != None:
11912 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
11913 
      oprot.writeI64(self.endDate)
11914 
      oprot.writeFieldEnd()
94 ashish 11915 
    oprot.writeFieldStop()
11916 
    oprot.writeStructEnd()
11917 
 
11918 
  def __repr__(self):
11919 
    L = ['%s=%r' % (key, value)
11920 
      for key, value in self.__dict__.iteritems()]
11921 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11922 
 
11923 
  def __eq__(self, other):
11924 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11925 
 
11926 
  def __ne__(self, other):
11927 
    return not (self == other)
11928 
 
2981 rajveer 11929 
class getAllUsers_result:
94 ashish 11930 
  """
11931 
  Attributes:
11932 
   - success
11933 
  """
11934 
 
11935 
  thrift_spec = (
2981 rajveer 11936 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 11937 
  )
11938 
 
2981 rajveer 11939 
  def __init__(self, success=None,):
94 ashish 11940 
    self.success = success
11941 
 
11942 
  def read(self, iprot):
11943 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11944 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11945 
      return
11946 
    iprot.readStructBegin()
11947 
    while True:
11948 
      (fname, ftype, fid) = iprot.readFieldBegin()
11949 
      if ftype == TType.STOP:
11950 
        break
11951 
      if fid == 0:
2981 rajveer 11952 
        if ftype == TType.LIST:
11953 
          self.success = []
11954 
          (_etype117, _size114) = iprot.readListBegin()
11955 
          for _i118 in xrange(_size114):
11956 
            _elem119 = User()
11957 
            _elem119.read(iprot)
11958 
            self.success.append(_elem119)
11959 
          iprot.readListEnd()
94 ashish 11960 
        else:
11961 
          iprot.skip(ftype)
11962 
      else:
11963 
        iprot.skip(ftype)
11964 
      iprot.readFieldEnd()
11965 
    iprot.readStructEnd()
11966 
 
11967 
  def write(self, oprot):
11968 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11969 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11970 
      return
2981 rajveer 11971 
    oprot.writeStructBegin('getAllUsers_result')
94 ashish 11972 
    if self.success != None:
2981 rajveer 11973 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11974 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11975 
      for iter120 in self.success:
11976 
        iter120.write(oprot)
11977 
      oprot.writeListEnd()
94 ashish 11978 
      oprot.writeFieldEnd()
11979 
    oprot.writeFieldStop()
11980 
    oprot.writeStructEnd()
11981 
 
11982 
  def __repr__(self):
11983 
    L = ['%s=%r' % (key, value)
11984 
      for key, value in self.__dict__.iteritems()]
11985 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11986 
 
11987 
  def __eq__(self, other):
11988 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11989 
 
11990 
  def __ne__(self, other):
11991 
    return not (self == other)
11992 
 
2981 rajveer 11993 
class putUserNote_args:
130 ashish 11994 
  """
11995 
  Attributes:
2981 rajveer 11996 
   - user_id
11997 
   - entity_id
11998 
   - slide
11999 
   - note
130 ashish 12000 
  """
94 ashish 12001 
 
130 ashish 12002 
  thrift_spec = (
12003 
    None, # 0
2981 rajveer 12004 
    (1, TType.I64, 'user_id', None, None, ), # 1
12005 
    (2, TType.I64, 'entity_id', None, None, ), # 2
12006 
    (3, TType.STRING, 'slide', None, None, ), # 3
12007 
    (4, TType.STRING, 'note', None, None, ), # 4
130 ashish 12008 
  )
12009 
 
2981 rajveer 12010 
  def __init__(self, user_id=None, entity_id=None, slide=None, note=None,):
12011 
    self.user_id = user_id
12012 
    self.entity_id = entity_id
12013 
    self.slide = slide
12014 
    self.note = note
130 ashish 12015 
 
12016 
  def read(self, iprot):
12017 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12018 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12019 
      return
12020 
    iprot.readStructBegin()
12021 
    while True:
12022 
      (fname, ftype, fid) = iprot.readFieldBegin()
12023 
      if ftype == TType.STOP:
12024 
        break
12025 
      if fid == 1:
12026 
        if ftype == TType.I64:
2981 rajveer 12027 
          self.user_id = iprot.readI64();
130 ashish 12028 
        else:
12029 
          iprot.skip(ftype)
559 chandransh 12030 
      elif fid == 2:
12031 
        if ftype == TType.I64:
2981 rajveer 12032 
          self.entity_id = iprot.readI64();
559 chandransh 12033 
        else:
12034 
          iprot.skip(ftype)
2981 rajveer 12035 
      elif fid == 3:
12036 
        if ftype == TType.STRING:
12037 
          self.slide = iprot.readString();
12038 
        else:
12039 
          iprot.skip(ftype)
12040 
      elif fid == 4:
12041 
        if ftype == TType.STRING:
12042 
          self.note = iprot.readString();
12043 
        else:
12044 
          iprot.skip(ftype)
130 ashish 12045 
      else:
12046 
        iprot.skip(ftype)
12047 
      iprot.readFieldEnd()
12048 
    iprot.readStructEnd()
12049 
 
12050 
  def write(self, oprot):
12051 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12052 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12053 
      return
2981 rajveer 12054 
    oprot.writeStructBegin('putUserNote_args')
12055 
    if self.user_id != None:
12056 
      oprot.writeFieldBegin('user_id', TType.I64, 1)
12057 
      oprot.writeI64(self.user_id)
130 ashish 12058 
      oprot.writeFieldEnd()
2981 rajveer 12059 
    if self.entity_id != None:
12060 
      oprot.writeFieldBegin('entity_id', TType.I64, 2)
12061 
      oprot.writeI64(self.entity_id)
559 chandransh 12062 
      oprot.writeFieldEnd()
2981 rajveer 12063 
    if self.slide != None:
12064 
      oprot.writeFieldBegin('slide', TType.STRING, 3)
12065 
      oprot.writeString(self.slide)
12066 
      oprot.writeFieldEnd()
12067 
    if self.note != None:
12068 
      oprot.writeFieldBegin('note', TType.STRING, 4)
12069 
      oprot.writeString(self.note)
12070 
      oprot.writeFieldEnd()
130 ashish 12071 
    oprot.writeFieldStop()
12072 
    oprot.writeStructEnd()
12073 
 
12074 
  def __repr__(self):
12075 
    L = ['%s=%r' % (key, value)
12076 
      for key, value in self.__dict__.iteritems()]
12077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12078 
 
12079 
  def __eq__(self, other):
12080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12081 
 
12082 
  def __ne__(self, other):
12083 
    return not (self == other)
12084 
 
2981 rajveer 12085 
class putUserNote_result:
559 chandransh 12086 
 
12087 
  thrift_spec = (
12088 
  )
12089 
 
12090 
  def read(self, iprot):
12091 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12092 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12093 
      return
12094 
    iprot.readStructBegin()
12095 
    while True:
12096 
      (fname, ftype, fid) = iprot.readFieldBegin()
12097 
      if ftype == TType.STOP:
12098 
        break
12099 
      else:
12100 
        iprot.skip(ftype)
12101 
      iprot.readFieldEnd()
12102 
    iprot.readStructEnd()
12103 
 
12104 
  def write(self, oprot):
12105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12107 
      return
2981 rajveer 12108 
    oprot.writeStructBegin('putUserNote_result')
559 chandransh 12109 
    oprot.writeFieldStop()
12110 
    oprot.writeStructEnd()
12111 
 
12112 
  def __repr__(self):
12113 
    L = ['%s=%r' % (key, value)
12114 
      for key, value in self.__dict__.iteritems()]
12115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12116 
 
12117 
  def __eq__(self, other):
12118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12119 
 
12120 
  def __ne__(self, other):
12121 
    return not (self == other)
12122 
 
2981 rajveer 12123 
class getUserNotes_args:
559 chandransh 12124 
  """
12125 
  Attributes:
2981 rajveer 12126 
   - user_id
12127 
   - entity_id
559 chandransh 12128 
  """
12129 
 
12130 
  thrift_spec = (
12131 
    None, # 0
2981 rajveer 12132 
    (1, TType.I64, 'user_id', None, None, ), # 1
12133 
    (2, TType.I64, 'entity_id', None, None, ), # 2
559 chandransh 12134 
  )
12135 
 
2981 rajveer 12136 
  def __init__(self, user_id=None, entity_id=None,):
12137 
    self.user_id = user_id
12138 
    self.entity_id = entity_id
559 chandransh 12139 
 
12140 
  def read(self, iprot):
12141 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12142 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12143 
      return
12144 
    iprot.readStructBegin()
12145 
    while True:
12146 
      (fname, ftype, fid) = iprot.readFieldBegin()
12147 
      if ftype == TType.STOP:
12148 
        break
12149 
      if fid == 1:
12150 
        if ftype == TType.I64:
2981 rajveer 12151 
          self.user_id = iprot.readI64();
559 chandransh 12152 
        else:
12153 
          iprot.skip(ftype)
12154 
      elif fid == 2:
12155 
        if ftype == TType.I64:
2981 rajveer 12156 
          self.entity_id = iprot.readI64();
559 chandransh 12157 
        else:
12158 
          iprot.skip(ftype)
12159 
      else:
12160 
        iprot.skip(ftype)
12161 
      iprot.readFieldEnd()
12162 
    iprot.readStructEnd()
12163 
 
12164 
  def write(self, oprot):
12165 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12166 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12167 
      return
2981 rajveer 12168 
    oprot.writeStructBegin('getUserNotes_args')
12169 
    if self.user_id != None:
12170 
      oprot.writeFieldBegin('user_id', TType.I64, 1)
12171 
      oprot.writeI64(self.user_id)
559 chandransh 12172 
      oprot.writeFieldEnd()
2981 rajveer 12173 
    if self.entity_id != None:
12174 
      oprot.writeFieldBegin('entity_id', TType.I64, 2)
12175 
      oprot.writeI64(self.entity_id)
559 chandransh 12176 
      oprot.writeFieldEnd()
12177 
    oprot.writeFieldStop()
12178 
    oprot.writeStructEnd()
12179 
 
12180 
  def __repr__(self):
12181 
    L = ['%s=%r' % (key, value)
12182 
      for key, value in self.__dict__.iteritems()]
12183 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12184 
 
12185 
  def __eq__(self, other):
12186 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12187 
 
12188 
  def __ne__(self, other):
12189 
    return not (self == other)
12190 
 
2981 rajveer 12191 
class getUserNotes_result:
12192 
  """
12193 
  Attributes:
12194 
   - success
12195 
  """
559 chandransh 12196 
 
12197 
  thrift_spec = (
2981 rajveer 12198 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserNote, UserNote.thrift_spec)), None, ), # 0
559 chandransh 12199 
  )
12200 
 
2981 rajveer 12201 
  def __init__(self, success=None,):
12202 
    self.success = success
12203 
 
559 chandransh 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
2981 rajveer 12213 
      if fid == 0:
12214 
        if ftype == TType.LIST:
12215 
          self.success = []
12216 
          (_etype124, _size121) = iprot.readListBegin()
12217 
          for _i125 in xrange(_size121):
12218 
            _elem126 = UserNote()
12219 
            _elem126.read(iprot)
12220 
            self.success.append(_elem126)
12221 
          iprot.readListEnd()
12222 
        else:
12223 
          iprot.skip(ftype)
559 chandransh 12224 
      else:
12225 
        iprot.skip(ftype)
12226 
      iprot.readFieldEnd()
12227 
    iprot.readStructEnd()
12228 
 
12229 
  def write(self, oprot):
12230 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12231 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12232 
      return
2981 rajveer 12233 
    oprot.writeStructBegin('getUserNotes_result')
12234 
    if self.success != None:
12235 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12236 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
12237 
      for iter127 in self.success:
12238 
        iter127.write(oprot)
12239 
      oprot.writeListEnd()
12240 
      oprot.writeFieldEnd()
559 chandransh 12241 
    oprot.writeFieldStop()
12242 
    oprot.writeStructEnd()
12243 
 
12244 
  def __repr__(self):
12245 
    L = ['%s=%r' % (key, value)
12246 
      for key, value in self.__dict__.iteritems()]
12247 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12248 
 
12249 
  def __eq__(self, other):
12250 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12251 
 
12252 
  def __ne__(self, other):
12253 
    return not (self == other)
12254 
 
2981 rajveer 12255 
class getMyResearchItems_args:
559 chandransh 12256 
  """
12257 
  Attributes:
772 rajveer 12258 
   - userId
559 chandransh 12259 
  """
12260 
 
12261 
  thrift_spec = (
12262 
    None, # 0
772 rajveer 12263 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 12264 
  )
12265 
 
772 rajveer 12266 
  def __init__(self, userId=None,):
12267 
    self.userId = userId
559 chandransh 12268 
 
12269 
  def read(self, iprot):
12270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12272 
      return
12273 
    iprot.readStructBegin()
12274 
    while True:
12275 
      (fname, ftype, fid) = iprot.readFieldBegin()
12276 
      if ftype == TType.STOP:
12277 
        break
12278 
      if fid == 1:
12279 
        if ftype == TType.I64:
772 rajveer 12280 
          self.userId = iprot.readI64();
559 chandransh 12281 
        else:
12282 
          iprot.skip(ftype)
12283 
      else:
12284 
        iprot.skip(ftype)
12285 
      iprot.readFieldEnd()
12286 
    iprot.readStructEnd()
12287 
 
12288 
  def write(self, oprot):
12289 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12290 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12291 
      return
2981 rajveer 12292 
    oprot.writeStructBegin('getMyResearchItems_args')
772 rajveer 12293 
    if self.userId != None:
12294 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12295 
      oprot.writeI64(self.userId)
559 chandransh 12296 
      oprot.writeFieldEnd()
12297 
    oprot.writeFieldStop()
12298 
    oprot.writeStructEnd()
12299 
 
12300 
  def __repr__(self):
12301 
    L = ['%s=%r' % (key, value)
12302 
      for key, value in self.__dict__.iteritems()]
12303 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12304 
 
12305 
  def __eq__(self, other):
12306 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12307 
 
12308 
  def __ne__(self, other):
12309 
    return not (self == other)
12310 
 
2981 rajveer 12311 
class getMyResearchItems_result:
559 chandransh 12312 
  """
12313 
  Attributes:
130 ashish 12314 
   - success
559 chandransh 12315 
   - scx
130 ashish 12316 
  """
12317 
 
12318 
  thrift_spec = (
2981 rajveer 12319 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 12320 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 12321 
  )
12322 
 
559 chandransh 12323 
  def __init__(self, success=None, scx=None,):
130 ashish 12324 
    self.success = success
559 chandransh 12325 
    self.scx = scx
130 ashish 12326 
 
12327 
  def read(self, iprot):
12328 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12329 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12330 
      return
12331 
    iprot.readStructBegin()
12332 
    while True:
12333 
      (fname, ftype, fid) = iprot.readFieldBegin()
12334 
      if ftype == TType.STOP:
12335 
        break
12336 
      if fid == 0:
2981 rajveer 12337 
        if ftype == TType.LIST:
12338 
          self.success = []
12339 
          (_etype131, _size128) = iprot.readListBegin()
12340 
          for _i132 in xrange(_size128):
12341 
            _elem133 = iprot.readI64();
12342 
            self.success.append(_elem133)
12343 
          iprot.readListEnd()
130 ashish 12344 
        else:
12345 
          iprot.skip(ftype)
12346 
      elif fid == 1:
12347 
        if ftype == TType.STRUCT:
559 chandransh 12348 
          self.scx = WidgetException()
12349 
          self.scx.read(iprot)
130 ashish 12350 
        else:
12351 
          iprot.skip(ftype)
12352 
      else:
12353 
        iprot.skip(ftype)
12354 
      iprot.readFieldEnd()
12355 
    iprot.readStructEnd()
12356 
 
12357 
  def write(self, oprot):
12358 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12359 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12360 
      return
2981 rajveer 12361 
    oprot.writeStructBegin('getMyResearchItems_result')
130 ashish 12362 
    if self.success != None:
2981 rajveer 12363 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12364 
      oprot.writeListBegin(TType.I64, len(self.success))
12365 
      for iter134 in self.success:
12366 
        oprot.writeI64(iter134)
12367 
      oprot.writeListEnd()
130 ashish 12368 
      oprot.writeFieldEnd()
559 chandransh 12369 
    if self.scx != None:
12370 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12371 
      self.scx.write(oprot)
130 ashish 12372 
      oprot.writeFieldEnd()
12373 
    oprot.writeFieldStop()
12374 
    oprot.writeStructEnd()
12375 
 
12376 
  def __repr__(self):
12377 
    L = ['%s=%r' % (key, value)
12378 
      for key, value in self.__dict__.iteritems()]
12379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12380 
 
12381 
  def __eq__(self, other):
12382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12383 
 
12384 
  def __ne__(self, other):
12385 
    return not (self == other)
12386 
 
2981 rajveer 12387 
class updateMyResearch_args:
130 ashish 12388 
  """
12389 
  Attributes:
2981 rajveer 12390 
   - userId
12391 
   - itemId
130 ashish 12392 
  """
12393 
 
12394 
  thrift_spec = (
12395 
    None, # 0
2981 rajveer 12396 
    (1, TType.I64, 'userId', None, None, ), # 1
12397 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 12398 
  )
12399 
 
2981 rajveer 12400 
  def __init__(self, userId=None, itemId=None,):
12401 
    self.userId = userId
12402 
    self.itemId = itemId
130 ashish 12403 
 
12404 
  def read(self, iprot):
12405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12407 
      return
12408 
    iprot.readStructBegin()
12409 
    while True:
12410 
      (fname, ftype, fid) = iprot.readFieldBegin()
12411 
      if ftype == TType.STOP:
12412 
        break
12413 
      if fid == 1:
559 chandransh 12414 
        if ftype == TType.I64:
2981 rajveer 12415 
          self.userId = iprot.readI64();
130 ashish 12416 
        else:
12417 
          iprot.skip(ftype)
12418 
      elif fid == 2:
559 chandransh 12419 
        if ftype == TType.I64:
2981 rajveer 12420 
          self.itemId = iprot.readI64();
559 chandransh 12421 
        else:
12422 
          iprot.skip(ftype)
130 ashish 12423 
      else:
12424 
        iprot.skip(ftype)
12425 
      iprot.readFieldEnd()
12426 
    iprot.readStructEnd()
12427 
 
12428 
  def write(self, oprot):
12429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12431 
      return
2981 rajveer 12432 
    oprot.writeStructBegin('updateMyResearch_args')
12433 
    if self.userId != None:
12434 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12435 
      oprot.writeI64(self.userId)
130 ashish 12436 
      oprot.writeFieldEnd()
2981 rajveer 12437 
    if self.itemId != None:
12438 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12439 
      oprot.writeI64(self.itemId)
130 ashish 12440 
      oprot.writeFieldEnd()
12441 
    oprot.writeFieldStop()
12442 
    oprot.writeStructEnd()
12443 
 
12444 
  def __repr__(self):
12445 
    L = ['%s=%r' % (key, value)
12446 
      for key, value in self.__dict__.iteritems()]
12447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12448 
 
12449 
  def __eq__(self, other):
12450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12451 
 
12452 
  def __ne__(self, other):
12453 
    return not (self == other)
12454 
 
2981 rajveer 12455 
class updateMyResearch_result:
12456 
  """
12457 
  Attributes:
12458 
   - success
12459 
   - scx
12460 
  """
559 chandransh 12461 
 
12462 
  thrift_spec = (
2981 rajveer 12463 
    (0, TType.BOOL, 'success', None, None, ), # 0
12464 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 12465 
  )
12466 
 
2981 rajveer 12467 
  def __init__(self, success=None, scx=None,):
12468 
    self.success = success
12469 
    self.scx = scx
12470 
 
559 chandransh 12471 
  def read(self, iprot):
12472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12474 
      return
12475 
    iprot.readStructBegin()
12476 
    while True:
12477 
      (fname, ftype, fid) = iprot.readFieldBegin()
12478 
      if ftype == TType.STOP:
12479 
        break
2981 rajveer 12480 
      if fid == 0:
12481 
        if ftype == TType.BOOL:
12482 
          self.success = iprot.readBool();
12483 
        else:
12484 
          iprot.skip(ftype)
12485 
      elif fid == 1:
12486 
        if ftype == TType.STRUCT:
12487 
          self.scx = WidgetException()
12488 
          self.scx.read(iprot)
12489 
        else:
12490 
          iprot.skip(ftype)
559 chandransh 12491 
      else:
12492 
        iprot.skip(ftype)
12493 
      iprot.readFieldEnd()
12494 
    iprot.readStructEnd()
12495 
 
12496 
  def write(self, oprot):
12497 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12498 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12499 
      return
2981 rajveer 12500 
    oprot.writeStructBegin('updateMyResearch_result')
12501 
    if self.success != None:
12502 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12503 
      oprot.writeBool(self.success)
12504 
      oprot.writeFieldEnd()
12505 
    if self.scx != None:
12506 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12507 
      self.scx.write(oprot)
12508 
      oprot.writeFieldEnd()
559 chandransh 12509 
    oprot.writeFieldStop()
12510 
    oprot.writeStructEnd()
12511 
 
12512 
  def __repr__(self):
12513 
    L = ['%s=%r' % (key, value)
12514 
      for key, value in self.__dict__.iteritems()]
12515 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12516 
 
12517 
  def __eq__(self, other):
12518 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12519 
 
12520 
  def __ne__(self, other):
12521 
    return not (self == other)
12522 
 
2981 rajveer 12523 
class deleteItemFromMyResearch_args:
1596 ankur.sing 12524 
  """
12525 
  Attributes:
2981 rajveer 12526 
   - userId
12527 
   - itemId
1596 ankur.sing 12528 
  """
559 chandransh 12529 
 
1596 ankur.sing 12530 
  thrift_spec = (
12531 
    None, # 0
2981 rajveer 12532 
    (1, TType.I64, 'userId', None, None, ), # 1
12533 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 12534 
  )
12535 
 
2981 rajveer 12536 
  def __init__(self, userId=None, itemId=None,):
12537 
    self.userId = userId
12538 
    self.itemId = itemId
1596 ankur.sing 12539 
 
12540 
  def read(self, iprot):
12541 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12542 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12543 
      return
12544 
    iprot.readStructBegin()
12545 
    while True:
12546 
      (fname, ftype, fid) = iprot.readFieldBegin()
12547 
      if ftype == TType.STOP:
12548 
        break
12549 
      if fid == 1:
2981 rajveer 12550 
        if ftype == TType.I64:
12551 
          self.userId = iprot.readI64();
1596 ankur.sing 12552 
        else:
12553 
          iprot.skip(ftype)
2981 rajveer 12554 
      elif fid == 2:
12555 
        if ftype == TType.I64:
12556 
          self.itemId = iprot.readI64();
12557 
        else:
12558 
          iprot.skip(ftype)
1596 ankur.sing 12559 
      else:
12560 
        iprot.skip(ftype)
12561 
      iprot.readFieldEnd()
12562 
    iprot.readStructEnd()
12563 
 
12564 
  def write(self, oprot):
12565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12567 
      return
2981 rajveer 12568 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
12569 
    if self.userId != None:
12570 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12571 
      oprot.writeI64(self.userId)
1596 ankur.sing 12572 
      oprot.writeFieldEnd()
2981 rajveer 12573 
    if self.itemId != None:
12574 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12575 
      oprot.writeI64(self.itemId)
12576 
      oprot.writeFieldEnd()
1596 ankur.sing 12577 
    oprot.writeFieldStop()
12578 
    oprot.writeStructEnd()
12579 
 
12580 
  def __repr__(self):
12581 
    L = ['%s=%r' % (key, value)
12582 
      for key, value in self.__dict__.iteritems()]
12583 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12584 
 
12585 
  def __eq__(self, other):
12586 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12587 
 
12588 
  def __ne__(self, other):
12589 
    return not (self == other)
12590 
 
2981 rajveer 12591 
class deleteItemFromMyResearch_result:
1596 ankur.sing 12592 
  """
12593 
  Attributes:
2981 rajveer 12594 
   - scx
1596 ankur.sing 12595 
  """
12596 
 
12597 
  thrift_spec = (
2981 rajveer 12598 
    None, # 0
12599 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 12600 
  )
12601 
 
2981 rajveer 12602 
  def __init__(self, scx=None,):
12603 
    self.scx = scx
1596 ankur.sing 12604 
 
12605 
  def read(self, iprot):
12606 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12607 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12608 
      return
12609 
    iprot.readStructBegin()
12610 
    while True:
12611 
      (fname, ftype, fid) = iprot.readFieldBegin()
12612 
      if ftype == TType.STOP:
12613 
        break
2981 rajveer 12614 
      if fid == 1:
12615 
        if ftype == TType.STRUCT:
12616 
          self.scx = WidgetException()
12617 
          self.scx.read(iprot)
1596 ankur.sing 12618 
        else:
12619 
          iprot.skip(ftype)
12620 
      else:
12621 
        iprot.skip(ftype)
12622 
      iprot.readFieldEnd()
12623 
    iprot.readStructEnd()
12624 
 
12625 
  def write(self, oprot):
12626 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12627 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12628 
      return
2981 rajveer 12629 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
12630 
    if self.scx != None:
12631 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12632 
      self.scx.write(oprot)
1596 ankur.sing 12633 
      oprot.writeFieldEnd()
12634 
    oprot.writeFieldStop()
12635 
    oprot.writeStructEnd()
12636 
 
12637 
  def __repr__(self):
12638 
    L = ['%s=%r' % (key, value)
12639 
      for key, value in self.__dict__.iteritems()]
12640 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12641 
 
12642 
  def __eq__(self, other):
12643 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12644 
 
12645 
  def __ne__(self, other):
12646 
    return not (self == other)
12647 
 
2981 rajveer 12648 
class getBrowseHistoryItems_args:
1673 ankur.sing 12649 
  """
12650 
  Attributes:
2981 rajveer 12651 
   - userId
1673 ankur.sing 12652 
  """
1596 ankur.sing 12653 
 
1673 ankur.sing 12654 
  thrift_spec = (
12655 
    None, # 0
2981 rajveer 12656 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 12657 
  )
12658 
 
2981 rajveer 12659 
  def __init__(self, userId=None,):
12660 
    self.userId = userId
1673 ankur.sing 12661 
 
12662 
  def read(self, iprot):
12663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12665 
      return
12666 
    iprot.readStructBegin()
12667 
    while True:
12668 
      (fname, ftype, fid) = iprot.readFieldBegin()
12669 
      if ftype == TType.STOP:
12670 
        break
12671 
      if fid == 1:
1891 ankur.sing 12672 
        if ftype == TType.I64:
2981 rajveer 12673 
          self.userId = iprot.readI64();
1891 ankur.sing 12674 
        else:
12675 
          iprot.skip(ftype)
1673 ankur.sing 12676 
      else:
12677 
        iprot.skip(ftype)
12678 
      iprot.readFieldEnd()
12679 
    iprot.readStructEnd()
12680 
 
12681 
  def write(self, oprot):
12682 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12683 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12684 
      return
2981 rajveer 12685 
    oprot.writeStructBegin('getBrowseHistoryItems_args')
12686 
    if self.userId != None:
12687 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12688 
      oprot.writeI64(self.userId)
1673 ankur.sing 12689 
      oprot.writeFieldEnd()
12690 
    oprot.writeFieldStop()
12691 
    oprot.writeStructEnd()
12692 
 
12693 
  def __repr__(self):
12694 
    L = ['%s=%r' % (key, value)
12695 
      for key, value in self.__dict__.iteritems()]
12696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12697 
 
12698 
  def __eq__(self, other):
12699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12700 
 
12701 
  def __ne__(self, other):
12702 
    return not (self == other)
12703 
 
2981 rajveer 12704 
class getBrowseHistoryItems_result:
1673 ankur.sing 12705 
  """
12706 
  Attributes:
12707 
   - success
2981 rajveer 12708 
   - scx
1673 ankur.sing 12709 
  """
12710 
 
12711 
  thrift_spec = (
2981 rajveer 12712 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12713 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 12714 
  )
12715 
 
2981 rajveer 12716 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 12717 
    self.success = success
2981 rajveer 12718 
    self.scx = scx
1673 ankur.sing 12719 
 
12720 
  def read(self, iprot):
12721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12723 
      return
12724 
    iprot.readStructBegin()
12725 
    while True:
12726 
      (fname, ftype, fid) = iprot.readFieldBegin()
12727 
      if ftype == TType.STOP:
12728 
        break
12729 
      if fid == 0:
12730 
        if ftype == TType.LIST:
12731 
          self.success = []
2981 rajveer 12732 
          (_etype138, _size135) = iprot.readListBegin()
12733 
          for _i139 in xrange(_size135):
12734 
            _elem140 = iprot.readI64();
12735 
            self.success.append(_elem140)
1673 ankur.sing 12736 
          iprot.readListEnd()
12737 
        else:
12738 
          iprot.skip(ftype)
2981 rajveer 12739 
      elif fid == 1:
12740 
        if ftype == TType.STRUCT:
12741 
          self.scx = WidgetException()
12742 
          self.scx.read(iprot)
12743 
        else:
12744 
          iprot.skip(ftype)
1673 ankur.sing 12745 
      else:
12746 
        iprot.skip(ftype)
12747 
      iprot.readFieldEnd()
12748 
    iprot.readStructEnd()
12749 
 
12750 
  def write(self, oprot):
12751 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12752 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12753 
      return
2981 rajveer 12754 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
1673 ankur.sing 12755 
    if self.success != None:
12756 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 12757 
      oprot.writeListBegin(TType.I64, len(self.success))
12758 
      for iter141 in self.success:
12759 
        oprot.writeI64(iter141)
1673 ankur.sing 12760 
      oprot.writeListEnd()
12761 
      oprot.writeFieldEnd()
2981 rajveer 12762 
    if self.scx != None:
12763 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12764 
      self.scx.write(oprot)
2642 varun.gupt 12765 
      oprot.writeFieldEnd()
12766 
    oprot.writeFieldStop()
12767 
    oprot.writeStructEnd()
12768 
 
12769 
  def __repr__(self):
12770 
    L = ['%s=%r' % (key, value)
12771 
      for key, value in self.__dict__.iteritems()]
12772 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12773 
 
12774 
  def __eq__(self, other):
12775 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12776 
 
12777 
  def __ne__(self, other):
12778 
    return not (self == other)
12779 
 
2981 rajveer 12780 
class updateBrowseHistory_args:
2642 varun.gupt 12781 
  """
12782 
  Attributes:
2981 rajveer 12783 
   - userId
12784 
   - itemId
2642 varun.gupt 12785 
  """
12786 
 
12787 
  thrift_spec = (
12788 
    None, # 0
2981 rajveer 12789 
    (1, TType.I64, 'userId', None, None, ), # 1
12790 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 12791 
  )
12792 
 
2981 rajveer 12793 
  def __init__(self, userId=None, itemId=None,):
12794 
    self.userId = userId
12795 
    self.itemId = itemId
2642 varun.gupt 12796 
 
12797 
  def read(self, iprot):
12798 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12799 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12800 
      return
12801 
    iprot.readStructBegin()
12802 
    while True:
12803 
      (fname, ftype, fid) = iprot.readFieldBegin()
12804 
      if ftype == TType.STOP:
12805 
        break
12806 
      if fid == 1:
12807 
        if ftype == TType.I64:
2981 rajveer 12808 
          self.userId = iprot.readI64();
2642 varun.gupt 12809 
        else:
12810 
          iprot.skip(ftype)
12811 
      elif fid == 2:
12812 
        if ftype == TType.I64:
2981 rajveer 12813 
          self.itemId = iprot.readI64();
2642 varun.gupt 12814 
        else:
12815 
          iprot.skip(ftype)
12816 
      else:
12817 
        iprot.skip(ftype)
12818 
      iprot.readFieldEnd()
12819 
    iprot.readStructEnd()
12820 
 
12821 
  def write(self, oprot):
12822 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12823 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12824 
      return
2981 rajveer 12825 
    oprot.writeStructBegin('updateBrowseHistory_args')
12826 
    if self.userId != None:
12827 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12828 
      oprot.writeI64(self.userId)
2642 varun.gupt 12829 
      oprot.writeFieldEnd()
2981 rajveer 12830 
    if self.itemId != None:
12831 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12832 
      oprot.writeI64(self.itemId)
2642 varun.gupt 12833 
      oprot.writeFieldEnd()
12834 
    oprot.writeFieldStop()
12835 
    oprot.writeStructEnd()
12836 
 
12837 
  def __repr__(self):
12838 
    L = ['%s=%r' % (key, value)
12839 
      for key, value in self.__dict__.iteritems()]
12840 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12841 
 
12842 
  def __eq__(self, other):
12843 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12844 
 
12845 
  def __ne__(self, other):
12846 
    return not (self == other)
12847 
 
2981 rajveer 12848 
class updateBrowseHistory_result:
2642 varun.gupt 12849 
 
12850 
  thrift_spec = (
12851 
  )
12852 
 
12853 
  def read(self, iprot):
12854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12856 
      return
12857 
    iprot.readStructBegin()
12858 
    while True:
12859 
      (fname, ftype, fid) = iprot.readFieldBegin()
12860 
      if ftype == TType.STOP:
12861 
        break
12862 
      else:
12863 
        iprot.skip(ftype)
12864 
      iprot.readFieldEnd()
12865 
    iprot.readStructEnd()
12866 
 
12867 
  def write(self, oprot):
12868 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12869 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12870 
      return
2981 rajveer 12871 
    oprot.writeStructBegin('updateBrowseHistory_result')
2642 varun.gupt 12872 
    oprot.writeFieldStop()
12873 
    oprot.writeStructEnd()
12874 
 
12875 
  def __repr__(self):
12876 
    L = ['%s=%r' % (key, value)
12877 
      for key, value in self.__dict__.iteritems()]
12878 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12879 
 
12880 
  def __eq__(self, other):
12881 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12882 
 
12883 
  def __ne__(self, other):
12884 
    return not (self == other)
12885 
 
12886