Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
2 
# Autogenerated by Thrift
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
from ttypes import *
9 
from thrift.Thrift import TProcessor
10 
from thrift.transport import TTransport
11 
from thrift.protocol import TBinaryProtocol
12 
try:
13 
  from thrift.protocol import fastbinary
14 
except:
15 
  fastbinary = None
16 
 
17 
 
18 
class Iface:
19 
  """
20 
  service
21 
  """
765 rajveer 22 
  def closeSession(self, ):
23 
    """
24 
    For closing the open session in sqlalchemy
25 
    """
26 
    pass
27 
 
559 chandransh 28 
  def createAnonymousUser(self, jsessionId):
94 ashish 29 
    """
30 
    Parameters:
559 chandransh 31 
     - jsessionId
94 ashish 32 
    """
33 
    pass
34 
 
559 chandransh 35 
  def getUserById(self, userId):
94 ashish 36 
    """
37 
    Parameters:
38 
     - userId
39 
    """
40 
    pass
41 
 
1491 vikas 42 
  def getUserByEmail(self, email):
43 
    """
44 
    Parameters:
45 
     - email
46 
    """
47 
    pass
48 
 
559 chandransh 49 
  def createUser(self, user):
94 ashish 50 
    """
51 
    Parameters:
559 chandransh 52 
     - user
94 ashish 53 
    """
54 
    pass
55 
 
559 chandransh 56 
  def updateUser(self, user):
94 ashish 57 
    """
58 
    Parameters:
559 chandransh 59 
     - user
94 ashish 60 
    """
61 
    pass
62 
 
559 chandransh 63 
  def deleteUser(self, userId):
94 ashish 64 
    """
65 
    Parameters:
66 
     - userId
67 
    """
68 
    pass
69 
 
559 chandransh 70 
  def getUserState(self, userId):
94 ashish 71 
    """
72 
    Parameters:
73 
     - userId
74 
    """
75 
    pass
76 
 
559 chandransh 77 
  def authenticateUser(self, email, password):
94 ashish 78 
    """
79 
    Parameters:
80 
     - email
81 
     - password
82 
    """
83 
    pass
84 
 
85 
  def userExists(self, email):
86 
    """
87 
    Parameters:
88 
     - email
89 
    """
90 
    pass
91 
 
567 rajveer 92 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 93 
    """
94 
    Parameters:
95 
     - userId
96 
     - address
513 rajveer 97 
     - setDefault
94 ashish 98 
    """
99 
    pass
100 
 
101 
  def removeAddressForUser(self, userid, addressId):
102 
    """
103 
    Parameters:
104 
     - userid
105 
     - addressId
106 
    """
107 
    pass
108 
 
109 
  def setUserAsLoggedIn(self, userId, timestamp):
110 
    """
111 
    Parameters:
112 
     - userId
113 
     - timestamp
114 
    """
115 
    pass
116 
 
117 
  def setUserAsLoggedOut(self, userid, timestamp):
118 
    """
119 
    Parameters:
120 
     - userid
121 
     - timestamp
122 
    """
123 
    pass
124 
 
504 rajveer 125 
  def setDefaultAddress(self, userid, addressId):
126 
    """
127 
    Parameters:
128 
     - userid
129 
     - addressId
130 
    """
131 
    pass
132 
 
594 rajveer 133 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 134 
    """
135 
    Parameters:
136 
     - userid
594 rajveer 137 
     - oldPassword
138 
     - newPassword
94 ashish 139 
    """
140 
    pass
141 
 
884 rajveer 142 
  def forgotPassword(self, email, newPassword):
581 rajveer 143 
    """
144 
    Parameters:
145 
     - email
884 rajveer 146 
     - newPassword
581 rajveer 147 
    """
148 
    pass
149 
 
594 rajveer 150 
  def getAllAddressesForUser(self, userId):
151 
    """
152 
    Parameters:
153 
     - userId
154 
    """
155 
    pass
156 
 
1894 vikas 157 
  def getAddressById(self, addressId):
158 
    """
159 
    Parameters:
160 
     - addressId
161 
    """
162 
    pass
163 
 
594 rajveer 164 
  def getDefaultAddressId(self, userId):
165 
    """
166 
    Parameters:
167 
     - userId
168 
    """
169 
    pass
170 
 
785 rajveer 171 
  def getDefaultPincode(self, userId):
172 
    """
173 
    Parameters:
174 
     - userId
175 
    """
176 
    pass
177 
 
1274 varun.gupt 178 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
179 
    """
180 
    Parameters:
181 
     - userId
182 
     - replyTo
183 
     - communicationType
184 
     - orderId
185 
     - airwaybillNo
186 
     - productName
187 
     - subject
188 
     - message
189 
    """
190 
    pass
191 
 
1590 varun.gupt 192 
  def getUserCommunicationById(self, id):
193 
    """
194 
    Parameters:
195 
     - id
196 
    """
197 
    pass
198 
 
199 
  def getUserCommunicationByUser(self, userId):
200 
    """
201 
    Parameters:
202 
     - userId
203 
    """
204 
    pass
205 
 
206 
  def getAllUserCommunications(self, ):
207 
    pass
208 
 
1859 vikas 209 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 210 
    """
211 
    Parameters:
212 
     - name
1859 vikas 213 
     - addedOn
1845 vikas 214 
    """
215 
    pass
216 
 
1899 vikas 217 
  def getAllMasterAffiliates(self, ):
218 
    pass
219 
 
1845 vikas 220 
  def getMasterAffiliateById(self, id):
221 
    """
222 
    Parameters:
223 
     - id
224 
    """
225 
    pass
226 
 
227 
  def getMasterAffiliateByName(self, name):
228 
    """
229 
    Parameters:
230 
     - name
231 
    """
232 
    pass
233 
 
1859 vikas 234 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 235 
    """
236 
    Parameters:
237 
     - name
238 
     - url
239 
     - masterAffiliateId
1859 vikas 240 
     - addedOn
1845 vikas 241 
    """
242 
    pass
243 
 
244 
  def getAffiliateById(self, id):
245 
    """
246 
    Parameters:
247 
     - id
248 
    """
249 
    pass
250 
 
251 
  def getAffiliateByName(self, name):
252 
    """
253 
    Parameters:
254 
     - name
255 
    """
256 
    pass
257 
 
1996 vikas 258 
  def getTrackerById(self, id):
1845 vikas 259 
    """
260 
    Parameters:
261 
     - id
262 
    """
263 
    pass
264 
 
1996 vikas 265 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 266 
    """
267 
    Parameters:
1996 vikas 268 
     - id
1845 vikas 269 
    """
270 
    pass
271 
 
1996 vikas 272 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 273 
    """
274 
    Parameters:
275 
     - affiliateId
276 
     - userId
277 
     - event
278 
     - url
279 
     - data
1859 vikas 280 
     - addedOn
1845 vikas 281 
    """
282 
    pass
283 
 
284 
  def getTrackLogById(self, id):
285 
    """
286 
    Parameters:
287 
     - id
288 
    """
289 
    pass
290 
 
1996 vikas 291 
  def getTrackLogsByAffiliate(self, affiliateId):
1845 vikas 292 
    """
293 
    Parameters:
1996 vikas 294 
     - affiliateId
1845 vikas 295 
    """
296 
    pass
297 
 
298 
  def getTrackLogsByUser(self, userId):
299 
    """
300 
    Parameters:
301 
     - userId
302 
    """
303 
    pass
304 
 
1996 vikas 305 
  def getTrackLogs(self, userId, event, url):
1845 vikas 306 
    """
307 
    Parameters:
308 
     - userId
309 
     - event
310 
     - url
311 
    """
312 
    pass
313 
 
559 chandransh 314 
  def createCart(self, userId):
94 ashish 315 
    """
316 
    Parameters:
559 chandransh 317 
     - userId
94 ashish 318 
    """
319 
    pass
320 
 
559 chandransh 321 
  def getCurrentCart(self, userId):
94 ashish 322 
    """
323 
    Parameters:
559 chandransh 324 
     - userId
94 ashish 325 
    """
326 
    pass
327 
 
559 chandransh 328 
  def getCart(self, cartId):
94 ashish 329 
    """
330 
    Parameters:
559 chandransh 331 
     - cartId
94 ashish 332 
    """
333 
    pass
334 
 
559 chandransh 335 
  def getCartsForUser(self, userId, status):
94 ashish 336 
    """
337 
    Parameters:
559 chandransh 338 
     - userId
339 
     - status
94 ashish 340 
    """
341 
    pass
342 
 
559 chandransh 343 
  def getCartsByStatus(self, status):
94 ashish 344 
    """
345 
    Parameters:
559 chandransh 346 
     - status
94 ashish 347 
    """
348 
    pass
349 
 
559 chandransh 350 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 351 
    """
352 
    Parameters:
559 chandransh 353 
     - from_time
354 
     - to_time
355 
     - status
94 ashish 356 
    """
357 
    pass
358 
 
559 chandransh 359 
  def changeCartStatus(self, cartId, status):
130 ashish 360 
    """
361 
    Parameters:
559 chandransh 362 
     - cartId
363 
     - status
130 ashish 364 
    """
365 
    pass
94 ashish 366 
 
559 chandransh 367 
  def addItemToCart(self, cartId, itemId, quantity):
130 ashish 368 
    """
369 
    Parameters:
559 chandransh 370 
     - cartId
371 
     - itemId
372 
     - quantity
130 ashish 373 
    """
374 
    pass
375 
 
559 chandransh 376 
  def deleteItemFromCart(self, cartId, itemId):
377 
    """
378 
    Parameters:
379 
     - cartId
380 
     - itemId
381 
    """
382 
    pass
130 ashish 383 
 
559 chandransh 384 
  def changeQuantity(self, cartId, itemId, quantity):
385 
    """
386 
    Parameters:
387 
     - cartId
388 
     - itemId
389 
     - quantity
390 
    """
391 
    pass
392 
 
393 
  def changeItemStatus(self, cartId, itemId, status):
394 
    """
395 
    Parameters:
396 
     - cartId
397 
     - itemId
398 
     - status
399 
    """
400 
    pass
401 
 
402 
  def addAddressToCart(self, cartId, addressId):
403 
    """
404 
    Parameters:
405 
     - cartId
406 
     - addressId
407 
    """
408 
    pass
409 
 
1976 varun.gupt 410 
  def applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
411 
    """
412 
    Parameters:
413 
     - cartId
414 
     - couponCode
415 
     - totalPrice
416 
     - discountedPrice
417 
    """
418 
    pass
419 
 
420 
  def removeCoupon(self, cartId):
421 
    """
422 
    Parameters:
423 
     - cartId
424 
    """
425 
    pass
426 
 
2815 vikas 427 
  def createOrders(self, cartId, sessionSource, sessionStartTime):
559 chandransh 428 
    """
690 chandransh 429 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
430 
 
559 chandransh 431 
    Parameters:
432 
     - cartId
2815 vikas 433 
     - sessionSource
434 
     - sessionStartTime
559 chandransh 435 
    """
436 
    pass
437 
 
438 
  def validateCart(self, cartId):
439 
    """
690 chandransh 440 
    Validates that:
441 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 442 
    2. All of the lines in the cart are active items.
690 chandransh 443 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 444 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 445 
 
559 chandransh 446 
    Parameters:
447 
     - cartId
448 
    """
449 
    pass
450 
 
690 chandransh 451 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 452 
    """
690 chandransh 453 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
454 
 
575 chandransh 455 
    Parameters:
690 chandransh 456 
     - fromCartId
457 
     - toCartId
458 
    """
459 
    pass
460 
 
461 
  def checkOut(self, cartId):
462 
    """
463 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
464 
 
465 
    Parameters:
575 chandransh 466 
     - cartId
467 
    """
468 
    pass
469 
 
690 chandransh 470 
  def resetCart(self, cartId, items):
559 chandransh 471 
    """
690 chandransh 472 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
473 
    This methods removes the specified quantiry of the specified item from the cart.
474 
 
559 chandransh 475 
    Parameters:
690 chandransh 476 
     - cartId
477 
     - items
559 chandransh 478 
    """
479 
    pass
480 
 
2981 rajveer 481 
  def getUserCount(self, userType):
559 chandransh 482 
    """
2981 rajveer 483 
    Returns number of registered users.
484 
    If userType = null, then it returns count of all users, including anonymous
485 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
486 
    If userType = UserType.USER, then it returns count of non-anonymous users only
772 rajveer 487 
 
559 chandransh 488 
    Parameters:
2981 rajveer 489 
     - userType
559 chandransh 490 
    """
491 
    pass
492 
 
2981 rajveer 493 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 494 
    """
2981 rajveer 495 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
496 
    If any of startDate or endDate is -1, then that filter is ignored.
497 
    If userType is null, then returns all the users, irrespective of anonymous flag
498 
 
499 
 
559 chandransh 500 
    Parameters:
2981 rajveer 501 
     - userType
502 
     - startDate
503 
     - endDate
559 chandransh 504 
    """
505 
    pass
506 
 
2981 rajveer 507 
  def putUserNote(self, user_id, entity_id, slide, note):
559 chandransh 508 
    """
509 
    Parameters:
2981 rajveer 510 
     - user_id
511 
     - entity_id
512 
     - slide
513 
     - note
559 chandransh 514 
    """
515 
    pass
516 
 
2981 rajveer 517 
  def getUserNotes(self, user_id, entity_id):
559 chandransh 518 
    """
519 
    Parameters:
2981 rajveer 520 
     - user_id
521 
     - entity_id
559 chandransh 522 
    """
523 
    pass
524 
 
2981 rajveer 525 
  def getMyResearchItems(self, userId):
559 chandransh 526 
    """
2981 rajveer 527 
    Returns list of item ids in myresearch for the user
528 
 
559 chandransh 529 
    Parameters:
530 
     - userId
531 
    """
532 
    pass
533 
 
2981 rajveer 534 
  def updateMyResearch(self, userId, itemId):
559 chandransh 535 
    """
2981 rajveer 536 
    add item to my research for a user
537 
 
559 chandransh 538 
    Parameters:
2981 rajveer 539 
     - userId
540 
     - itemId
559 chandransh 541 
    """
542 
    pass
543 
 
2981 rajveer 544 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 545 
    """
2981 rajveer 546 
    delete item from my research for a user
1596 ankur.sing 547 
 
548 
    Parameters:
2981 rajveer 549 
     - userId
550 
     - itemId
1596 ankur.sing 551 
    """
552 
    pass
559 chandransh 553 
 
2981 rajveer 554 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 555 
    """
2981 rajveer 556 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
1673 ankur.sing 557 
 
558 
    Parameters:
2981 rajveer 559 
     - userId
1673 ankur.sing 560 
    """
561 
    pass
1596 ankur.sing 562 
 
2981 rajveer 563 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 564 
    """
2981 rajveer 565 
    add item to browse history for a user
2642 varun.gupt 566 
 
567 
    Parameters:
2981 rajveer 568 
     - userId
569 
     - itemId
2642 varun.gupt 570 
    """
571 
    pass
1673 ankur.sing 572 
 
2642 varun.gupt 573 
 
94 ashish 574 
class Client(Iface):
575 
  """
576 
  service
577 
  """
578 
  def __init__(self, iprot, oprot=None):
579 
    self._iprot = self._oprot = iprot
580 
    if oprot != None:
581 
      self._oprot = oprot
582 
    self._seqid = 0
583 
 
765 rajveer 584 
  def closeSession(self, ):
585 
    """
586 
    For closing the open session in sqlalchemy
587 
    """
588 
    self.send_closeSession()
589 
    self.recv_closeSession()
590 
 
591 
  def send_closeSession(self, ):
592 
    self._oprot.writeMessageBegin('closeSession', TMessageType.CALL, self._seqid)
593 
    args = closeSession_args()
594 
    args.write(self._oprot)
595 
    self._oprot.writeMessageEnd()
596 
    self._oprot.trans.flush()
597 
 
598 
  def recv_closeSession(self, ):
599 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
600 
    if mtype == TMessageType.EXCEPTION:
601 
      x = TApplicationException()
602 
      x.read(self._iprot)
603 
      self._iprot.readMessageEnd()
604 
      raise x
605 
    result = closeSession_result()
606 
    result.read(self._iprot)
607 
    self._iprot.readMessageEnd()
608 
    return
609 
 
559 chandransh 610 
  def createAnonymousUser(self, jsessionId):
94 ashish 611 
    """
612 
    Parameters:
559 chandransh 613 
     - jsessionId
94 ashish 614 
    """
559 chandransh 615 
    self.send_createAnonymousUser(jsessionId)
616 
    return self.recv_createAnonymousUser()
94 ashish 617 
 
559 chandransh 618 
  def send_createAnonymousUser(self, jsessionId):
619 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
620 
    args = createAnonymousUser_args()
621 
    args.jsessionId = jsessionId
94 ashish 622 
    args.write(self._oprot)
623 
    self._oprot.writeMessageEnd()
624 
    self._oprot.trans.flush()
625 
 
559 chandransh 626 
  def recv_createAnonymousUser(self, ):
94 ashish 627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
628 
    if mtype == TMessageType.EXCEPTION:
629 
      x = TApplicationException()
630 
      x.read(self._iprot)
631 
      self._iprot.readMessageEnd()
632 
      raise x
559 chandransh 633 
    result = createAnonymousUser_result()
94 ashish 634 
    result.read(self._iprot)
635 
    self._iprot.readMessageEnd()
636 
    if result.success != None:
637 
      return result.success
559 chandransh 638 
    if result.ucex != None:
639 
      raise result.ucex
640 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 641 
 
559 chandransh 642 
  def getUserById(self, userId):
94 ashish 643 
    """
644 
    Parameters:
645 
     - userId
646 
    """
559 chandransh 647 
    self.send_getUserById(userId)
648 
    return self.recv_getUserById()
94 ashish 649 
 
559 chandransh 650 
  def send_getUserById(self, userId):
651 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
652 
    args = getUserById_args()
94 ashish 653 
    args.userId = userId
654 
    args.write(self._oprot)
655 
    self._oprot.writeMessageEnd()
656 
    self._oprot.trans.flush()
657 
 
559 chandransh 658 
  def recv_getUserById(self, ):
94 ashish 659 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
660 
    if mtype == TMessageType.EXCEPTION:
661 
      x = TApplicationException()
662 
      x.read(self._iprot)
663 
      self._iprot.readMessageEnd()
664 
      raise x
559 chandransh 665 
    result = getUserById_result()
94 ashish 666 
    result.read(self._iprot)
667 
    self._iprot.readMessageEnd()
668 
    if result.success != None:
669 
      return result.success
559 chandransh 670 
    if result.ucex != None:
671 
      raise result.ucex
672 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 673 
 
1491 vikas 674 
  def getUserByEmail(self, email):
675 
    """
676 
    Parameters:
677 
     - email
678 
    """
679 
    self.send_getUserByEmail(email)
680 
    return self.recv_getUserByEmail()
681 
 
682 
  def send_getUserByEmail(self, email):
683 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
684 
    args = getUserByEmail_args()
685 
    args.email = email
686 
    args.write(self._oprot)
687 
    self._oprot.writeMessageEnd()
688 
    self._oprot.trans.flush()
689 
 
690 
  def recv_getUserByEmail(self, ):
691 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
692 
    if mtype == TMessageType.EXCEPTION:
693 
      x = TApplicationException()
694 
      x.read(self._iprot)
695 
      self._iprot.readMessageEnd()
696 
      raise x
697 
    result = getUserByEmail_result()
698 
    result.read(self._iprot)
699 
    self._iprot.readMessageEnd()
700 
    if result.success != None:
701 
      return result.success
702 
    if result.ucex != None:
703 
      raise result.ucex
704 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
705 
 
559 chandransh 706 
  def createUser(self, user):
94 ashish 707 
    """
708 
    Parameters:
559 chandransh 709 
     - user
94 ashish 710 
    """
559 chandransh 711 
    self.send_createUser(user)
712 
    return self.recv_createUser()
94 ashish 713 
 
559 chandransh 714 
  def send_createUser(self, user):
715 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
716 
    args = createUser_args()
717 
    args.user = user
94 ashish 718 
    args.write(self._oprot)
719 
    self._oprot.writeMessageEnd()
720 
    self._oprot.trans.flush()
721 
 
559 chandransh 722 
  def recv_createUser(self, ):
94 ashish 723 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
724 
    if mtype == TMessageType.EXCEPTION:
725 
      x = TApplicationException()
726 
      x.read(self._iprot)
727 
      self._iprot.readMessageEnd()
728 
      raise x
559 chandransh 729 
    result = createUser_result()
94 ashish 730 
    result.read(self._iprot)
731 
    self._iprot.readMessageEnd()
732 
    if result.success != None:
733 
      return result.success
559 chandransh 734 
    if result.ucex != None:
735 
      raise result.ucex
736 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 737 
 
559 chandransh 738 
  def updateUser(self, user):
94 ashish 739 
    """
740 
    Parameters:
559 chandransh 741 
     - user
94 ashish 742 
    """
559 chandransh 743 
    self.send_updateUser(user)
744 
    return self.recv_updateUser()
94 ashish 745 
 
559 chandransh 746 
  def send_updateUser(self, user):
747 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
748 
    args = updateUser_args()
749 
    args.user = user
94 ashish 750 
    args.write(self._oprot)
751 
    self._oprot.writeMessageEnd()
752 
    self._oprot.trans.flush()
753 
 
559 chandransh 754 
  def recv_updateUser(self, ):
94 ashish 755 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
756 
    if mtype == TMessageType.EXCEPTION:
757 
      x = TApplicationException()
758 
      x.read(self._iprot)
759 
      self._iprot.readMessageEnd()
760 
      raise x
559 chandransh 761 
    result = updateUser_result()
94 ashish 762 
    result.read(self._iprot)
763 
    self._iprot.readMessageEnd()
764 
    if result.success != None:
765 
      return result.success
559 chandransh 766 
    if result.ucex != None:
767 
      raise result.ucex
768 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 769 
 
559 chandransh 770 
  def deleteUser(self, userId):
94 ashish 771 
    """
772 
    Parameters:
773 
     - userId
774 
    """
559 chandransh 775 
    self.send_deleteUser(userId)
776 
    return self.recv_deleteUser()
94 ashish 777 
 
559 chandransh 778 
  def send_deleteUser(self, userId):
779 
    self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
780 
    args = deleteUser_args()
94 ashish 781 
    args.userId = userId
782 
    args.write(self._oprot)
783 
    self._oprot.writeMessageEnd()
784 
    self._oprot.trans.flush()
785 
 
559 chandransh 786 
  def recv_deleteUser(self, ):
94 ashish 787 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
788 
    if mtype == TMessageType.EXCEPTION:
789 
      x = TApplicationException()
790 
      x.read(self._iprot)
791 
      self._iprot.readMessageEnd()
792 
      raise x
559 chandransh 793 
    result = deleteUser_result()
94 ashish 794 
    result.read(self._iprot)
795 
    self._iprot.readMessageEnd()
796 
    if result.success != None:
797 
      return result.success
559 chandransh 798 
    if result.ucex != None:
799 
      raise result.ucex
800 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
94 ashish 801 
 
559 chandransh 802 
  def getUserState(self, userId):
94 ashish 803 
    """
804 
    Parameters:
805 
     - userId
806 
    """
559 chandransh 807 
    self.send_getUserState(userId)
808 
    return self.recv_getUserState()
94 ashish 809 
 
559 chandransh 810 
  def send_getUserState(self, userId):
811 
    self._oprot.writeMessageBegin('getUserState', TMessageType.CALL, self._seqid)
812 
    args = getUserState_args()
94 ashish 813 
    args.userId = userId
814 
    args.write(self._oprot)
815 
    self._oprot.writeMessageEnd()
816 
    self._oprot.trans.flush()
817 
 
559 chandransh 818 
  def recv_getUserState(self, ):
94 ashish 819 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
820 
    if mtype == TMessageType.EXCEPTION:
821 
      x = TApplicationException()
822 
      x.read(self._iprot)
823 
      self._iprot.readMessageEnd()
824 
      raise x
559 chandransh 825 
    result = getUserState_result()
94 ashish 826 
    result.read(self._iprot)
827 
    self._iprot.readMessageEnd()
828 
    if result.success != None:
829 
      return result.success
559 chandransh 830 
    if result.ucex != None:
831 
      raise result.ucex
832 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserState failed: unknown result");
94 ashish 833 
 
559 chandransh 834 
  def authenticateUser(self, email, password):
94 ashish 835 
    """
836 
    Parameters:
837 
     - email
838 
     - password
839 
    """
559 chandransh 840 
    self.send_authenticateUser(email, password)
122 ashish 841 
    return self.recv_authenticateUser()
842 
 
559 chandransh 843 
  def send_authenticateUser(self, email, password):
122 ashish 844 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
845 
    args = authenticateUser_args()
559 chandransh 846 
    args.email = email
122 ashish 847 
    args.password = password
848 
    args.write(self._oprot)
849 
    self._oprot.writeMessageEnd()
850 
    self._oprot.trans.flush()
851 
 
852 
  def recv_authenticateUser(self, ):
853 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
854 
    if mtype == TMessageType.EXCEPTION:
855 
      x = TApplicationException()
856 
      x.read(self._iprot)
857 
      self._iprot.readMessageEnd()
858 
      raise x
859 
    result = authenticateUser_result()
860 
    result.read(self._iprot)
861 
    self._iprot.readMessageEnd()
862 
    if result.success != None:
863 
      return result.success
559 chandransh 864 
    if result.auex != None:
865 
      raise result.auex
122 ashish 866 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
867 
 
94 ashish 868 
  def userExists(self, email):
869 
    """
870 
    Parameters:
871 
     - email
872 
    """
873 
    self.send_userExists(email)
874 
    return self.recv_userExists()
875 
 
876 
  def send_userExists(self, email):
877 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
878 
    args = userExists_args()
879 
    args.email = email
880 
    args.write(self._oprot)
881 
    self._oprot.writeMessageEnd()
882 
    self._oprot.trans.flush()
883 
 
884 
  def recv_userExists(self, ):
885 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
886 
    if mtype == TMessageType.EXCEPTION:
887 
      x = TApplicationException()
888 
      x.read(self._iprot)
889 
      self._iprot.readMessageEnd()
890 
      raise x
891 
    result = userExists_result()
892 
    result.read(self._iprot)
893 
    self._iprot.readMessageEnd()
894 
    if result.success != None:
895 
      return result.success
896 
    if result.ucx != None:
897 
      raise result.ucx
898 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
899 
 
567 rajveer 900 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 901 
    """
902 
    Parameters:
903 
     - userId
904 
     - address
513 rajveer 905 
     - setDefault
94 ashish 906 
    """
567 rajveer 907 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 908 
    return self.recv_addAddressForUser()
909 
 
567 rajveer 910 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 911 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
912 
    args = addAddressForUser_args()
559 chandransh 913 
    args.userId = userId
94 ashish 914 
    args.address = address
513 rajveer 915 
    args.setDefault = setDefault
94 ashish 916 
    args.write(self._oprot)
917 
    self._oprot.writeMessageEnd()
918 
    self._oprot.trans.flush()
919 
 
920 
  def recv_addAddressForUser(self, ):
921 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
922 
    if mtype == TMessageType.EXCEPTION:
923 
      x = TApplicationException()
924 
      x.read(self._iprot)
925 
      self._iprot.readMessageEnd()
926 
      raise x
927 
    result = addAddressForUser_result()
928 
    result.read(self._iprot)
929 
    self._iprot.readMessageEnd()
930 
    if result.success != None:
931 
      return result.success
932 
    if result.ucx != None:
933 
      raise result.ucx
934 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
935 
 
936 
  def removeAddressForUser(self, userid, addressId):
937 
    """
938 
    Parameters:
939 
     - userid
940 
     - addressId
941 
    """
942 
    self.send_removeAddressForUser(userid, addressId)
943 
    return self.recv_removeAddressForUser()
944 
 
945 
  def send_removeAddressForUser(self, userid, addressId):
946 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
947 
    args = removeAddressForUser_args()
948 
    args.userid = userid
949 
    args.addressId = addressId
950 
    args.write(self._oprot)
951 
    self._oprot.writeMessageEnd()
952 
    self._oprot.trans.flush()
953 
 
954 
  def recv_removeAddressForUser(self, ):
955 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
956 
    if mtype == TMessageType.EXCEPTION:
957 
      x = TApplicationException()
958 
      x.read(self._iprot)
959 
      self._iprot.readMessageEnd()
960 
      raise x
961 
    result = removeAddressForUser_result()
962 
    result.read(self._iprot)
963 
    self._iprot.readMessageEnd()
964 
    if result.success != None:
965 
      return result.success
966 
    if result.ucx != None:
967 
      raise result.ucx
968 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
969 
 
970 
  def setUserAsLoggedIn(self, userId, timestamp):
971 
    """
972 
    Parameters:
973 
     - userId
974 
     - timestamp
975 
    """
976 
    self.send_setUserAsLoggedIn(userId, timestamp)
977 
    return self.recv_setUserAsLoggedIn()
978 
 
979 
  def send_setUserAsLoggedIn(self, userId, timestamp):
980 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
981 
    args = setUserAsLoggedIn_args()
982 
    args.userId = userId
983 
    args.timestamp = timestamp
984 
    args.write(self._oprot)
985 
    self._oprot.writeMessageEnd()
986 
    self._oprot.trans.flush()
987 
 
988 
  def recv_setUserAsLoggedIn(self, ):
989 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
990 
    if mtype == TMessageType.EXCEPTION:
991 
      x = TApplicationException()
992 
      x.read(self._iprot)
993 
      self._iprot.readMessageEnd()
994 
      raise x
995 
    result = setUserAsLoggedIn_result()
996 
    result.read(self._iprot)
997 
    self._iprot.readMessageEnd()
998 
    if result.success != None:
999 
      return result.success
1000 
    if result.ucx != None:
1001 
      raise result.ucx
1002 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1003 
 
1004 
  def setUserAsLoggedOut(self, userid, timestamp):
1005 
    """
1006 
    Parameters:
1007 
     - userid
1008 
     - timestamp
1009 
    """
1010 
    self.send_setUserAsLoggedOut(userid, timestamp)
1011 
    return self.recv_setUserAsLoggedOut()
1012 
 
1013 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1014 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1015 
    args = setUserAsLoggedOut_args()
1016 
    args.userid = userid
1017 
    args.timestamp = timestamp
1018 
    args.write(self._oprot)
1019 
    self._oprot.writeMessageEnd()
1020 
    self._oprot.trans.flush()
1021 
 
1022 
  def recv_setUserAsLoggedOut(self, ):
1023 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1024 
    if mtype == TMessageType.EXCEPTION:
1025 
      x = TApplicationException()
1026 
      x.read(self._iprot)
1027 
      self._iprot.readMessageEnd()
1028 
      raise x
1029 
    result = setUserAsLoggedOut_result()
1030 
    result.read(self._iprot)
1031 
    self._iprot.readMessageEnd()
1032 
    if result.success != None:
1033 
      return result.success
1034 
    if result.ucx != None:
1035 
      raise result.ucx
1036 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1037 
 
504 rajveer 1038 
  def setDefaultAddress(self, userid, addressId):
1039 
    """
1040 
    Parameters:
1041 
     - userid
1042 
     - addressId
1043 
    """
1044 
    self.send_setDefaultAddress(userid, addressId)
1045 
    return self.recv_setDefaultAddress()
1046 
 
1047 
  def send_setDefaultAddress(self, userid, addressId):
1048 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1049 
    args = setDefaultAddress_args()
1050 
    args.userid = userid
1051 
    args.addressId = addressId
1052 
    args.write(self._oprot)
1053 
    self._oprot.writeMessageEnd()
1054 
    self._oprot.trans.flush()
1055 
 
1056 
  def recv_setDefaultAddress(self, ):
1057 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1058 
    if mtype == TMessageType.EXCEPTION:
1059 
      x = TApplicationException()
1060 
      x.read(self._iprot)
1061 
      self._iprot.readMessageEnd()
1062 
      raise x
1063 
    result = setDefaultAddress_result()
1064 
    result.read(self._iprot)
1065 
    self._iprot.readMessageEnd()
1066 
    if result.success != None:
1067 
      return result.success
1068 
    if result.ucx != None:
1069 
      raise result.ucx
1070 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1071 
 
594 rajveer 1072 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1073 
    """
1074 
    Parameters:
1075 
     - userid
594 rajveer 1076 
     - oldPassword
1077 
     - newPassword
94 ashish 1078 
    """
594 rajveer 1079 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1080 
    return self.recv_updatePassword()
1081 
 
594 rajveer 1082 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1083 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1084 
    args = updatePassword_args()
1085 
    args.userid = userid
594 rajveer 1086 
    args.oldPassword = oldPassword
1087 
    args.newPassword = newPassword
94 ashish 1088 
    args.write(self._oprot)
1089 
    self._oprot.writeMessageEnd()
1090 
    self._oprot.trans.flush()
1091 
 
1092 
  def recv_updatePassword(self, ):
1093 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1094 
    if mtype == TMessageType.EXCEPTION:
1095 
      x = TApplicationException()
1096 
      x.read(self._iprot)
1097 
      self._iprot.readMessageEnd()
1098 
      raise x
1099 
    result = updatePassword_result()
1100 
    result.read(self._iprot)
1101 
    self._iprot.readMessageEnd()
1102 
    if result.success != None:
1103 
      return result.success
1104 
    if result.ucx != None:
1105 
      raise result.ucx
1106 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1107 
 
884 rajveer 1108 
  def forgotPassword(self, email, newPassword):
581 rajveer 1109 
    """
1110 
    Parameters:
1111 
     - email
884 rajveer 1112 
     - newPassword
581 rajveer 1113 
    """
884 rajveer 1114 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1115 
    return self.recv_forgotPassword()
1116 
 
884 rajveer 1117 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1118 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1119 
    args = forgotPassword_args()
1120 
    args.email = email
884 rajveer 1121 
    args.newPassword = newPassword
581 rajveer 1122 
    args.write(self._oprot)
1123 
    self._oprot.writeMessageEnd()
1124 
    self._oprot.trans.flush()
1125 
 
1126 
  def recv_forgotPassword(self, ):
1127 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1128 
    if mtype == TMessageType.EXCEPTION:
1129 
      x = TApplicationException()
1130 
      x.read(self._iprot)
1131 
      self._iprot.readMessageEnd()
1132 
      raise x
1133 
    result = forgotPassword_result()
1134 
    result.read(self._iprot)
1135 
    self._iprot.readMessageEnd()
1136 
    if result.success != None:
1137 
      return result.success
1138 
    if result.ucx != None:
1139 
      raise result.ucx
1140 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1141 
 
594 rajveer 1142 
  def getAllAddressesForUser(self, userId):
1143 
    """
1144 
    Parameters:
1145 
     - userId
1146 
    """
1147 
    self.send_getAllAddressesForUser(userId)
1148 
    return self.recv_getAllAddressesForUser()
1149 
 
1150 
  def send_getAllAddressesForUser(self, userId):
1151 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1152 
    args = getAllAddressesForUser_args()
1153 
    args.userId = userId
1154 
    args.write(self._oprot)
1155 
    self._oprot.writeMessageEnd()
1156 
    self._oprot.trans.flush()
1157 
 
1158 
  def recv_getAllAddressesForUser(self, ):
1159 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1160 
    if mtype == TMessageType.EXCEPTION:
1161 
      x = TApplicationException()
1162 
      x.read(self._iprot)
1163 
      self._iprot.readMessageEnd()
1164 
      raise x
1165 
    result = getAllAddressesForUser_result()
1166 
    result.read(self._iprot)
1167 
    self._iprot.readMessageEnd()
1168 
    if result.success != None:
1169 
      return result.success
1170 
    if result.ucx != None:
1171 
      raise result.ucx
1172 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1173 
 
1894 vikas 1174 
  def getAddressById(self, addressId):
1175 
    """
1176 
    Parameters:
1177 
     - addressId
1178 
    """
1179 
    self.send_getAddressById(addressId)
1180 
    return self.recv_getAddressById()
1181 
 
1182 
  def send_getAddressById(self, addressId):
1183 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1184 
    args = getAddressById_args()
1185 
    args.addressId = addressId
1186 
    args.write(self._oprot)
1187 
    self._oprot.writeMessageEnd()
1188 
    self._oprot.trans.flush()
1189 
 
1190 
  def recv_getAddressById(self, ):
1191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1192 
    if mtype == TMessageType.EXCEPTION:
1193 
      x = TApplicationException()
1194 
      x.read(self._iprot)
1195 
      self._iprot.readMessageEnd()
1196 
      raise x
1197 
    result = getAddressById_result()
1198 
    result.read(self._iprot)
1199 
    self._iprot.readMessageEnd()
1200 
    if result.success != None:
1201 
      return result.success
1202 
    if result.ucx != None:
1203 
      raise result.ucx
1204 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1205 
 
594 rajveer 1206 
  def getDefaultAddressId(self, userId):
1207 
    """
1208 
    Parameters:
1209 
     - userId
1210 
    """
1211 
    self.send_getDefaultAddressId(userId)
1212 
    return self.recv_getDefaultAddressId()
1213 
 
1214 
  def send_getDefaultAddressId(self, userId):
1215 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1216 
    args = getDefaultAddressId_args()
1217 
    args.userId = userId
1218 
    args.write(self._oprot)
1219 
    self._oprot.writeMessageEnd()
1220 
    self._oprot.trans.flush()
1221 
 
1222 
  def recv_getDefaultAddressId(self, ):
1223 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1224 
    if mtype == TMessageType.EXCEPTION:
1225 
      x = TApplicationException()
1226 
      x.read(self._iprot)
1227 
      self._iprot.readMessageEnd()
1228 
      raise x
1229 
    result = getDefaultAddressId_result()
1230 
    result.read(self._iprot)
1231 
    self._iprot.readMessageEnd()
1232 
    if result.success != None:
1233 
      return result.success
1234 
    if result.ucx != None:
1235 
      raise result.ucx
1236 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1237 
 
785 rajveer 1238 
  def getDefaultPincode(self, userId):
1239 
    """
1240 
    Parameters:
1241 
     - userId
1242 
    """
1243 
    self.send_getDefaultPincode(userId)
1244 
    return self.recv_getDefaultPincode()
1245 
 
1246 
  def send_getDefaultPincode(self, userId):
1247 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1248 
    args = getDefaultPincode_args()
1249 
    args.userId = userId
1250 
    args.write(self._oprot)
1251 
    self._oprot.writeMessageEnd()
1252 
    self._oprot.trans.flush()
1253 
 
1254 
  def recv_getDefaultPincode(self, ):
1255 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1256 
    if mtype == TMessageType.EXCEPTION:
1257 
      x = TApplicationException()
1258 
      x.read(self._iprot)
1259 
      self._iprot.readMessageEnd()
1260 
      raise x
1261 
    result = getDefaultPincode_result()
1262 
    result.read(self._iprot)
1263 
    self._iprot.readMessageEnd()
1264 
    if result.success != None:
1265 
      return result.success
1266 
    if result.ucx != None:
1267 
      raise result.ucx
1268 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1269 
 
1274 varun.gupt 1270 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1271 
    """
1272 
    Parameters:
1273 
     - userId
1274 
     - replyTo
1275 
     - communicationType
1276 
     - orderId
1277 
     - airwaybillNo
1278 
     - productName
1279 
     - subject
1280 
     - message
1281 
    """
1282 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1283 
    return self.recv_saveUserCommunication()
1284 
 
1285 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1286 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1287 
    args = saveUserCommunication_args()
1288 
    args.userId = userId
1289 
    args.replyTo = replyTo
1290 
    args.communicationType = communicationType
1291 
    args.orderId = orderId
1292 
    args.airwaybillNo = airwaybillNo
1293 
    args.productName = productName
1294 
    args.subject = subject
1295 
    args.message = message
1296 
    args.write(self._oprot)
1297 
    self._oprot.writeMessageEnd()
1298 
    self._oprot.trans.flush()
1299 
 
1300 
  def recv_saveUserCommunication(self, ):
1301 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1302 
    if mtype == TMessageType.EXCEPTION:
1303 
      x = TApplicationException()
1304 
      x.read(self._iprot)
1305 
      self._iprot.readMessageEnd()
1306 
      raise x
1307 
    result = saveUserCommunication_result()
1308 
    result.read(self._iprot)
1309 
    self._iprot.readMessageEnd()
1310 
    if result.success != None:
1311 
      return result.success
1312 
    if result.ucx != None:
1313 
      raise result.ucx
1314 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1315 
 
1590 varun.gupt 1316 
  def getUserCommunicationById(self, id):
1317 
    """
1318 
    Parameters:
1319 
     - id
1320 
    """
1321 
    self.send_getUserCommunicationById(id)
1322 
    return self.recv_getUserCommunicationById()
1323 
 
1324 
  def send_getUserCommunicationById(self, id):
1325 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1326 
    args = getUserCommunicationById_args()
1327 
    args.id = id
1328 
    args.write(self._oprot)
1329 
    self._oprot.writeMessageEnd()
1330 
    self._oprot.trans.flush()
1331 
 
1332 
  def recv_getUserCommunicationById(self, ):
1333 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1334 
    if mtype == TMessageType.EXCEPTION:
1335 
      x = TApplicationException()
1336 
      x.read(self._iprot)
1337 
      self._iprot.readMessageEnd()
1338 
      raise x
1339 
    result = getUserCommunicationById_result()
1340 
    result.read(self._iprot)
1341 
    self._iprot.readMessageEnd()
1342 
    if result.success != None:
1343 
      return result.success
1344 
    if result.ucx != None:
1345 
      raise result.ucx
1346 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1347 
 
1348 
  def getUserCommunicationByUser(self, userId):
1349 
    """
1350 
    Parameters:
1351 
     - userId
1352 
    """
1353 
    self.send_getUserCommunicationByUser(userId)
1354 
    return self.recv_getUserCommunicationByUser()
1355 
 
1356 
  def send_getUserCommunicationByUser(self, userId):
1357 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1358 
    args = getUserCommunicationByUser_args()
1359 
    args.userId = userId
1360 
    args.write(self._oprot)
1361 
    self._oprot.writeMessageEnd()
1362 
    self._oprot.trans.flush()
1363 
 
1364 
  def recv_getUserCommunicationByUser(self, ):
1365 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1366 
    if mtype == TMessageType.EXCEPTION:
1367 
      x = TApplicationException()
1368 
      x.read(self._iprot)
1369 
      self._iprot.readMessageEnd()
1370 
      raise x
1371 
    result = getUserCommunicationByUser_result()
1372 
    result.read(self._iprot)
1373 
    self._iprot.readMessageEnd()
1374 
    if result.success != None:
1375 
      return result.success
1376 
    if result.ucx != None:
1377 
      raise result.ucx
1378 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1379 
 
1380 
  def getAllUserCommunications(self, ):
1381 
    self.send_getAllUserCommunications()
1382 
    return self.recv_getAllUserCommunications()
1383 
 
1384 
  def send_getAllUserCommunications(self, ):
1385 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1386 
    args = getAllUserCommunications_args()
1387 
    args.write(self._oprot)
1388 
    self._oprot.writeMessageEnd()
1389 
    self._oprot.trans.flush()
1390 
 
1391 
  def recv_getAllUserCommunications(self, ):
1392 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1393 
    if mtype == TMessageType.EXCEPTION:
1394 
      x = TApplicationException()
1395 
      x.read(self._iprot)
1396 
      self._iprot.readMessageEnd()
1397 
      raise x
1398 
    result = getAllUserCommunications_result()
1399 
    result.read(self._iprot)
1400 
    self._iprot.readMessageEnd()
1401 
    if result.success != None:
1402 
      return result.success
1403 
    if result.ucx != None:
1404 
      raise result.ucx
1405 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1406 
 
1859 vikas 1407 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1408 
    """
1409 
    Parameters:
1410 
     - name
1859 vikas 1411 
     - addedOn
1845 vikas 1412 
    """
1859 vikas 1413 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1414 
    return self.recv_createMasterAffiliate()
1415 
 
1859 vikas 1416 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1417 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1418 
    args = createMasterAffiliate_args()
1419 
    args.name = name
1859 vikas 1420 
    args.addedOn = addedOn
1845 vikas 1421 
    args.write(self._oprot)
1422 
    self._oprot.writeMessageEnd()
1423 
    self._oprot.trans.flush()
1424 
 
1425 
  def recv_createMasterAffiliate(self, ):
1426 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1427 
    if mtype == TMessageType.EXCEPTION:
1428 
      x = TApplicationException()
1429 
      x.read(self._iprot)
1430 
      self._iprot.readMessageEnd()
1431 
      raise x
1432 
    result = createMasterAffiliate_result()
1433 
    result.read(self._iprot)
1434 
    self._iprot.readMessageEnd()
1435 
    if result.success != None:
1436 
      return result.success
1437 
    if result.utx != None:
1438 
      raise result.utx
1439 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1440 
 
1899 vikas 1441 
  def getAllMasterAffiliates(self, ):
1442 
    self.send_getAllMasterAffiliates()
1443 
    return self.recv_getAllMasterAffiliates()
1444 
 
1445 
  def send_getAllMasterAffiliates(self, ):
1446 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1447 
    args = getAllMasterAffiliates_args()
1448 
    args.write(self._oprot)
1449 
    self._oprot.writeMessageEnd()
1450 
    self._oprot.trans.flush()
1451 
 
1452 
  def recv_getAllMasterAffiliates(self, ):
1453 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1454 
    if mtype == TMessageType.EXCEPTION:
1455 
      x = TApplicationException()
1456 
      x.read(self._iprot)
1457 
      self._iprot.readMessageEnd()
1458 
      raise x
1459 
    result = getAllMasterAffiliates_result()
1460 
    result.read(self._iprot)
1461 
    self._iprot.readMessageEnd()
1462 
    if result.success != None:
1463 
      return result.success
1464 
    if result.utx != None:
1465 
      raise result.utx
1466 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1467 
 
1845 vikas 1468 
  def getMasterAffiliateById(self, id):
1469 
    """
1470 
    Parameters:
1471 
     - id
1472 
    """
1473 
    self.send_getMasterAffiliateById(id)
1474 
    return self.recv_getMasterAffiliateById()
1475 
 
1476 
  def send_getMasterAffiliateById(self, id):
1477 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1478 
    args = getMasterAffiliateById_args()
1479 
    args.id = id
1480 
    args.write(self._oprot)
1481 
    self._oprot.writeMessageEnd()
1482 
    self._oprot.trans.flush()
1483 
 
1484 
  def recv_getMasterAffiliateById(self, ):
1485 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1486 
    if mtype == TMessageType.EXCEPTION:
1487 
      x = TApplicationException()
1488 
      x.read(self._iprot)
1489 
      self._iprot.readMessageEnd()
1490 
      raise x
1491 
    result = getMasterAffiliateById_result()
1492 
    result.read(self._iprot)
1493 
    self._iprot.readMessageEnd()
1494 
    if result.success != None:
1495 
      return result.success
1496 
    if result.utx != None:
1497 
      raise result.utx
1498 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1499 
 
1500 
  def getMasterAffiliateByName(self, name):
1501 
    """
1502 
    Parameters:
1503 
     - name
1504 
    """
1505 
    self.send_getMasterAffiliateByName(name)
1506 
    return self.recv_getMasterAffiliateByName()
1507 
 
1508 
  def send_getMasterAffiliateByName(self, name):
1509 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1510 
    args = getMasterAffiliateByName_args()
1511 
    args.name = name
1512 
    args.write(self._oprot)
1513 
    self._oprot.writeMessageEnd()
1514 
    self._oprot.trans.flush()
1515 
 
1516 
  def recv_getMasterAffiliateByName(self, ):
1517 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1518 
    if mtype == TMessageType.EXCEPTION:
1519 
      x = TApplicationException()
1520 
      x.read(self._iprot)
1521 
      self._iprot.readMessageEnd()
1522 
      raise x
1523 
    result = getMasterAffiliateByName_result()
1524 
    result.read(self._iprot)
1525 
    self._iprot.readMessageEnd()
1526 
    if result.success != None:
1527 
      return result.success
1528 
    if result.utx != None:
1529 
      raise result.utx
1530 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1531 
 
1859 vikas 1532 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1533 
    """
1534 
    Parameters:
1535 
     - name
1536 
     - url
1537 
     - masterAffiliateId
1859 vikas 1538 
     - addedOn
1845 vikas 1539 
    """
1859 vikas 1540 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1541 
    return self.recv_createAffiliate()
1542 
 
1859 vikas 1543 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1544 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1545 
    args = createAffiliate_args()
1546 
    args.name = name
1547 
    args.url = url
1548 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1549 
    args.addedOn = addedOn
1845 vikas 1550 
    args.write(self._oprot)
1551 
    self._oprot.writeMessageEnd()
1552 
    self._oprot.trans.flush()
1553 
 
1554 
  def recv_createAffiliate(self, ):
1555 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1556 
    if mtype == TMessageType.EXCEPTION:
1557 
      x = TApplicationException()
1558 
      x.read(self._iprot)
1559 
      self._iprot.readMessageEnd()
1560 
      raise x
1561 
    result = createAffiliate_result()
1562 
    result.read(self._iprot)
1563 
    self._iprot.readMessageEnd()
1564 
    if result.success != None:
1565 
      return result.success
1566 
    if result.utx != None:
1567 
      raise result.utx
1568 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1569 
 
1570 
  def getAffiliateById(self, id):
1571 
    """
1572 
    Parameters:
1573 
     - id
1574 
    """
1575 
    self.send_getAffiliateById(id)
1576 
    return self.recv_getAffiliateById()
1577 
 
1578 
  def send_getAffiliateById(self, id):
1579 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1580 
    args = getAffiliateById_args()
1581 
    args.id = id
1582 
    args.write(self._oprot)
1583 
    self._oprot.writeMessageEnd()
1584 
    self._oprot.trans.flush()
1585 
 
1586 
  def recv_getAffiliateById(self, ):
1587 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1588 
    if mtype == TMessageType.EXCEPTION:
1589 
      x = TApplicationException()
1590 
      x.read(self._iprot)
1591 
      self._iprot.readMessageEnd()
1592 
      raise x
1593 
    result = getAffiliateById_result()
1594 
    result.read(self._iprot)
1595 
    self._iprot.readMessageEnd()
1596 
    if result.success != None:
1597 
      return result.success
1598 
    if result.utx != None:
1599 
      raise result.utx
1600 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1601 
 
1602 
  def getAffiliateByName(self, name):
1603 
    """
1604 
    Parameters:
1605 
     - name
1606 
    """
1607 
    self.send_getAffiliateByName(name)
1608 
    return self.recv_getAffiliateByName()
1609 
 
1610 
  def send_getAffiliateByName(self, name):
1611 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1612 
    args = getAffiliateByName_args()
1613 
    args.name = name
1614 
    args.write(self._oprot)
1615 
    self._oprot.writeMessageEnd()
1616 
    self._oprot.trans.flush()
1617 
 
1618 
  def recv_getAffiliateByName(self, ):
1619 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1620 
    if mtype == TMessageType.EXCEPTION:
1621 
      x = TApplicationException()
1622 
      x.read(self._iprot)
1623 
      self._iprot.readMessageEnd()
1624 
      raise x
1625 
    result = getAffiliateByName_result()
1626 
    result.read(self._iprot)
1627 
    self._iprot.readMessageEnd()
1628 
    if result.success != None:
1629 
      return result.success
1630 
    if result.utx != None:
1631 
      raise result.utx
1632 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1633 
 
1996 vikas 1634 
  def getTrackerById(self, id):
1845 vikas 1635 
    """
1636 
    Parameters:
1637 
     - id
1638 
    """
1996 vikas 1639 
    self.send_getTrackerById(id)
1845 vikas 1640 
    return self.recv_getTrackerById()
1641 
 
1996 vikas 1642 
  def send_getTrackerById(self, id):
1845 vikas 1643 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1644 
    args = getTrackerById_args()
1996 vikas 1645 
    args.id = id
1845 vikas 1646 
    args.write(self._oprot)
1647 
    self._oprot.writeMessageEnd()
1648 
    self._oprot.trans.flush()
1649 
 
1650 
  def recv_getTrackerById(self, ):
1651 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1652 
    if mtype == TMessageType.EXCEPTION:
1653 
      x = TApplicationException()
1654 
      x.read(self._iprot)
1655 
      self._iprot.readMessageEnd()
1656 
      raise x
1657 
    result = getTrackerById_result()
1658 
    result.read(self._iprot)
1659 
    self._iprot.readMessageEnd()
1660 
    if result.success != None:
1661 
      return result.success
1662 
    if result.utx != None:
1663 
      raise result.utx
1664 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1665 
 
1996 vikas 1666 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1667 
    """
1668 
    Parameters:
1996 vikas 1669 
     - id
1845 vikas 1670 
    """
1996 vikas 1671 
    self.send_getAffiliatesByMasterAffiliate(id)
1672 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1673 
 
1996 vikas 1674 
  def send_getAffiliatesByMasterAffiliate(self, id):
1675 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1676 
    args = getAffiliatesByMasterAffiliate_args()
1677 
    args.id = id
1845 vikas 1678 
    args.write(self._oprot)
1679 
    self._oprot.writeMessageEnd()
1680 
    self._oprot.trans.flush()
1681 
 
1996 vikas 1682 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1683 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1684 
    if mtype == TMessageType.EXCEPTION:
1685 
      x = TApplicationException()
1686 
      x.read(self._iprot)
1687 
      self._iprot.readMessageEnd()
1688 
      raise x
1996 vikas 1689 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1690 
    result.read(self._iprot)
1691 
    self._iprot.readMessageEnd()
1692 
    if result.success != None:
1693 
      return result.success
1694 
    if result.utx != None:
1695 
      raise result.utx
1996 vikas 1696 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1697 
 
1996 vikas 1698 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1699 
    """
1700 
    Parameters:
1996 vikas 1701 
     - affiliateId
1845 vikas 1702 
     - userId
1703 
     - event
1704 
     - url
1705 
     - data
1859 vikas 1706 
     - addedOn
1845 vikas 1707 
    """
1996 vikas 1708 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1709 
    return self.recv_addTrackLog()
1710 
 
1996 vikas 1711 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1712 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1713 
    args = addTrackLog_args()
1996 vikas 1714 
    args.affiliateId = affiliateId
1845 vikas 1715 
    args.userId = userId
1716 
    args.event = event
1717 
    args.url = url
1718 
    args.data = data
1859 vikas 1719 
    args.addedOn = addedOn
1845 vikas 1720 
    args.write(self._oprot)
1721 
    self._oprot.writeMessageEnd()
1722 
    self._oprot.trans.flush()
1723 
 
1724 
  def recv_addTrackLog(self, ):
1725 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1726 
    if mtype == TMessageType.EXCEPTION:
1727 
      x = TApplicationException()
1728 
      x.read(self._iprot)
1729 
      self._iprot.readMessageEnd()
1730 
      raise x
1731 
    result = addTrackLog_result()
1732 
    result.read(self._iprot)
1733 
    self._iprot.readMessageEnd()
1734 
    if result.success != None:
1735 
      return result.success
1736 
    if result.utx != None:
1737 
      raise result.utx
1738 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1739 
 
1740 
  def getTrackLogById(self, id):
1741 
    """
1742 
    Parameters:
1743 
     - id
1744 
    """
1745 
    self.send_getTrackLogById(id)
1746 
    return self.recv_getTrackLogById()
1747 
 
1748 
  def send_getTrackLogById(self, id):
1749 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1750 
    args = getTrackLogById_args()
1751 
    args.id = id
1752 
    args.write(self._oprot)
1753 
    self._oprot.writeMessageEnd()
1754 
    self._oprot.trans.flush()
1755 
 
1756 
  def recv_getTrackLogById(self, ):
1757 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1758 
    if mtype == TMessageType.EXCEPTION:
1759 
      x = TApplicationException()
1760 
      x.read(self._iprot)
1761 
      self._iprot.readMessageEnd()
1762 
      raise x
1763 
    result = getTrackLogById_result()
1764 
    result.read(self._iprot)
1765 
    self._iprot.readMessageEnd()
1766 
    if result.success != None:
1767 
      return result.success
1768 
    if result.utx != None:
1769 
      raise result.utx
1770 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1771 
 
1996 vikas 1772 
  def getTrackLogsByAffiliate(self, affiliateId):
1845 vikas 1773 
    """
1774 
    Parameters:
1996 vikas 1775 
     - affiliateId
1845 vikas 1776 
    """
1996 vikas 1777 
    self.send_getTrackLogsByAffiliate(affiliateId)
1778 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 1779 
 
1996 vikas 1780 
  def send_getTrackLogsByAffiliate(self, affiliateId):
1781 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
1782 
    args = getTrackLogsByAffiliate_args()
1783 
    args.affiliateId = affiliateId
1845 vikas 1784 
    args.write(self._oprot)
1785 
    self._oprot.writeMessageEnd()
1786 
    self._oprot.trans.flush()
1787 
 
1996 vikas 1788 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 1789 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1790 
    if mtype == TMessageType.EXCEPTION:
1791 
      x = TApplicationException()
1792 
      x.read(self._iprot)
1793 
      self._iprot.readMessageEnd()
1794 
      raise x
1996 vikas 1795 
    result = getTrackLogsByAffiliate_result()
1845 vikas 1796 
    result.read(self._iprot)
1797 
    self._iprot.readMessageEnd()
1798 
    if result.success != None:
1799 
      return result.success
1800 
    if result.utx != None:
1801 
      raise result.utx
1996 vikas 1802 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 1803 
 
1804 
  def getTrackLogsByUser(self, userId):
1805 
    """
1806 
    Parameters:
1807 
     - userId
1808 
    """
1809 
    self.send_getTrackLogsByUser(userId)
1810 
    return self.recv_getTrackLogsByUser()
1811 
 
1812 
  def send_getTrackLogsByUser(self, userId):
1813 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
1814 
    args = getTrackLogsByUser_args()
1815 
    args.userId = userId
1816 
    args.write(self._oprot)
1817 
    self._oprot.writeMessageEnd()
1818 
    self._oprot.trans.flush()
1819 
 
1820 
  def recv_getTrackLogsByUser(self, ):
1821 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1822 
    if mtype == TMessageType.EXCEPTION:
1823 
      x = TApplicationException()
1824 
      x.read(self._iprot)
1825 
      self._iprot.readMessageEnd()
1826 
      raise x
1827 
    result = getTrackLogsByUser_result()
1828 
    result.read(self._iprot)
1829 
    self._iprot.readMessageEnd()
1830 
    if result.success != None:
1831 
      return result.success
1832 
    if result.utx != None:
1833 
      raise result.utx
1834 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
1835 
 
1996 vikas 1836 
  def getTrackLogs(self, userId, event, url):
1845 vikas 1837 
    """
1838 
    Parameters:
1839 
     - userId
1840 
     - event
1841 
     - url
1842 
    """
1996 vikas 1843 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 1844 
    return self.recv_getTrackLogs()
1845 
 
1996 vikas 1846 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 1847 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
1848 
    args = getTrackLogs_args()
1849 
    args.userId = userId
1850 
    args.event = event
1851 
    args.url = url
1852 
    args.write(self._oprot)
1853 
    self._oprot.writeMessageEnd()
1854 
    self._oprot.trans.flush()
1855 
 
1856 
  def recv_getTrackLogs(self, ):
1857 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1858 
    if mtype == TMessageType.EXCEPTION:
1859 
      x = TApplicationException()
1860 
      x.read(self._iprot)
1861 
      self._iprot.readMessageEnd()
1862 
      raise x
1863 
    result = getTrackLogs_result()
1864 
    result.read(self._iprot)
1865 
    self._iprot.readMessageEnd()
1866 
    if result.success != None:
1867 
      return result.success
1868 
    if result.utx != None:
1869 
      raise result.utx
1870 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
1871 
 
559 chandransh 1872 
  def createCart(self, userId):
94 ashish 1873 
    """
1874 
    Parameters:
559 chandransh 1875 
     - userId
94 ashish 1876 
    """
559 chandransh 1877 
    self.send_createCart(userId)
1878 
    return self.recv_createCart()
94 ashish 1879 
 
559 chandransh 1880 
  def send_createCart(self, userId):
1881 
    self._oprot.writeMessageBegin('createCart', TMessageType.CALL, self._seqid)
1882 
    args = createCart_args()
1883 
    args.userId = userId
94 ashish 1884 
    args.write(self._oprot)
1885 
    self._oprot.writeMessageEnd()
1886 
    self._oprot.trans.flush()
1887 
 
559 chandransh 1888 
  def recv_createCart(self, ):
94 ashish 1889 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1890 
    if mtype == TMessageType.EXCEPTION:
1891 
      x = TApplicationException()
1892 
      x.read(self._iprot)
1893 
      self._iprot.readMessageEnd()
1894 
      raise x
559 chandransh 1895 
    result = createCart_result()
94 ashish 1896 
    result.read(self._iprot)
1897 
    self._iprot.readMessageEnd()
1898 
    if result.success != None:
1899 
      return result.success
559 chandransh 1900 
    if result.scx != None:
1901 
      raise result.scx
1902 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createCart failed: unknown result");
94 ashish 1903 
 
559 chandransh 1904 
  def getCurrentCart(self, userId):
94 ashish 1905 
    """
1906 
    Parameters:
559 chandransh 1907 
     - userId
94 ashish 1908 
    """
559 chandransh 1909 
    self.send_getCurrentCart(userId)
1910 
    return self.recv_getCurrentCart()
94 ashish 1911 
 
559 chandransh 1912 
  def send_getCurrentCart(self, userId):
1913 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
1914 
    args = getCurrentCart_args()
1915 
    args.userId = userId
94 ashish 1916 
    args.write(self._oprot)
1917 
    self._oprot.writeMessageEnd()
1918 
    self._oprot.trans.flush()
1919 
 
559 chandransh 1920 
  def recv_getCurrentCart(self, ):
94 ashish 1921 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1922 
    if mtype == TMessageType.EXCEPTION:
1923 
      x = TApplicationException()
1924 
      x.read(self._iprot)
1925 
      self._iprot.readMessageEnd()
1926 
      raise x
559 chandransh 1927 
    result = getCurrentCart_result()
94 ashish 1928 
    result.read(self._iprot)
1929 
    self._iprot.readMessageEnd()
1930 
    if result.success != None:
1931 
      return result.success
559 chandransh 1932 
    if result.scx != None:
1933 
      raise result.scx
1934 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 1935 
 
559 chandransh 1936 
  def getCart(self, cartId):
94 ashish 1937 
    """
1938 
    Parameters:
559 chandransh 1939 
     - cartId
94 ashish 1940 
    """
559 chandransh 1941 
    self.send_getCart(cartId)
1942 
    return self.recv_getCart()
94 ashish 1943 
 
559 chandransh 1944 
  def send_getCart(self, cartId):
1945 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
1946 
    args = getCart_args()
1947 
    args.cartId = cartId
94 ashish 1948 
    args.write(self._oprot)
1949 
    self._oprot.writeMessageEnd()
1950 
    self._oprot.trans.flush()
1951 
 
559 chandransh 1952 
  def recv_getCart(self, ):
94 ashish 1953 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1954 
    if mtype == TMessageType.EXCEPTION:
1955 
      x = TApplicationException()
1956 
      x.read(self._iprot)
1957 
      self._iprot.readMessageEnd()
1958 
      raise x
559 chandransh 1959 
    result = getCart_result()
94 ashish 1960 
    result.read(self._iprot)
1961 
    self._iprot.readMessageEnd()
1962 
    if result.success != None:
1963 
      return result.success
559 chandransh 1964 
    if result.scx != None:
1965 
      raise result.scx
1966 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 1967 
 
559 chandransh 1968 
  def getCartsForUser(self, userId, status):
94 ashish 1969 
    """
1970 
    Parameters:
559 chandransh 1971 
     - userId
1972 
     - status
94 ashish 1973 
    """
559 chandransh 1974 
    self.send_getCartsForUser(userId, status)
1975 
    return self.recv_getCartsForUser()
94 ashish 1976 
 
559 chandransh 1977 
  def send_getCartsForUser(self, userId, status):
1978 
    self._oprot.writeMessageBegin('getCartsForUser', TMessageType.CALL, self._seqid)
1979 
    args = getCartsForUser_args()
1980 
    args.userId = userId
1981 
    args.status = status
94 ashish 1982 
    args.write(self._oprot)
1983 
    self._oprot.writeMessageEnd()
1984 
    self._oprot.trans.flush()
1985 
 
559 chandransh 1986 
  def recv_getCartsForUser(self, ):
94 ashish 1987 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1988 
    if mtype == TMessageType.EXCEPTION:
1989 
      x = TApplicationException()
1990 
      x.read(self._iprot)
1991 
      self._iprot.readMessageEnd()
1992 
      raise x
559 chandransh 1993 
    result = getCartsForUser_result()
94 ashish 1994 
    result.read(self._iprot)
1995 
    self._iprot.readMessageEnd()
1996 
    if result.success != None:
1997 
      return result.success
559 chandransh 1998 
    if result.scx != None:
1999 
      raise result.scx
2000 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsForUser failed: unknown result");
94 ashish 2001 
 
559 chandransh 2002 
  def getCartsByStatus(self, status):
94 ashish 2003 
    """
2004 
    Parameters:
559 chandransh 2005 
     - status
94 ashish 2006 
    """
559 chandransh 2007 
    self.send_getCartsByStatus(status)
2008 
    return self.recv_getCartsByStatus()
94 ashish 2009 
 
559 chandransh 2010 
  def send_getCartsByStatus(self, status):
2011 
    self._oprot.writeMessageBegin('getCartsByStatus', TMessageType.CALL, self._seqid)
2012 
    args = getCartsByStatus_args()
2013 
    args.status = status
94 ashish 2014 
    args.write(self._oprot)
2015 
    self._oprot.writeMessageEnd()
2016 
    self._oprot.trans.flush()
2017 
 
559 chandransh 2018 
  def recv_getCartsByStatus(self, ):
94 ashish 2019 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2020 
    if mtype == TMessageType.EXCEPTION:
2021 
      x = TApplicationException()
2022 
      x.read(self._iprot)
2023 
      self._iprot.readMessageEnd()
2024 
      raise x
559 chandransh 2025 
    result = getCartsByStatus_result()
94 ashish 2026 
    result.read(self._iprot)
2027 
    self._iprot.readMessageEnd()
2028 
    if result.success != None:
2029 
      return result.success
559 chandransh 2030 
    if result.scx != None:
2031 
      raise result.scx
2032 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByStatus failed: unknown result");
94 ashish 2033 
 
559 chandransh 2034 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2035 
    """
2036 
    Parameters:
559 chandransh 2037 
     - from_time
2038 
     - to_time
2039 
     - status
94 ashish 2040 
    """
559 chandransh 2041 
    self.send_getCartsByTime(from_time, to_time, status)
2042 
    return self.recv_getCartsByTime()
94 ashish 2043 
 
559 chandransh 2044 
  def send_getCartsByTime(self, from_time, to_time, status):
2045 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2046 
    args = getCartsByTime_args()
2047 
    args.from_time = from_time
2048 
    args.to_time = to_time
2049 
    args.status = status
94 ashish 2050 
    args.write(self._oprot)
2051 
    self._oprot.writeMessageEnd()
2052 
    self._oprot.trans.flush()
2053 
 
559 chandransh 2054 
  def recv_getCartsByTime(self, ):
94 ashish 2055 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2056 
    if mtype == TMessageType.EXCEPTION:
2057 
      x = TApplicationException()
2058 
      x.read(self._iprot)
2059 
      self._iprot.readMessageEnd()
2060 
      raise x
559 chandransh 2061 
    result = getCartsByTime_result()
94 ashish 2062 
    result.read(self._iprot)
2063 
    self._iprot.readMessageEnd()
2064 
    if result.success != None:
2065 
      return result.success
559 chandransh 2066 
    if result.scx != None:
2067 
      raise result.scx
2068 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2069 
 
559 chandransh 2070 
  def changeCartStatus(self, cartId, status):
130 ashish 2071 
    """
2072 
    Parameters:
559 chandransh 2073 
     - cartId
2074 
     - status
130 ashish 2075 
    """
559 chandransh 2076 
    self.send_changeCartStatus(cartId, status)
2077 
    self.recv_changeCartStatus()
94 ashish 2078 
 
559 chandransh 2079 
  def send_changeCartStatus(self, cartId, status):
2080 
    self._oprot.writeMessageBegin('changeCartStatus', TMessageType.CALL, self._seqid)
2081 
    args = changeCartStatus_args()
2082 
    args.cartId = cartId
2083 
    args.status = status
130 ashish 2084 
    args.write(self._oprot)
2085 
    self._oprot.writeMessageEnd()
2086 
    self._oprot.trans.flush()
2087 
 
559 chandransh 2088 
  def recv_changeCartStatus(self, ):
130 ashish 2089 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2090 
    if mtype == TMessageType.EXCEPTION:
2091 
      x = TApplicationException()
2092 
      x.read(self._iprot)
2093 
      self._iprot.readMessageEnd()
2094 
      raise x
559 chandransh 2095 
    result = changeCartStatus_result()
130 ashish 2096 
    result.read(self._iprot)
2097 
    self._iprot.readMessageEnd()
559 chandransh 2098 
    if result.scx != None:
2099 
      raise result.scx
2100 
    return
2101 
 
2102 
  def addItemToCart(self, cartId, itemId, quantity):
2103 
    """
2104 
    Parameters:
2105 
     - cartId
2106 
     - itemId
2107 
     - quantity
2108 
    """
2109 
    self.send_addItemToCart(cartId, itemId, quantity)
2035 rajveer 2110 
    return self.recv_addItemToCart()
559 chandransh 2111 
 
2112 
  def send_addItemToCart(self, cartId, itemId, quantity):
2113 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2114 
    args = addItemToCart_args()
2115 
    args.cartId = cartId
2116 
    args.itemId = itemId
2117 
    args.quantity = quantity
2118 
    args.write(self._oprot)
2119 
    self._oprot.writeMessageEnd()
2120 
    self._oprot.trans.flush()
2121 
 
2122 
  def recv_addItemToCart(self, ):
2123 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2124 
    if mtype == TMessageType.EXCEPTION:
2125 
      x = TApplicationException()
2126 
      x.read(self._iprot)
2127 
      self._iprot.readMessageEnd()
2128 
      raise x
2129 
    result = addItemToCart_result()
2130 
    result.read(self._iprot)
2131 
    self._iprot.readMessageEnd()
2035 rajveer 2132 
    if result.success != None:
2133 
      return result.success
559 chandransh 2134 
    if result.scx != None:
2135 
      raise result.scx
2035 rajveer 2136 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2137 
 
2138 
  def deleteItemFromCart(self, cartId, itemId):
2139 
    """
2140 
    Parameters:
2141 
     - cartId
2142 
     - itemId
2143 
    """
2144 
    self.send_deleteItemFromCart(cartId, itemId)
2145 
    self.recv_deleteItemFromCart()
2146 
 
2147 
  def send_deleteItemFromCart(self, cartId, itemId):
2148 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2149 
    args = deleteItemFromCart_args()
2150 
    args.cartId = cartId
2151 
    args.itemId = itemId
2152 
    args.write(self._oprot)
2153 
    self._oprot.writeMessageEnd()
2154 
    self._oprot.trans.flush()
2155 
 
2156 
  def recv_deleteItemFromCart(self, ):
2157 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2158 
    if mtype == TMessageType.EXCEPTION:
2159 
      x = TApplicationException()
2160 
      x.read(self._iprot)
2161 
      self._iprot.readMessageEnd()
2162 
      raise x
2163 
    result = deleteItemFromCart_result()
2164 
    result.read(self._iprot)
2165 
    self._iprot.readMessageEnd()
2166 
    if result.scx != None:
2167 
      raise result.scx
2168 
    return
2169 
 
2170 
  def changeQuantity(self, cartId, itemId, quantity):
2171 
    """
2172 
    Parameters:
2173 
     - cartId
2174 
     - itemId
2175 
     - quantity
2176 
    """
2177 
    self.send_changeQuantity(cartId, itemId, quantity)
2178 
    self.recv_changeQuantity()
2179 
 
2180 
  def send_changeQuantity(self, cartId, itemId, quantity):
2181 
    self._oprot.writeMessageBegin('changeQuantity', TMessageType.CALL, self._seqid)
2182 
    args = changeQuantity_args()
2183 
    args.cartId = cartId
2184 
    args.itemId = itemId
2185 
    args.quantity = quantity
2186 
    args.write(self._oprot)
2187 
    self._oprot.writeMessageEnd()
2188 
    self._oprot.trans.flush()
2189 
 
2190 
  def recv_changeQuantity(self, ):
2191 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2192 
    if mtype == TMessageType.EXCEPTION:
2193 
      x = TApplicationException()
2194 
      x.read(self._iprot)
2195 
      self._iprot.readMessageEnd()
2196 
      raise x
2197 
    result = changeQuantity_result()
2198 
    result.read(self._iprot)
2199 
    self._iprot.readMessageEnd()
2200 
    if result.scx != None:
2201 
      raise result.scx
2202 
    return
2203 
 
2204 
  def changeItemStatus(self, cartId, itemId, status):
2205 
    """
2206 
    Parameters:
2207 
     - cartId
2208 
     - itemId
2209 
     - status
2210 
    """
2211 
    self.send_changeItemStatus(cartId, itemId, status)
2212 
    self.recv_changeItemStatus()
2213 
 
2214 
  def send_changeItemStatus(self, cartId, itemId, status):
2215 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
2216 
    args = changeItemStatus_args()
2217 
    args.cartId = cartId
2218 
    args.itemId = itemId
2219 
    args.status = status
2220 
    args.write(self._oprot)
2221 
    self._oprot.writeMessageEnd()
2222 
    self._oprot.trans.flush()
2223 
 
2224 
  def recv_changeItemStatus(self, ):
2225 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2226 
    if mtype == TMessageType.EXCEPTION:
2227 
      x = TApplicationException()
2228 
      x.read(self._iprot)
2229 
      self._iprot.readMessageEnd()
2230 
      raise x
2231 
    result = changeItemStatus_result()
2232 
    result.read(self._iprot)
2233 
    self._iprot.readMessageEnd()
2234 
    if result.scx != None:
2235 
      raise result.scx
2236 
    return
2237 
 
2238 
  def addAddressToCart(self, cartId, addressId):
2239 
    """
2240 
    Parameters:
2241 
     - cartId
2242 
     - addressId
2243 
    """
2244 
    self.send_addAddressToCart(cartId, addressId)
2245 
    self.recv_addAddressToCart()
2246 
 
2247 
  def send_addAddressToCart(self, cartId, addressId):
2248 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2249 
    args = addAddressToCart_args()
2250 
    args.cartId = cartId
2251 
    args.addressId = addressId
2252 
    args.write(self._oprot)
2253 
    self._oprot.writeMessageEnd()
2254 
    self._oprot.trans.flush()
2255 
 
2256 
  def recv_addAddressToCart(self, ):
2257 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2258 
    if mtype == TMessageType.EXCEPTION:
2259 
      x = TApplicationException()
2260 
      x.read(self._iprot)
2261 
      self._iprot.readMessageEnd()
2262 
      raise x
2263 
    result = addAddressToCart_result()
2264 
    result.read(self._iprot)
2265 
    self._iprot.readMessageEnd()
575 chandransh 2266 
    if result.scx != None:
2267 
      raise result.scx
559 chandransh 2268 
    return
2269 
 
1976 varun.gupt 2270 
  def applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
2271 
    """
2272 
    Parameters:
2273 
     - cartId
2274 
     - couponCode
2275 
     - totalPrice
2276 
     - discountedPrice
2277 
    """
2278 
    self.send_applyCouponToCart(cartId, couponCode, totalPrice, discountedPrice)
2279 
    self.recv_applyCouponToCart()
2280 
 
2281 
  def send_applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
2282 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2283 
    args = applyCouponToCart_args()
2284 
    args.cartId = cartId
2285 
    args.couponCode = couponCode
2286 
    args.totalPrice = totalPrice
2287 
    args.discountedPrice = discountedPrice
2288 
    args.write(self._oprot)
2289 
    self._oprot.writeMessageEnd()
2290 
    self._oprot.trans.flush()
2291 
 
2292 
  def recv_applyCouponToCart(self, ):
2293 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2294 
    if mtype == TMessageType.EXCEPTION:
2295 
      x = TApplicationException()
2296 
      x.read(self._iprot)
2297 
      self._iprot.readMessageEnd()
2298 
      raise x
2299 
    result = applyCouponToCart_result()
2300 
    result.read(self._iprot)
2301 
    self._iprot.readMessageEnd()
2302 
    if result.scx != None:
2303 
      raise result.scx
2304 
    return
2305 
 
2306 
  def removeCoupon(self, cartId):
2307 
    """
2308 
    Parameters:
2309 
     - cartId
2310 
    """
2311 
    self.send_removeCoupon(cartId)
2312 
    self.recv_removeCoupon()
2313 
 
2314 
  def send_removeCoupon(self, cartId):
2315 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2316 
    args = removeCoupon_args()
2317 
    args.cartId = cartId
2318 
    args.write(self._oprot)
2319 
    self._oprot.writeMessageEnd()
2320 
    self._oprot.trans.flush()
2321 
 
2322 
  def recv_removeCoupon(self, ):
2323 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2324 
    if mtype == TMessageType.EXCEPTION:
2325 
      x = TApplicationException()
2326 
      x.read(self._iprot)
2327 
      self._iprot.readMessageEnd()
2328 
      raise x
2329 
    result = removeCoupon_result()
2330 
    result.read(self._iprot)
2331 
    self._iprot.readMessageEnd()
2332 
    if result.scx != None:
2333 
      raise result.scx
2334 
    return
2335 
 
2815 vikas 2336 
  def createOrders(self, cartId, sessionSource, sessionStartTime):
559 chandransh 2337 
    """
690 chandransh 2338 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
2339 
 
559 chandransh 2340 
    Parameters:
2341 
     - cartId
2815 vikas 2342 
     - sessionSource
2343 
     - sessionStartTime
559 chandransh 2344 
    """
2815 vikas 2345 
    self.send_createOrders(cartId, sessionSource, sessionStartTime)
690 chandransh 2346 
    return self.recv_createOrders()
559 chandransh 2347 
 
2815 vikas 2348 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime):
690 chandransh 2349 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2350 
    args = createOrders_args()
559 chandransh 2351 
    args.cartId = cartId
2815 vikas 2352 
    args.sessionSource = sessionSource
2353 
    args.sessionStartTime = sessionStartTime
559 chandransh 2354 
    args.write(self._oprot)
2355 
    self._oprot.writeMessageEnd()
2356 
    self._oprot.trans.flush()
2357 
 
690 chandransh 2358 
  def recv_createOrders(self, ):
559 chandransh 2359 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2360 
    if mtype == TMessageType.EXCEPTION:
2361 
      x = TApplicationException()
2362 
      x.read(self._iprot)
2363 
      self._iprot.readMessageEnd()
2364 
      raise x
690 chandransh 2365 
    result = createOrders_result()
559 chandransh 2366 
    result.read(self._iprot)
2367 
    self._iprot.readMessageEnd()
130 ashish 2368 
    if result.success != None:
2369 
      return result.success
559 chandransh 2370 
    if result.scx != None:
2371 
      raise result.scx
690 chandransh 2372 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2373 
 
559 chandransh 2374 
  def validateCart(self, cartId):
130 ashish 2375 
    """
690 chandransh 2376 
    Validates that:
2377 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2378 
    2. All of the lines in the cart are active items.
690 chandransh 2379 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2380 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 2381 
 
130 ashish 2382 
    Parameters:
559 chandransh 2383 
     - cartId
130 ashish 2384 
    """
559 chandransh 2385 
    self.send_validateCart(cartId)
2386 
    return self.recv_validateCart()
130 ashish 2387 
 
559 chandransh 2388 
  def send_validateCart(self, cartId):
2389 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2390 
    args = validateCart_args()
2391 
    args.cartId = cartId
130 ashish 2392 
    args.write(self._oprot)
2393 
    self._oprot.writeMessageEnd()
2394 
    self._oprot.trans.flush()
2395 
 
559 chandransh 2396 
  def recv_validateCart(self, ):
130 ashish 2397 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2398 
    if mtype == TMessageType.EXCEPTION:
2399 
      x = TApplicationException()
2400 
      x.read(self._iprot)
2401 
      self._iprot.readMessageEnd()
2402 
      raise x
559 chandransh 2403 
    result = validateCart_result()
130 ashish 2404 
    result.read(self._iprot)
2405 
    self._iprot.readMessageEnd()
2406 
    if result.success != None:
2407 
      return result.success
575 chandransh 2408 
    if result.scex != None:
2409 
      raise result.scex
559 chandransh 2410 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2411 
 
690 chandransh 2412 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2413 
    """
690 chandransh 2414 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
2415 
 
575 chandransh 2416 
    Parameters:
690 chandransh 2417 
     - fromCartId
2418 
     - toCartId
2419 
    """
2420 
    self.send_mergeCart(fromCartId, toCartId)
2421 
    self.recv_mergeCart()
2422 
 
2423 
  def send_mergeCart(self, fromCartId, toCartId):
2424 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2425 
    args = mergeCart_args()
2426 
    args.fromCartId = fromCartId
2427 
    args.toCartId = toCartId
2428 
    args.write(self._oprot)
2429 
    self._oprot.writeMessageEnd()
2430 
    self._oprot.trans.flush()
2431 
 
2432 
  def recv_mergeCart(self, ):
2433 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2434 
    if mtype == TMessageType.EXCEPTION:
2435 
      x = TApplicationException()
2436 
      x.read(self._iprot)
2437 
      self._iprot.readMessageEnd()
2438 
      raise x
2439 
    result = mergeCart_result()
2440 
    result.read(self._iprot)
2441 
    self._iprot.readMessageEnd()
2442 
    return
2443 
 
2444 
  def checkOut(self, cartId):
2445 
    """
2446 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
2447 
 
2448 
    Parameters:
575 chandransh 2449 
     - cartId
2450 
    """
690 chandransh 2451 
    self.send_checkOut(cartId)
2452 
    return self.recv_checkOut()
575 chandransh 2453 
 
690 chandransh 2454 
  def send_checkOut(self, cartId):
2455 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2456 
    args = checkOut_args()
575 chandransh 2457 
    args.cartId = cartId
2458 
    args.write(self._oprot)
2459 
    self._oprot.writeMessageEnd()
2460 
    self._oprot.trans.flush()
2461 
 
690 chandransh 2462 
  def recv_checkOut(self, ):
575 chandransh 2463 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2464 
    if mtype == TMessageType.EXCEPTION:
2465 
      x = TApplicationException()
2466 
      x.read(self._iprot)
2467 
      self._iprot.readMessageEnd()
2468 
      raise x
690 chandransh 2469 
    result = checkOut_result()
575 chandransh 2470 
    result.read(self._iprot)
2471 
    self._iprot.readMessageEnd()
2472 
    if result.success != None:
2473 
      return result.success
2474 
    if result.scex != None:
2475 
      raise result.scex
690 chandransh 2476 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2477 
 
690 chandransh 2478 
  def resetCart(self, cartId, items):
559 chandransh 2479 
    """
690 chandransh 2480 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2481 
    This methods removes the specified quantiry of the specified item from the cart.
2482 
 
559 chandransh 2483 
    Parameters:
690 chandransh 2484 
     - cartId
2485 
     - items
559 chandransh 2486 
    """
690 chandransh 2487 
    self.send_resetCart(cartId, items)
2488 
    return self.recv_resetCart()
130 ashish 2489 
 
690 chandransh 2490 
  def send_resetCart(self, cartId, items):
2491 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2492 
    args = resetCart_args()
2493 
    args.cartId = cartId
2494 
    args.items = items
559 chandransh 2495 
    args.write(self._oprot)
2496 
    self._oprot.writeMessageEnd()
2497 
    self._oprot.trans.flush()
2498 
 
690 chandransh 2499 
  def recv_resetCart(self, ):
559 chandransh 2500 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2501 
    if mtype == TMessageType.EXCEPTION:
2502 
      x = TApplicationException()
2503 
      x.read(self._iprot)
2504 
      self._iprot.readMessageEnd()
2505 
      raise x
690 chandransh 2506 
    result = resetCart_result()
559 chandransh 2507 
    result.read(self._iprot)
2508 
    self._iprot.readMessageEnd()
690 chandransh 2509 
    if result.success != None:
2510 
      return result.success
2511 
    if result.scex != None:
2512 
      raise result.scex
2513 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2514 
 
2981 rajveer 2515 
  def getUserCount(self, userType):
559 chandransh 2516 
    """
2981 rajveer 2517 
    Returns number of registered users.
2518 
    If userType = null, then it returns count of all users, including anonymous
2519 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2520 
    If userType = UserType.USER, then it returns count of non-anonymous users only
772 rajveer 2521 
 
559 chandransh 2522 
    Parameters:
2981 rajveer 2523 
     - userType
559 chandransh 2524 
    """
2981 rajveer 2525 
    self.send_getUserCount(userType)
2526 
    return self.recv_getUserCount()
559 chandransh 2527 
 
2981 rajveer 2528 
  def send_getUserCount(self, userType):
2529 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2530 
    args = getUserCount_args()
2531 
    args.userType = userType
559 chandransh 2532 
    args.write(self._oprot)
2533 
    self._oprot.writeMessageEnd()
2534 
    self._oprot.trans.flush()
2535 
 
2981 rajveer 2536 
  def recv_getUserCount(self, ):
559 chandransh 2537 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2538 
    if mtype == TMessageType.EXCEPTION:
2539 
      x = TApplicationException()
2540 
      x.read(self._iprot)
2541 
      self._iprot.readMessageEnd()
2542 
      raise x
2981 rajveer 2543 
    result = getUserCount_result()
559 chandransh 2544 
    result.read(self._iprot)
2545 
    self._iprot.readMessageEnd()
2546 
    if result.success != None:
2547 
      return result.success
2981 rajveer 2548 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
559 chandransh 2549 
 
2981 rajveer 2550 
  def getAllUsers(self, userType, startDate, endDate):
559 chandransh 2551 
    """
2981 rajveer 2552 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2553 
    If any of startDate or endDate is -1, then that filter is ignored.
2554 
    If userType is null, then returns all the users, irrespective of anonymous flag
2555 
 
2556 
 
559 chandransh 2557 
    Parameters:
2981 rajveer 2558 
     - userType
2559 
     - startDate
2560 
     - endDate
559 chandransh 2561 
    """
2981 rajveer 2562 
    self.send_getAllUsers(userType, startDate, endDate)
2563 
    return self.recv_getAllUsers()
559 chandransh 2564 
 
2981 rajveer 2565 
  def send_getAllUsers(self, userType, startDate, endDate):
2566 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2567 
    args = getAllUsers_args()
2568 
    args.userType = userType
2569 
    args.startDate = startDate
2570 
    args.endDate = endDate
559 chandransh 2571 
    args.write(self._oprot)
2572 
    self._oprot.writeMessageEnd()
2573 
    self._oprot.trans.flush()
2574 
 
2981 rajveer 2575 
  def recv_getAllUsers(self, ):
559 chandransh 2576 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2577 
    if mtype == TMessageType.EXCEPTION:
2578 
      x = TApplicationException()
2579 
      x.read(self._iprot)
2580 
      self._iprot.readMessageEnd()
2581 
      raise x
2981 rajveer 2582 
    result = getAllUsers_result()
559 chandransh 2583 
    result.read(self._iprot)
2584 
    self._iprot.readMessageEnd()
2585 
    if result.success != None:
2586 
      return result.success
2981 rajveer 2587 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
559 chandransh 2588 
 
2981 rajveer 2589 
  def putUserNote(self, user_id, entity_id, slide, note):
559 chandransh 2590 
    """
2591 
    Parameters:
2981 rajveer 2592 
     - user_id
2593 
     - entity_id
2594 
     - slide
2595 
     - note
559 chandransh 2596 
    """
2981 rajveer 2597 
    self.send_putUserNote(user_id, entity_id, slide, note)
2598 
    self.recv_putUserNote()
559 chandransh 2599 
 
2981 rajveer 2600 
  def send_putUserNote(self, user_id, entity_id, slide, note):
2601 
    self._oprot.writeMessageBegin('putUserNote', TMessageType.CALL, self._seqid)
2602 
    args = putUserNote_args()
2603 
    args.user_id = user_id
2604 
    args.entity_id = entity_id
2605 
    args.slide = slide
2606 
    args.note = note
559 chandransh 2607 
    args.write(self._oprot)
2608 
    self._oprot.writeMessageEnd()
2609 
    self._oprot.trans.flush()
2610 
 
2981 rajveer 2611 
  def recv_putUserNote(self, ):
559 chandransh 2612 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2613 
    if mtype == TMessageType.EXCEPTION:
2614 
      x = TApplicationException()
2615 
      x.read(self._iprot)
2616 
      self._iprot.readMessageEnd()
2617 
      raise x
2981 rajveer 2618 
    result = putUserNote_result()
559 chandransh 2619 
    result.read(self._iprot)
2620 
    self._iprot.readMessageEnd()
2621 
    return
2622 
 
2981 rajveer 2623 
  def getUserNotes(self, user_id, entity_id):
559 chandransh 2624 
    """
2625 
    Parameters:
2981 rajveer 2626 
     - user_id
2627 
     - entity_id
559 chandransh 2628 
    """
2981 rajveer 2629 
    self.send_getUserNotes(user_id, entity_id)
2630 
    return self.recv_getUserNotes()
559 chandransh 2631 
 
2981 rajveer 2632 
  def send_getUserNotes(self, user_id, entity_id):
2633 
    self._oprot.writeMessageBegin('getUserNotes', TMessageType.CALL, self._seqid)
2634 
    args = getUserNotes_args()
2635 
    args.user_id = user_id
2636 
    args.entity_id = entity_id
559 chandransh 2637 
    args.write(self._oprot)
2638 
    self._oprot.writeMessageEnd()
2639 
    self._oprot.trans.flush()
2640 
 
2981 rajveer 2641 
  def recv_getUserNotes(self, ):
559 chandransh 2642 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2643 
    if mtype == TMessageType.EXCEPTION:
2644 
      x = TApplicationException()
2645 
      x.read(self._iprot)
2646 
      self._iprot.readMessageEnd()
2647 
      raise x
2981 rajveer 2648 
    result = getUserNotes_result()
559 chandransh 2649 
    result.read(self._iprot)
2650 
    self._iprot.readMessageEnd()
2981 rajveer 2651 
    if result.success != None:
2652 
      return result.success
2653 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserNotes failed: unknown result");
559 chandransh 2654 
 
2981 rajveer 2655 
  def getMyResearchItems(self, userId):
559 chandransh 2656 
    """
2981 rajveer 2657 
    Returns list of item ids in myresearch for the user
2658 
 
559 chandransh 2659 
    Parameters:
772 rajveer 2660 
     - userId
559 chandransh 2661 
    """
2981 rajveer 2662 
    self.send_getMyResearchItems(userId)
2663 
    return self.recv_getMyResearchItems()
559 chandransh 2664 
 
2981 rajveer 2665 
  def send_getMyResearchItems(self, userId):
2666 
    self._oprot.writeMessageBegin('getMyResearchItems', TMessageType.CALL, self._seqid)
2667 
    args = getMyResearchItems_args()
772 rajveer 2668 
    args.userId = userId
559 chandransh 2669 
    args.write(self._oprot)
2670 
    self._oprot.writeMessageEnd()
2671 
    self._oprot.trans.flush()
2672 
 
2981 rajveer 2673 
  def recv_getMyResearchItems(self, ):
559 chandransh 2674 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2675 
    if mtype == TMessageType.EXCEPTION:
2676 
      x = TApplicationException()
2677 
      x.read(self._iprot)
2678 
      self._iprot.readMessageEnd()
2679 
      raise x
2981 rajveer 2680 
    result = getMyResearchItems_result()
559 chandransh 2681 
    result.read(self._iprot)
2682 
    self._iprot.readMessageEnd()
2683 
    if result.success != None:
2684 
      return result.success
2685 
    if result.scx != None:
2686 
      raise result.scx
2981 rajveer 2687 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearchItems failed: unknown result");
559 chandransh 2688 
 
2981 rajveer 2689 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2690 
    """
2981 rajveer 2691 
    add item to my research for a user
2692 
 
559 chandransh 2693 
    Parameters:
2981 rajveer 2694 
     - userId
2695 
     - itemId
559 chandransh 2696 
    """
2981 rajveer 2697 
    self.send_updateMyResearch(userId, itemId)
2698 
    return self.recv_updateMyResearch()
559 chandransh 2699 
 
2981 rajveer 2700 
  def send_updateMyResearch(self, userId, itemId):
2701 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2702 
    args = updateMyResearch_args()
2703 
    args.userId = userId
2704 
    args.itemId = itemId
559 chandransh 2705 
    args.write(self._oprot)
2706 
    self._oprot.writeMessageEnd()
2707 
    self._oprot.trans.flush()
2708 
 
2981 rajveer 2709 
  def recv_updateMyResearch(self, ):
559 chandransh 2710 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2711 
    if mtype == TMessageType.EXCEPTION:
2712 
      x = TApplicationException()
2713 
      x.read(self._iprot)
2714 
      self._iprot.readMessageEnd()
2715 
      raise x
2981 rajveer 2716 
    result = updateMyResearch_result()
559 chandransh 2717 
    result.read(self._iprot)
2718 
    self._iprot.readMessageEnd()
2981 rajveer 2719 
    if result.success != None:
2720 
      return result.success
2721 
    if result.scx != None:
2722 
      raise result.scx
2723 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
559 chandransh 2724 
 
2981 rajveer 2725 
  def deleteItemFromMyResearch(self, userId, itemId):
1596 ankur.sing 2726 
    """
2981 rajveer 2727 
    delete item from my research for a user
1596 ankur.sing 2728 
 
2729 
    Parameters:
2981 rajveer 2730 
     - userId
2731 
     - itemId
1596 ankur.sing 2732 
    """
2981 rajveer 2733 
    self.send_deleteItemFromMyResearch(userId, itemId)
2734 
    self.recv_deleteItemFromMyResearch()
559 chandransh 2735 
 
2981 rajveer 2736 
  def send_deleteItemFromMyResearch(self, userId, itemId):
2737 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2738 
    args = deleteItemFromMyResearch_args()
2739 
    args.userId = userId
2740 
    args.itemId = itemId
1596 ankur.sing 2741 
    args.write(self._oprot)
2742 
    self._oprot.writeMessageEnd()
2743 
    self._oprot.trans.flush()
2744 
 
2981 rajveer 2745 
  def recv_deleteItemFromMyResearch(self, ):
1596 ankur.sing 2746 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2747 
    if mtype == TMessageType.EXCEPTION:
2748 
      x = TApplicationException()
2749 
      x.read(self._iprot)
2750 
      self._iprot.readMessageEnd()
2751 
      raise x
2981 rajveer 2752 
    result = deleteItemFromMyResearch_result()
1596 ankur.sing 2753 
    result.read(self._iprot)
2754 
    self._iprot.readMessageEnd()
2981 rajveer 2755 
    if result.scx != None:
2756 
      raise result.scx
2757 
    return
1596 ankur.sing 2758 
 
2981 rajveer 2759 
  def getBrowseHistoryItems(self, userId):
1673 ankur.sing 2760 
    """
2981 rajveer 2761 
    Returns list of item ids in browse history for the user. It will return maximum 10 items.
1673 ankur.sing 2762 
 
2763 
    Parameters:
2981 rajveer 2764 
     - userId
1673 ankur.sing 2765 
    """
2981 rajveer 2766 
    self.send_getBrowseHistoryItems(userId)
2767 
    return self.recv_getBrowseHistoryItems()
1596 ankur.sing 2768 
 
2981 rajveer 2769 
  def send_getBrowseHistoryItems(self, userId):
2770 
    self._oprot.writeMessageBegin('getBrowseHistoryItems', TMessageType.CALL, self._seqid)
2771 
    args = getBrowseHistoryItems_args()
2772 
    args.userId = userId
1673 ankur.sing 2773 
    args.write(self._oprot)
2774 
    self._oprot.writeMessageEnd()
2775 
    self._oprot.trans.flush()
2776 
 
2981 rajveer 2777 
  def recv_getBrowseHistoryItems(self, ):
1673 ankur.sing 2778 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2779 
    if mtype == TMessageType.EXCEPTION:
2780 
      x = TApplicationException()
2781 
      x.read(self._iprot)
2782 
      self._iprot.readMessageEnd()
2783 
      raise x
2981 rajveer 2784 
    result = getBrowseHistoryItems_result()
1673 ankur.sing 2785 
    result.read(self._iprot)
2786 
    self._iprot.readMessageEnd()
2787 
    if result.success != None:
2788 
      return result.success
2981 rajveer 2789 
    if result.scx != None:
2790 
      raise result.scx
2791 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistoryItems failed: unknown result");
1673 ankur.sing 2792 
 
2981 rajveer 2793 
  def updateBrowseHistory(self, userId, itemId):
2642 varun.gupt 2794 
    """
2981 rajveer 2795 
    add item to browse history for a user
2642 varun.gupt 2796 
 
2797 
    Parameters:
2981 rajveer 2798 
     - userId
2799 
     - itemId
2642 varun.gupt 2800 
    """
2981 rajveer 2801 
    self.send_updateBrowseHistory(userId, itemId)
2802 
    self.recv_updateBrowseHistory()
1673 ankur.sing 2803 
 
2981 rajveer 2804 
  def send_updateBrowseHistory(self, userId, itemId):
2805 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2806 
    args = updateBrowseHistory_args()
2807 
    args.userId = userId
2808 
    args.itemId = itemId
2642 varun.gupt 2809 
    args.write(self._oprot)
2810 
    self._oprot.writeMessageEnd()
2811 
    self._oprot.trans.flush()
2812 
 
2981 rajveer 2813 
  def recv_updateBrowseHistory(self, ):
2642 varun.gupt 2814 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2815 
    if mtype == TMessageType.EXCEPTION:
2816 
      x = TApplicationException()
2817 
      x.read(self._iprot)
2818 
      self._iprot.readMessageEnd()
2819 
      raise x
2981 rajveer 2820 
    result = updateBrowseHistory_result()
2642 varun.gupt 2821 
    result.read(self._iprot)
2822 
    self._iprot.readMessageEnd()
2823 
    return
2824 
 
2825 
 
94 ashish 2826 
class Processor(Iface, TProcessor):
2827 
  def __init__(self, handler):
2828 
    self._handler = handler
2829 
    self._processMap = {}
765 rajveer 2830 
    self._processMap["closeSession"] = Processor.process_closeSession
559 chandransh 2831 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
2832 
    self._processMap["getUserById"] = Processor.process_getUserById
1491 vikas 2833 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
559 chandransh 2834 
    self._processMap["createUser"] = Processor.process_createUser
2835 
    self._processMap["updateUser"] = Processor.process_updateUser
2836 
    self._processMap["deleteUser"] = Processor.process_deleteUser
2837 
    self._processMap["getUserState"] = Processor.process_getUserState
122 ashish 2838 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 2839 
    self._processMap["userExists"] = Processor.process_userExists
2840 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
2841 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
2842 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
2843 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 2844 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 2845 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 2846 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 2847 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 2848 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 2849 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 2850 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 2851 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 2852 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
2853 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
2854 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
1845 vikas 2855 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 2856 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 2857 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
2858 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
2859 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
2860 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
2861 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 2862 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 2863 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
2864 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
2865 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 2866 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 2867 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
2868 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 2869 
    self._processMap["createCart"] = Processor.process_createCart
2870 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
2871 
    self._processMap["getCart"] = Processor.process_getCart
2872 
    self._processMap["getCartsForUser"] = Processor.process_getCartsForUser
2873 
    self._processMap["getCartsByStatus"] = Processor.process_getCartsByStatus
2874 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
2875 
    self._processMap["changeCartStatus"] = Processor.process_changeCartStatus
2876 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
2877 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
2878 
    self._processMap["changeQuantity"] = Processor.process_changeQuantity
2879 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
2880 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
1976 varun.gupt 2881 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
2882 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
690 chandransh 2883 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 2884 
    self._processMap["validateCart"] = Processor.process_validateCart
2885 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 2886 
    self._processMap["checkOut"] = Processor.process_checkOut
2887 
    self._processMap["resetCart"] = Processor.process_resetCart
1596 ankur.sing 2888 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 2889 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2642 varun.gupt 2890 
    self._processMap["putUserNote"] = Processor.process_putUserNote
2891 
    self._processMap["getUserNotes"] = Processor.process_getUserNotes
2981 rajveer 2892 
    self._processMap["getMyResearchItems"] = Processor.process_getMyResearchItems
2893 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
2894 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
2895 
    self._processMap["getBrowseHistoryItems"] = Processor.process_getBrowseHistoryItems
2896 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
94 ashish 2897 
 
2898 
  def process(self, iprot, oprot):
2899 
    (name, type, seqid) = iprot.readMessageBegin()
2900 
    if name not in self._processMap:
2901 
      iprot.skip(TType.STRUCT)
2902 
      iprot.readMessageEnd()
2903 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
2904 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
2905 
      x.write(oprot)
2906 
      oprot.writeMessageEnd()
2907 
      oprot.trans.flush()
2908 
      return
2909 
    else:
2910 
      self._processMap[name](self, seqid, iprot, oprot)
2911 
    return True
2912 
 
765 rajveer 2913 
  def process_closeSession(self, seqid, iprot, oprot):
2914 
    args = closeSession_args()
2915 
    args.read(iprot)
2916 
    iprot.readMessageEnd()
2917 
    result = closeSession_result()
2918 
    self._handler.closeSession()
2919 
    oprot.writeMessageBegin("closeSession", TMessageType.REPLY, seqid)
2920 
    result.write(oprot)
2921 
    oprot.writeMessageEnd()
2922 
    oprot.trans.flush()
2923 
 
559 chandransh 2924 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
2925 
    args = createAnonymousUser_args()
94 ashish 2926 
    args.read(iprot)
2927 
    iprot.readMessageEnd()
559 chandransh 2928 
    result = createAnonymousUser_result()
94 ashish 2929 
    try:
559 chandransh 2930 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
2931 
    except UserContextException, ucex:
2932 
      result.ucex = ucex
2933 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 2934 
    result.write(oprot)
2935 
    oprot.writeMessageEnd()
2936 
    oprot.trans.flush()
2937 
 
559 chandransh 2938 
  def process_getUserById(self, seqid, iprot, oprot):
2939 
    args = getUserById_args()
94 ashish 2940 
    args.read(iprot)
2941 
    iprot.readMessageEnd()
559 chandransh 2942 
    result = getUserById_result()
94 ashish 2943 
    try:
559 chandransh 2944 
      result.success = self._handler.getUserById(args.userId)
2945 
    except UserContextException, ucex:
2946 
      result.ucex = ucex
2947 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 2948 
    result.write(oprot)
2949 
    oprot.writeMessageEnd()
2950 
    oprot.trans.flush()
2951 
 
1491 vikas 2952 
  def process_getUserByEmail(self, seqid, iprot, oprot):
2953 
    args = getUserByEmail_args()
2954 
    args.read(iprot)
2955 
    iprot.readMessageEnd()
2956 
    result = getUserByEmail_result()
2957 
    try:
2958 
      result.success = self._handler.getUserByEmail(args.email)
2959 
    except UserContextException, ucex:
2960 
      result.ucex = ucex
2961 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
2962 
    result.write(oprot)
2963 
    oprot.writeMessageEnd()
2964 
    oprot.trans.flush()
2965 
 
559 chandransh 2966 
  def process_createUser(self, seqid, iprot, oprot):
2967 
    args = createUser_args()
94 ashish 2968 
    args.read(iprot)
2969 
    iprot.readMessageEnd()
559 chandransh 2970 
    result = createUser_result()
94 ashish 2971 
    try:
559 chandransh 2972 
      result.success = self._handler.createUser(args.user)
2973 
    except UserContextException, ucex:
2974 
      result.ucex = ucex
2975 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 2976 
    result.write(oprot)
2977 
    oprot.writeMessageEnd()
2978 
    oprot.trans.flush()
2979 
 
559 chandransh 2980 
  def process_updateUser(self, seqid, iprot, oprot):
2981 
    args = updateUser_args()
94 ashish 2982 
    args.read(iprot)
2983 
    iprot.readMessageEnd()
559 chandransh 2984 
    result = updateUser_result()
94 ashish 2985 
    try:
559 chandransh 2986 
      result.success = self._handler.updateUser(args.user)
2987 
    except UserContextException, ucex:
2988 
      result.ucex = ucex
2989 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 2990 
    result.write(oprot)
2991 
    oprot.writeMessageEnd()
2992 
    oprot.trans.flush()
2993 
 
559 chandransh 2994 
  def process_deleteUser(self, seqid, iprot, oprot):
2995 
    args = deleteUser_args()
94 ashish 2996 
    args.read(iprot)
2997 
    iprot.readMessageEnd()
559 chandransh 2998 
    result = deleteUser_result()
94 ashish 2999 
    try:
559 chandransh 3000 
      result.success = self._handler.deleteUser(args.userId)
3001 
    except UserContextException, ucex:
3002 
      result.ucex = ucex
3003 
    oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
94 ashish 3004 
    result.write(oprot)
3005 
    oprot.writeMessageEnd()
3006 
    oprot.trans.flush()
3007 
 
559 chandransh 3008 
  def process_getUserState(self, seqid, iprot, oprot):
3009 
    args = getUserState_args()
94 ashish 3010 
    args.read(iprot)
3011 
    iprot.readMessageEnd()
559 chandransh 3012 
    result = getUserState_result()
94 ashish 3013 
    try:
559 chandransh 3014 
      result.success = self._handler.getUserState(args.userId)
3015 
    except UserContextException, ucex:
3016 
      result.ucex = ucex
3017 
    oprot.writeMessageBegin("getUserState", TMessageType.REPLY, seqid)
94 ashish 3018 
    result.write(oprot)
3019 
    oprot.writeMessageEnd()
3020 
    oprot.trans.flush()
3021 
 
122 ashish 3022 
  def process_authenticateUser(self, seqid, iprot, oprot):
3023 
    args = authenticateUser_args()
3024 
    args.read(iprot)
3025 
    iprot.readMessageEnd()
3026 
    result = authenticateUser_result()
3027 
    try:
559 chandransh 3028 
      result.success = self._handler.authenticateUser(args.email, args.password)
3029 
    except AuthenticationException, auex:
3030 
      result.auex = auex
122 ashish 3031 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
3032 
    result.write(oprot)
3033 
    oprot.writeMessageEnd()
3034 
    oprot.trans.flush()
3035 
 
94 ashish 3036 
  def process_userExists(self, seqid, iprot, oprot):
3037 
    args = userExists_args()
3038 
    args.read(iprot)
3039 
    iprot.readMessageEnd()
3040 
    result = userExists_result()
3041 
    try:
3042 
      result.success = self._handler.userExists(args.email)
3043 
    except UserContextException, ucx:
3044 
      result.ucx = ucx
3045 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
3046 
    result.write(oprot)
3047 
    oprot.writeMessageEnd()
3048 
    oprot.trans.flush()
3049 
 
3050 
  def process_addAddressForUser(self, seqid, iprot, oprot):
3051 
    args = addAddressForUser_args()
3052 
    args.read(iprot)
3053 
    iprot.readMessageEnd()
3054 
    result = addAddressForUser_result()
3055 
    try:
567 rajveer 3056 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 3057 
    except UserContextException, ucx:
3058 
      result.ucx = ucx
3059 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
3060 
    result.write(oprot)
3061 
    oprot.writeMessageEnd()
3062 
    oprot.trans.flush()
3063 
 
3064 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
3065 
    args = removeAddressForUser_args()
3066 
    args.read(iprot)
3067 
    iprot.readMessageEnd()
3068 
    result = removeAddressForUser_result()
3069 
    try:
3070 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
3071 
    except UserContextException, ucx:
3072 
      result.ucx = ucx
3073 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
3074 
    result.write(oprot)
3075 
    oprot.writeMessageEnd()
3076 
    oprot.trans.flush()
3077 
 
3078 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
3079 
    args = setUserAsLoggedIn_args()
3080 
    args.read(iprot)
3081 
    iprot.readMessageEnd()
3082 
    result = setUserAsLoggedIn_result()
3083 
    try:
3084 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
3085 
    except UserContextException, ucx:
3086 
      result.ucx = ucx
3087 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
3088 
    result.write(oprot)
3089 
    oprot.writeMessageEnd()
3090 
    oprot.trans.flush()
3091 
 
3092 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
3093 
    args = setUserAsLoggedOut_args()
3094 
    args.read(iprot)
3095 
    iprot.readMessageEnd()
3096 
    result = setUserAsLoggedOut_result()
3097 
    try:
3098 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
3099 
    except UserContextException, ucx:
3100 
      result.ucx = ucx
3101 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
3102 
    result.write(oprot)
3103 
    oprot.writeMessageEnd()
3104 
    oprot.trans.flush()
3105 
 
504 rajveer 3106 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
3107 
    args = setDefaultAddress_args()
3108 
    args.read(iprot)
3109 
    iprot.readMessageEnd()
3110 
    result = setDefaultAddress_result()
3111 
    try:
3112 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
3113 
    except UserContextException, ucx:
3114 
      result.ucx = ucx
3115 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
3116 
    result.write(oprot)
3117 
    oprot.writeMessageEnd()
3118 
    oprot.trans.flush()
3119 
 
94 ashish 3120 
  def process_updatePassword(self, seqid, iprot, oprot):
3121 
    args = updatePassword_args()
3122 
    args.read(iprot)
3123 
    iprot.readMessageEnd()
3124 
    result = updatePassword_result()
3125 
    try:
594 rajveer 3126 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 3127 
    except UserContextException, ucx:
3128 
      result.ucx = ucx
3129 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
3130 
    result.write(oprot)
3131 
    oprot.writeMessageEnd()
3132 
    oprot.trans.flush()
3133 
 
581 rajveer 3134 
  def process_forgotPassword(self, seqid, iprot, oprot):
3135 
    args = forgotPassword_args()
3136 
    args.read(iprot)
3137 
    iprot.readMessageEnd()
3138 
    result = forgotPassword_result()
3139 
    try:
884 rajveer 3140 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 3141 
    except UserContextException, ucx:
3142 
      result.ucx = ucx
3143 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
3144 
    result.write(oprot)
3145 
    oprot.writeMessageEnd()
3146 
    oprot.trans.flush()
3147 
 
594 rajveer 3148 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
3149 
    args = getAllAddressesForUser_args()
3150 
    args.read(iprot)
3151 
    iprot.readMessageEnd()
3152 
    result = getAllAddressesForUser_result()
3153 
    try:
3154 
      result.success = self._handler.getAllAddressesForUser(args.userId)
3155 
    except UserContextException, ucx:
3156 
      result.ucx = ucx
3157 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
3158 
    result.write(oprot)
3159 
    oprot.writeMessageEnd()
3160 
    oprot.trans.flush()
3161 
 
1894 vikas 3162 
  def process_getAddressById(self, seqid, iprot, oprot):
3163 
    args = getAddressById_args()
3164 
    args.read(iprot)
3165 
    iprot.readMessageEnd()
3166 
    result = getAddressById_result()
3167 
    try:
3168 
      result.success = self._handler.getAddressById(args.addressId)
3169 
    except UserContextException, ucx:
3170 
      result.ucx = ucx
3171 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
3172 
    result.write(oprot)
3173 
    oprot.writeMessageEnd()
3174 
    oprot.trans.flush()
3175 
 
594 rajveer 3176 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
3177 
    args = getDefaultAddressId_args()
3178 
    args.read(iprot)
3179 
    iprot.readMessageEnd()
3180 
    result = getDefaultAddressId_result()
3181 
    try:
3182 
      result.success = self._handler.getDefaultAddressId(args.userId)
3183 
    except UserContextException, ucx:
3184 
      result.ucx = ucx
3185 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
3186 
    result.write(oprot)
3187 
    oprot.writeMessageEnd()
3188 
    oprot.trans.flush()
3189 
 
785 rajveer 3190 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
3191 
    args = getDefaultPincode_args()
3192 
    args.read(iprot)
3193 
    iprot.readMessageEnd()
3194 
    result = getDefaultPincode_result()
3195 
    try:
3196 
      result.success = self._handler.getDefaultPincode(args.userId)
3197 
    except UserContextException, ucx:
3198 
      result.ucx = ucx
3199 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
3200 
    result.write(oprot)
3201 
    oprot.writeMessageEnd()
3202 
    oprot.trans.flush()
3203 
 
1274 varun.gupt 3204 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
3205 
    args = saveUserCommunication_args()
3206 
    args.read(iprot)
3207 
    iprot.readMessageEnd()
3208 
    result = saveUserCommunication_result()
3209 
    try:
3210 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
3211 
    except UserCommunicationException, ucx:
3212 
      result.ucx = ucx
3213 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
3214 
    result.write(oprot)
3215 
    oprot.writeMessageEnd()
3216 
    oprot.trans.flush()
3217 
 
1590 varun.gupt 3218 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
3219 
    args = getUserCommunicationById_args()
3220 
    args.read(iprot)
3221 
    iprot.readMessageEnd()
3222 
    result = getUserCommunicationById_result()
3223 
    try:
3224 
      result.success = self._handler.getUserCommunicationById(args.id)
3225 
    except UserCommunicationException, ucx:
3226 
      result.ucx = ucx
3227 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
3228 
    result.write(oprot)
3229 
    oprot.writeMessageEnd()
3230 
    oprot.trans.flush()
3231 
 
3232 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
3233 
    args = getUserCommunicationByUser_args()
3234 
    args.read(iprot)
3235 
    iprot.readMessageEnd()
3236 
    result = getUserCommunicationByUser_result()
3237 
    try:
3238 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
3239 
    except UserCommunicationException, ucx:
3240 
      result.ucx = ucx
3241 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
3242 
    result.write(oprot)
3243 
    oprot.writeMessageEnd()
3244 
    oprot.trans.flush()
3245 
 
3246 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
3247 
    args = getAllUserCommunications_args()
3248 
    args.read(iprot)
3249 
    iprot.readMessageEnd()
3250 
    result = getAllUserCommunications_result()
3251 
    try:
3252 
      result.success = self._handler.getAllUserCommunications()
3253 
    except UserCommunicationException, ucx:
3254 
      result.ucx = ucx
3255 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
3256 
    result.write(oprot)
3257 
    oprot.writeMessageEnd()
3258 
    oprot.trans.flush()
3259 
 
1845 vikas 3260 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
3261 
    args = createMasterAffiliate_args()
3262 
    args.read(iprot)
3263 
    iprot.readMessageEnd()
3264 
    result = createMasterAffiliate_result()
3265 
    try:
1859 vikas 3266 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 3267 
    except UserAffiliateException, utx:
1845 vikas 3268 
      result.utx = utx
3269 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
3270 
    result.write(oprot)
3271 
    oprot.writeMessageEnd()
3272 
    oprot.trans.flush()
3273 
 
1899 vikas 3274 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
3275 
    args = getAllMasterAffiliates_args()
3276 
    args.read(iprot)
3277 
    iprot.readMessageEnd()
3278 
    result = getAllMasterAffiliates_result()
3279 
    try:
3280 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 3281 
    except UserAffiliateException, utx:
1899 vikas 3282 
      result.utx = utx
3283 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
3284 
    result.write(oprot)
3285 
    oprot.writeMessageEnd()
3286 
    oprot.trans.flush()
3287 
 
1845 vikas 3288 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
3289 
    args = getMasterAffiliateById_args()
3290 
    args.read(iprot)
3291 
    iprot.readMessageEnd()
3292 
    result = getMasterAffiliateById_result()
3293 
    try:
3294 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 3295 
    except UserAffiliateException, utx:
1845 vikas 3296 
      result.utx = utx
3297 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
3298 
    result.write(oprot)
3299 
    oprot.writeMessageEnd()
3300 
    oprot.trans.flush()
3301 
 
3302 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
3303 
    args = getMasterAffiliateByName_args()
3304 
    args.read(iprot)
3305 
    iprot.readMessageEnd()
3306 
    result = getMasterAffiliateByName_result()
3307 
    try:
3308 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 3309 
    except UserAffiliateException, utx:
1845 vikas 3310 
      result.utx = utx
3311 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
3312 
    result.write(oprot)
3313 
    oprot.writeMessageEnd()
3314 
    oprot.trans.flush()
3315 
 
3316 
  def process_createAffiliate(self, seqid, iprot, oprot):
3317 
    args = createAffiliate_args()
3318 
    args.read(iprot)
3319 
    iprot.readMessageEnd()
3320 
    result = createAffiliate_result()
3321 
    try:
1859 vikas 3322 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 3323 
    except UserAffiliateException, utx:
1845 vikas 3324 
      result.utx = utx
3325 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
3326 
    result.write(oprot)
3327 
    oprot.writeMessageEnd()
3328 
    oprot.trans.flush()
3329 
 
3330 
  def process_getAffiliateById(self, seqid, iprot, oprot):
3331 
    args = getAffiliateById_args()
3332 
    args.read(iprot)
3333 
    iprot.readMessageEnd()
3334 
    result = getAffiliateById_result()
3335 
    try:
3336 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 3337 
    except UserAffiliateException, utx:
1845 vikas 3338 
      result.utx = utx
3339 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
3340 
    result.write(oprot)
3341 
    oprot.writeMessageEnd()
3342 
    oprot.trans.flush()
3343 
 
3344 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
3345 
    args = getAffiliateByName_args()
3346 
    args.read(iprot)
3347 
    iprot.readMessageEnd()
3348 
    result = getAffiliateByName_result()
3349 
    try:
3350 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 3351 
    except UserAffiliateException, utx:
1845 vikas 3352 
      result.utx = utx
3353 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
3354 
    result.write(oprot)
3355 
    oprot.writeMessageEnd()
3356 
    oprot.trans.flush()
3357 
 
3358 
  def process_getTrackerById(self, seqid, iprot, oprot):
3359 
    args = getTrackerById_args()
3360 
    args.read(iprot)
3361 
    iprot.readMessageEnd()
3362 
    result = getTrackerById_result()
3363 
    try:
1996 vikas 3364 
      result.success = self._handler.getTrackerById(args.id)
3365 
    except UserAffiliateException, utx:
1845 vikas 3366 
      result.utx = utx
3367 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
3368 
    result.write(oprot)
3369 
    oprot.writeMessageEnd()
3370 
    oprot.trans.flush()
3371 
 
1996 vikas 3372 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
3373 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 3374 
    args.read(iprot)
3375 
    iprot.readMessageEnd()
1996 vikas 3376 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 3377 
    try:
1996 vikas 3378 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
3379 
    except UserAffiliateException, utx:
1845 vikas 3380 
      result.utx = utx
1996 vikas 3381 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3382 
    result.write(oprot)
3383 
    oprot.writeMessageEnd()
3384 
    oprot.trans.flush()
3385 
 
3386 
  def process_addTrackLog(self, seqid, iprot, oprot):
3387 
    args = addTrackLog_args()
3388 
    args.read(iprot)
3389 
    iprot.readMessageEnd()
3390 
    result = addTrackLog_result()
3391 
    try:
1996 vikas 3392 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
3393 
    except UserAffiliateException, utx:
1845 vikas 3394 
      result.utx = utx
3395 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
3396 
    result.write(oprot)
3397 
    oprot.writeMessageEnd()
3398 
    oprot.trans.flush()
3399 
 
3400 
  def process_getTrackLogById(self, seqid, iprot, oprot):
3401 
    args = getTrackLogById_args()
3402 
    args.read(iprot)
3403 
    iprot.readMessageEnd()
3404 
    result = getTrackLogById_result()
3405 
    try:
3406 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 3407 
    except UserAffiliateException, utx:
1845 vikas 3408 
      result.utx = utx
3409 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
3410 
    result.write(oprot)
3411 
    oprot.writeMessageEnd()
3412 
    oprot.trans.flush()
3413 
 
1996 vikas 3414 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
3415 
    args = getTrackLogsByAffiliate_args()
1845 vikas 3416 
    args.read(iprot)
3417 
    iprot.readMessageEnd()
1996 vikas 3418 
    result = getTrackLogsByAffiliate_result()
1845 vikas 3419 
    try:
1996 vikas 3420 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId)
3421 
    except UserAffiliateException, utx:
1845 vikas 3422 
      result.utx = utx
1996 vikas 3423 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3424 
    result.write(oprot)
3425 
    oprot.writeMessageEnd()
3426 
    oprot.trans.flush()
3427 
 
3428 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
3429 
    args = getTrackLogsByUser_args()
3430 
    args.read(iprot)
3431 
    iprot.readMessageEnd()
3432 
    result = getTrackLogsByUser_result()
3433 
    try:
3434 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 3435 
    except UserAffiliateException, utx:
1845 vikas 3436 
      result.utx = utx
3437 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
3438 
    result.write(oprot)
3439 
    oprot.writeMessageEnd()
3440 
    oprot.trans.flush()
3441 
 
3442 
  def process_getTrackLogs(self, seqid, iprot, oprot):
3443 
    args = getTrackLogs_args()
3444 
    args.read(iprot)
3445 
    iprot.readMessageEnd()
3446 
    result = getTrackLogs_result()
3447 
    try:
1996 vikas 3448 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
3449 
    except UserAffiliateException, utx:
1845 vikas 3450 
      result.utx = utx
3451 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
3452 
    result.write(oprot)
3453 
    oprot.writeMessageEnd()
3454 
    oprot.trans.flush()
3455 
 
559 chandransh 3456 
  def process_createCart(self, seqid, iprot, oprot):
3457 
    args = createCart_args()
94 ashish 3458 
    args.read(iprot)
3459 
    iprot.readMessageEnd()
559 chandransh 3460 
    result = createCart_result()
94 ashish 3461 
    try:
559 chandransh 3462 
      result.success = self._handler.createCart(args.userId)
3463 
    except ShoppingCartException, scx:
3464 
      result.scx = scx
3465 
    oprot.writeMessageBegin("createCart", TMessageType.REPLY, seqid)
94 ashish 3466 
    result.write(oprot)
3467 
    oprot.writeMessageEnd()
3468 
    oprot.trans.flush()
3469 
 
559 chandransh 3470 
  def process_getCurrentCart(self, seqid, iprot, oprot):
3471 
    args = getCurrentCart_args()
94 ashish 3472 
    args.read(iprot)
3473 
    iprot.readMessageEnd()
559 chandransh 3474 
    result = getCurrentCart_result()
94 ashish 3475 
    try:
559 chandransh 3476 
      result.success = self._handler.getCurrentCart(args.userId)
3477 
    except ShoppingCartException, scx:
3478 
      result.scx = scx
3479 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 3480 
    result.write(oprot)
3481 
    oprot.writeMessageEnd()
3482 
    oprot.trans.flush()
3483 
 
559 chandransh 3484 
  def process_getCart(self, seqid, iprot, oprot):
3485 
    args = getCart_args()
94 ashish 3486 
    args.read(iprot)
3487 
    iprot.readMessageEnd()
559 chandransh 3488 
    result = getCart_result()
94 ashish 3489 
    try:
559 chandransh 3490 
      result.success = self._handler.getCart(args.cartId)
3491 
    except ShoppingCartException, scx:
3492 
      result.scx = scx
3493 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 3494 
    result.write(oprot)
3495 
    oprot.writeMessageEnd()
3496 
    oprot.trans.flush()
3497 
 
559 chandransh 3498 
  def process_getCartsForUser(self, seqid, iprot, oprot):
3499 
    args = getCartsForUser_args()
94 ashish 3500 
    args.read(iprot)
3501 
    iprot.readMessageEnd()
559 chandransh 3502 
    result = getCartsForUser_result()
94 ashish 3503 
    try:
559 chandransh 3504 
      result.success = self._handler.getCartsForUser(args.userId, args.status)
3505 
    except ShoppingCartException, scx:
3506 
      result.scx = scx
3507 
    oprot.writeMessageBegin("getCartsForUser", TMessageType.REPLY, seqid)
94 ashish 3508 
    result.write(oprot)
3509 
    oprot.writeMessageEnd()
3510 
    oprot.trans.flush()
3511 
 
559 chandransh 3512 
  def process_getCartsByStatus(self, seqid, iprot, oprot):
3513 
    args = getCartsByStatus_args()
94 ashish 3514 
    args.read(iprot)
3515 
    iprot.readMessageEnd()
559 chandransh 3516 
    result = getCartsByStatus_result()
94 ashish 3517 
    try:
559 chandransh 3518 
      result.success = self._handler.getCartsByStatus(args.status)
3519 
    except ShoppingCartException, scx:
3520 
      result.scx = scx
3521 
    oprot.writeMessageBegin("getCartsByStatus", TMessageType.REPLY, seqid)
94 ashish 3522 
    result.write(oprot)
3523 
    oprot.writeMessageEnd()
3524 
    oprot.trans.flush()
3525 
 
559 chandransh 3526 
  def process_getCartsByTime(self, seqid, iprot, oprot):
3527 
    args = getCartsByTime_args()
94 ashish 3528 
    args.read(iprot)
3529 
    iprot.readMessageEnd()
559 chandransh 3530 
    result = getCartsByTime_result()
94 ashish 3531 
    try:
559 chandransh 3532 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
3533 
    except ShoppingCartException, scx:
3534 
      result.scx = scx
3535 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 3536 
    result.write(oprot)
3537 
    oprot.writeMessageEnd()
3538 
    oprot.trans.flush()
3539 
 
559 chandransh 3540 
  def process_changeCartStatus(self, seqid, iprot, oprot):
3541 
    args = changeCartStatus_args()
130 ashish 3542 
    args.read(iprot)
3543 
    iprot.readMessageEnd()
559 chandransh 3544 
    result = changeCartStatus_result()
130 ashish 3545 
    try:
559 chandransh 3546 
      self._handler.changeCartStatus(args.cartId, args.status)
3547 
    except ShoppingCartException, scx:
3548 
      result.scx = scx
3549 
    oprot.writeMessageBegin("changeCartStatus", TMessageType.REPLY, seqid)
130 ashish 3550 
    result.write(oprot)
3551 
    oprot.writeMessageEnd()
3552 
    oprot.trans.flush()
94 ashish 3553 
 
559 chandransh 3554 
  def process_addItemToCart(self, seqid, iprot, oprot):
3555 
    args = addItemToCart_args()
130 ashish 3556 
    args.read(iprot)
3557 
    iprot.readMessageEnd()
559 chandransh 3558 
    result = addItemToCart_result()
130 ashish 3559 
    try:
2035 rajveer 3560 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity)
559 chandransh 3561 
    except ShoppingCartException, scx:
3562 
      result.scx = scx
3563 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 3564 
    result.write(oprot)
3565 
    oprot.writeMessageEnd()
3566 
    oprot.trans.flush()
3567 
 
559 chandransh 3568 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
3569 
    args = deleteItemFromCart_args()
3570 
    args.read(iprot)
3571 
    iprot.readMessageEnd()
3572 
    result = deleteItemFromCart_result()
3573 
    try:
3574 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
3575 
    except ShoppingCartException, scx:
3576 
      result.scx = scx
3577 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
3578 
    result.write(oprot)
3579 
    oprot.writeMessageEnd()
3580 
    oprot.trans.flush()
130 ashish 3581 
 
559 chandransh 3582 
  def process_changeQuantity(self, seqid, iprot, oprot):
3583 
    args = changeQuantity_args()
3584 
    args.read(iprot)
3585 
    iprot.readMessageEnd()
3586 
    result = changeQuantity_result()
3587 
    try:
3588 
      self._handler.changeQuantity(args.cartId, args.itemId, args.quantity)
3589 
    except ShoppingCartException, scx:
3590 
      result.scx = scx
3591 
    oprot.writeMessageBegin("changeQuantity", TMessageType.REPLY, seqid)
3592 
    result.write(oprot)
3593 
    oprot.writeMessageEnd()
3594 
    oprot.trans.flush()
3595 
 
3596 
  def process_changeItemStatus(self, seqid, iprot, oprot):
3597 
    args = changeItemStatus_args()
3598 
    args.read(iprot)
3599 
    iprot.readMessageEnd()
3600 
    result = changeItemStatus_result()
3601 
    try:
3602 
      self._handler.changeItemStatus(args.cartId, args.itemId, args.status)
3603 
    except ShoppingCartException, scx:
3604 
      result.scx = scx
3605 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
3606 
    result.write(oprot)
3607 
    oprot.writeMessageEnd()
3608 
    oprot.trans.flush()
3609 
 
3610 
  def process_addAddressToCart(self, seqid, iprot, oprot):
3611 
    args = addAddressToCart_args()
3612 
    args.read(iprot)
3613 
    iprot.readMessageEnd()
3614 
    result = addAddressToCart_result()
575 chandransh 3615 
    try:
3616 
      self._handler.addAddressToCart(args.cartId, args.addressId)
3617 
    except ShoppingCartException, scx:
3618 
      result.scx = scx
559 chandransh 3619 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
3620 
    result.write(oprot)
3621 
    oprot.writeMessageEnd()
3622 
    oprot.trans.flush()
3623 
 
1976 varun.gupt 3624 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
3625 
    args = applyCouponToCart_args()
3626 
    args.read(iprot)
3627 
    iprot.readMessageEnd()
3628 
    result = applyCouponToCart_result()
3629 
    try:
3630 
      self._handler.applyCouponToCart(args.cartId, args.couponCode, args.totalPrice, args.discountedPrice)
3631 
    except ShoppingCartException, scx:
3632 
      result.scx = scx
3633 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
3634 
    result.write(oprot)
3635 
    oprot.writeMessageEnd()
3636 
    oprot.trans.flush()
3637 
 
3638 
  def process_removeCoupon(self, seqid, iprot, oprot):
3639 
    args = removeCoupon_args()
3640 
    args.read(iprot)
3641 
    iprot.readMessageEnd()
3642 
    result = removeCoupon_result()
3643 
    try:
3644 
      self._handler.removeCoupon(args.cartId)
3645 
    except ShoppingCartException, scx:
3646 
      result.scx = scx
3647 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
3648 
    result.write(oprot)
3649 
    oprot.writeMessageEnd()
3650 
    oprot.trans.flush()
3651 
 
690 chandransh 3652 
  def process_createOrders(self, seqid, iprot, oprot):
3653 
    args = createOrders_args()
559 chandransh 3654 
    args.read(iprot)
3655 
    iprot.readMessageEnd()
690 chandransh 3656 
    result = createOrders_result()
559 chandransh 3657 
    try:
2815 vikas 3658 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime)
559 chandransh 3659 
    except ShoppingCartException, scx:
3660 
      result.scx = scx
690 chandransh 3661 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 3662 
    result.write(oprot)
3663 
    oprot.writeMessageEnd()
3664 
    oprot.trans.flush()
3665 
 
3666 
  def process_validateCart(self, seqid, iprot, oprot):
3667 
    args = validateCart_args()
3668 
    args.read(iprot)
3669 
    iprot.readMessageEnd()
3670 
    result = validateCart_result()
575 chandransh 3671 
    try:
3672 
      result.success = self._handler.validateCart(args.cartId)
3673 
    except ShoppingCartException, scex:
3674 
      result.scex = scex
559 chandransh 3675 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
3676 
    result.write(oprot)
3677 
    oprot.writeMessageEnd()
3678 
    oprot.trans.flush()
3679 
 
690 chandransh 3680 
  def process_mergeCart(self, seqid, iprot, oprot):
3681 
    args = mergeCart_args()
575 chandransh 3682 
    args.read(iprot)
3683 
    iprot.readMessageEnd()
690 chandransh 3684 
    result = mergeCart_result()
3685 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
3686 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
3687 
    result.write(oprot)
3688 
    oprot.writeMessageEnd()
3689 
    oprot.trans.flush()
3690 
 
3691 
  def process_checkOut(self, seqid, iprot, oprot):
3692 
    args = checkOut_args()
3693 
    args.read(iprot)
3694 
    iprot.readMessageEnd()
3695 
    result = checkOut_result()
575 chandransh 3696 
    try:
690 chandransh 3697 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 3698 
    except ShoppingCartException, scex:
3699 
      result.scex = scex
690 chandransh 3700 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 3701 
    result.write(oprot)
3702 
    oprot.writeMessageEnd()
3703 
    oprot.trans.flush()
3704 
 
690 chandransh 3705 
  def process_resetCart(self, seqid, iprot, oprot):
3706 
    args = resetCart_args()
559 chandransh 3707 
    args.read(iprot)
3708 
    iprot.readMessageEnd()
690 chandransh 3709 
    result = resetCart_result()
3710 
    try:
3711 
      result.success = self._handler.resetCart(args.cartId, args.items)
3712 
    except ShoppingCartException, scex:
3713 
      result.scex = scex
3714 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 3715 
    result.write(oprot)
3716 
    oprot.writeMessageEnd()
3717 
    oprot.trans.flush()
3718 
 
2981 rajveer 3719 
  def process_getUserCount(self, seqid, iprot, oprot):
3720 
    args = getUserCount_args()
559 chandransh 3721 
    args.read(iprot)
3722 
    iprot.readMessageEnd()
2981 rajveer 3723 
    result = getUserCount_result()
3724 
    result.success = self._handler.getUserCount(args.userType)
3725 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
559 chandransh 3726 
    result.write(oprot)
3727 
    oprot.writeMessageEnd()
3728 
    oprot.trans.flush()
3729 
 
2981 rajveer 3730 
  def process_getAllUsers(self, seqid, iprot, oprot):
3731 
    args = getAllUsers_args()
559 chandransh 3732 
    args.read(iprot)
3733 
    iprot.readMessageEnd()
2981 rajveer 3734 
    result = getAllUsers_result()
3735 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
3736 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
559 chandransh 3737 
    result.write(oprot)
3738 
    oprot.writeMessageEnd()
3739 
    oprot.trans.flush()
3740 
 
2981 rajveer 3741 
  def process_putUserNote(self, seqid, iprot, oprot):
3742 
    args = putUserNote_args()
559 chandransh 3743 
    args.read(iprot)
3744 
    iprot.readMessageEnd()
2981 rajveer 3745 
    result = putUserNote_result()
3746 
    self._handler.putUserNote(args.user_id, args.entity_id, args.slide, args.note)
3747 
    oprot.writeMessageBegin("putUserNote", TMessageType.REPLY, seqid)
559 chandransh 3748 
    result.write(oprot)
3749 
    oprot.writeMessageEnd()
3750 
    oprot.trans.flush()
3751 
 
2981 rajveer 3752 
  def process_getUserNotes(self, seqid, iprot, oprot):
3753 
    args = getUserNotes_args()
559 chandransh 3754 
    args.read(iprot)
3755 
    iprot.readMessageEnd()
2981 rajveer 3756 
    result = getUserNotes_result()
3757 
    result.success = self._handler.getUserNotes(args.user_id, args.entity_id)
3758 
    oprot.writeMessageBegin("getUserNotes", TMessageType.REPLY, seqid)
559 chandransh 3759 
    result.write(oprot)
3760 
    oprot.writeMessageEnd()
3761 
    oprot.trans.flush()
3762 
 
2981 rajveer 3763 
  def process_getMyResearchItems(self, seqid, iprot, oprot):
3764 
    args = getMyResearchItems_args()
559 chandransh 3765 
    args.read(iprot)
3766 
    iprot.readMessageEnd()
2981 rajveer 3767 
    result = getMyResearchItems_result()
559 chandransh 3768 
    try:
2981 rajveer 3769 
      result.success = self._handler.getMyResearchItems(args.userId)
559 chandransh 3770 
    except WidgetException, scx:
3771 
      result.scx = scx
2981 rajveer 3772 
    oprot.writeMessageBegin("getMyResearchItems", TMessageType.REPLY, seqid)
559 chandransh 3773 
    result.write(oprot)
3774 
    oprot.writeMessageEnd()
3775 
    oprot.trans.flush()
3776 
 
2981 rajveer 3777 
  def process_updateMyResearch(self, seqid, iprot, oprot):
3778 
    args = updateMyResearch_args()
772 rajveer 3779 
    args.read(iprot)
3780 
    iprot.readMessageEnd()
2981 rajveer 3781 
    result = updateMyResearch_result()
3782 
    try:
3783 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
3784 
    except WidgetException, scx:
3785 
      result.scx = scx
3786 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
772 rajveer 3787 
    result.write(oprot)
3788 
    oprot.writeMessageEnd()
3789 
    oprot.trans.flush()
559 chandransh 3790 
 
2981 rajveer 3791 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
3792 
    args = deleteItemFromMyResearch_args()
1596 ankur.sing 3793 
    args.read(iprot)
3794 
    iprot.readMessageEnd()
2981 rajveer 3795 
    result = deleteItemFromMyResearch_result()
3796 
    try:
3797 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
3798 
    except WidgetException, scx:
3799 
      result.scx = scx
3800 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
1596 ankur.sing 3801 
    result.write(oprot)
3802 
    oprot.writeMessageEnd()
3803 
    oprot.trans.flush()
772 rajveer 3804 
 
2981 rajveer 3805 
  def process_getBrowseHistoryItems(self, seqid, iprot, oprot):
3806 
    args = getBrowseHistoryItems_args()
1673 ankur.sing 3807 
    args.read(iprot)
3808 
    iprot.readMessageEnd()
2981 rajveer 3809 
    result = getBrowseHistoryItems_result()
3810 
    try:
3811 
      result.success = self._handler.getBrowseHistoryItems(args.userId)
3812 
    except WidgetException, scx:
3813 
      result.scx = scx
3814 
    oprot.writeMessageBegin("getBrowseHistoryItems", TMessageType.REPLY, seqid)
1673 ankur.sing 3815 
    result.write(oprot)
3816 
    oprot.writeMessageEnd()
3817 
    oprot.trans.flush()
1596 ankur.sing 3818 
 
2981 rajveer 3819 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
3820 
    args = updateBrowseHistory_args()
2642 varun.gupt 3821 
    args.read(iprot)
3822 
    iprot.readMessageEnd()
2981 rajveer 3823 
    result = updateBrowseHistory_result()
3824 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
3825 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
2642 varun.gupt 3826 
    result.write(oprot)
3827 
    oprot.writeMessageEnd()
3828 
    oprot.trans.flush()
1673 ankur.sing 3829 
 
2642 varun.gupt 3830 
 
94 ashish 3831 
# HELPER FUNCTIONS AND STRUCTURES
3832 
 
765 rajveer 3833 
class closeSession_args:
3834 
 
3835 
  thrift_spec = (
3836 
  )
3837 
 
3838 
  def read(self, iprot):
3839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3841 
      return
3842 
    iprot.readStructBegin()
3843 
    while True:
3844 
      (fname, ftype, fid) = iprot.readFieldBegin()
3845 
      if ftype == TType.STOP:
3846 
        break
3847 
      else:
3848 
        iprot.skip(ftype)
3849 
      iprot.readFieldEnd()
3850 
    iprot.readStructEnd()
3851 
 
3852 
  def write(self, oprot):
3853 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3854 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3855 
      return
3856 
    oprot.writeStructBegin('closeSession_args')
3857 
    oprot.writeFieldStop()
3858 
    oprot.writeStructEnd()
3859 
 
3860 
  def __repr__(self):
3861 
    L = ['%s=%r' % (key, value)
3862 
      for key, value in self.__dict__.iteritems()]
3863 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3864 
 
3865 
  def __eq__(self, other):
3866 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3867 
 
3868 
  def __ne__(self, other):
3869 
    return not (self == other)
3870 
 
3871 
class closeSession_result:
3872 
 
3873 
  thrift_spec = (
3874 
  )
3875 
 
3876 
  def read(self, iprot):
3877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3879 
      return
3880 
    iprot.readStructBegin()
3881 
    while True:
3882 
      (fname, ftype, fid) = iprot.readFieldBegin()
3883 
      if ftype == TType.STOP:
3884 
        break
3885 
      else:
3886 
        iprot.skip(ftype)
3887 
      iprot.readFieldEnd()
3888 
    iprot.readStructEnd()
3889 
 
3890 
  def write(self, oprot):
3891 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3892 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3893 
      return
3894 
    oprot.writeStructBegin('closeSession_result')
3895 
    oprot.writeFieldStop()
3896 
    oprot.writeStructEnd()
3897 
 
3898 
  def __repr__(self):
3899 
    L = ['%s=%r' % (key, value)
3900 
      for key, value in self.__dict__.iteritems()]
3901 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3902 
 
3903 
  def __eq__(self, other):
3904 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3905 
 
3906 
  def __ne__(self, other):
3907 
    return not (self == other)
3908 
 
559 chandransh 3909 
class createAnonymousUser_args:
94 ashish 3910 
  """
3911 
  Attributes:
559 chandransh 3912 
   - jsessionId
94 ashish 3913 
  """
3914 
 
3915 
  thrift_spec = (
3916 
    None, # 0
559 chandransh 3917 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 3918 
  )
3919 
 
559 chandransh 3920 
  def __init__(self, jsessionId=None,):
3921 
    self.jsessionId = jsessionId
94 ashish 3922 
 
3923 
  def read(self, iprot):
3924 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3925 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3926 
      return
3927 
    iprot.readStructBegin()
3928 
    while True:
3929 
      (fname, ftype, fid) = iprot.readFieldBegin()
3930 
      if ftype == TType.STOP:
3931 
        break
3932 
      if fid == 1:
559 chandransh 3933 
        if ftype == TType.STRING:
3934 
          self.jsessionId = iprot.readString();
94 ashish 3935 
        else:
3936 
          iprot.skip(ftype)
3937 
      else:
3938 
        iprot.skip(ftype)
3939 
      iprot.readFieldEnd()
3940 
    iprot.readStructEnd()
3941 
 
3942 
  def write(self, oprot):
3943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3945 
      return
559 chandransh 3946 
    oprot.writeStructBegin('createAnonymousUser_args')
3947 
    if self.jsessionId != None:
3948 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
3949 
      oprot.writeString(self.jsessionId)
94 ashish 3950 
      oprot.writeFieldEnd()
3951 
    oprot.writeFieldStop()
3952 
    oprot.writeStructEnd()
3953 
 
3954 
  def __repr__(self):
3955 
    L = ['%s=%r' % (key, value)
3956 
      for key, value in self.__dict__.iteritems()]
3957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3958 
 
3959 
  def __eq__(self, other):
3960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3961 
 
3962 
  def __ne__(self, other):
3963 
    return not (self == other)
3964 
 
559 chandransh 3965 
class createAnonymousUser_result:
94 ashish 3966 
  """
3967 
  Attributes:
3968 
   - success
559 chandransh 3969 
   - ucex
94 ashish 3970 
  """
3971 
 
3972 
  thrift_spec = (
559 chandransh 3973 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
3974 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 3975 
  )
3976 
 
559 chandransh 3977 
  def __init__(self, success=None, ucex=None,):
94 ashish 3978 
    self.success = success
559 chandransh 3979 
    self.ucex = ucex
94 ashish 3980 
 
3981 
  def read(self, iprot):
3982 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3983 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3984 
      return
3985 
    iprot.readStructBegin()
3986 
    while True:
3987 
      (fname, ftype, fid) = iprot.readFieldBegin()
3988 
      if ftype == TType.STOP:
3989 
        break
3990 
      if fid == 0:
3991 
        if ftype == TType.STRUCT:
559 chandransh 3992 
          self.success = User()
94 ashish 3993 
          self.success.read(iprot)
3994 
        else:
3995 
          iprot.skip(ftype)
3996 
      elif fid == 1:
3997 
        if ftype == TType.STRUCT:
559 chandransh 3998 
          self.ucex = UserContextException()
3999 
          self.ucex.read(iprot)
94 ashish 4000 
        else:
4001 
          iprot.skip(ftype)
4002 
      else:
4003 
        iprot.skip(ftype)
4004 
      iprot.readFieldEnd()
4005 
    iprot.readStructEnd()
4006 
 
4007 
  def write(self, oprot):
4008 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4009 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4010 
      return
559 chandransh 4011 
    oprot.writeStructBegin('createAnonymousUser_result')
94 ashish 4012 
    if self.success != None:
4013 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4014 
      self.success.write(oprot)
4015 
      oprot.writeFieldEnd()
559 chandransh 4016 
    if self.ucex != None:
4017 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4018 
      self.ucex.write(oprot)
94 ashish 4019 
      oprot.writeFieldEnd()
4020 
    oprot.writeFieldStop()
4021 
    oprot.writeStructEnd()
4022 
 
4023 
  def __repr__(self):
4024 
    L = ['%s=%r' % (key, value)
4025 
      for key, value in self.__dict__.iteritems()]
4026 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4027 
 
4028 
  def __eq__(self, other):
4029 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4030 
 
4031 
  def __ne__(self, other):
4032 
    return not (self == other)
4033 
 
559 chandransh 4034 
class getUserById_args:
94 ashish 4035 
  """
4036 
  Attributes:
4037 
   - userId
4038 
  """
4039 
 
4040 
  thrift_spec = (
4041 
    None, # 0
4042 
    (1, TType.I64, 'userId', None, None, ), # 1
4043 
  )
4044 
 
559 chandransh 4045 
  def __init__(self, userId=None,):
94 ashish 4046 
    self.userId = userId
4047 
 
4048 
  def read(self, iprot):
4049 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4050 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4051 
      return
4052 
    iprot.readStructBegin()
4053 
    while True:
4054 
      (fname, ftype, fid) = iprot.readFieldBegin()
4055 
      if ftype == TType.STOP:
4056 
        break
4057 
      if fid == 1:
4058 
        if ftype == TType.I64:
4059 
          self.userId = iprot.readI64();
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('getUserById_args')
94 ashish 4072 
    if self.userId != None:
4073 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4074 
      oprot.writeI64(self.userId)
4075 
      oprot.writeFieldEnd()
4076 
    oprot.writeFieldStop()
4077 
    oprot.writeStructEnd()
4078 
 
4079 
  def __repr__(self):
4080 
    L = ['%s=%r' % (key, value)
4081 
      for key, value in self.__dict__.iteritems()]
4082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4083 
 
4084 
  def __eq__(self, other):
4085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4086 
 
4087 
  def __ne__(self, other):
4088 
    return not (self == other)
4089 
 
559 chandransh 4090 
class getUserById_result:
94 ashish 4091 
  """
4092 
  Attributes:
4093 
   - success
559 chandransh 4094 
   - ucex
94 ashish 4095 
  """
4096 
 
4097 
  thrift_spec = (
559 chandransh 4098 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4099 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4100 
  )
4101 
 
559 chandransh 4102 
  def __init__(self, success=None, ucex=None,):
94 ashish 4103 
    self.success = success
559 chandransh 4104 
    self.ucex = ucex
94 ashish 4105 
 
4106 
  def read(self, iprot):
4107 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4108 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4109 
      return
4110 
    iprot.readStructBegin()
4111 
    while True:
4112 
      (fname, ftype, fid) = iprot.readFieldBegin()
4113 
      if ftype == TType.STOP:
4114 
        break
4115 
      if fid == 0:
4116 
        if ftype == TType.STRUCT:
559 chandransh 4117 
          self.success = User()
94 ashish 4118 
          self.success.read(iprot)
4119 
        else:
4120 
          iprot.skip(ftype)
4121 
      elif fid == 1:
4122 
        if ftype == TType.STRUCT:
559 chandransh 4123 
          self.ucex = UserContextException()
4124 
          self.ucex.read(iprot)
94 ashish 4125 
        else:
4126 
          iprot.skip(ftype)
4127 
      else:
4128 
        iprot.skip(ftype)
4129 
      iprot.readFieldEnd()
4130 
    iprot.readStructEnd()
4131 
 
4132 
  def write(self, oprot):
4133 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4134 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4135 
      return
559 chandransh 4136 
    oprot.writeStructBegin('getUserById_result')
94 ashish 4137 
    if self.success != None:
4138 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4139 
      self.success.write(oprot)
4140 
      oprot.writeFieldEnd()
559 chandransh 4141 
    if self.ucex != None:
4142 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4143 
      self.ucex.write(oprot)
94 ashish 4144 
      oprot.writeFieldEnd()
4145 
    oprot.writeFieldStop()
4146 
    oprot.writeStructEnd()
4147 
 
4148 
  def __repr__(self):
4149 
    L = ['%s=%r' % (key, value)
4150 
      for key, value in self.__dict__.iteritems()]
4151 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4152 
 
4153 
  def __eq__(self, other):
4154 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4155 
 
4156 
  def __ne__(self, other):
4157 
    return not (self == other)
4158 
 
1491 vikas 4159 
class getUserByEmail_args:
4160 
  """
4161 
  Attributes:
4162 
   - email
4163 
  """
4164 
 
4165 
  thrift_spec = (
4166 
    None, # 0
4167 
    (1, TType.STRING, 'email', None, None, ), # 1
4168 
  )
4169 
 
4170 
  def __init__(self, email=None,):
4171 
    self.email = email
4172 
 
4173 
  def read(self, iprot):
4174 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4175 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4176 
      return
4177 
    iprot.readStructBegin()
4178 
    while True:
4179 
      (fname, ftype, fid) = iprot.readFieldBegin()
4180 
      if ftype == TType.STOP:
4181 
        break
4182 
      if fid == 1:
4183 
        if ftype == TType.STRING:
4184 
          self.email = iprot.readString();
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
4196 
    oprot.writeStructBegin('getUserByEmail_args')
4197 
    if self.email != None:
4198 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4199 
      oprot.writeString(self.email)
4200 
      oprot.writeFieldEnd()
4201 
    oprot.writeFieldStop()
4202 
    oprot.writeStructEnd()
4203 
 
4204 
  def __repr__(self):
4205 
    L = ['%s=%r' % (key, value)
4206 
      for key, value in self.__dict__.iteritems()]
4207 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4208 
 
4209 
  def __eq__(self, other):
4210 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4211 
 
4212 
  def __ne__(self, other):
4213 
    return not (self == other)
4214 
 
4215 
class getUserByEmail_result:
4216 
  """
4217 
  Attributes:
4218 
   - success
4219 
   - ucex
4220 
  """
4221 
 
4222 
  thrift_spec = (
4223 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4224 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4225 
  )
4226 
 
4227 
  def __init__(self, success=None, ucex=None,):
4228 
    self.success = success
4229 
    self.ucex = ucex
4230 
 
4231 
  def read(self, iprot):
4232 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4233 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4234 
      return
4235 
    iprot.readStructBegin()
4236 
    while True:
4237 
      (fname, ftype, fid) = iprot.readFieldBegin()
4238 
      if ftype == TType.STOP:
4239 
        break
4240 
      if fid == 0:
4241 
        if ftype == TType.STRUCT:
4242 
          self.success = User()
4243 
          self.success.read(iprot)
4244 
        else:
4245 
          iprot.skip(ftype)
4246 
      elif fid == 1:
4247 
        if ftype == TType.STRUCT:
4248 
          self.ucex = UserContextException()
4249 
          self.ucex.read(iprot)
4250 
        else:
4251 
          iprot.skip(ftype)
4252 
      else:
4253 
        iprot.skip(ftype)
4254 
      iprot.readFieldEnd()
4255 
    iprot.readStructEnd()
4256 
 
4257 
  def write(self, oprot):
4258 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4259 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4260 
      return
4261 
    oprot.writeStructBegin('getUserByEmail_result')
4262 
    if self.success != None:
4263 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4264 
      self.success.write(oprot)
4265 
      oprot.writeFieldEnd()
4266 
    if self.ucex != None:
4267 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4268 
      self.ucex.write(oprot)
4269 
      oprot.writeFieldEnd()
4270 
    oprot.writeFieldStop()
4271 
    oprot.writeStructEnd()
4272 
 
4273 
  def __repr__(self):
4274 
    L = ['%s=%r' % (key, value)
4275 
      for key, value in self.__dict__.iteritems()]
4276 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4277 
 
4278 
  def __eq__(self, other):
4279 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4280 
 
4281 
  def __ne__(self, other):
4282 
    return not (self == other)
4283 
 
559 chandransh 4284 
class createUser_args:
94 ashish 4285 
  """
4286 
  Attributes:
559 chandransh 4287 
   - user
94 ashish 4288 
  """
4289 
 
4290 
  thrift_spec = (
4291 
    None, # 0
559 chandransh 4292 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4293 
  )
4294 
 
559 chandransh 4295 
  def __init__(self, user=None,):
4296 
    self.user = user
94 ashish 4297 
 
4298 
  def read(self, iprot):
4299 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4300 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4301 
      return
4302 
    iprot.readStructBegin()
4303 
    while True:
4304 
      (fname, ftype, fid) = iprot.readFieldBegin()
4305 
      if ftype == TType.STOP:
4306 
        break
4307 
      if fid == 1:
559 chandransh 4308 
        if ftype == TType.STRUCT:
4309 
          self.user = User()
4310 
          self.user.read(iprot)
94 ashish 4311 
        else:
4312 
          iprot.skip(ftype)
4313 
      else:
4314 
        iprot.skip(ftype)
4315 
      iprot.readFieldEnd()
4316 
    iprot.readStructEnd()
4317 
 
4318 
  def write(self, oprot):
4319 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4320 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4321 
      return
559 chandransh 4322 
    oprot.writeStructBegin('createUser_args')
4323 
    if self.user != None:
4324 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4325 
      self.user.write(oprot)
94 ashish 4326 
      oprot.writeFieldEnd()
4327 
    oprot.writeFieldStop()
4328 
    oprot.writeStructEnd()
4329 
 
4330 
  def __repr__(self):
4331 
    L = ['%s=%r' % (key, value)
4332 
      for key, value in self.__dict__.iteritems()]
4333 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4334 
 
4335 
  def __eq__(self, other):
4336 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4337 
 
4338 
  def __ne__(self, other):
4339 
    return not (self == other)
4340 
 
559 chandransh 4341 
class createUser_result:
94 ashish 4342 
  """
4343 
  Attributes:
4344 
   - success
559 chandransh 4345 
   - ucex
94 ashish 4346 
  """
4347 
 
4348 
  thrift_spec = (
559 chandransh 4349 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4350 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4351 
  )
4352 
 
559 chandransh 4353 
  def __init__(self, success=None, ucex=None,):
94 ashish 4354 
    self.success = success
559 chandransh 4355 
    self.ucex = ucex
94 ashish 4356 
 
4357 
  def read(self, iprot):
4358 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4359 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4360 
      return
4361 
    iprot.readStructBegin()
4362 
    while True:
4363 
      (fname, ftype, fid) = iprot.readFieldBegin()
4364 
      if ftype == TType.STOP:
4365 
        break
4366 
      if fid == 0:
4367 
        if ftype == TType.STRUCT:
559 chandransh 4368 
          self.success = User()
94 ashish 4369 
          self.success.read(iprot)
4370 
        else:
4371 
          iprot.skip(ftype)
4372 
      elif fid == 1:
4373 
        if ftype == TType.STRUCT:
559 chandransh 4374 
          self.ucex = UserContextException()
4375 
          self.ucex.read(iprot)
94 ashish 4376 
        else:
4377 
          iprot.skip(ftype)
4378 
      else:
4379 
        iprot.skip(ftype)
4380 
      iprot.readFieldEnd()
4381 
    iprot.readStructEnd()
4382 
 
4383 
  def write(self, oprot):
4384 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4385 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4386 
      return
559 chandransh 4387 
    oprot.writeStructBegin('createUser_result')
94 ashish 4388 
    if self.success != None:
4389 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4390 
      self.success.write(oprot)
4391 
      oprot.writeFieldEnd()
559 chandransh 4392 
    if self.ucex != None:
4393 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4394 
      self.ucex.write(oprot)
94 ashish 4395 
      oprot.writeFieldEnd()
4396 
    oprot.writeFieldStop()
4397 
    oprot.writeStructEnd()
4398 
 
4399 
  def __repr__(self):
4400 
    L = ['%s=%r' % (key, value)
4401 
      for key, value in self.__dict__.iteritems()]
4402 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4403 
 
4404 
  def __eq__(self, other):
4405 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4406 
 
4407 
  def __ne__(self, other):
4408 
    return not (self == other)
4409 
 
559 chandransh 4410 
class updateUser_args:
94 ashish 4411 
  """
4412 
  Attributes:
559 chandransh 4413 
   - user
94 ashish 4414 
  """
4415 
 
4416 
  thrift_spec = (
4417 
    None, # 0
559 chandransh 4418 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4419 
  )
4420 
 
559 chandransh 4421 
  def __init__(self, user=None,):
4422 
    self.user = user
94 ashish 4423 
 
4424 
  def read(self, iprot):
4425 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4426 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4427 
      return
4428 
    iprot.readStructBegin()
4429 
    while True:
4430 
      (fname, ftype, fid) = iprot.readFieldBegin()
4431 
      if ftype == TType.STOP:
4432 
        break
4433 
      if fid == 1:
559 chandransh 4434 
        if ftype == TType.STRUCT:
4435 
          self.user = User()
4436 
          self.user.read(iprot)
94 ashish 4437 
        else:
4438 
          iprot.skip(ftype)
4439 
      else:
4440 
        iprot.skip(ftype)
4441 
      iprot.readFieldEnd()
4442 
    iprot.readStructEnd()
4443 
 
4444 
  def write(self, oprot):
4445 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4446 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4447 
      return
559 chandransh 4448 
    oprot.writeStructBegin('updateUser_args')
4449 
    if self.user != None:
4450 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4451 
      self.user.write(oprot)
94 ashish 4452 
      oprot.writeFieldEnd()
4453 
    oprot.writeFieldStop()
4454 
    oprot.writeStructEnd()
4455 
 
4456 
  def __repr__(self):
4457 
    L = ['%s=%r' % (key, value)
4458 
      for key, value in self.__dict__.iteritems()]
4459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4460 
 
4461 
  def __eq__(self, other):
4462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4463 
 
4464 
  def __ne__(self, other):
4465 
    return not (self == other)
4466 
 
559 chandransh 4467 
class updateUser_result:
94 ashish 4468 
  """
4469 
  Attributes:
4470 
   - success
559 chandransh 4471 
   - ucex
94 ashish 4472 
  """
4473 
 
4474 
  thrift_spec = (
559 chandransh 4475 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4476 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4477 
  )
4478 
 
559 chandransh 4479 
  def __init__(self, success=None, ucex=None,):
94 ashish 4480 
    self.success = success
559 chandransh 4481 
    self.ucex = ucex
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 == 0:
4493 
        if ftype == TType.STRUCT:
559 chandransh 4494 
          self.success = User()
94 ashish 4495 
          self.success.read(iprot)
4496 
        else:
4497 
          iprot.skip(ftype)
4498 
      elif fid == 1:
4499 
        if ftype == TType.STRUCT:
559 chandransh 4500 
          self.ucex = UserContextException()
4501 
          self.ucex.read(iprot)
94 ashish 4502 
        else:
4503 
          iprot.skip(ftype)
4504 
      else:
4505 
        iprot.skip(ftype)
4506 
      iprot.readFieldEnd()
4507 
    iprot.readStructEnd()
4508 
 
4509 
  def write(self, oprot):
4510 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4511 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4512 
      return
559 chandransh 4513 
    oprot.writeStructBegin('updateUser_result')
94 ashish 4514 
    if self.success != None:
4515 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4516 
      self.success.write(oprot)
4517 
      oprot.writeFieldEnd()
559 chandransh 4518 
    if self.ucex != None:
4519 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4520 
      self.ucex.write(oprot)
94 ashish 4521 
      oprot.writeFieldEnd()
4522 
    oprot.writeFieldStop()
4523 
    oprot.writeStructEnd()
4524 
 
4525 
  def __repr__(self):
4526 
    L = ['%s=%r' % (key, value)
4527 
      for key, value in self.__dict__.iteritems()]
4528 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4529 
 
4530 
  def __eq__(self, other):
4531 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4532 
 
4533 
  def __ne__(self, other):
4534 
    return not (self == other)
4535 
 
559 chandransh 4536 
class deleteUser_args:
94 ashish 4537 
  """
4538 
  Attributes:
4539 
   - userId
4540 
  """
4541 
 
4542 
  thrift_spec = (
4543 
    None, # 0
4544 
    (1, TType.I64, 'userId', None, None, ), # 1
4545 
  )
4546 
 
559 chandransh 4547 
  def __init__(self, userId=None,):
94 ashish 4548 
    self.userId = userId
4549 
 
4550 
  def read(self, iprot):
4551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4553 
      return
4554 
    iprot.readStructBegin()
4555 
    while True:
4556 
      (fname, ftype, fid) = iprot.readFieldBegin()
4557 
      if ftype == TType.STOP:
4558 
        break
4559 
      if fid == 1:
4560 
        if ftype == TType.I64:
4561 
          self.userId = iprot.readI64();
4562 
        else:
4563 
          iprot.skip(ftype)
4564 
      else:
4565 
        iprot.skip(ftype)
4566 
      iprot.readFieldEnd()
4567 
    iprot.readStructEnd()
4568 
 
4569 
  def write(self, oprot):
4570 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4571 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4572 
      return
559 chandransh 4573 
    oprot.writeStructBegin('deleteUser_args')
94 ashish 4574 
    if self.userId != None:
4575 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4576 
      oprot.writeI64(self.userId)
4577 
      oprot.writeFieldEnd()
4578 
    oprot.writeFieldStop()
4579 
    oprot.writeStructEnd()
4580 
 
4581 
  def __repr__(self):
4582 
    L = ['%s=%r' % (key, value)
4583 
      for key, value in self.__dict__.iteritems()]
4584 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4585 
 
4586 
  def __eq__(self, other):
4587 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4588 
 
4589 
  def __ne__(self, other):
4590 
    return not (self == other)
4591 
 
559 chandransh 4592 
class deleteUser_result:
94 ashish 4593 
  """
4594 
  Attributes:
4595 
   - success
559 chandransh 4596 
   - ucex
94 ashish 4597 
  """
4598 
 
4599 
  thrift_spec = (
559 chandransh 4600 
    (0, TType.BOOL, 'success', None, None, ), # 0
4601 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4602 
  )
4603 
 
559 chandransh 4604 
  def __init__(self, success=None, ucex=None,):
94 ashish 4605 
    self.success = success
559 chandransh 4606 
    self.ucex = ucex
94 ashish 4607 
 
4608 
  def read(self, iprot):
4609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4611 
      return
4612 
    iprot.readStructBegin()
4613 
    while True:
4614 
      (fname, ftype, fid) = iprot.readFieldBegin()
4615 
      if ftype == TType.STOP:
4616 
        break
4617 
      if fid == 0:
559 chandransh 4618 
        if ftype == TType.BOOL:
4619 
          self.success = iprot.readBool();
94 ashish 4620 
        else:
4621 
          iprot.skip(ftype)
4622 
      elif fid == 1:
4623 
        if ftype == TType.STRUCT:
559 chandransh 4624 
          self.ucex = UserContextException()
4625 
          self.ucex.read(iprot)
94 ashish 4626 
        else:
4627 
          iprot.skip(ftype)
4628 
      else:
4629 
        iprot.skip(ftype)
4630 
      iprot.readFieldEnd()
4631 
    iprot.readStructEnd()
4632 
 
4633 
  def write(self, oprot):
4634 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4635 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4636 
      return
559 chandransh 4637 
    oprot.writeStructBegin('deleteUser_result')
94 ashish 4638 
    if self.success != None:
559 chandransh 4639 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4640 
      oprot.writeBool(self.success)
94 ashish 4641 
      oprot.writeFieldEnd()
559 chandransh 4642 
    if self.ucex != None:
4643 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4644 
      self.ucex.write(oprot)
94 ashish 4645 
      oprot.writeFieldEnd()
4646 
    oprot.writeFieldStop()
4647 
    oprot.writeStructEnd()
4648 
 
4649 
  def __repr__(self):
4650 
    L = ['%s=%r' % (key, value)
4651 
      for key, value in self.__dict__.iteritems()]
4652 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4653 
 
4654 
  def __eq__(self, other):
4655 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4656 
 
4657 
  def __ne__(self, other):
4658 
    return not (self == other)
4659 
 
559 chandransh 4660 
class getUserState_args:
94 ashish 4661 
  """
4662 
  Attributes:
4663 
   - userId
4664 
  """
4665 
 
4666 
  thrift_spec = (
4667 
    None, # 0
4668 
    (1, TType.I64, 'userId', None, None, ), # 1
4669 
  )
4670 
 
559 chandransh 4671 
  def __init__(self, userId=None,):
94 ashish 4672 
    self.userId = userId
4673 
 
4674 
  def read(self, iprot):
4675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4677 
      return
4678 
    iprot.readStructBegin()
4679 
    while True:
4680 
      (fname, ftype, fid) = iprot.readFieldBegin()
4681 
      if ftype == TType.STOP:
4682 
        break
4683 
      if fid == 1:
4684 
        if ftype == TType.I64:
4685 
          self.userId = iprot.readI64();
4686 
        else:
4687 
          iprot.skip(ftype)
4688 
      else:
4689 
        iprot.skip(ftype)
4690 
      iprot.readFieldEnd()
4691 
    iprot.readStructEnd()
4692 
 
4693 
  def write(self, oprot):
4694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4696 
      return
559 chandransh 4697 
    oprot.writeStructBegin('getUserState_args')
94 ashish 4698 
    if self.userId != None:
4699 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4700 
      oprot.writeI64(self.userId)
4701 
      oprot.writeFieldEnd()
4702 
    oprot.writeFieldStop()
4703 
    oprot.writeStructEnd()
4704 
 
4705 
  def __repr__(self):
4706 
    L = ['%s=%r' % (key, value)
4707 
      for key, value in self.__dict__.iteritems()]
4708 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4709 
 
4710 
  def __eq__(self, other):
4711 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4712 
 
4713 
  def __ne__(self, other):
4714 
    return not (self == other)
4715 
 
559 chandransh 4716 
class getUserState_result:
94 ashish 4717 
  """
4718 
  Attributes:
4719 
   - success
559 chandransh 4720 
   - ucex
94 ashish 4721 
  """
4722 
 
4723 
  thrift_spec = (
559 chandransh 4724 
    (0, TType.STRUCT, 'success', (UserState, UserState.thrift_spec), None, ), # 0
4725 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4726 
  )
4727 
 
559 chandransh 4728 
  def __init__(self, success=None, ucex=None,):
94 ashish 4729 
    self.success = success
559 chandransh 4730 
    self.ucex = ucex
94 ashish 4731 
 
4732 
  def read(self, iprot):
4733 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4734 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4735 
      return
4736 
    iprot.readStructBegin()
4737 
    while True:
4738 
      (fname, ftype, fid) = iprot.readFieldBegin()
4739 
      if ftype == TType.STOP:
4740 
        break
4741 
      if fid == 0:
4742 
        if ftype == TType.STRUCT:
559 chandransh 4743 
          self.success = UserState()
94 ashish 4744 
          self.success.read(iprot)
4745 
        else:
4746 
          iprot.skip(ftype)
4747 
      elif fid == 1:
4748 
        if ftype == TType.STRUCT:
559 chandransh 4749 
          self.ucex = UserContextException()
4750 
          self.ucex.read(iprot)
94 ashish 4751 
        else:
4752 
          iprot.skip(ftype)
4753 
      else:
4754 
        iprot.skip(ftype)
4755 
      iprot.readFieldEnd()
4756 
    iprot.readStructEnd()
4757 
 
4758 
  def write(self, oprot):
4759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4761 
      return
559 chandransh 4762 
    oprot.writeStructBegin('getUserState_result')
94 ashish 4763 
    if self.success != None:
4764 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4765 
      self.success.write(oprot)
4766 
      oprot.writeFieldEnd()
559 chandransh 4767 
    if self.ucex != None:
4768 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4769 
      self.ucex.write(oprot)
94 ashish 4770 
      oprot.writeFieldEnd()
4771 
    oprot.writeFieldStop()
4772 
    oprot.writeStructEnd()
4773 
 
4774 
  def __repr__(self):
4775 
    L = ['%s=%r' % (key, value)
4776 
      for key, value in self.__dict__.iteritems()]
4777 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4778 
 
4779 
  def __eq__(self, other):
4780 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4781 
 
4782 
  def __ne__(self, other):
4783 
    return not (self == other)
4784 
 
559 chandransh 4785 
class authenticateUser_args:
94 ashish 4786 
  """
4787 
  Attributes:
4788 
   - email
4789 
   - password
4790 
  """
4791 
 
4792 
  thrift_spec = (
4793 
    None, # 0
4794 
    (1, TType.STRING, 'email', None, None, ), # 1
4795 
    (2, TType.STRING, 'password', None, None, ), # 2
4796 
  )
4797 
 
4798 
  def __init__(self, email=None, password=None,):
4799 
    self.email = email
4800 
    self.password = password
4801 
 
4802 
  def read(self, iprot):
4803 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4804 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4805 
      return
4806 
    iprot.readStructBegin()
4807 
    while True:
4808 
      (fname, ftype, fid) = iprot.readFieldBegin()
4809 
      if ftype == TType.STOP:
4810 
        break
4811 
      if fid == 1:
4812 
        if ftype == TType.STRING:
4813 
          self.email = iprot.readString();
4814 
        else:
4815 
          iprot.skip(ftype)
4816 
      elif fid == 2:
4817 
        if ftype == TType.STRING:
4818 
          self.password = iprot.readString();
4819 
        else:
4820 
          iprot.skip(ftype)
4821 
      else:
4822 
        iprot.skip(ftype)
4823 
      iprot.readFieldEnd()
4824 
    iprot.readStructEnd()
4825 
 
4826 
  def write(self, oprot):
4827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4829 
      return
559 chandransh 4830 
    oprot.writeStructBegin('authenticateUser_args')
94 ashish 4831 
    if self.email != None:
4832 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4833 
      oprot.writeString(self.email)
4834 
      oprot.writeFieldEnd()
4835 
    if self.password != None:
4836 
      oprot.writeFieldBegin('password', TType.STRING, 2)
4837 
      oprot.writeString(self.password)
4838 
      oprot.writeFieldEnd()
4839 
    oprot.writeFieldStop()
4840 
    oprot.writeStructEnd()
4841 
 
4842 
  def __repr__(self):
4843 
    L = ['%s=%r' % (key, value)
4844 
      for key, value in self.__dict__.iteritems()]
4845 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4846 
 
4847 
  def __eq__(self, other):
4848 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4849 
 
4850 
  def __ne__(self, other):
4851 
    return not (self == other)
4852 
 
559 chandransh 4853 
class authenticateUser_result:
94 ashish 4854 
  """
4855 
  Attributes:
4856 
   - success
559 chandransh 4857 
   - auex
94 ashish 4858 
  """
4859 
 
4860 
  thrift_spec = (
559 chandransh 4861 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4862 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 4863 
  )
4864 
 
559 chandransh 4865 
  def __init__(self, success=None, auex=None,):
94 ashish 4866 
    self.success = success
559 chandransh 4867 
    self.auex = auex
94 ashish 4868 
 
4869 
  def read(self, iprot):
4870 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4871 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4872 
      return
4873 
    iprot.readStructBegin()
4874 
    while True:
4875 
      (fname, ftype, fid) = iprot.readFieldBegin()
4876 
      if ftype == TType.STOP:
4877 
        break
4878 
      if fid == 0:
4879 
        if ftype == TType.STRUCT:
559 chandransh 4880 
          self.success = User()
94 ashish 4881 
          self.success.read(iprot)
4882 
        else:
4883 
          iprot.skip(ftype)
4884 
      elif fid == 1:
4885 
        if ftype == TType.STRUCT:
559 chandransh 4886 
          self.auex = AuthenticationException()
4887 
          self.auex.read(iprot)
94 ashish 4888 
        else:
4889 
          iprot.skip(ftype)
4890 
      else:
4891 
        iprot.skip(ftype)
4892 
      iprot.readFieldEnd()
4893 
    iprot.readStructEnd()
4894 
 
4895 
  def write(self, oprot):
4896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4898 
      return
559 chandransh 4899 
    oprot.writeStructBegin('authenticateUser_result')
94 ashish 4900 
    if self.success != None:
4901 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4902 
      self.success.write(oprot)
4903 
      oprot.writeFieldEnd()
559 chandransh 4904 
    if self.auex != None:
4905 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
4906 
      self.auex.write(oprot)
94 ashish 4907 
      oprot.writeFieldEnd()
4908 
    oprot.writeFieldStop()
4909 
    oprot.writeStructEnd()
4910 
 
4911 
  def __repr__(self):
4912 
    L = ['%s=%r' % (key, value)
4913 
      for key, value in self.__dict__.iteritems()]
4914 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4915 
 
4916 
  def __eq__(self, other):
4917 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4918 
 
4919 
  def __ne__(self, other):
4920 
    return not (self == other)
4921 
 
559 chandransh 4922 
class userExists_args:
122 ashish 4923 
  """
4924 
  Attributes:
559 chandransh 4925 
   - email
122 ashish 4926 
  """
4927 
 
4928 
  thrift_spec = (
4929 
    None, # 0
559 chandransh 4930 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 4931 
  )
4932 
 
559 chandransh 4933 
  def __init__(self, email=None,):
4934 
    self.email = email
122 ashish 4935 
 
4936 
  def read(self, iprot):
4937 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4938 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4939 
      return
4940 
    iprot.readStructBegin()
4941 
    while True:
4942 
      (fname, ftype, fid) = iprot.readFieldBegin()
4943 
      if ftype == TType.STOP:
4944 
        break
4945 
      if fid == 1:
4946 
        if ftype == TType.STRING:
559 chandransh 4947 
          self.email = iprot.readString();
122 ashish 4948 
        else:
4949 
          iprot.skip(ftype)
559 chandransh 4950 
      else:
4951 
        iprot.skip(ftype)
4952 
      iprot.readFieldEnd()
4953 
    iprot.readStructEnd()
4954 
 
4955 
  def write(self, oprot):
4956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4958 
      return
4959 
    oprot.writeStructBegin('userExists_args')
4960 
    if self.email != None:
4961 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4962 
      oprot.writeString(self.email)
4963 
      oprot.writeFieldEnd()
4964 
    oprot.writeFieldStop()
4965 
    oprot.writeStructEnd()
4966 
 
4967 
  def __repr__(self):
4968 
    L = ['%s=%r' % (key, value)
4969 
      for key, value in self.__dict__.iteritems()]
4970 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4971 
 
4972 
  def __eq__(self, other):
4973 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4974 
 
4975 
  def __ne__(self, other):
4976 
    return not (self == other)
4977 
 
4978 
class userExists_result:
4979 
  """
4980 
  Attributes:
4981 
   - success
4982 
   - ucx
4983 
  """
4984 
 
4985 
  thrift_spec = (
4986 
    (0, TType.BOOL, 'success', None, None, ), # 0
4987 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4988 
  )
4989 
 
4990 
  def __init__(self, success=None, ucx=None,):
4991 
    self.success = success
4992 
    self.ucx = ucx
4993 
 
4994 
  def read(self, iprot):
4995 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4996 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4997 
      return
4998 
    iprot.readStructBegin()
4999 
    while True:
5000 
      (fname, ftype, fid) = iprot.readFieldBegin()
5001 
      if ftype == TType.STOP:
5002 
        break
5003 
      if fid == 0:
5004 
        if ftype == TType.BOOL:
5005 
          self.success = iprot.readBool();
5006 
        else:
5007 
          iprot.skip(ftype)
5008 
      elif fid == 1:
5009 
        if ftype == TType.STRUCT:
5010 
          self.ucx = UserContextException()
5011 
          self.ucx.read(iprot)
5012 
        else:
5013 
          iprot.skip(ftype)
5014 
      else:
5015 
        iprot.skip(ftype)
5016 
      iprot.readFieldEnd()
5017 
    iprot.readStructEnd()
5018 
 
5019 
  def write(self, oprot):
5020 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5021 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5022 
      return
5023 
    oprot.writeStructBegin('userExists_result')
5024 
    if self.success != None:
5025 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5026 
      oprot.writeBool(self.success)
5027 
      oprot.writeFieldEnd()
5028 
    if self.ucx != None:
5029 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5030 
      self.ucx.write(oprot)
5031 
      oprot.writeFieldEnd()
5032 
    oprot.writeFieldStop()
5033 
    oprot.writeStructEnd()
5034 
 
5035 
  def __repr__(self):
5036 
    L = ['%s=%r' % (key, value)
5037 
      for key, value in self.__dict__.iteritems()]
5038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5039 
 
5040 
  def __eq__(self, other):
5041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5042 
 
5043 
  def __ne__(self, other):
5044 
    return not (self == other)
5045 
 
5046 
class addAddressForUser_args:
5047 
  """
5048 
  Attributes:
5049 
   - userId
5050 
   - address
5051 
   - setDefault
5052 
  """
5053 
 
5054 
  thrift_spec = (
5055 
    None, # 0
5056 
    (1, TType.I64, 'userId', None, None, ), # 1
5057 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 5058 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 5059 
  )
5060 
 
567 rajveer 5061 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 5062 
    self.userId = userId
5063 
    self.address = address
5064 
    self.setDefault = setDefault
5065 
 
5066 
  def read(self, iprot):
5067 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5068 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5069 
      return
5070 
    iprot.readStructBegin()
5071 
    while True:
5072 
      (fname, ftype, fid) = iprot.readFieldBegin()
5073 
      if ftype == TType.STOP:
5074 
        break
5075 
      if fid == 1:
5076 
        if ftype == TType.I64:
5077 
          self.userId = iprot.readI64();
5078 
        else:
5079 
          iprot.skip(ftype)
122 ashish 5080 
      elif fid == 2:
559 chandransh 5081 
        if ftype == TType.STRUCT:
5082 
          self.address = Address()
5083 
          self.address.read(iprot)
122 ashish 5084 
        else:
5085 
          iprot.skip(ftype)
5086 
      elif fid == 3:
5087 
        if ftype == TType.BOOL:
559 chandransh 5088 
          self.setDefault = iprot.readBool();
122 ashish 5089 
        else:
5090 
          iprot.skip(ftype)
5091 
      else:
5092 
        iprot.skip(ftype)
5093 
      iprot.readFieldEnd()
5094 
    iprot.readStructEnd()
5095 
 
5096 
  def write(self, oprot):
5097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5099 
      return
559 chandransh 5100 
    oprot.writeStructBegin('addAddressForUser_args')
5101 
    if self.userId != None:
5102 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5103 
      oprot.writeI64(self.userId)
122 ashish 5104 
      oprot.writeFieldEnd()
559 chandransh 5105 
    if self.address != None:
5106 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
5107 
      self.address.write(oprot)
122 ashish 5108 
      oprot.writeFieldEnd()
559 chandransh 5109 
    if self.setDefault != None:
567 rajveer 5110 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 5111 
      oprot.writeBool(self.setDefault)
5112 
      oprot.writeFieldEnd()
122 ashish 5113 
    oprot.writeFieldStop()
5114 
    oprot.writeStructEnd()
5115 
 
5116 
  def __repr__(self):
5117 
    L = ['%s=%r' % (key, value)
5118 
      for key, value in self.__dict__.iteritems()]
5119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5120 
 
5121 
  def __eq__(self, other):
5122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5123 
 
5124 
  def __ne__(self, other):
5125 
    return not (self == other)
5126 
 
559 chandransh 5127 
class addAddressForUser_result:
122 ashish 5128 
  """
5129 
  Attributes:
5130 
   - success
559 chandransh 5131 
   - ucx
122 ashish 5132 
  """
5133 
 
5134 
  thrift_spec = (
567 rajveer 5135 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 5136 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 5137 
  )
5138 
 
559 chandransh 5139 
  def __init__(self, success=None, ucx=None,):
122 ashish 5140 
    self.success = success
559 chandransh 5141 
    self.ucx = ucx
122 ashish 5142 
 
5143 
  def read(self, iprot):
5144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5146 
      return
5147 
    iprot.readStructBegin()
5148 
    while True:
5149 
      (fname, ftype, fid) = iprot.readFieldBegin()
5150 
      if ftype == TType.STOP:
5151 
        break
5152 
      if fid == 0:
567 rajveer 5153 
        if ftype == TType.I64:
5154 
          self.success = iprot.readI64();
122 ashish 5155 
        else:
5156 
          iprot.skip(ftype)
5157 
      elif fid == 1:
5158 
        if ftype == TType.STRUCT:
559 chandransh 5159 
          self.ucx = UserContextException()
5160 
          self.ucx.read(iprot)
122 ashish 5161 
        else:
5162 
          iprot.skip(ftype)
5163 
      else:
5164 
        iprot.skip(ftype)
5165 
      iprot.readFieldEnd()
5166 
    iprot.readStructEnd()
5167 
 
5168 
  def write(self, oprot):
5169 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5170 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5171 
      return
559 chandransh 5172 
    oprot.writeStructBegin('addAddressForUser_result')
122 ashish 5173 
    if self.success != None:
567 rajveer 5174 
      oprot.writeFieldBegin('success', TType.I64, 0)
5175 
      oprot.writeI64(self.success)
122 ashish 5176 
      oprot.writeFieldEnd()
559 chandransh 5177 
    if self.ucx != None:
5178 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5179 
      self.ucx.write(oprot)
122 ashish 5180 
      oprot.writeFieldEnd()
5181 
    oprot.writeFieldStop()
5182 
    oprot.writeStructEnd()
5183 
 
5184 
  def __repr__(self):
5185 
    L = ['%s=%r' % (key, value)
5186 
      for key, value in self.__dict__.iteritems()]
5187 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5188 
 
5189 
  def __eq__(self, other):
5190 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5191 
 
5192 
  def __ne__(self, other):
5193 
    return not (self == other)
5194 
 
559 chandransh 5195 
class removeAddressForUser_args:
94 ashish 5196 
  """
5197 
  Attributes:
559 chandransh 5198 
   - userid
5199 
   - addressId
94 ashish 5200 
  """
5201 
 
5202 
  thrift_spec = (
5203 
    None, # 0
559 chandransh 5204 
    (1, TType.I64, 'userid', None, None, ), # 1
5205 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 5206 
  )
5207 
 
559 chandransh 5208 
  def __init__(self, userid=None, addressId=None,):
5209 
    self.userid = userid
5210 
    self.addressId = addressId
94 ashish 5211 
 
5212 
  def read(self, iprot):
5213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5215 
      return
5216 
    iprot.readStructBegin()
5217 
    while True:
5218 
      (fname, ftype, fid) = iprot.readFieldBegin()
5219 
      if ftype == TType.STOP:
5220 
        break
5221 
      if fid == 1:
559 chandransh 5222 
        if ftype == TType.I64:
5223 
          self.userid = iprot.readI64();
94 ashish 5224 
        else:
5225 
          iprot.skip(ftype)
559 chandransh 5226 
      elif fid == 2:
5227 
        if ftype == TType.I64:
5228 
          self.addressId = iprot.readI64();
5229 
        else:
5230 
          iprot.skip(ftype)
94 ashish 5231 
      else:
5232 
        iprot.skip(ftype)
5233 
      iprot.readFieldEnd()
5234 
    iprot.readStructEnd()
5235 
 
5236 
  def write(self, oprot):
5237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5239 
      return
559 chandransh 5240 
    oprot.writeStructBegin('removeAddressForUser_args')
5241 
    if self.userid != None:
5242 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5243 
      oprot.writeI64(self.userid)
94 ashish 5244 
      oprot.writeFieldEnd()
559 chandransh 5245 
    if self.addressId != None:
5246 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5247 
      oprot.writeI64(self.addressId)
5248 
      oprot.writeFieldEnd()
94 ashish 5249 
    oprot.writeFieldStop()
5250 
    oprot.writeStructEnd()
5251 
 
5252 
  def __repr__(self):
5253 
    L = ['%s=%r' % (key, value)
5254 
      for key, value in self.__dict__.iteritems()]
5255 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5256 
 
5257 
  def __eq__(self, other):
5258 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5259 
 
5260 
  def __ne__(self, other):
5261 
    return not (self == other)
5262 
 
559 chandransh 5263 
class removeAddressForUser_result:
94 ashish 5264 
  """
5265 
  Attributes:
5266 
   - success
5267 
   - ucx
5268 
  """
5269 
 
5270 
  thrift_spec = (
5271 
    (0, TType.BOOL, 'success', None, None, ), # 0
5272 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5273 
  )
5274 
 
5275 
  def __init__(self, success=None, ucx=None,):
5276 
    self.success = success
5277 
    self.ucx = ucx
5278 
 
5279 
  def read(self, iprot):
5280 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5281 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5282 
      return
5283 
    iprot.readStructBegin()
5284 
    while True:
5285 
      (fname, ftype, fid) = iprot.readFieldBegin()
5286 
      if ftype == TType.STOP:
5287 
        break
5288 
      if fid == 0:
5289 
        if ftype == TType.BOOL:
5290 
          self.success = iprot.readBool();
5291 
        else:
5292 
          iprot.skip(ftype)
5293 
      elif fid == 1:
5294 
        if ftype == TType.STRUCT:
5295 
          self.ucx = UserContextException()
5296 
          self.ucx.read(iprot)
5297 
        else:
5298 
          iprot.skip(ftype)
5299 
      else:
5300 
        iprot.skip(ftype)
5301 
      iprot.readFieldEnd()
5302 
    iprot.readStructEnd()
5303 
 
5304 
  def write(self, oprot):
5305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5307 
      return
559 chandransh 5308 
    oprot.writeStructBegin('removeAddressForUser_result')
94 ashish 5309 
    if self.success != None:
5310 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5311 
      oprot.writeBool(self.success)
5312 
      oprot.writeFieldEnd()
5313 
    if self.ucx != None:
5314 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5315 
      self.ucx.write(oprot)
5316 
      oprot.writeFieldEnd()
5317 
    oprot.writeFieldStop()
5318 
    oprot.writeStructEnd()
5319 
 
5320 
  def __repr__(self):
5321 
    L = ['%s=%r' % (key, value)
5322 
      for key, value in self.__dict__.iteritems()]
5323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5324 
 
5325 
  def __eq__(self, other):
5326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5327 
 
5328 
  def __ne__(self, other):
5329 
    return not (self == other)
5330 
 
559 chandransh 5331 
class setUserAsLoggedIn_args:
94 ashish 5332 
  """
5333 
  Attributes:
559 chandransh 5334 
   - userId
94 ashish 5335 
   - timestamp
5336 
  """
5337 
 
5338 
  thrift_spec = (
5339 
    None, # 0
559 chandransh 5340 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 5341 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5342 
  )
5343 
 
559 chandransh 5344 
  def __init__(self, userId=None, timestamp=None,):
5345 
    self.userId = userId
94 ashish 5346 
    self.timestamp = timestamp
5347 
 
5348 
  def read(self, iprot):
5349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5351 
      return
5352 
    iprot.readStructBegin()
5353 
    while True:
5354 
      (fname, ftype, fid) = iprot.readFieldBegin()
5355 
      if ftype == TType.STOP:
5356 
        break
5357 
      if fid == 1:
559 chandransh 5358 
        if ftype == TType.I64:
5359 
          self.userId = iprot.readI64();
94 ashish 5360 
        else:
5361 
          iprot.skip(ftype)
5362 
      elif fid == 2:
5363 
        if ftype == TType.I64:
5364 
          self.timestamp = iprot.readI64();
5365 
        else:
5366 
          iprot.skip(ftype)
5367 
      else:
5368 
        iprot.skip(ftype)
5369 
      iprot.readFieldEnd()
5370 
    iprot.readStructEnd()
5371 
 
5372 
  def write(self, oprot):
5373 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5374 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5375 
      return
559 chandransh 5376 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
5377 
    if self.userId != None:
5378 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5379 
      oprot.writeI64(self.userId)
94 ashish 5380 
      oprot.writeFieldEnd()
5381 
    if self.timestamp != None:
5382 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5383 
      oprot.writeI64(self.timestamp)
5384 
      oprot.writeFieldEnd()
5385 
    oprot.writeFieldStop()
5386 
    oprot.writeStructEnd()
5387 
 
5388 
  def __repr__(self):
5389 
    L = ['%s=%r' % (key, value)
5390 
      for key, value in self.__dict__.iteritems()]
5391 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5392 
 
5393 
  def __eq__(self, other):
5394 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5395 
 
5396 
  def __ne__(self, other):
5397 
    return not (self == other)
5398 
 
559 chandransh 5399 
class setUserAsLoggedIn_result:
94 ashish 5400 
  """
5401 
  Attributes:
5402 
   - success
5403 
   - ucx
5404 
  """
5405 
 
5406 
  thrift_spec = (
5407 
    (0, TType.BOOL, 'success', None, None, ), # 0
5408 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5409 
  )
5410 
 
5411 
  def __init__(self, success=None, ucx=None,):
5412 
    self.success = success
5413 
    self.ucx = ucx
5414 
 
5415 
  def read(self, iprot):
5416 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5417 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5418 
      return
5419 
    iprot.readStructBegin()
5420 
    while True:
5421 
      (fname, ftype, fid) = iprot.readFieldBegin()
5422 
      if ftype == TType.STOP:
5423 
        break
5424 
      if fid == 0:
5425 
        if ftype == TType.BOOL:
5426 
          self.success = iprot.readBool();
5427 
        else:
5428 
          iprot.skip(ftype)
5429 
      elif fid == 1:
5430 
        if ftype == TType.STRUCT:
5431 
          self.ucx = UserContextException()
5432 
          self.ucx.read(iprot)
5433 
        else:
5434 
          iprot.skip(ftype)
5435 
      else:
5436 
        iprot.skip(ftype)
5437 
      iprot.readFieldEnd()
5438 
    iprot.readStructEnd()
5439 
 
5440 
  def write(self, oprot):
5441 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5442 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5443 
      return
559 chandransh 5444 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
94 ashish 5445 
    if self.success != None:
5446 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5447 
      oprot.writeBool(self.success)
5448 
      oprot.writeFieldEnd()
5449 
    if self.ucx != None:
5450 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5451 
      self.ucx.write(oprot)
5452 
      oprot.writeFieldEnd()
5453 
    oprot.writeFieldStop()
5454 
    oprot.writeStructEnd()
5455 
 
5456 
  def __repr__(self):
5457 
    L = ['%s=%r' % (key, value)
5458 
      for key, value in self.__dict__.iteritems()]
5459 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5460 
 
5461 
  def __eq__(self, other):
5462 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5463 
 
5464 
  def __ne__(self, other):
5465 
    return not (self == other)
5466 
 
559 chandransh 5467 
class setUserAsLoggedOut_args:
94 ashish 5468 
  """
5469 
  Attributes:
5470 
   - userid
5471 
   - timestamp
5472 
  """
5473 
 
5474 
  thrift_spec = (
5475 
    None, # 0
559 chandransh 5476 
    (1, TType.I64, 'userid', None, None, ), # 1
5477 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 5478 
  )
5479 
 
559 chandransh 5480 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 5481 
    self.userid = userid
5482 
    self.timestamp = timestamp
5483 
 
5484 
  def read(self, iprot):
5485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5487 
      return
5488 
    iprot.readStructBegin()
5489 
    while True:
5490 
      (fname, ftype, fid) = iprot.readFieldBegin()
5491 
      if ftype == TType.STOP:
5492 
        break
5493 
      if fid == 1:
5494 
        if ftype == TType.I64:
5495 
          self.userid = iprot.readI64();
5496 
        else:
5497 
          iprot.skip(ftype)
559 chandransh 5498 
      elif fid == 2:
94 ashish 5499 
        if ftype == TType.I64:
5500 
          self.timestamp = iprot.readI64();
5501 
        else:
5502 
          iprot.skip(ftype)
5503 
      else:
5504 
        iprot.skip(ftype)
5505 
      iprot.readFieldEnd()
5506 
    iprot.readStructEnd()
5507 
 
5508 
  def write(self, oprot):
5509 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5510 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5511 
      return
559 chandransh 5512 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
94 ashish 5513 
    if self.userid != None:
559 chandransh 5514 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 5515 
      oprot.writeI64(self.userid)
5516 
      oprot.writeFieldEnd()
5517 
    if self.timestamp != None:
559 chandransh 5518 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 5519 
      oprot.writeI64(self.timestamp)
5520 
      oprot.writeFieldEnd()
5521 
    oprot.writeFieldStop()
5522 
    oprot.writeStructEnd()
5523 
 
5524 
  def __repr__(self):
5525 
    L = ['%s=%r' % (key, value)
5526 
      for key, value in self.__dict__.iteritems()]
5527 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5528 
 
5529 
  def __eq__(self, other):
5530 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5531 
 
5532 
  def __ne__(self, other):
5533 
    return not (self == other)
5534 
 
559 chandransh 5535 
class setUserAsLoggedOut_result:
94 ashish 5536 
  """
5537 
  Attributes:
5538 
   - success
5539 
   - ucx
5540 
  """
5541 
 
5542 
  thrift_spec = (
5543 
    (0, TType.BOOL, 'success', None, None, ), # 0
5544 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5545 
  )
5546 
 
5547 
  def __init__(self, success=None, ucx=None,):
5548 
    self.success = success
5549 
    self.ucx = ucx
5550 
 
5551 
  def read(self, iprot):
5552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5554 
      return
5555 
    iprot.readStructBegin()
5556 
    while True:
5557 
      (fname, ftype, fid) = iprot.readFieldBegin()
5558 
      if ftype == TType.STOP:
5559 
        break
5560 
      if fid == 0:
5561 
        if ftype == TType.BOOL:
5562 
          self.success = iprot.readBool();
5563 
        else:
5564 
          iprot.skip(ftype)
5565 
      elif fid == 1:
5566 
        if ftype == TType.STRUCT:
5567 
          self.ucx = UserContextException()
5568 
          self.ucx.read(iprot)
5569 
        else:
5570 
          iprot.skip(ftype)
5571 
      else:
5572 
        iprot.skip(ftype)
5573 
      iprot.readFieldEnd()
5574 
    iprot.readStructEnd()
5575 
 
5576 
  def write(self, oprot):
5577 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5578 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5579 
      return
559 chandransh 5580 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
94 ashish 5581 
    if self.success != None:
5582 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5583 
      oprot.writeBool(self.success)
5584 
      oprot.writeFieldEnd()
5585 
    if self.ucx != None:
5586 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5587 
      self.ucx.write(oprot)
5588 
      oprot.writeFieldEnd()
5589 
    oprot.writeFieldStop()
5590 
    oprot.writeStructEnd()
5591 
 
5592 
  def __repr__(self):
5593 
    L = ['%s=%r' % (key, value)
5594 
      for key, value in self.__dict__.iteritems()]
5595 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5596 
 
5597 
  def __eq__(self, other):
5598 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5599 
 
5600 
  def __ne__(self, other):
5601 
    return not (self == other)
5602 
 
559 chandransh 5603 
class setDefaultAddress_args:
94 ashish 5604 
  """
5605 
  Attributes:
5606 
   - userid
5607 
   - addressId
5608 
  """
5609 
 
5610 
  thrift_spec = (
5611 
    None, # 0
5612 
    (1, TType.I64, 'userid', None, None, ), # 1
5613 
    (2, TType.I64, 'addressId', None, None, ), # 2
5614 
  )
5615 
 
5616 
  def __init__(self, userid=None, addressId=None,):
5617 
    self.userid = userid
5618 
    self.addressId = addressId
5619 
 
5620 
  def read(self, iprot):
5621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5623 
      return
5624 
    iprot.readStructBegin()
5625 
    while True:
5626 
      (fname, ftype, fid) = iprot.readFieldBegin()
5627 
      if ftype == TType.STOP:
5628 
        break
5629 
      if fid == 1:
5630 
        if ftype == TType.I64:
5631 
          self.userid = iprot.readI64();
5632 
        else:
5633 
          iprot.skip(ftype)
5634 
      elif fid == 2:
5635 
        if ftype == TType.I64:
5636 
          self.addressId = iprot.readI64();
5637 
        else:
5638 
          iprot.skip(ftype)
5639 
      else:
5640 
        iprot.skip(ftype)
5641 
      iprot.readFieldEnd()
5642 
    iprot.readStructEnd()
5643 
 
5644 
  def write(self, oprot):
5645 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5646 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5647 
      return
559 chandransh 5648 
    oprot.writeStructBegin('setDefaultAddress_args')
94 ashish 5649 
    if self.userid != None:
5650 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5651 
      oprot.writeI64(self.userid)
5652 
      oprot.writeFieldEnd()
5653 
    if self.addressId != None:
5654 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5655 
      oprot.writeI64(self.addressId)
5656 
      oprot.writeFieldEnd()
5657 
    oprot.writeFieldStop()
5658 
    oprot.writeStructEnd()
5659 
 
5660 
  def __repr__(self):
5661 
    L = ['%s=%r' % (key, value)
5662 
      for key, value in self.__dict__.iteritems()]
5663 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5664 
 
5665 
  def __eq__(self, other):
5666 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5667 
 
5668 
  def __ne__(self, other):
5669 
    return not (self == other)
5670 
 
559 chandransh 5671 
class setDefaultAddress_result:
94 ashish 5672 
  """
5673 
  Attributes:
5674 
   - success
5675 
   - ucx
5676 
  """
5677 
 
5678 
  thrift_spec = (
5679 
    (0, TType.BOOL, 'success', None, None, ), # 0
5680 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5681 
  )
5682 
 
5683 
  def __init__(self, success=None, ucx=None,):
5684 
    self.success = success
5685 
    self.ucx = ucx
5686 
 
5687 
  def read(self, iprot):
5688 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5689 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5690 
      return
5691 
    iprot.readStructBegin()
5692 
    while True:
5693 
      (fname, ftype, fid) = iprot.readFieldBegin()
5694 
      if ftype == TType.STOP:
5695 
        break
5696 
      if fid == 0:
5697 
        if ftype == TType.BOOL:
5698 
          self.success = iprot.readBool();
5699 
        else:
5700 
          iprot.skip(ftype)
5701 
      elif fid == 1:
5702 
        if ftype == TType.STRUCT:
5703 
          self.ucx = UserContextException()
5704 
          self.ucx.read(iprot)
5705 
        else:
5706 
          iprot.skip(ftype)
5707 
      else:
5708 
        iprot.skip(ftype)
5709 
      iprot.readFieldEnd()
5710 
    iprot.readStructEnd()
5711 
 
5712 
  def write(self, oprot):
5713 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5714 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5715 
      return
559 chandransh 5716 
    oprot.writeStructBegin('setDefaultAddress_result')
94 ashish 5717 
    if self.success != None:
5718 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5719 
      oprot.writeBool(self.success)
5720 
      oprot.writeFieldEnd()
5721 
    if self.ucx != None:
5722 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5723 
      self.ucx.write(oprot)
5724 
      oprot.writeFieldEnd()
5725 
    oprot.writeFieldStop()
5726 
    oprot.writeStructEnd()
5727 
 
5728 
  def __repr__(self):
5729 
    L = ['%s=%r' % (key, value)
5730 
      for key, value in self.__dict__.iteritems()]
5731 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5732 
 
5733 
  def __eq__(self, other):
5734 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5735 
 
5736 
  def __ne__(self, other):
5737 
    return not (self == other)
5738 
 
559 chandransh 5739 
class updatePassword_args:
94 ashish 5740 
  """
5741 
  Attributes:
559 chandransh 5742 
   - userid
594 rajveer 5743 
   - oldPassword
5744 
   - newPassword
94 ashish 5745 
  """
5746 
 
5747 
  thrift_spec = (
5748 
    None, # 0
559 chandransh 5749 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 5750 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
5751 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 5752 
  )
5753 
 
594 rajveer 5754 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 5755 
    self.userid = userid
594 rajveer 5756 
    self.oldPassword = oldPassword
5757 
    self.newPassword = newPassword
94 ashish 5758 
 
5759 
  def read(self, iprot):
5760 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5761 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5762 
      return
5763 
    iprot.readStructBegin()
5764 
    while True:
5765 
      (fname, ftype, fid) = iprot.readFieldBegin()
5766 
      if ftype == TType.STOP:
5767 
        break
5768 
      if fid == 1:
5769 
        if ftype == TType.I64:
559 chandransh 5770 
          self.userid = iprot.readI64();
94 ashish 5771 
        else:
5772 
          iprot.skip(ftype)
5773 
      elif fid == 2:
559 chandransh 5774 
        if ftype == TType.STRING:
594 rajveer 5775 
          self.oldPassword = iprot.readString();
94 ashish 5776 
        else:
5777 
          iprot.skip(ftype)
594 rajveer 5778 
      elif fid == 3:
5779 
        if ftype == TType.STRING:
5780 
          self.newPassword = iprot.readString();
5781 
        else:
5782 
          iprot.skip(ftype)
94 ashish 5783 
      else:
5784 
        iprot.skip(ftype)
5785 
      iprot.readFieldEnd()
5786 
    iprot.readStructEnd()
5787 
 
5788 
  def write(self, oprot):
5789 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5790 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5791 
      return
559 chandransh 5792 
    oprot.writeStructBegin('updatePassword_args')
5793 
    if self.userid != None:
5794 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5795 
      oprot.writeI64(self.userid)
94 ashish 5796 
      oprot.writeFieldEnd()
594 rajveer 5797 
    if self.oldPassword != None:
5798 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
5799 
      oprot.writeString(self.oldPassword)
94 ashish 5800 
      oprot.writeFieldEnd()
594 rajveer 5801 
    if self.newPassword != None:
5802 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
5803 
      oprot.writeString(self.newPassword)
5804 
      oprot.writeFieldEnd()
94 ashish 5805 
    oprot.writeFieldStop()
5806 
    oprot.writeStructEnd()
5807 
 
5808 
  def __repr__(self):
5809 
    L = ['%s=%r' % (key, value)
5810 
      for key, value in self.__dict__.iteritems()]
5811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5812 
 
5813 
  def __eq__(self, other):
5814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5815 
 
5816 
  def __ne__(self, other):
5817 
    return not (self == other)
5818 
 
559 chandransh 5819 
class updatePassword_result:
94 ashish 5820 
  """
5821 
  Attributes:
5822 
   - success
5823 
   - ucx
5824 
  """
5825 
 
5826 
  thrift_spec = (
5827 
    (0, TType.BOOL, 'success', None, None, ), # 0
5828 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5829 
  )
5830 
 
5831 
  def __init__(self, success=None, ucx=None,):
5832 
    self.success = success
5833 
    self.ucx = ucx
5834 
 
5835 
  def read(self, iprot):
5836 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5837 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5838 
      return
5839 
    iprot.readStructBegin()
5840 
    while True:
5841 
      (fname, ftype, fid) = iprot.readFieldBegin()
5842 
      if ftype == TType.STOP:
5843 
        break
5844 
      if fid == 0:
5845 
        if ftype == TType.BOOL:
5846 
          self.success = iprot.readBool();
5847 
        else:
5848 
          iprot.skip(ftype)
5849 
      elif fid == 1:
5850 
        if ftype == TType.STRUCT:
5851 
          self.ucx = UserContextException()
5852 
          self.ucx.read(iprot)
5853 
        else:
5854 
          iprot.skip(ftype)
5855 
      else:
5856 
        iprot.skip(ftype)
5857 
      iprot.readFieldEnd()
5858 
    iprot.readStructEnd()
5859 
 
5860 
  def write(self, oprot):
5861 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5862 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5863 
      return
559 chandransh 5864 
    oprot.writeStructBegin('updatePassword_result')
94 ashish 5865 
    if self.success != None:
5866 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5867 
      oprot.writeBool(self.success)
5868 
      oprot.writeFieldEnd()
5869 
    if self.ucx != None:
5870 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5871 
      self.ucx.write(oprot)
5872 
      oprot.writeFieldEnd()
5873 
    oprot.writeFieldStop()
5874 
    oprot.writeStructEnd()
5875 
 
5876 
  def __repr__(self):
5877 
    L = ['%s=%r' % (key, value)
5878 
      for key, value in self.__dict__.iteritems()]
5879 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5880 
 
5881 
  def __eq__(self, other):
5882 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5883 
 
5884 
  def __ne__(self, other):
5885 
    return not (self == other)
5886 
 
581 rajveer 5887 
class forgotPassword_args:
5888 
  """
5889 
  Attributes:
5890 
   - email
884 rajveer 5891 
   - newPassword
581 rajveer 5892 
  """
5893 
 
5894 
  thrift_spec = (
5895 
    None, # 0
5896 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 5897 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 5898 
  )
5899 
 
884 rajveer 5900 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 5901 
    self.email = email
884 rajveer 5902 
    self.newPassword = newPassword
581 rajveer 5903 
 
5904 
  def read(self, iprot):
5905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5907 
      return
5908 
    iprot.readStructBegin()
5909 
    while True:
5910 
      (fname, ftype, fid) = iprot.readFieldBegin()
5911 
      if ftype == TType.STOP:
5912 
        break
5913 
      if fid == 1:
5914 
        if ftype == TType.STRING:
5915 
          self.email = iprot.readString();
5916 
        else:
5917 
          iprot.skip(ftype)
884 rajveer 5918 
      elif fid == 2:
5919 
        if ftype == TType.STRING:
5920 
          self.newPassword = iprot.readString();
5921 
        else:
5922 
          iprot.skip(ftype)
581 rajveer 5923 
      else:
5924 
        iprot.skip(ftype)
5925 
      iprot.readFieldEnd()
5926 
    iprot.readStructEnd()
5927 
 
5928 
  def write(self, oprot):
5929 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5930 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5931 
      return
5932 
    oprot.writeStructBegin('forgotPassword_args')
5933 
    if self.email != None:
5934 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5935 
      oprot.writeString(self.email)
5936 
      oprot.writeFieldEnd()
884 rajveer 5937 
    if self.newPassword != None:
5938 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
5939 
      oprot.writeString(self.newPassword)
5940 
      oprot.writeFieldEnd()
581 rajveer 5941 
    oprot.writeFieldStop()
5942 
    oprot.writeStructEnd()
5943 
 
5944 
  def __repr__(self):
5945 
    L = ['%s=%r' % (key, value)
5946 
      for key, value in self.__dict__.iteritems()]
5947 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5948 
 
5949 
  def __eq__(self, other):
5950 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5951 
 
5952 
  def __ne__(self, other):
5953 
    return not (self == other)
5954 
 
5955 
class forgotPassword_result:
5956 
  """
5957 
  Attributes:
5958 
   - success
5959 
   - ucx
5960 
  """
5961 
 
5962 
  thrift_spec = (
5963 
    (0, TType.BOOL, 'success', None, None, ), # 0
5964 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5965 
  )
5966 
 
5967 
  def __init__(self, success=None, ucx=None,):
5968 
    self.success = success
5969 
    self.ucx = ucx
5970 
 
5971 
  def read(self, iprot):
5972 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5973 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5974 
      return
5975 
    iprot.readStructBegin()
5976 
    while True:
5977 
      (fname, ftype, fid) = iprot.readFieldBegin()
5978 
      if ftype == TType.STOP:
5979 
        break
5980 
      if fid == 0:
5981 
        if ftype == TType.BOOL:
5982 
          self.success = iprot.readBool();
5983 
        else:
5984 
          iprot.skip(ftype)
5985 
      elif fid == 1:
5986 
        if ftype == TType.STRUCT:
5987 
          self.ucx = UserContextException()
5988 
          self.ucx.read(iprot)
5989 
        else:
5990 
          iprot.skip(ftype)
5991 
      else:
5992 
        iprot.skip(ftype)
5993 
      iprot.readFieldEnd()
5994 
    iprot.readStructEnd()
5995 
 
5996 
  def write(self, oprot):
5997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5999 
      return
6000 
    oprot.writeStructBegin('forgotPassword_result')
6001 
    if self.success != None:
6002 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6003 
      oprot.writeBool(self.success)
6004 
      oprot.writeFieldEnd()
6005 
    if self.ucx != None:
6006 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6007 
      self.ucx.write(oprot)
6008 
      oprot.writeFieldEnd()
6009 
    oprot.writeFieldStop()
6010 
    oprot.writeStructEnd()
6011 
 
6012 
  def __repr__(self):
6013 
    L = ['%s=%r' % (key, value)
6014 
      for key, value in self.__dict__.iteritems()]
6015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6016 
 
6017 
  def __eq__(self, other):
6018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6019 
 
6020 
  def __ne__(self, other):
6021 
    return not (self == other)
6022 
 
594 rajveer 6023 
class getAllAddressesForUser_args:
6024 
  """
6025 
  Attributes:
6026 
   - userId
6027 
  """
6028 
 
6029 
  thrift_spec = (
6030 
    None, # 0
6031 
    (1, TType.I64, 'userId', None, None, ), # 1
6032 
  )
6033 
 
6034 
  def __init__(self, userId=None,):
6035 
    self.userId = userId
6036 
 
6037 
  def read(self, iprot):
6038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6040 
      return
6041 
    iprot.readStructBegin()
6042 
    while True:
6043 
      (fname, ftype, fid) = iprot.readFieldBegin()
6044 
      if ftype == TType.STOP:
6045 
        break
6046 
      if fid == 1:
6047 
        if ftype == TType.I64:
6048 
          self.userId = iprot.readI64();
6049 
        else:
6050 
          iprot.skip(ftype)
6051 
      else:
6052 
        iprot.skip(ftype)
6053 
      iprot.readFieldEnd()
6054 
    iprot.readStructEnd()
6055 
 
6056 
  def write(self, oprot):
6057 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6058 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6059 
      return
6060 
    oprot.writeStructBegin('getAllAddressesForUser_args')
6061 
    if self.userId != None:
6062 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6063 
      oprot.writeI64(self.userId)
6064 
      oprot.writeFieldEnd()
6065 
    oprot.writeFieldStop()
6066 
    oprot.writeStructEnd()
6067 
 
6068 
  def __repr__(self):
6069 
    L = ['%s=%r' % (key, value)
6070 
      for key, value in self.__dict__.iteritems()]
6071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6072 
 
6073 
  def __eq__(self, other):
6074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6075 
 
6076 
  def __ne__(self, other):
6077 
    return not (self == other)
6078 
 
6079 
class getAllAddressesForUser_result:
6080 
  """
6081 
  Attributes:
6082 
   - success
6083 
   - ucx
6084 
  """
6085 
 
6086 
  thrift_spec = (
6087 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
6088 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6089 
  )
6090 
 
6091 
  def __init__(self, success=None, ucx=None,):
6092 
    self.success = success
6093 
    self.ucx = ucx
6094 
 
6095 
  def read(self, iprot):
6096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6098 
      return
6099 
    iprot.readStructBegin()
6100 
    while True:
6101 
      (fname, ftype, fid) = iprot.readFieldBegin()
6102 
      if ftype == TType.STOP:
6103 
        break
6104 
      if fid == 0:
6105 
        if ftype == TType.LIST:
6106 
          self.success = []
2981 rajveer 6107 
          (_etype31, _size28) = iprot.readListBegin()
6108 
          for _i32 in xrange(_size28):
6109 
            _elem33 = Address()
6110 
            _elem33.read(iprot)
6111 
            self.success.append(_elem33)
594 rajveer 6112 
          iprot.readListEnd()
6113 
        else:
6114 
          iprot.skip(ftype)
6115 
      elif fid == 1:
6116 
        if ftype == TType.STRUCT:
6117 
          self.ucx = UserContextException()
6118 
          self.ucx.read(iprot)
6119 
        else:
6120 
          iprot.skip(ftype)
6121 
      else:
6122 
        iprot.skip(ftype)
6123 
      iprot.readFieldEnd()
6124 
    iprot.readStructEnd()
6125 
 
6126 
  def write(self, oprot):
6127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6129 
      return
6130 
    oprot.writeStructBegin('getAllAddressesForUser_result')
6131 
    if self.success != None:
6132 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6133 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 6134 
      for iter34 in self.success:
6135 
        iter34.write(oprot)
594 rajveer 6136 
      oprot.writeListEnd()
6137 
      oprot.writeFieldEnd()
6138 
    if self.ucx != None:
6139 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6140 
      self.ucx.write(oprot)
6141 
      oprot.writeFieldEnd()
6142 
    oprot.writeFieldStop()
6143 
    oprot.writeStructEnd()
6144 
 
6145 
  def __repr__(self):
6146 
    L = ['%s=%r' % (key, value)
6147 
      for key, value in self.__dict__.iteritems()]
6148 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6149 
 
6150 
  def __eq__(self, other):
6151 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6152 
 
6153 
  def __ne__(self, other):
6154 
    return not (self == other)
6155 
 
1894 vikas 6156 
class getAddressById_args:
6157 
  """
6158 
  Attributes:
6159 
   - addressId
6160 
  """
6161 
 
6162 
  thrift_spec = (
6163 
    None, # 0
6164 
    (1, TType.I64, 'addressId', None, None, ), # 1
6165 
  )
6166 
 
6167 
  def __init__(self, addressId=None,):
6168 
    self.addressId = addressId
6169 
 
6170 
  def read(self, iprot):
6171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6173 
      return
6174 
    iprot.readStructBegin()
6175 
    while True:
6176 
      (fname, ftype, fid) = iprot.readFieldBegin()
6177 
      if ftype == TType.STOP:
6178 
        break
6179 
      if fid == 1:
6180 
        if ftype == TType.I64:
6181 
          self.addressId = iprot.readI64();
6182 
        else:
6183 
          iprot.skip(ftype)
6184 
      else:
6185 
        iprot.skip(ftype)
6186 
      iprot.readFieldEnd()
6187 
    iprot.readStructEnd()
6188 
 
6189 
  def write(self, oprot):
6190 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6191 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6192 
      return
6193 
    oprot.writeStructBegin('getAddressById_args')
6194 
    if self.addressId != None:
6195 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
6196 
      oprot.writeI64(self.addressId)
6197 
      oprot.writeFieldEnd()
6198 
    oprot.writeFieldStop()
6199 
    oprot.writeStructEnd()
6200 
 
6201 
  def __repr__(self):
6202 
    L = ['%s=%r' % (key, value)
6203 
      for key, value in self.__dict__.iteritems()]
6204 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6205 
 
6206 
  def __eq__(self, other):
6207 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6208 
 
6209 
  def __ne__(self, other):
6210 
    return not (self == other)
6211 
 
6212 
class getAddressById_result:
6213 
  """
6214 
  Attributes:
6215 
   - success
6216 
   - ucx
6217 
  """
6218 
 
6219 
  thrift_spec = (
6220 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
6221 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6222 
  )
6223 
 
6224 
  def __init__(self, success=None, ucx=None,):
6225 
    self.success = success
6226 
    self.ucx = ucx
6227 
 
6228 
  def read(self, iprot):
6229 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6230 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6231 
      return
6232 
    iprot.readStructBegin()
6233 
    while True:
6234 
      (fname, ftype, fid) = iprot.readFieldBegin()
6235 
      if ftype == TType.STOP:
6236 
        break
6237 
      if fid == 0:
6238 
        if ftype == TType.STRUCT:
6239 
          self.success = Address()
6240 
          self.success.read(iprot)
6241 
        else:
6242 
          iprot.skip(ftype)
6243 
      elif fid == 1:
6244 
        if ftype == TType.STRUCT:
6245 
          self.ucx = UserContextException()
6246 
          self.ucx.read(iprot)
6247 
        else:
6248 
          iprot.skip(ftype)
6249 
      else:
6250 
        iprot.skip(ftype)
6251 
      iprot.readFieldEnd()
6252 
    iprot.readStructEnd()
6253 
 
6254 
  def write(self, oprot):
6255 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6256 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6257 
      return
6258 
    oprot.writeStructBegin('getAddressById_result')
6259 
    if self.success != None:
6260 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6261 
      self.success.write(oprot)
6262 
      oprot.writeFieldEnd()
6263 
    if self.ucx != None:
6264 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6265 
      self.ucx.write(oprot)
6266 
      oprot.writeFieldEnd()
6267 
    oprot.writeFieldStop()
6268 
    oprot.writeStructEnd()
6269 
 
6270 
  def __repr__(self):
6271 
    L = ['%s=%r' % (key, value)
6272 
      for key, value in self.__dict__.iteritems()]
6273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6274 
 
6275 
  def __eq__(self, other):
6276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6277 
 
6278 
  def __ne__(self, other):
6279 
    return not (self == other)
6280 
 
594 rajveer 6281 
class getDefaultAddressId_args:
6282 
  """
6283 
  Attributes:
6284 
   - userId
6285 
  """
6286 
 
6287 
  thrift_spec = (
6288 
    None, # 0
6289 
    (1, TType.I64, 'userId', None, None, ), # 1
6290 
  )
6291 
 
6292 
  def __init__(self, userId=None,):
6293 
    self.userId = userId
6294 
 
6295 
  def read(self, iprot):
6296 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6297 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6298 
      return
6299 
    iprot.readStructBegin()
6300 
    while True:
6301 
      (fname, ftype, fid) = iprot.readFieldBegin()
6302 
      if ftype == TType.STOP:
6303 
        break
6304 
      if fid == 1:
6305 
        if ftype == TType.I64:
6306 
          self.userId = iprot.readI64();
6307 
        else:
6308 
          iprot.skip(ftype)
6309 
      else:
6310 
        iprot.skip(ftype)
6311 
      iprot.readFieldEnd()
6312 
    iprot.readStructEnd()
6313 
 
6314 
  def write(self, oprot):
6315 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6316 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6317 
      return
6318 
    oprot.writeStructBegin('getDefaultAddressId_args')
6319 
    if self.userId != None:
6320 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6321 
      oprot.writeI64(self.userId)
6322 
      oprot.writeFieldEnd()
6323 
    oprot.writeFieldStop()
6324 
    oprot.writeStructEnd()
6325 
 
6326 
  def __repr__(self):
6327 
    L = ['%s=%r' % (key, value)
6328 
      for key, value in self.__dict__.iteritems()]
6329 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6330 
 
6331 
  def __eq__(self, other):
6332 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6333 
 
6334 
  def __ne__(self, other):
6335 
    return not (self == other)
6336 
 
6337 
class getDefaultAddressId_result:
6338 
  """
6339 
  Attributes:
6340 
   - success
6341 
   - ucx
6342 
  """
6343 
 
6344 
  thrift_spec = (
6345 
    (0, TType.I64, 'success', None, None, ), # 0
6346 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6347 
  )
6348 
 
6349 
  def __init__(self, success=None, ucx=None,):
6350 
    self.success = success
6351 
    self.ucx = ucx
6352 
 
6353 
  def read(self, iprot):
6354 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6355 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6356 
      return
6357 
    iprot.readStructBegin()
6358 
    while True:
6359 
      (fname, ftype, fid) = iprot.readFieldBegin()
6360 
      if ftype == TType.STOP:
6361 
        break
6362 
      if fid == 0:
6363 
        if ftype == TType.I64:
6364 
          self.success = iprot.readI64();
6365 
        else:
6366 
          iprot.skip(ftype)
6367 
      elif fid == 1:
6368 
        if ftype == TType.STRUCT:
6369 
          self.ucx = UserContextException()
6370 
          self.ucx.read(iprot)
6371 
        else:
6372 
          iprot.skip(ftype)
6373 
      else:
6374 
        iprot.skip(ftype)
6375 
      iprot.readFieldEnd()
6376 
    iprot.readStructEnd()
6377 
 
6378 
  def write(self, oprot):
6379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6381 
      return
6382 
    oprot.writeStructBegin('getDefaultAddressId_result')
6383 
    if self.success != None:
6384 
      oprot.writeFieldBegin('success', TType.I64, 0)
6385 
      oprot.writeI64(self.success)
6386 
      oprot.writeFieldEnd()
6387 
    if self.ucx != None:
6388 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6389 
      self.ucx.write(oprot)
6390 
      oprot.writeFieldEnd()
6391 
    oprot.writeFieldStop()
6392 
    oprot.writeStructEnd()
6393 
 
6394 
  def __repr__(self):
6395 
    L = ['%s=%r' % (key, value)
6396 
      for key, value in self.__dict__.iteritems()]
6397 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6398 
 
6399 
  def __eq__(self, other):
6400 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6401 
 
6402 
  def __ne__(self, other):
6403 
    return not (self == other)
6404 
 
785 rajveer 6405 
class getDefaultPincode_args:
6406 
  """
6407 
  Attributes:
6408 
   - userId
6409 
  """
6410 
 
6411 
  thrift_spec = (
6412 
    None, # 0
6413 
    (1, TType.I64, 'userId', None, None, ), # 1
6414 
  )
6415 
 
6416 
  def __init__(self, userId=None,):
6417 
    self.userId = userId
6418 
 
6419 
  def read(self, iprot):
6420 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6421 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6422 
      return
6423 
    iprot.readStructBegin()
6424 
    while True:
6425 
      (fname, ftype, fid) = iprot.readFieldBegin()
6426 
      if ftype == TType.STOP:
6427 
        break
6428 
      if fid == 1:
6429 
        if ftype == TType.I64:
6430 
          self.userId = iprot.readI64();
6431 
        else:
6432 
          iprot.skip(ftype)
6433 
      else:
6434 
        iprot.skip(ftype)
6435 
      iprot.readFieldEnd()
6436 
    iprot.readStructEnd()
6437 
 
6438 
  def write(self, oprot):
6439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6441 
      return
6442 
    oprot.writeStructBegin('getDefaultPincode_args')
6443 
    if self.userId != None:
6444 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6445 
      oprot.writeI64(self.userId)
6446 
      oprot.writeFieldEnd()
6447 
    oprot.writeFieldStop()
6448 
    oprot.writeStructEnd()
6449 
 
6450 
  def __repr__(self):
6451 
    L = ['%s=%r' % (key, value)
6452 
      for key, value in self.__dict__.iteritems()]
6453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6454 
 
6455 
  def __eq__(self, other):
6456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6457 
 
6458 
  def __ne__(self, other):
6459 
    return not (self == other)
6460 
 
6461 
class getDefaultPincode_result:
6462 
  """
6463 
  Attributes:
6464 
   - success
6465 
   - ucx
6466 
  """
6467 
 
6468 
  thrift_spec = (
6469 
    (0, TType.STRING, 'success', None, None, ), # 0
6470 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6471 
  )
6472 
 
6473 
  def __init__(self, success=None, ucx=None,):
6474 
    self.success = success
6475 
    self.ucx = ucx
6476 
 
6477 
  def read(self, iprot):
6478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6480 
      return
6481 
    iprot.readStructBegin()
6482 
    while True:
6483 
      (fname, ftype, fid) = iprot.readFieldBegin()
6484 
      if ftype == TType.STOP:
6485 
        break
6486 
      if fid == 0:
6487 
        if ftype == TType.STRING:
6488 
          self.success = iprot.readString();
6489 
        else:
6490 
          iprot.skip(ftype)
6491 
      elif fid == 1:
6492 
        if ftype == TType.STRUCT:
6493 
          self.ucx = UserContextException()
6494 
          self.ucx.read(iprot)
6495 
        else:
6496 
          iprot.skip(ftype)
6497 
      else:
6498 
        iprot.skip(ftype)
6499 
      iprot.readFieldEnd()
6500 
    iprot.readStructEnd()
6501 
 
6502 
  def write(self, oprot):
6503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6505 
      return
6506 
    oprot.writeStructBegin('getDefaultPincode_result')
6507 
    if self.success != None:
6508 
      oprot.writeFieldBegin('success', TType.STRING, 0)
6509 
      oprot.writeString(self.success)
6510 
      oprot.writeFieldEnd()
6511 
    if self.ucx != None:
6512 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6513 
      self.ucx.write(oprot)
6514 
      oprot.writeFieldEnd()
6515 
    oprot.writeFieldStop()
6516 
    oprot.writeStructEnd()
6517 
 
6518 
  def __repr__(self):
6519 
    L = ['%s=%r' % (key, value)
6520 
      for key, value in self.__dict__.iteritems()]
6521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6522 
 
6523 
  def __eq__(self, other):
6524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6525 
 
6526 
  def __ne__(self, other):
6527 
    return not (self == other)
6528 
 
1274 varun.gupt 6529 
class saveUserCommunication_args:
6530 
  """
6531 
  Attributes:
6532 
   - userId
6533 
   - replyTo
6534 
   - communicationType
6535 
   - orderId
6536 
   - airwaybillNo
6537 
   - productName
6538 
   - subject
6539 
   - message
6540 
  """
6541 
 
6542 
  thrift_spec = (
6543 
    None, # 0
6544 
    (1, TType.I64, 'userId', None, None, ), # 1
6545 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
6546 
    (3, TType.I64, 'communicationType', None, None, ), # 3
6547 
    (4, TType.I64, 'orderId', None, None, ), # 4
6548 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
6549 
    (6, TType.STRING, 'productName', None, None, ), # 6
6550 
    (7, TType.STRING, 'subject', None, None, ), # 7
6551 
    (8, TType.STRING, 'message', None, None, ), # 8
6552 
  )
6553 
 
6554 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
6555 
    self.userId = userId
6556 
    self.replyTo = replyTo
6557 
    self.communicationType = communicationType
6558 
    self.orderId = orderId
6559 
    self.airwaybillNo = airwaybillNo
6560 
    self.productName = productName
6561 
    self.subject = subject
6562 
    self.message = message
6563 
 
6564 
  def read(self, iprot):
6565 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6566 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6567 
      return
6568 
    iprot.readStructBegin()
6569 
    while True:
6570 
      (fname, ftype, fid) = iprot.readFieldBegin()
6571 
      if ftype == TType.STOP:
6572 
        break
6573 
      if fid == 1:
6574 
        if ftype == TType.I64:
6575 
          self.userId = iprot.readI64();
6576 
        else:
6577 
          iprot.skip(ftype)
6578 
      elif fid == 2:
6579 
        if ftype == TType.STRING:
6580 
          self.replyTo = iprot.readString();
6581 
        else:
6582 
          iprot.skip(ftype)
6583 
      elif fid == 3:
6584 
        if ftype == TType.I64:
6585 
          self.communicationType = iprot.readI64();
6586 
        else:
6587 
          iprot.skip(ftype)
6588 
      elif fid == 4:
6589 
        if ftype == TType.I64:
6590 
          self.orderId = iprot.readI64();
6591 
        else:
6592 
          iprot.skip(ftype)
6593 
      elif fid == 5:
6594 
        if ftype == TType.STRING:
6595 
          self.airwaybillNo = iprot.readString();
6596 
        else:
6597 
          iprot.skip(ftype)
6598 
      elif fid == 6:
6599 
        if ftype == TType.STRING:
6600 
          self.productName = iprot.readString();
6601 
        else:
6602 
          iprot.skip(ftype)
6603 
      elif fid == 7:
6604 
        if ftype == TType.STRING:
6605 
          self.subject = iprot.readString();
6606 
        else:
6607 
          iprot.skip(ftype)
6608 
      elif fid == 8:
6609 
        if ftype == TType.STRING:
6610 
          self.message = iprot.readString();
6611 
        else:
6612 
          iprot.skip(ftype)
6613 
      else:
6614 
        iprot.skip(ftype)
6615 
      iprot.readFieldEnd()
6616 
    iprot.readStructEnd()
6617 
 
6618 
  def write(self, oprot):
6619 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6620 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6621 
      return
6622 
    oprot.writeStructBegin('saveUserCommunication_args')
6623 
    if self.userId != None:
6624 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6625 
      oprot.writeI64(self.userId)
6626 
      oprot.writeFieldEnd()
6627 
    if self.replyTo != None:
6628 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
6629 
      oprot.writeString(self.replyTo)
6630 
      oprot.writeFieldEnd()
6631 
    if self.communicationType != None:
6632 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
6633 
      oprot.writeI64(self.communicationType)
6634 
      oprot.writeFieldEnd()
6635 
    if self.orderId != None:
6636 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
6637 
      oprot.writeI64(self.orderId)
6638 
      oprot.writeFieldEnd()
6639 
    if self.airwaybillNo != None:
6640 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
6641 
      oprot.writeString(self.airwaybillNo)
6642 
      oprot.writeFieldEnd()
6643 
    if self.productName != None:
6644 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
6645 
      oprot.writeString(self.productName)
6646 
      oprot.writeFieldEnd()
6647 
    if self.subject != None:
6648 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
6649 
      oprot.writeString(self.subject)
6650 
      oprot.writeFieldEnd()
6651 
    if self.message != None:
6652 
      oprot.writeFieldBegin('message', TType.STRING, 8)
6653 
      oprot.writeString(self.message)
6654 
      oprot.writeFieldEnd()
6655 
    oprot.writeFieldStop()
6656 
    oprot.writeStructEnd()
6657 
 
6658 
  def __repr__(self):
6659 
    L = ['%s=%r' % (key, value)
6660 
      for key, value in self.__dict__.iteritems()]
6661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6662 
 
6663 
  def __eq__(self, other):
6664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6665 
 
6666 
  def __ne__(self, other):
6667 
    return not (self == other)
6668 
 
6669 
class saveUserCommunication_result:
6670 
  """
6671 
  Attributes:
6672 
   - success
6673 
   - ucx
6674 
  """
6675 
 
6676 
  thrift_spec = (
6677 
    (0, TType.BOOL, 'success', None, None, ), # 0
6678 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6679 
  )
6680 
 
6681 
  def __init__(self, success=None, ucx=None,):
6682 
    self.success = success
6683 
    self.ucx = ucx
6684 
 
6685 
  def read(self, iprot):
6686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6688 
      return
6689 
    iprot.readStructBegin()
6690 
    while True:
6691 
      (fname, ftype, fid) = iprot.readFieldBegin()
6692 
      if ftype == TType.STOP:
6693 
        break
6694 
      if fid == 0:
6695 
        if ftype == TType.BOOL:
6696 
          self.success = iprot.readBool();
6697 
        else:
6698 
          iprot.skip(ftype)
6699 
      elif fid == 1:
6700 
        if ftype == TType.STRUCT:
6701 
          self.ucx = UserCommunicationException()
6702 
          self.ucx.read(iprot)
6703 
        else:
6704 
          iprot.skip(ftype)
6705 
      else:
6706 
        iprot.skip(ftype)
6707 
      iprot.readFieldEnd()
6708 
    iprot.readStructEnd()
6709 
 
6710 
  def write(self, oprot):
6711 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6712 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6713 
      return
6714 
    oprot.writeStructBegin('saveUserCommunication_result')
6715 
    if self.success != None:
6716 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6717 
      oprot.writeBool(self.success)
6718 
      oprot.writeFieldEnd()
6719 
    if self.ucx != None:
6720 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6721 
      self.ucx.write(oprot)
6722 
      oprot.writeFieldEnd()
6723 
    oprot.writeFieldStop()
6724 
    oprot.writeStructEnd()
6725 
 
6726 
  def __repr__(self):
6727 
    L = ['%s=%r' % (key, value)
6728 
      for key, value in self.__dict__.iteritems()]
6729 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6730 
 
6731 
  def __eq__(self, other):
6732 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6733 
 
6734 
  def __ne__(self, other):
6735 
    return not (self == other)
6736 
 
1590 varun.gupt 6737 
class getUserCommunicationById_args:
6738 
  """
6739 
  Attributes:
6740 
   - id
6741 
  """
6742 
 
6743 
  thrift_spec = (
6744 
    None, # 0
6745 
    (1, TType.I64, 'id', None, None, ), # 1
6746 
  )
6747 
 
6748 
  def __init__(self, id=None,):
6749 
    self.id = id
6750 
 
6751 
  def read(self, iprot):
6752 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6753 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6754 
      return
6755 
    iprot.readStructBegin()
6756 
    while True:
6757 
      (fname, ftype, fid) = iprot.readFieldBegin()
6758 
      if ftype == TType.STOP:
6759 
        break
6760 
      if fid == 1:
6761 
        if ftype == TType.I64:
6762 
          self.id = iprot.readI64();
6763 
        else:
6764 
          iprot.skip(ftype)
6765 
      else:
6766 
        iprot.skip(ftype)
6767 
      iprot.readFieldEnd()
6768 
    iprot.readStructEnd()
6769 
 
6770 
  def write(self, oprot):
6771 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6772 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6773 
      return
6774 
    oprot.writeStructBegin('getUserCommunicationById_args')
6775 
    if self.id != None:
6776 
      oprot.writeFieldBegin('id', TType.I64, 1)
6777 
      oprot.writeI64(self.id)
6778 
      oprot.writeFieldEnd()
6779 
    oprot.writeFieldStop()
6780 
    oprot.writeStructEnd()
6781 
 
6782 
  def __repr__(self):
6783 
    L = ['%s=%r' % (key, value)
6784 
      for key, value in self.__dict__.iteritems()]
6785 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6786 
 
6787 
  def __eq__(self, other):
6788 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6789 
 
6790 
  def __ne__(self, other):
6791 
    return not (self == other)
6792 
 
6793 
class getUserCommunicationById_result:
6794 
  """
6795 
  Attributes:
6796 
   - success
6797 
   - ucx
6798 
  """
6799 
 
6800 
  thrift_spec = (
6801 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
6802 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6803 
  )
6804 
 
6805 
  def __init__(self, success=None, ucx=None,):
6806 
    self.success = success
6807 
    self.ucx = ucx
6808 
 
6809 
  def read(self, iprot):
6810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6812 
      return
6813 
    iprot.readStructBegin()
6814 
    while True:
6815 
      (fname, ftype, fid) = iprot.readFieldBegin()
6816 
      if ftype == TType.STOP:
6817 
        break
6818 
      if fid == 0:
6819 
        if ftype == TType.STRUCT:
6820 
          self.success = UserCommunication()
6821 
          self.success.read(iprot)
6822 
        else:
6823 
          iprot.skip(ftype)
6824 
      elif fid == 1:
6825 
        if ftype == TType.STRUCT:
6826 
          self.ucx = UserCommunicationException()
6827 
          self.ucx.read(iprot)
6828 
        else:
6829 
          iprot.skip(ftype)
6830 
      else:
6831 
        iprot.skip(ftype)
6832 
      iprot.readFieldEnd()
6833 
    iprot.readStructEnd()
6834 
 
6835 
  def write(self, oprot):
6836 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6837 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6838 
      return
6839 
    oprot.writeStructBegin('getUserCommunicationById_result')
6840 
    if self.success != None:
6841 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6842 
      self.success.write(oprot)
6843 
      oprot.writeFieldEnd()
6844 
    if self.ucx != None:
6845 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6846 
      self.ucx.write(oprot)
6847 
      oprot.writeFieldEnd()
6848 
    oprot.writeFieldStop()
6849 
    oprot.writeStructEnd()
6850 
 
6851 
  def __repr__(self):
6852 
    L = ['%s=%r' % (key, value)
6853 
      for key, value in self.__dict__.iteritems()]
6854 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6855 
 
6856 
  def __eq__(self, other):
6857 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6858 
 
6859 
  def __ne__(self, other):
6860 
    return not (self == other)
6861 
 
6862 
class getUserCommunicationByUser_args:
6863 
  """
6864 
  Attributes:
6865 
   - userId
6866 
  """
6867 
 
6868 
  thrift_spec = (
6869 
    None, # 0
6870 
    (1, TType.I64, 'userId', None, None, ), # 1
6871 
  )
6872 
 
6873 
  def __init__(self, userId=None,):
6874 
    self.userId = userId
6875 
 
6876 
  def read(self, iprot):
6877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6879 
      return
6880 
    iprot.readStructBegin()
6881 
    while True:
6882 
      (fname, ftype, fid) = iprot.readFieldBegin()
6883 
      if ftype == TType.STOP:
6884 
        break
6885 
      if fid == 1:
6886 
        if ftype == TType.I64:
6887 
          self.userId = iprot.readI64();
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('getUserCommunicationByUser_args')
6900 
    if self.userId != None:
6901 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6902 
      oprot.writeI64(self.userId)
6903 
      oprot.writeFieldEnd()
6904 
    oprot.writeFieldStop()
6905 
    oprot.writeStructEnd()
6906 
 
6907 
  def __repr__(self):
6908 
    L = ['%s=%r' % (key, value)
6909 
      for key, value in self.__dict__.iteritems()]
6910 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6911 
 
6912 
  def __eq__(self, other):
6913 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6914 
 
6915 
  def __ne__(self, other):
6916 
    return not (self == other)
6917 
 
6918 
class getUserCommunicationByUser_result:
6919 
  """
6920 
  Attributes:
6921 
   - success
6922 
   - ucx
6923 
  """
6924 
 
6925 
  thrift_spec = (
6926 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
6927 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6928 
  )
6929 
 
6930 
  def __init__(self, success=None, ucx=None,):
6931 
    self.success = success
6932 
    self.ucx = ucx
6933 
 
6934 
  def read(self, iprot):
6935 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6936 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6937 
      return
6938 
    iprot.readStructBegin()
6939 
    while True:
6940 
      (fname, ftype, fid) = iprot.readFieldBegin()
6941 
      if ftype == TType.STOP:
6942 
        break
6943 
      if fid == 0:
6944 
        if ftype == TType.LIST:
6945 
          self.success = []
2981 rajveer 6946 
          (_etype38, _size35) = iprot.readListBegin()
6947 
          for _i39 in xrange(_size35):
6948 
            _elem40 = UserCommunication()
6949 
            _elem40.read(iprot)
6950 
            self.success.append(_elem40)
1590 varun.gupt 6951 
          iprot.readListEnd()
6952 
        else:
6953 
          iprot.skip(ftype)
6954 
      elif fid == 1:
6955 
        if ftype == TType.STRUCT:
6956 
          self.ucx = UserCommunicationException()
6957 
          self.ucx.read(iprot)
6958 
        else:
6959 
          iprot.skip(ftype)
6960 
      else:
6961 
        iprot.skip(ftype)
6962 
      iprot.readFieldEnd()
6963 
    iprot.readStructEnd()
6964 
 
6965 
  def write(self, oprot):
6966 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6967 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6968 
      return
6969 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
6970 
    if self.success != None:
6971 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6972 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 6973 
      for iter41 in self.success:
6974 
        iter41.write(oprot)
1590 varun.gupt 6975 
      oprot.writeListEnd()
6976 
      oprot.writeFieldEnd()
6977 
    if self.ucx != None:
6978 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6979 
      self.ucx.write(oprot)
6980 
      oprot.writeFieldEnd()
6981 
    oprot.writeFieldStop()
6982 
    oprot.writeStructEnd()
6983 
 
6984 
  def __repr__(self):
6985 
    L = ['%s=%r' % (key, value)
6986 
      for key, value in self.__dict__.iteritems()]
6987 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6988 
 
6989 
  def __eq__(self, other):
6990 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6991 
 
6992 
  def __ne__(self, other):
6993 
    return not (self == other)
6994 
 
6995 
class getAllUserCommunications_args:
6996 
 
6997 
  thrift_spec = (
6998 
  )
6999 
 
7000 
  def read(self, iprot):
7001 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7002 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7003 
      return
7004 
    iprot.readStructBegin()
7005 
    while True:
7006 
      (fname, ftype, fid) = iprot.readFieldBegin()
7007 
      if ftype == TType.STOP:
7008 
        break
7009 
      else:
7010 
        iprot.skip(ftype)
7011 
      iprot.readFieldEnd()
7012 
    iprot.readStructEnd()
7013 
 
7014 
  def write(self, oprot):
7015 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7016 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7017 
      return
7018 
    oprot.writeStructBegin('getAllUserCommunications_args')
7019 
    oprot.writeFieldStop()
7020 
    oprot.writeStructEnd()
7021 
 
7022 
  def __repr__(self):
7023 
    L = ['%s=%r' % (key, value)
7024 
      for key, value in self.__dict__.iteritems()]
7025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7026 
 
7027 
  def __eq__(self, other):
7028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7029 
 
7030 
  def __ne__(self, other):
7031 
    return not (self == other)
7032 
 
7033 
class getAllUserCommunications_result:
7034 
  """
7035 
  Attributes:
7036 
   - success
7037 
   - ucx
7038 
  """
7039 
 
7040 
  thrift_spec = (
7041 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
7042 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7043 
  )
7044 
 
7045 
  def __init__(self, success=None, ucx=None,):
7046 
    self.success = success
7047 
    self.ucx = ucx
7048 
 
7049 
  def read(self, iprot):
7050 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7051 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7052 
      return
7053 
    iprot.readStructBegin()
7054 
    while True:
7055 
      (fname, ftype, fid) = iprot.readFieldBegin()
7056 
      if ftype == TType.STOP:
7057 
        break
7058 
      if fid == 0:
7059 
        if ftype == TType.LIST:
7060 
          self.success = []
2981 rajveer 7061 
          (_etype45, _size42) = iprot.readListBegin()
7062 
          for _i46 in xrange(_size42):
7063 
            _elem47 = UserCommunication()
7064 
            _elem47.read(iprot)
7065 
            self.success.append(_elem47)
1590 varun.gupt 7066 
          iprot.readListEnd()
7067 
        else:
7068 
          iprot.skip(ftype)
7069 
      elif fid == 1:
7070 
        if ftype == TType.STRUCT:
7071 
          self.ucx = UserCommunicationException()
7072 
          self.ucx.read(iprot)
7073 
        else:
7074 
          iprot.skip(ftype)
7075 
      else:
7076 
        iprot.skip(ftype)
7077 
      iprot.readFieldEnd()
7078 
    iprot.readStructEnd()
7079 
 
7080 
  def write(self, oprot):
7081 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7082 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7083 
      return
7084 
    oprot.writeStructBegin('getAllUserCommunications_result')
7085 
    if self.success != None:
7086 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7087 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 7088 
      for iter48 in self.success:
7089 
        iter48.write(oprot)
1590 varun.gupt 7090 
      oprot.writeListEnd()
7091 
      oprot.writeFieldEnd()
7092 
    if self.ucx != None:
7093 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7094 
      self.ucx.write(oprot)
7095 
      oprot.writeFieldEnd()
7096 
    oprot.writeFieldStop()
7097 
    oprot.writeStructEnd()
7098 
 
7099 
  def __repr__(self):
7100 
    L = ['%s=%r' % (key, value)
7101 
      for key, value in self.__dict__.iteritems()]
7102 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7103 
 
7104 
  def __eq__(self, other):
7105 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7106 
 
7107 
  def __ne__(self, other):
7108 
    return not (self == other)
7109 
 
1845 vikas 7110 
class createMasterAffiliate_args:
7111 
  """
7112 
  Attributes:
7113 
   - name
1859 vikas 7114 
   - addedOn
1845 vikas 7115 
  """
7116 
 
7117 
  thrift_spec = (
7118 
    None, # 0
7119 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 7120 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 7121 
  )
7122 
 
1859 vikas 7123 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 7124 
    self.name = name
1859 vikas 7125 
    self.addedOn = addedOn
1845 vikas 7126 
 
7127 
  def read(self, iprot):
7128 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7129 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7130 
      return
7131 
    iprot.readStructBegin()
7132 
    while True:
7133 
      (fname, ftype, fid) = iprot.readFieldBegin()
7134 
      if ftype == TType.STOP:
7135 
        break
7136 
      if fid == 1:
7137 
        if ftype == TType.STRING:
7138 
          self.name = iprot.readString();
7139 
        else:
7140 
          iprot.skip(ftype)
1859 vikas 7141 
      elif fid == 2:
7142 
        if ftype == TType.I64:
7143 
          self.addedOn = iprot.readI64();
7144 
        else:
7145 
          iprot.skip(ftype)
1845 vikas 7146 
      else:
7147 
        iprot.skip(ftype)
7148 
      iprot.readFieldEnd()
7149 
    iprot.readStructEnd()
7150 
 
7151 
  def write(self, oprot):
7152 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7153 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7154 
      return
7155 
    oprot.writeStructBegin('createMasterAffiliate_args')
7156 
    if self.name != None:
7157 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7158 
      oprot.writeString(self.name)
7159 
      oprot.writeFieldEnd()
1859 vikas 7160 
    if self.addedOn != None:
7161 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
7162 
      oprot.writeI64(self.addedOn)
7163 
      oprot.writeFieldEnd()
1845 vikas 7164 
    oprot.writeFieldStop()
7165 
    oprot.writeStructEnd()
7166 
 
7167 
  def __repr__(self):
7168 
    L = ['%s=%r' % (key, value)
7169 
      for key, value in self.__dict__.iteritems()]
7170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7171 
 
7172 
  def __eq__(self, other):
7173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7174 
 
7175 
  def __ne__(self, other):
7176 
    return not (self == other)
7177 
 
7178 
class createMasterAffiliate_result:
7179 
  """
7180 
  Attributes:
7181 
   - success
7182 
   - utx
7183 
  """
7184 
 
7185 
  thrift_spec = (
7186 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7187 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7188 
  )
7189 
 
7190 
  def __init__(self, success=None, utx=None,):
7191 
    self.success = success
7192 
    self.utx = utx
7193 
 
7194 
  def read(self, iprot):
7195 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7196 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7197 
      return
7198 
    iprot.readStructBegin()
7199 
    while True:
7200 
      (fname, ftype, fid) = iprot.readFieldBegin()
7201 
      if ftype == TType.STOP:
7202 
        break
7203 
      if fid == 0:
7204 
        if ftype == TType.STRUCT:
7205 
          self.success = MasterAffiliate()
7206 
          self.success.read(iprot)
7207 
        else:
7208 
          iprot.skip(ftype)
7209 
      elif fid == 1:
7210 
        if ftype == TType.STRUCT:
1996 vikas 7211 
          self.utx = UserAffiliateException()
1845 vikas 7212 
          self.utx.read(iprot)
7213 
        else:
7214 
          iprot.skip(ftype)
7215 
      else:
7216 
        iprot.skip(ftype)
7217 
      iprot.readFieldEnd()
7218 
    iprot.readStructEnd()
7219 
 
7220 
  def write(self, oprot):
7221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7223 
      return
7224 
    oprot.writeStructBegin('createMasterAffiliate_result')
7225 
    if self.success != None:
7226 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7227 
      self.success.write(oprot)
7228 
      oprot.writeFieldEnd()
7229 
    if self.utx != None:
7230 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7231 
      self.utx.write(oprot)
7232 
      oprot.writeFieldEnd()
7233 
    oprot.writeFieldStop()
7234 
    oprot.writeStructEnd()
7235 
 
7236 
  def __repr__(self):
7237 
    L = ['%s=%r' % (key, value)
7238 
      for key, value in self.__dict__.iteritems()]
7239 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7240 
 
7241 
  def __eq__(self, other):
7242 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7243 
 
7244 
  def __ne__(self, other):
7245 
    return not (self == other)
7246 
 
1899 vikas 7247 
class getAllMasterAffiliates_args:
7248 
 
7249 
  thrift_spec = (
7250 
  )
7251 
 
7252 
  def read(self, iprot):
7253 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7254 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7255 
      return
7256 
    iprot.readStructBegin()
7257 
    while True:
7258 
      (fname, ftype, fid) = iprot.readFieldBegin()
7259 
      if ftype == TType.STOP:
7260 
        break
7261 
      else:
7262 
        iprot.skip(ftype)
7263 
      iprot.readFieldEnd()
7264 
    iprot.readStructEnd()
7265 
 
7266 
  def write(self, oprot):
7267 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7268 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7269 
      return
7270 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
7271 
    oprot.writeFieldStop()
7272 
    oprot.writeStructEnd()
7273 
 
7274 
  def __repr__(self):
7275 
    L = ['%s=%r' % (key, value)
7276 
      for key, value in self.__dict__.iteritems()]
7277 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7278 
 
7279 
  def __eq__(self, other):
7280 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7281 
 
7282 
  def __ne__(self, other):
7283 
    return not (self == other)
7284 
 
7285 
class getAllMasterAffiliates_result:
7286 
  """
7287 
  Attributes:
7288 
   - success
7289 
   - utx
7290 
  """
7291 
 
7292 
  thrift_spec = (
7293 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 7294 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 7295 
  )
7296 
 
7297 
  def __init__(self, success=None, utx=None,):
7298 
    self.success = success
7299 
    self.utx = utx
7300 
 
7301 
  def read(self, iprot):
7302 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7303 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7304 
      return
7305 
    iprot.readStructBegin()
7306 
    while True:
7307 
      (fname, ftype, fid) = iprot.readFieldBegin()
7308 
      if ftype == TType.STOP:
7309 
        break
7310 
      if fid == 0:
7311 
        if ftype == TType.LIST:
7312 
          self.success = []
2981 rajveer 7313 
          (_etype52, _size49) = iprot.readListBegin()
7314 
          for _i53 in xrange(_size49):
7315 
            _elem54 = MasterAffiliate()
7316 
            _elem54.read(iprot)
7317 
            self.success.append(_elem54)
1899 vikas 7318 
          iprot.readListEnd()
7319 
        else:
7320 
          iprot.skip(ftype)
7321 
      elif fid == 1:
7322 
        if ftype == TType.STRUCT:
1996 vikas 7323 
          self.utx = UserAffiliateException()
1899 vikas 7324 
          self.utx.read(iprot)
7325 
        else:
7326 
          iprot.skip(ftype)
7327 
      else:
7328 
        iprot.skip(ftype)
7329 
      iprot.readFieldEnd()
7330 
    iprot.readStructEnd()
7331 
 
7332 
  def write(self, oprot):
7333 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7334 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7335 
      return
7336 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
7337 
    if self.success != None:
7338 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7339 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 7340 
      for iter55 in self.success:
7341 
        iter55.write(oprot)
1899 vikas 7342 
      oprot.writeListEnd()
7343 
      oprot.writeFieldEnd()
7344 
    if self.utx != None:
7345 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7346 
      self.utx.write(oprot)
7347 
      oprot.writeFieldEnd()
7348 
    oprot.writeFieldStop()
7349 
    oprot.writeStructEnd()
7350 
 
7351 
  def __repr__(self):
7352 
    L = ['%s=%r' % (key, value)
7353 
      for key, value in self.__dict__.iteritems()]
7354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7355 
 
7356 
  def __eq__(self, other):
7357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7358 
 
7359 
  def __ne__(self, other):
7360 
    return not (self == other)
7361 
 
1845 vikas 7362 
class getMasterAffiliateById_args:
7363 
  """
7364 
  Attributes:
7365 
   - id
7366 
  """
7367 
 
7368 
  thrift_spec = (
7369 
    None, # 0
7370 
    (1, TType.I64, 'id', None, None, ), # 1
7371 
  )
7372 
 
7373 
  def __init__(self, id=None,):
7374 
    self.id = id
7375 
 
7376 
  def read(self, iprot):
7377 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7378 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7379 
      return
7380 
    iprot.readStructBegin()
7381 
    while True:
7382 
      (fname, ftype, fid) = iprot.readFieldBegin()
7383 
      if ftype == TType.STOP:
7384 
        break
7385 
      if fid == 1:
7386 
        if ftype == TType.I64:
7387 
          self.id = iprot.readI64();
7388 
        else:
7389 
          iprot.skip(ftype)
7390 
      else:
7391 
        iprot.skip(ftype)
7392 
      iprot.readFieldEnd()
7393 
    iprot.readStructEnd()
7394 
 
7395 
  def write(self, oprot):
7396 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7397 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7398 
      return
7399 
    oprot.writeStructBegin('getMasterAffiliateById_args')
7400 
    if self.id != None:
7401 
      oprot.writeFieldBegin('id', TType.I64, 1)
7402 
      oprot.writeI64(self.id)
7403 
      oprot.writeFieldEnd()
7404 
    oprot.writeFieldStop()
7405 
    oprot.writeStructEnd()
7406 
 
7407 
  def __repr__(self):
7408 
    L = ['%s=%r' % (key, value)
7409 
      for key, value in self.__dict__.iteritems()]
7410 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7411 
 
7412 
  def __eq__(self, other):
7413 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7414 
 
7415 
  def __ne__(self, other):
7416 
    return not (self == other)
7417 
 
7418 
class getMasterAffiliateById_result:
7419 
  """
7420 
  Attributes:
7421 
   - success
7422 
   - utx
7423 
  """
7424 
 
7425 
  thrift_spec = (
7426 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7427 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7428 
  )
7429 
 
7430 
  def __init__(self, success=None, utx=None,):
7431 
    self.success = success
7432 
    self.utx = utx
7433 
 
7434 
  def read(self, iprot):
7435 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7436 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7437 
      return
7438 
    iprot.readStructBegin()
7439 
    while True:
7440 
      (fname, ftype, fid) = iprot.readFieldBegin()
7441 
      if ftype == TType.STOP:
7442 
        break
7443 
      if fid == 0:
7444 
        if ftype == TType.STRUCT:
7445 
          self.success = MasterAffiliate()
7446 
          self.success.read(iprot)
7447 
        else:
7448 
          iprot.skip(ftype)
7449 
      elif fid == 1:
7450 
        if ftype == TType.STRUCT:
1996 vikas 7451 
          self.utx = UserAffiliateException()
1845 vikas 7452 
          self.utx.read(iprot)
7453 
        else:
7454 
          iprot.skip(ftype)
7455 
      else:
7456 
        iprot.skip(ftype)
7457 
      iprot.readFieldEnd()
7458 
    iprot.readStructEnd()
7459 
 
7460 
  def write(self, oprot):
7461 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7462 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7463 
      return
7464 
    oprot.writeStructBegin('getMasterAffiliateById_result')
7465 
    if self.success != None:
7466 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7467 
      self.success.write(oprot)
7468 
      oprot.writeFieldEnd()
7469 
    if self.utx != None:
7470 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7471 
      self.utx.write(oprot)
7472 
      oprot.writeFieldEnd()
7473 
    oprot.writeFieldStop()
7474 
    oprot.writeStructEnd()
7475 
 
7476 
  def __repr__(self):
7477 
    L = ['%s=%r' % (key, value)
7478 
      for key, value in self.__dict__.iteritems()]
7479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7480 
 
7481 
  def __eq__(self, other):
7482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7483 
 
7484 
  def __ne__(self, other):
7485 
    return not (self == other)
7486 
 
7487 
class getMasterAffiliateByName_args:
7488 
  """
7489 
  Attributes:
7490 
   - name
7491 
  """
7492 
 
7493 
  thrift_spec = (
7494 
    None, # 0
7495 
    (1, TType.STRING, 'name', None, None, ), # 1
7496 
  )
7497 
 
7498 
  def __init__(self, name=None,):
7499 
    self.name = name
7500 
 
7501 
  def read(self, iprot):
7502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7504 
      return
7505 
    iprot.readStructBegin()
7506 
    while True:
7507 
      (fname, ftype, fid) = iprot.readFieldBegin()
7508 
      if ftype == TType.STOP:
7509 
        break
7510 
      if fid == 1:
7511 
        if ftype == TType.STRING:
7512 
          self.name = iprot.readString();
7513 
        else:
7514 
          iprot.skip(ftype)
7515 
      else:
7516 
        iprot.skip(ftype)
7517 
      iprot.readFieldEnd()
7518 
    iprot.readStructEnd()
7519 
 
7520 
  def write(self, oprot):
7521 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7522 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7523 
      return
7524 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
7525 
    if self.name != None:
7526 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7527 
      oprot.writeString(self.name)
7528 
      oprot.writeFieldEnd()
7529 
    oprot.writeFieldStop()
7530 
    oprot.writeStructEnd()
7531 
 
7532 
  def __repr__(self):
7533 
    L = ['%s=%r' % (key, value)
7534 
      for key, value in self.__dict__.iteritems()]
7535 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7536 
 
7537 
  def __eq__(self, other):
7538 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7539 
 
7540 
  def __ne__(self, other):
7541 
    return not (self == other)
7542 
 
7543 
class getMasterAffiliateByName_result:
7544 
  """
7545 
  Attributes:
7546 
   - success
7547 
   - utx
7548 
  """
7549 
 
7550 
  thrift_spec = (
7551 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7552 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7553 
  )
7554 
 
7555 
  def __init__(self, success=None, utx=None,):
7556 
    self.success = success
7557 
    self.utx = utx
7558 
 
7559 
  def read(self, iprot):
7560 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7561 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7562 
      return
7563 
    iprot.readStructBegin()
7564 
    while True:
7565 
      (fname, ftype, fid) = iprot.readFieldBegin()
7566 
      if ftype == TType.STOP:
7567 
        break
7568 
      if fid == 0:
7569 
        if ftype == TType.STRUCT:
7570 
          self.success = MasterAffiliate()
7571 
          self.success.read(iprot)
7572 
        else:
7573 
          iprot.skip(ftype)
7574 
      elif fid == 1:
7575 
        if ftype == TType.STRUCT:
1996 vikas 7576 
          self.utx = UserAffiliateException()
1845 vikas 7577 
          self.utx.read(iprot)
7578 
        else:
7579 
          iprot.skip(ftype)
7580 
      else:
7581 
        iprot.skip(ftype)
7582 
      iprot.readFieldEnd()
7583 
    iprot.readStructEnd()
7584 
 
7585 
  def write(self, oprot):
7586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7588 
      return
7589 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
7590 
    if self.success != None:
7591 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7592 
      self.success.write(oprot)
7593 
      oprot.writeFieldEnd()
7594 
    if self.utx != None:
7595 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7596 
      self.utx.write(oprot)
7597 
      oprot.writeFieldEnd()
7598 
    oprot.writeFieldStop()
7599 
    oprot.writeStructEnd()
7600 
 
7601 
  def __repr__(self):
7602 
    L = ['%s=%r' % (key, value)
7603 
      for key, value in self.__dict__.iteritems()]
7604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7605 
 
7606 
  def __eq__(self, other):
7607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7608 
 
7609 
  def __ne__(self, other):
7610 
    return not (self == other)
7611 
 
7612 
class createAffiliate_args:
7613 
  """
7614 
  Attributes:
7615 
   - name
7616 
   - url
7617 
   - masterAffiliateId
1859 vikas 7618 
   - addedOn
1845 vikas 7619 
  """
7620 
 
7621 
  thrift_spec = (
7622 
    None, # 0
7623 
    (1, TType.STRING, 'name', None, None, ), # 1
7624 
    (2, TType.STRING, 'url', None, None, ), # 2
7625 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 7626 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 7627 
  )
7628 
 
1859 vikas 7629 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 7630 
    self.name = name
7631 
    self.url = url
7632 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 7633 
    self.addedOn = addedOn
1845 vikas 7634 
 
7635 
  def read(self, iprot):
7636 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7637 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7638 
      return
7639 
    iprot.readStructBegin()
7640 
    while True:
7641 
      (fname, ftype, fid) = iprot.readFieldBegin()
7642 
      if ftype == TType.STOP:
7643 
        break
7644 
      if fid == 1:
7645 
        if ftype == TType.STRING:
7646 
          self.name = iprot.readString();
7647 
        else:
7648 
          iprot.skip(ftype)
7649 
      elif fid == 2:
7650 
        if ftype == TType.STRING:
7651 
          self.url = iprot.readString();
7652 
        else:
7653 
          iprot.skip(ftype)
7654 
      elif fid == 3:
7655 
        if ftype == TType.I64:
7656 
          self.masterAffiliateId = iprot.readI64();
7657 
        else:
7658 
          iprot.skip(ftype)
1859 vikas 7659 
      elif fid == 4:
7660 
        if ftype == TType.I64:
7661 
          self.addedOn = iprot.readI64();
7662 
        else:
7663 
          iprot.skip(ftype)
1845 vikas 7664 
      else:
7665 
        iprot.skip(ftype)
7666 
      iprot.readFieldEnd()
7667 
    iprot.readStructEnd()
7668 
 
7669 
  def write(self, oprot):
7670 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7671 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7672 
      return
7673 
    oprot.writeStructBegin('createAffiliate_args')
7674 
    if self.name != None:
7675 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7676 
      oprot.writeString(self.name)
7677 
      oprot.writeFieldEnd()
7678 
    if self.url != None:
7679 
      oprot.writeFieldBegin('url', TType.STRING, 2)
7680 
      oprot.writeString(self.url)
7681 
      oprot.writeFieldEnd()
7682 
    if self.masterAffiliateId != None:
7683 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
7684 
      oprot.writeI64(self.masterAffiliateId)
7685 
      oprot.writeFieldEnd()
1859 vikas 7686 
    if self.addedOn != None:
7687 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
7688 
      oprot.writeI64(self.addedOn)
7689 
      oprot.writeFieldEnd()
1845 vikas 7690 
    oprot.writeFieldStop()
7691 
    oprot.writeStructEnd()
7692 
 
7693 
  def __repr__(self):
7694 
    L = ['%s=%r' % (key, value)
7695 
      for key, value in self.__dict__.iteritems()]
7696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7697 
 
7698 
  def __eq__(self, other):
7699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7700 
 
7701 
  def __ne__(self, other):
7702 
    return not (self == other)
7703 
 
7704 
class createAffiliate_result:
7705 
  """
7706 
  Attributes:
7707 
   - success
7708 
   - utx
7709 
  """
7710 
 
7711 
  thrift_spec = (
7712 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 7713 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7714 
  )
7715 
 
7716 
  def __init__(self, success=None, utx=None,):
7717 
    self.success = success
7718 
    self.utx = utx
7719 
 
7720 
  def read(self, iprot):
7721 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7722 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7723 
      return
7724 
    iprot.readStructBegin()
7725 
    while True:
7726 
      (fname, ftype, fid) = iprot.readFieldBegin()
7727 
      if ftype == TType.STOP:
7728 
        break
7729 
      if fid == 0:
7730 
        if ftype == TType.STRUCT:
7731 
          self.success = Affiliate()
7732 
          self.success.read(iprot)
7733 
        else:
7734 
          iprot.skip(ftype)
7735 
      elif fid == 1:
7736 
        if ftype == TType.STRUCT:
1996 vikas 7737 
          self.utx = UserAffiliateException()
1845 vikas 7738 
          self.utx.read(iprot)
7739 
        else:
7740 
          iprot.skip(ftype)
7741 
      else:
7742 
        iprot.skip(ftype)
7743 
      iprot.readFieldEnd()
7744 
    iprot.readStructEnd()
7745 
 
7746 
  def write(self, oprot):
7747 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7748 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7749 
      return
7750 
    oprot.writeStructBegin('createAffiliate_result')
7751 
    if self.success != None:
7752 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7753 
      self.success.write(oprot)
7754 
      oprot.writeFieldEnd()
7755 
    if self.utx != None:
7756 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7757 
      self.utx.write(oprot)
7758 
      oprot.writeFieldEnd()
7759 
    oprot.writeFieldStop()
7760 
    oprot.writeStructEnd()
7761 
 
7762 
  def __repr__(self):
7763 
    L = ['%s=%r' % (key, value)
7764 
      for key, value in self.__dict__.iteritems()]
7765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7766 
 
7767 
  def __eq__(self, other):
7768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7769 
 
7770 
  def __ne__(self, other):
7771 
    return not (self == other)
7772 
 
7773 
class getAffiliateById_args:
7774 
  """
7775 
  Attributes:
7776 
   - id
7777 
  """
7778 
 
7779 
  thrift_spec = (
7780 
    None, # 0
7781 
    (1, TType.I64, 'id', None, None, ), # 1
7782 
  )
7783 
 
7784 
  def __init__(self, id=None,):
7785 
    self.id = id
7786 
 
7787 
  def read(self, iprot):
7788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7790 
      return
7791 
    iprot.readStructBegin()
7792 
    while True:
7793 
      (fname, ftype, fid) = iprot.readFieldBegin()
7794 
      if ftype == TType.STOP:
7795 
        break
7796 
      if fid == 1:
7797 
        if ftype == TType.I64:
7798 
          self.id = iprot.readI64();
7799 
        else:
7800 
          iprot.skip(ftype)
7801 
      else:
7802 
        iprot.skip(ftype)
7803 
      iprot.readFieldEnd()
7804 
    iprot.readStructEnd()
7805 
 
7806 
  def write(self, oprot):
7807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7809 
      return
7810 
    oprot.writeStructBegin('getAffiliateById_args')
7811 
    if self.id != None:
7812 
      oprot.writeFieldBegin('id', TType.I64, 1)
7813 
      oprot.writeI64(self.id)
7814 
      oprot.writeFieldEnd()
7815 
    oprot.writeFieldStop()
7816 
    oprot.writeStructEnd()
7817 
 
7818 
  def __repr__(self):
7819 
    L = ['%s=%r' % (key, value)
7820 
      for key, value in self.__dict__.iteritems()]
7821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7822 
 
7823 
  def __eq__(self, other):
7824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7825 
 
7826 
  def __ne__(self, other):
7827 
    return not (self == other)
7828 
 
7829 
class getAffiliateById_result:
7830 
  """
7831 
  Attributes:
7832 
   - success
7833 
   - utx
7834 
  """
7835 
 
7836 
  thrift_spec = (
7837 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 7838 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7839 
  )
7840 
 
7841 
  def __init__(self, success=None, utx=None,):
7842 
    self.success = success
7843 
    self.utx = utx
7844 
 
7845 
  def read(self, iprot):
7846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7848 
      return
7849 
    iprot.readStructBegin()
7850 
    while True:
7851 
      (fname, ftype, fid) = iprot.readFieldBegin()
7852 
      if ftype == TType.STOP:
7853 
        break
7854 
      if fid == 0:
7855 
        if ftype == TType.STRUCT:
7856 
          self.success = Affiliate()
7857 
          self.success.read(iprot)
7858 
        else:
7859 
          iprot.skip(ftype)
7860 
      elif fid == 1:
7861 
        if ftype == TType.STRUCT:
1996 vikas 7862 
          self.utx = UserAffiliateException()
1845 vikas 7863 
          self.utx.read(iprot)
7864 
        else:
7865 
          iprot.skip(ftype)
7866 
      else:
7867 
        iprot.skip(ftype)
7868 
      iprot.readFieldEnd()
7869 
    iprot.readStructEnd()
7870 
 
7871 
  def write(self, oprot):
7872 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7873 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7874 
      return
7875 
    oprot.writeStructBegin('getAffiliateById_result')
7876 
    if self.success != None:
7877 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7878 
      self.success.write(oprot)
7879 
      oprot.writeFieldEnd()
7880 
    if self.utx != None:
7881 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7882 
      self.utx.write(oprot)
7883 
      oprot.writeFieldEnd()
7884 
    oprot.writeFieldStop()
7885 
    oprot.writeStructEnd()
7886 
 
7887 
  def __repr__(self):
7888 
    L = ['%s=%r' % (key, value)
7889 
      for key, value in self.__dict__.iteritems()]
7890 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7891 
 
7892 
  def __eq__(self, other):
7893 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7894 
 
7895 
  def __ne__(self, other):
7896 
    return not (self == other)
7897 
 
7898 
class getAffiliateByName_args:
7899 
  """
7900 
  Attributes:
7901 
   - name
7902 
  """
7903 
 
7904 
  thrift_spec = (
7905 
    None, # 0
7906 
    (1, TType.STRING, 'name', None, None, ), # 1
7907 
  )
7908 
 
7909 
  def __init__(self, name=None,):
7910 
    self.name = name
7911 
 
7912 
  def read(self, iprot):
7913 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7914 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7915 
      return
7916 
    iprot.readStructBegin()
7917 
    while True:
7918 
      (fname, ftype, fid) = iprot.readFieldBegin()
7919 
      if ftype == TType.STOP:
7920 
        break
7921 
      if fid == 1:
7922 
        if ftype == TType.STRING:
7923 
          self.name = iprot.readString();
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('getAffiliateByName_args')
7936 
    if self.name != None:
7937 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7938 
      oprot.writeString(self.name)
7939 
      oprot.writeFieldEnd()
7940 
    oprot.writeFieldStop()
7941 
    oprot.writeStructEnd()
7942 
 
7943 
  def __repr__(self):
7944 
    L = ['%s=%r' % (key, value)
7945 
      for key, value in self.__dict__.iteritems()]
7946 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7947 
 
7948 
  def __eq__(self, other):
7949 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7950 
 
7951 
  def __ne__(self, other):
7952 
    return not (self == other)
7953 
 
7954 
class getAffiliateByName_result:
7955 
  """
7956 
  Attributes:
7957 
   - success
7958 
   - utx
7959 
  """
7960 
 
7961 
  thrift_spec = (
7962 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 7963 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7964 
  )
7965 
 
7966 
  def __init__(self, success=None, utx=None,):
7967 
    self.success = success
7968 
    self.utx = utx
7969 
 
7970 
  def read(self, iprot):
7971 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7972 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7973 
      return
7974 
    iprot.readStructBegin()
7975 
    while True:
7976 
      (fname, ftype, fid) = iprot.readFieldBegin()
7977 
      if ftype == TType.STOP:
7978 
        break
7979 
      if fid == 0:
7980 
        if ftype == TType.STRUCT:
7981 
          self.success = Affiliate()
7982 
          self.success.read(iprot)
7983 
        else:
7984 
          iprot.skip(ftype)
7985 
      elif fid == 1:
7986 
        if ftype == TType.STRUCT:
1996 vikas 7987 
          self.utx = UserAffiliateException()
1845 vikas 7988 
          self.utx.read(iprot)
7989 
        else:
7990 
          iprot.skip(ftype)
7991 
      else:
7992 
        iprot.skip(ftype)
7993 
      iprot.readFieldEnd()
7994 
    iprot.readStructEnd()
7995 
 
7996 
  def write(self, oprot):
7997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7999 
      return
8000 
    oprot.writeStructBegin('getAffiliateByName_result')
8001 
    if self.success != None:
8002 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8003 
      self.success.write(oprot)
8004 
      oprot.writeFieldEnd()
8005 
    if self.utx != None:
8006 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8007 
      self.utx.write(oprot)
8008 
      oprot.writeFieldEnd()
8009 
    oprot.writeFieldStop()
8010 
    oprot.writeStructEnd()
8011 
 
8012 
  def __repr__(self):
8013 
    L = ['%s=%r' % (key, value)
8014 
      for key, value in self.__dict__.iteritems()]
8015 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8016 
 
8017 
  def __eq__(self, other):
8018 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8019 
 
8020 
  def __ne__(self, other):
8021 
    return not (self == other)
8022 
 
1996 vikas 8023 
class getTrackerById_args:
1845 vikas 8024 
  """
8025 
  Attributes:
8026 
   - id
8027 
  """
8028 
 
8029 
  thrift_spec = (
8030 
    None, # 0
8031 
    (1, TType.I64, 'id', None, None, ), # 1
8032 
  )
8033 
 
8034 
  def __init__(self, id=None,):
8035 
    self.id = id
8036 
 
8037 
  def read(self, iprot):
8038 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8039 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8040 
      return
8041 
    iprot.readStructBegin()
8042 
    while True:
8043 
      (fname, ftype, fid) = iprot.readFieldBegin()
8044 
      if ftype == TType.STOP:
8045 
        break
8046 
      if fid == 1:
8047 
        if ftype == TType.I64:
8048 
          self.id = iprot.readI64();
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
1996 vikas 8060 
    oprot.writeStructBegin('getTrackerById_args')
1845 vikas 8061 
    if self.id != None:
8062 
      oprot.writeFieldBegin('id', TType.I64, 1)
8063 
      oprot.writeI64(self.id)
8064 
      oprot.writeFieldEnd()
8065 
    oprot.writeFieldStop()
8066 
    oprot.writeStructEnd()
8067 
 
8068 
  def __repr__(self):
8069 
    L = ['%s=%r' % (key, value)
8070 
      for key, value in self.__dict__.iteritems()]
8071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8072 
 
8073 
  def __eq__(self, other):
8074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8075 
 
8076 
  def __ne__(self, other):
8077 
    return not (self == other)
8078 
 
8079 
class getTrackerById_result:
8080 
  """
8081 
  Attributes:
8082 
   - success
8083 
   - utx
8084 
  """
8085 
 
8086 
  thrift_spec = (
8087 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 8088 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8089 
  )
8090 
 
8091 
  def __init__(self, success=None, utx=None,):
8092 
    self.success = success
8093 
    self.utx = utx
8094 
 
8095 
  def read(self, iprot):
8096 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8097 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8098 
      return
8099 
    iprot.readStructBegin()
8100 
    while True:
8101 
      (fname, ftype, fid) = iprot.readFieldBegin()
8102 
      if ftype == TType.STOP:
8103 
        break
8104 
      if fid == 0:
8105 
        if ftype == TType.STRUCT:
8106 
          self.success = Tracker()
8107 
          self.success.read(iprot)
8108 
        else:
8109 
          iprot.skip(ftype)
8110 
      elif fid == 1:
8111 
        if ftype == TType.STRUCT:
1996 vikas 8112 
          self.utx = UserAffiliateException()
1845 vikas 8113 
          self.utx.read(iprot)
8114 
        else:
8115 
          iprot.skip(ftype)
8116 
      else:
8117 
        iprot.skip(ftype)
8118 
      iprot.readFieldEnd()
8119 
    iprot.readStructEnd()
8120 
 
8121 
  def write(self, oprot):
8122 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8123 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8124 
      return
8125 
    oprot.writeStructBegin('getTrackerById_result')
8126 
    if self.success != None:
8127 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8128 
      self.success.write(oprot)
8129 
      oprot.writeFieldEnd()
8130 
    if self.utx != None:
8131 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8132 
      self.utx.write(oprot)
8133 
      oprot.writeFieldEnd()
8134 
    oprot.writeFieldStop()
8135 
    oprot.writeStructEnd()
8136 
 
8137 
  def __repr__(self):
8138 
    L = ['%s=%r' % (key, value)
8139 
      for key, value in self.__dict__.iteritems()]
8140 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8141 
 
8142 
  def __eq__(self, other):
8143 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8144 
 
8145 
  def __ne__(self, other):
8146 
    return not (self == other)
8147 
 
1996 vikas 8148 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 8149 
  """
8150 
  Attributes:
1996 vikas 8151 
   - id
1845 vikas 8152 
  """
8153 
 
8154 
  thrift_spec = (
8155 
    None, # 0
1996 vikas 8156 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 8157 
  )
8158 
 
1996 vikas 8159 
  def __init__(self, id=None,):
8160 
    self.id = id
1845 vikas 8161 
 
8162 
  def read(self, iprot):
8163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8165 
      return
8166 
    iprot.readStructBegin()
8167 
    while True:
8168 
      (fname, ftype, fid) = iprot.readFieldBegin()
8169 
      if ftype == TType.STOP:
8170 
        break
8171 
      if fid == 1:
8172 
        if ftype == TType.I64:
1996 vikas 8173 
          self.id = iprot.readI64();
1845 vikas 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
1996 vikas 8185 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
8186 
    if self.id != None:
8187 
      oprot.writeFieldBegin('id', TType.I64, 1)
8188 
      oprot.writeI64(self.id)
1845 vikas 8189 
      oprot.writeFieldEnd()
8190 
    oprot.writeFieldStop()
8191 
    oprot.writeStructEnd()
8192 
 
8193 
  def __repr__(self):
8194 
    L = ['%s=%r' % (key, value)
8195 
      for key, value in self.__dict__.iteritems()]
8196 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8197 
 
8198 
  def __eq__(self, other):
8199 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8200 
 
8201 
  def __ne__(self, other):
8202 
    return not (self == other)
8203 
 
1996 vikas 8204 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 8205 
  """
8206 
  Attributes:
8207 
   - success
8208 
   - utx
8209 
  """
8210 
 
8211 
  thrift_spec = (
1996 vikas 8212 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
8213 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8214 
  )
8215 
 
8216 
  def __init__(self, success=None, utx=None,):
8217 
    self.success = success
8218 
    self.utx = utx
8219 
 
8220 
  def read(self, iprot):
8221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8223 
      return
8224 
    iprot.readStructBegin()
8225 
    while True:
8226 
      (fname, ftype, fid) = iprot.readFieldBegin()
8227 
      if ftype == TType.STOP:
8228 
        break
8229 
      if fid == 0:
8230 
        if ftype == TType.LIST:
8231 
          self.success = []
2981 rajveer 8232 
          (_etype59, _size56) = iprot.readListBegin()
8233 
          for _i60 in xrange(_size56):
8234 
            _elem61 = Affiliate()
8235 
            _elem61.read(iprot)
8236 
            self.success.append(_elem61)
1845 vikas 8237 
          iprot.readListEnd()
8238 
        else:
8239 
          iprot.skip(ftype)
8240 
      elif fid == 1:
8241 
        if ftype == TType.STRUCT:
1996 vikas 8242 
          self.utx = UserAffiliateException()
1845 vikas 8243 
          self.utx.read(iprot)
8244 
        else:
8245 
          iprot.skip(ftype)
8246 
      else:
8247 
        iprot.skip(ftype)
8248 
      iprot.readFieldEnd()
8249 
    iprot.readStructEnd()
8250 
 
8251 
  def write(self, oprot):
8252 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8253 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8254 
      return
1996 vikas 8255 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
1845 vikas 8256 
    if self.success != None:
8257 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8258 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 8259 
      for iter62 in self.success:
8260 
        iter62.write(oprot)
1845 vikas 8261 
      oprot.writeListEnd()
8262 
      oprot.writeFieldEnd()
8263 
    if self.utx != None:
8264 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8265 
      self.utx.write(oprot)
8266 
      oprot.writeFieldEnd()
8267 
    oprot.writeFieldStop()
8268 
    oprot.writeStructEnd()
8269 
 
8270 
  def __repr__(self):
8271 
    L = ['%s=%r' % (key, value)
8272 
      for key, value in self.__dict__.iteritems()]
8273 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8274 
 
8275 
  def __eq__(self, other):
8276 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8277 
 
8278 
  def __ne__(self, other):
8279 
    return not (self == other)
8280 
 
8281 
class addTrackLog_args:
8282 
  """
8283 
  Attributes:
1996 vikas 8284 
   - affiliateId
1845 vikas 8285 
   - userId
8286 
   - event
8287 
   - url
8288 
   - data
1859 vikas 8289 
   - addedOn
1845 vikas 8290 
  """
8291 
 
8292 
  thrift_spec = (
8293 
    None, # 0
1996 vikas 8294 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 8295 
    (2, TType.I64, 'userId', None, None, ), # 2
8296 
    (3, TType.STRING, 'event', None, None, ), # 3
8297 
    (4, TType.STRING, 'url', None, None, ), # 4
8298 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 8299 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 8300 
  )
8301 
 
1996 vikas 8302 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
8303 
    self.affiliateId = affiliateId
1845 vikas 8304 
    self.userId = userId
8305 
    self.event = event
8306 
    self.url = url
8307 
    self.data = data
1859 vikas 8308 
    self.addedOn = addedOn
1845 vikas 8309 
 
8310 
  def read(self, iprot):
8311 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8312 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8313 
      return
8314 
    iprot.readStructBegin()
8315 
    while True:
8316 
      (fname, ftype, fid) = iprot.readFieldBegin()
8317 
      if ftype == TType.STOP:
8318 
        break
8319 
      if fid == 1:
8320 
        if ftype == TType.I64:
1996 vikas 8321 
          self.affiliateId = iprot.readI64();
1845 vikas 8322 
        else:
8323 
          iprot.skip(ftype)
8324 
      elif fid == 2:
8325 
        if ftype == TType.I64:
8326 
          self.userId = iprot.readI64();
8327 
        else:
8328 
          iprot.skip(ftype)
8329 
      elif fid == 3:
8330 
        if ftype == TType.STRING:
8331 
          self.event = iprot.readString();
8332 
        else:
8333 
          iprot.skip(ftype)
8334 
      elif fid == 4:
8335 
        if ftype == TType.STRING:
8336 
          self.url = iprot.readString();
8337 
        else:
8338 
          iprot.skip(ftype)
8339 
      elif fid == 5:
8340 
        if ftype == TType.STRING:
8341 
          self.data = iprot.readString();
8342 
        else:
8343 
          iprot.skip(ftype)
1859 vikas 8344 
      elif fid == 6:
8345 
        if ftype == TType.I64:
8346 
          self.addedOn = iprot.readI64();
8347 
        else:
8348 
          iprot.skip(ftype)
1845 vikas 8349 
      else:
8350 
        iprot.skip(ftype)
8351 
      iprot.readFieldEnd()
8352 
    iprot.readStructEnd()
8353 
 
8354 
  def write(self, oprot):
8355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8357 
      return
8358 
    oprot.writeStructBegin('addTrackLog_args')
1996 vikas 8359 
    if self.affiliateId != None:
8360 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
8361 
      oprot.writeI64(self.affiliateId)
1845 vikas 8362 
      oprot.writeFieldEnd()
8363 
    if self.userId != None:
8364 
      oprot.writeFieldBegin('userId', TType.I64, 2)
8365 
      oprot.writeI64(self.userId)
8366 
      oprot.writeFieldEnd()
8367 
    if self.event != None:
8368 
      oprot.writeFieldBegin('event', TType.STRING, 3)
8369 
      oprot.writeString(self.event)
8370 
      oprot.writeFieldEnd()
8371 
    if self.url != None:
8372 
      oprot.writeFieldBegin('url', TType.STRING, 4)
8373 
      oprot.writeString(self.url)
8374 
      oprot.writeFieldEnd()
8375 
    if self.data != None:
8376 
      oprot.writeFieldBegin('data', TType.STRING, 5)
8377 
      oprot.writeString(self.data)
8378 
      oprot.writeFieldEnd()
1859 vikas 8379 
    if self.addedOn != None:
8380 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
8381 
      oprot.writeI64(self.addedOn)
8382 
      oprot.writeFieldEnd()
1845 vikas 8383 
    oprot.writeFieldStop()
8384 
    oprot.writeStructEnd()
8385 
 
8386 
  def __repr__(self):
8387 
    L = ['%s=%r' % (key, value)
8388 
      for key, value in self.__dict__.iteritems()]
8389 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8390 
 
8391 
  def __eq__(self, other):
8392 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8393 
 
8394 
  def __ne__(self, other):
8395 
    return not (self == other)
8396 
 
8397 
class addTrackLog_result:
8398 
  """
8399 
  Attributes:
8400 
   - success
8401 
   - utx
8402 
  """
8403 
 
8404 
  thrift_spec = (
8405 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 8406 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8407 
  )
8408 
 
8409 
  def __init__(self, success=None, utx=None,):
8410 
    self.success = success
8411 
    self.utx = utx
8412 
 
8413 
  def read(self, iprot):
8414 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8415 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8416 
      return
8417 
    iprot.readStructBegin()
8418 
    while True:
8419 
      (fname, ftype, fid) = iprot.readFieldBegin()
8420 
      if ftype == TType.STOP:
8421 
        break
8422 
      if fid == 0:
8423 
        if ftype == TType.I64:
8424 
          self.success = iprot.readI64();
8425 
        else:
8426 
          iprot.skip(ftype)
8427 
      elif fid == 1:
8428 
        if ftype == TType.STRUCT:
1996 vikas 8429 
          self.utx = UserAffiliateException()
1845 vikas 8430 
          self.utx.read(iprot)
8431 
        else:
8432 
          iprot.skip(ftype)
8433 
      else:
8434 
        iprot.skip(ftype)
8435 
      iprot.readFieldEnd()
8436 
    iprot.readStructEnd()
8437 
 
8438 
  def write(self, oprot):
8439 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8440 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8441 
      return
8442 
    oprot.writeStructBegin('addTrackLog_result')
8443 
    if self.success != None:
8444 
      oprot.writeFieldBegin('success', TType.I64, 0)
8445 
      oprot.writeI64(self.success)
8446 
      oprot.writeFieldEnd()
8447 
    if self.utx != None:
8448 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8449 
      self.utx.write(oprot)
8450 
      oprot.writeFieldEnd()
8451 
    oprot.writeFieldStop()
8452 
    oprot.writeStructEnd()
8453 
 
8454 
  def __repr__(self):
8455 
    L = ['%s=%r' % (key, value)
8456 
      for key, value in self.__dict__.iteritems()]
8457 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8458 
 
8459 
  def __eq__(self, other):
8460 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8461 
 
8462 
  def __ne__(self, other):
8463 
    return not (self == other)
8464 
 
8465 
class getTrackLogById_args:
8466 
  """
8467 
  Attributes:
8468 
   - id
8469 
  """
8470 
 
8471 
  thrift_spec = (
8472 
    None, # 0
8473 
    (1, TType.I64, 'id', None, None, ), # 1
8474 
  )
8475 
 
8476 
  def __init__(self, id=None,):
8477 
    self.id = id
8478 
 
8479 
  def read(self, iprot):
8480 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8481 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8482 
      return
8483 
    iprot.readStructBegin()
8484 
    while True:
8485 
      (fname, ftype, fid) = iprot.readFieldBegin()
8486 
      if ftype == TType.STOP:
8487 
        break
8488 
      if fid == 1:
8489 
        if ftype == TType.I64:
8490 
          self.id = iprot.readI64();
8491 
        else:
8492 
          iprot.skip(ftype)
8493 
      else:
8494 
        iprot.skip(ftype)
8495 
      iprot.readFieldEnd()
8496 
    iprot.readStructEnd()
8497 
 
8498 
  def write(self, oprot):
8499 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8500 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8501 
      return
8502 
    oprot.writeStructBegin('getTrackLogById_args')
8503 
    if self.id != None:
8504 
      oprot.writeFieldBegin('id', TType.I64, 1)
8505 
      oprot.writeI64(self.id)
8506 
      oprot.writeFieldEnd()
8507 
    oprot.writeFieldStop()
8508 
    oprot.writeStructEnd()
8509 
 
8510 
  def __repr__(self):
8511 
    L = ['%s=%r' % (key, value)
8512 
      for key, value in self.__dict__.iteritems()]
8513 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8514 
 
8515 
  def __eq__(self, other):
8516 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8517 
 
8518 
  def __ne__(self, other):
8519 
    return not (self == other)
8520 
 
8521 
class getTrackLogById_result:
8522 
  """
8523 
  Attributes:
8524 
   - success
8525 
   - utx
8526 
  """
8527 
 
8528 
  thrift_spec = (
8529 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 8530 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8531 
  )
8532 
 
8533 
  def __init__(self, success=None, utx=None,):
8534 
    self.success = success
8535 
    self.utx = utx
8536 
 
8537 
  def read(self, iprot):
8538 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8539 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8540 
      return
8541 
    iprot.readStructBegin()
8542 
    while True:
8543 
      (fname, ftype, fid) = iprot.readFieldBegin()
8544 
      if ftype == TType.STOP:
8545 
        break
8546 
      if fid == 0:
8547 
        if ftype == TType.STRUCT:
8548 
          self.success = TrackLog()
8549 
          self.success.read(iprot)
8550 
        else:
8551 
          iprot.skip(ftype)
8552 
      elif fid == 1:
8553 
        if ftype == TType.STRUCT:
1996 vikas 8554 
          self.utx = UserAffiliateException()
1845 vikas 8555 
          self.utx.read(iprot)
8556 
        else:
8557 
          iprot.skip(ftype)
8558 
      else:
8559 
        iprot.skip(ftype)
8560 
      iprot.readFieldEnd()
8561 
    iprot.readStructEnd()
8562 
 
8563 
  def write(self, oprot):
8564 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8565 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8566 
      return
8567 
    oprot.writeStructBegin('getTrackLogById_result')
8568 
    if self.success != None:
8569 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8570 
      self.success.write(oprot)
8571 
      oprot.writeFieldEnd()
8572 
    if self.utx != None:
8573 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8574 
      self.utx.write(oprot)
8575 
      oprot.writeFieldEnd()
8576 
    oprot.writeFieldStop()
8577 
    oprot.writeStructEnd()
8578 
 
8579 
  def __repr__(self):
8580 
    L = ['%s=%r' % (key, value)
8581 
      for key, value in self.__dict__.iteritems()]
8582 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8583 
 
8584 
  def __eq__(self, other):
8585 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8586 
 
8587 
  def __ne__(self, other):
8588 
    return not (self == other)
8589 
 
1996 vikas 8590 
class getTrackLogsByAffiliate_args:
1845 vikas 8591 
  """
8592 
  Attributes:
1996 vikas 8593 
   - affiliateId
1845 vikas 8594 
  """
8595 
 
8596 
  thrift_spec = (
8597 
    None, # 0
1996 vikas 8598 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 8599 
  )
8600 
 
1996 vikas 8601 
  def __init__(self, affiliateId=None,):
8602 
    self.affiliateId = affiliateId
1845 vikas 8603 
 
8604 
  def read(self, iprot):
8605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8607 
      return
8608 
    iprot.readStructBegin()
8609 
    while True:
8610 
      (fname, ftype, fid) = iprot.readFieldBegin()
8611 
      if ftype == TType.STOP:
8612 
        break
8613 
      if fid == 1:
8614 
        if ftype == TType.I64:
1996 vikas 8615 
          self.affiliateId = iprot.readI64();
1845 vikas 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
1996 vikas 8627 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
8628 
    if self.affiliateId != None:
8629 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
8630 
      oprot.writeI64(self.affiliateId)
1845 vikas 8631 
      oprot.writeFieldEnd()
8632 
    oprot.writeFieldStop()
8633 
    oprot.writeStructEnd()
8634 
 
8635 
  def __repr__(self):
8636 
    L = ['%s=%r' % (key, value)
8637 
      for key, value in self.__dict__.iteritems()]
8638 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8639 
 
8640 
  def __eq__(self, other):
8641 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8642 
 
8643 
  def __ne__(self, other):
8644 
    return not (self == other)
8645 
 
1996 vikas 8646 
class getTrackLogsByAffiliate_result:
1845 vikas 8647 
  """
8648 
  Attributes:
8649 
   - success
8650 
   - utx
8651 
  """
8652 
 
8653 
  thrift_spec = (
8654 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 8655 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8656 
  )
8657 
 
8658 
  def __init__(self, success=None, utx=None,):
8659 
    self.success = success
8660 
    self.utx = utx
8661 
 
8662 
  def read(self, iprot):
8663 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8664 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8665 
      return
8666 
    iprot.readStructBegin()
8667 
    while True:
8668 
      (fname, ftype, fid) = iprot.readFieldBegin()
8669 
      if ftype == TType.STOP:
8670 
        break
8671 
      if fid == 0:
8672 
        if ftype == TType.LIST:
8673 
          self.success = []
2981 rajveer 8674 
          (_etype66, _size63) = iprot.readListBegin()
8675 
          for _i67 in xrange(_size63):
8676 
            _elem68 = TrackLog()
8677 
            _elem68.read(iprot)
8678 
            self.success.append(_elem68)
1845 vikas 8679 
          iprot.readListEnd()
8680 
        else:
8681 
          iprot.skip(ftype)
8682 
      elif fid == 1:
8683 
        if ftype == TType.STRUCT:
1996 vikas 8684 
          self.utx = UserAffiliateException()
1845 vikas 8685 
          self.utx.read(iprot)
8686 
        else:
8687 
          iprot.skip(ftype)
8688 
      else:
8689 
        iprot.skip(ftype)
8690 
      iprot.readFieldEnd()
8691 
    iprot.readStructEnd()
8692 
 
8693 
  def write(self, oprot):
8694 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8695 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8696 
      return
1996 vikas 8697 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
1845 vikas 8698 
    if self.success != None:
8699 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8700 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 8701 
      for iter69 in self.success:
8702 
        iter69.write(oprot)
1845 vikas 8703 
      oprot.writeListEnd()
8704 
      oprot.writeFieldEnd()
8705 
    if self.utx != None:
8706 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8707 
      self.utx.write(oprot)
8708 
      oprot.writeFieldEnd()
8709 
    oprot.writeFieldStop()
8710 
    oprot.writeStructEnd()
8711 
 
8712 
  def __repr__(self):
8713 
    L = ['%s=%r' % (key, value)
8714 
      for key, value in self.__dict__.iteritems()]
8715 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8716 
 
8717 
  def __eq__(self, other):
8718 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8719 
 
8720 
  def __ne__(self, other):
8721 
    return not (self == other)
8722 
 
8723 
class getTrackLogsByUser_args:
8724 
  """
8725 
  Attributes:
8726 
   - userId
8727 
  """
8728 
 
8729 
  thrift_spec = (
8730 
    None, # 0
8731 
    (1, TType.I64, 'userId', None, None, ), # 1
8732 
  )
8733 
 
8734 
  def __init__(self, userId=None,):
8735 
    self.userId = userId
8736 
 
8737 
  def read(self, iprot):
8738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8740 
      return
8741 
    iprot.readStructBegin()
8742 
    while True:
8743 
      (fname, ftype, fid) = iprot.readFieldBegin()
8744 
      if ftype == TType.STOP:
8745 
        break
8746 
      if fid == 1:
8747 
        if ftype == TType.I64:
8748 
          self.userId = iprot.readI64();
8749 
        else:
8750 
          iprot.skip(ftype)
8751 
      else:
8752 
        iprot.skip(ftype)
8753 
      iprot.readFieldEnd()
8754 
    iprot.readStructEnd()
8755 
 
8756 
  def write(self, oprot):
8757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8759 
      return
8760 
    oprot.writeStructBegin('getTrackLogsByUser_args')
8761 
    if self.userId != None:
8762 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8763 
      oprot.writeI64(self.userId)
8764 
      oprot.writeFieldEnd()
8765 
    oprot.writeFieldStop()
8766 
    oprot.writeStructEnd()
8767 
 
8768 
  def __repr__(self):
8769 
    L = ['%s=%r' % (key, value)
8770 
      for key, value in self.__dict__.iteritems()]
8771 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8772 
 
8773 
  def __eq__(self, other):
8774 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8775 
 
8776 
  def __ne__(self, other):
8777 
    return not (self == other)
8778 
 
8779 
class getTrackLogsByUser_result:
8780 
  """
8781 
  Attributes:
8782 
   - success
8783 
   - utx
8784 
  """
8785 
 
8786 
  thrift_spec = (
8787 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 8788 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8789 
  )
8790 
 
8791 
  def __init__(self, success=None, utx=None,):
8792 
    self.success = success
8793 
    self.utx = utx
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 == 0:
8805 
        if ftype == TType.LIST:
8806 
          self.success = []
2981 rajveer 8807 
          (_etype73, _size70) = iprot.readListBegin()
8808 
          for _i74 in xrange(_size70):
8809 
            _elem75 = TrackLog()
8810 
            _elem75.read(iprot)
8811 
            self.success.append(_elem75)
1845 vikas 8812 
          iprot.readListEnd()
8813 
        else:
8814 
          iprot.skip(ftype)
8815 
      elif fid == 1:
8816 
        if ftype == TType.STRUCT:
1996 vikas 8817 
          self.utx = UserAffiliateException()
1845 vikas 8818 
          self.utx.read(iprot)
8819 
        else:
8820 
          iprot.skip(ftype)
8821 
      else:
8822 
        iprot.skip(ftype)
8823 
      iprot.readFieldEnd()
8824 
    iprot.readStructEnd()
8825 
 
8826 
  def write(self, oprot):
8827 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8828 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8829 
      return
8830 
    oprot.writeStructBegin('getTrackLogsByUser_result')
8831 
    if self.success != None:
8832 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8833 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 8834 
      for iter76 in self.success:
8835 
        iter76.write(oprot)
1845 vikas 8836 
      oprot.writeListEnd()
8837 
      oprot.writeFieldEnd()
8838 
    if self.utx != None:
8839 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8840 
      self.utx.write(oprot)
8841 
      oprot.writeFieldEnd()
8842 
    oprot.writeFieldStop()
8843 
    oprot.writeStructEnd()
8844 
 
8845 
  def __repr__(self):
8846 
    L = ['%s=%r' % (key, value)
8847 
      for key, value in self.__dict__.iteritems()]
8848 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8849 
 
8850 
  def __eq__(self, other):
8851 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8852 
 
8853 
  def __ne__(self, other):
8854 
    return not (self == other)
8855 
 
8856 
class getTrackLogs_args:
8857 
  """
8858 
  Attributes:
8859 
   - userId
8860 
   - event
8861 
   - url
8862 
  """
8863 
 
8864 
  thrift_spec = (
8865 
    None, # 0
1996 vikas 8866 
    (1, TType.I64, 'userId', None, None, ), # 1
8867 
    (2, TType.STRING, 'event', None, None, ), # 2
8868 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 8869 
  )
8870 
 
1996 vikas 8871 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 8872 
    self.userId = userId
8873 
    self.event = event
8874 
    self.url = url
8875 
 
8876 
  def read(self, iprot):
8877 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8878 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8879 
      return
8880 
    iprot.readStructBegin()
8881 
    while True:
8882 
      (fname, ftype, fid) = iprot.readFieldBegin()
8883 
      if ftype == TType.STOP:
8884 
        break
8885 
      if fid == 1:
8886 
        if ftype == TType.I64:
1996 vikas 8887 
          self.userId = iprot.readI64();
1845 vikas 8888 
        else:
8889 
          iprot.skip(ftype)
8890 
      elif fid == 2:
8891 
        if ftype == TType.STRING:
8892 
          self.event = iprot.readString();
8893 
        else:
8894 
          iprot.skip(ftype)
1996 vikas 8895 
      elif fid == 3:
1845 vikas 8896 
        if ftype == TType.STRING:
8897 
          self.url = iprot.readString();
8898 
        else:
8899 
          iprot.skip(ftype)
8900 
      else:
8901 
        iprot.skip(ftype)
8902 
      iprot.readFieldEnd()
8903 
    iprot.readStructEnd()
8904 
 
8905 
  def write(self, oprot):
8906 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8907 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8908 
      return
8909 
    oprot.writeStructBegin('getTrackLogs_args')
8910 
    if self.userId != None:
1996 vikas 8911 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 8912 
      oprot.writeI64(self.userId)
8913 
      oprot.writeFieldEnd()
8914 
    if self.event != None:
1996 vikas 8915 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 8916 
      oprot.writeString(self.event)
8917 
      oprot.writeFieldEnd()
8918 
    if self.url != None:
1996 vikas 8919 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 8920 
      oprot.writeString(self.url)
8921 
      oprot.writeFieldEnd()
8922 
    oprot.writeFieldStop()
8923 
    oprot.writeStructEnd()
8924 
 
8925 
  def __repr__(self):
8926 
    L = ['%s=%r' % (key, value)
8927 
      for key, value in self.__dict__.iteritems()]
8928 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8929 
 
8930 
  def __eq__(self, other):
8931 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8932 
 
8933 
  def __ne__(self, other):
8934 
    return not (self == other)
8935 
 
8936 
class getTrackLogs_result:
8937 
  """
8938 
  Attributes:
8939 
   - success
8940 
   - utx
8941 
  """
8942 
 
8943 
  thrift_spec = (
8944 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 8945 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8946 
  )
8947 
 
8948 
  def __init__(self, success=None, utx=None,):
8949 
    self.success = success
8950 
    self.utx = utx
8951 
 
8952 
  def read(self, iprot):
8953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8955 
      return
8956 
    iprot.readStructBegin()
8957 
    while True:
8958 
      (fname, ftype, fid) = iprot.readFieldBegin()
8959 
      if ftype == TType.STOP:
8960 
        break
8961 
      if fid == 0:
8962 
        if ftype == TType.LIST:
8963 
          self.success = []
2981 rajveer 8964 
          (_etype80, _size77) = iprot.readListBegin()
8965 
          for _i81 in xrange(_size77):
8966 
            _elem82 = TrackLog()
8967 
            _elem82.read(iprot)
8968 
            self.success.append(_elem82)
1845 vikas 8969 
          iprot.readListEnd()
8970 
        else:
8971 
          iprot.skip(ftype)
8972 
      elif fid == 1:
8973 
        if ftype == TType.STRUCT:
1996 vikas 8974 
          self.utx = UserAffiliateException()
1845 vikas 8975 
          self.utx.read(iprot)
8976 
        else:
8977 
          iprot.skip(ftype)
8978 
      else:
8979 
        iprot.skip(ftype)
8980 
      iprot.readFieldEnd()
8981 
    iprot.readStructEnd()
8982 
 
8983 
  def write(self, oprot):
8984 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8985 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8986 
      return
8987 
    oprot.writeStructBegin('getTrackLogs_result')
8988 
    if self.success != None:
8989 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8990 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 8991 
      for iter83 in self.success:
8992 
        iter83.write(oprot)
1845 vikas 8993 
      oprot.writeListEnd()
8994 
      oprot.writeFieldEnd()
8995 
    if self.utx != None:
8996 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8997 
      self.utx.write(oprot)
8998 
      oprot.writeFieldEnd()
8999 
    oprot.writeFieldStop()
9000 
    oprot.writeStructEnd()
9001 
 
9002 
  def __repr__(self):
9003 
    L = ['%s=%r' % (key, value)
9004 
      for key, value in self.__dict__.iteritems()]
9005 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9006 
 
9007 
  def __eq__(self, other):
9008 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9009 
 
9010 
  def __ne__(self, other):
9011 
    return not (self == other)
9012 
 
559 chandransh 9013 
class createCart_args:
94 ashish 9014 
  """
9015 
  Attributes:
559 chandransh 9016 
   - userId
94 ashish 9017 
  """
9018 
 
9019 
  thrift_spec = (
9020 
    None, # 0
559 chandransh 9021 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 9022 
  )
9023 
 
559 chandransh 9024 
  def __init__(self, userId=None,):
9025 
    self.userId = userId
94 ashish 9026 
 
9027 
  def read(self, iprot):
9028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9030 
      return
9031 
    iprot.readStructBegin()
9032 
    while True:
9033 
      (fname, ftype, fid) = iprot.readFieldBegin()
9034 
      if ftype == TType.STOP:
9035 
        break
9036 
      if fid == 1:
9037 
        if ftype == TType.I64:
559 chandransh 9038 
          self.userId = iprot.readI64();
94 ashish 9039 
        else:
9040 
          iprot.skip(ftype)
559 chandransh 9041 
      else:
9042 
        iprot.skip(ftype)
9043 
      iprot.readFieldEnd()
9044 
    iprot.readStructEnd()
9045 
 
9046 
  def write(self, oprot):
9047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9049 
      return
9050 
    oprot.writeStructBegin('createCart_args')
9051 
    if self.userId != None:
9052 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9053 
      oprot.writeI64(self.userId)
9054 
      oprot.writeFieldEnd()
9055 
    oprot.writeFieldStop()
9056 
    oprot.writeStructEnd()
9057 
 
9058 
  def __repr__(self):
9059 
    L = ['%s=%r' % (key, value)
9060 
      for key, value in self.__dict__.iteritems()]
9061 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9062 
 
9063 
  def __eq__(self, other):
9064 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9065 
 
9066 
  def __ne__(self, other):
9067 
    return not (self == other)
9068 
 
9069 
class createCart_result:
9070 
  """
9071 
  Attributes:
9072 
   - success
9073 
   - scx
9074 
  """
9075 
 
9076 
  thrift_spec = (
9077 
    (0, TType.I64, 'success', None, None, ), # 0
9078 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9079 
  )
9080 
 
9081 
  def __init__(self, success=None, scx=None,):
9082 
    self.success = success
9083 
    self.scx = scx
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 == 0:
94 ashish 9095 
        if ftype == TType.I64:
559 chandransh 9096 
          self.success = iprot.readI64();
94 ashish 9097 
        else:
9098 
          iprot.skip(ftype)
559 chandransh 9099 
      elif fid == 1:
9100 
        if ftype == TType.STRUCT:
9101 
          self.scx = ShoppingCartException()
9102 
          self.scx.read(iprot)
9103 
        else:
9104 
          iprot.skip(ftype)
94 ashish 9105 
      else:
9106 
        iprot.skip(ftype)
9107 
      iprot.readFieldEnd()
9108 
    iprot.readStructEnd()
9109 
 
9110 
  def write(self, oprot):
9111 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9112 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9113 
      return
559 chandransh 9114 
    oprot.writeStructBegin('createCart_result')
9115 
    if self.success != None:
9116 
      oprot.writeFieldBegin('success', TType.I64, 0)
9117 
      oprot.writeI64(self.success)
94 ashish 9118 
      oprot.writeFieldEnd()
559 chandransh 9119 
    if self.scx != None:
9120 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9121 
      self.scx.write(oprot)
94 ashish 9122 
      oprot.writeFieldEnd()
9123 
    oprot.writeFieldStop()
9124 
    oprot.writeStructEnd()
9125 
 
9126 
  def __repr__(self):
9127 
    L = ['%s=%r' % (key, value)
9128 
      for key, value in self.__dict__.iteritems()]
9129 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9130 
 
9131 
  def __eq__(self, other):
9132 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9133 
 
9134 
  def __ne__(self, other):
9135 
    return not (self == other)
9136 
 
559 chandransh 9137 
class getCurrentCart_args:
94 ashish 9138 
  """
9139 
  Attributes:
559 chandransh 9140 
   - userId
9141 
  """
9142 
 
9143 
  thrift_spec = (
9144 
    None, # 0
9145 
    (1, TType.I64, 'userId', None, None, ), # 1
9146 
  )
9147 
 
9148 
  def __init__(self, userId=None,):
9149 
    self.userId = userId
9150 
 
9151 
  def read(self, iprot):
9152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9154 
      return
9155 
    iprot.readStructBegin()
9156 
    while True:
9157 
      (fname, ftype, fid) = iprot.readFieldBegin()
9158 
      if ftype == TType.STOP:
9159 
        break
9160 
      if fid == 1:
9161 
        if ftype == TType.I64:
9162 
          self.userId = iprot.readI64();
9163 
        else:
9164 
          iprot.skip(ftype)
9165 
      else:
9166 
        iprot.skip(ftype)
9167 
      iprot.readFieldEnd()
9168 
    iprot.readStructEnd()
9169 
 
9170 
  def write(self, oprot):
9171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9173 
      return
9174 
    oprot.writeStructBegin('getCurrentCart_args')
9175 
    if self.userId != None:
9176 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9177 
      oprot.writeI64(self.userId)
9178 
      oprot.writeFieldEnd()
9179 
    oprot.writeFieldStop()
9180 
    oprot.writeStructEnd()
9181 
 
9182 
  def __repr__(self):
9183 
    L = ['%s=%r' % (key, value)
9184 
      for key, value in self.__dict__.iteritems()]
9185 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9186 
 
9187 
  def __eq__(self, other):
9188 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9189 
 
9190 
  def __ne__(self, other):
9191 
    return not (self == other)
9192 
 
9193 
class getCurrentCart_result:
9194 
  """
9195 
  Attributes:
94 ashish 9196 
   - success
559 chandransh 9197 
   - scx
94 ashish 9198 
  """
9199 
 
9200 
  thrift_spec = (
559 chandransh 9201 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9202 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9203 
  )
9204 
 
559 chandransh 9205 
  def __init__(self, success=None, scx=None,):
94 ashish 9206 
    self.success = success
559 chandransh 9207 
    self.scx = scx
94 ashish 9208 
 
9209 
  def read(self, iprot):
9210 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9211 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9212 
      return
9213 
    iprot.readStructBegin()
9214 
    while True:
9215 
      (fname, ftype, fid) = iprot.readFieldBegin()
9216 
      if ftype == TType.STOP:
9217 
        break
9218 
      if fid == 0:
559 chandransh 9219 
        if ftype == TType.STRUCT:
9220 
          self.success = Cart()
9221 
          self.success.read(iprot)
94 ashish 9222 
        else:
9223 
          iprot.skip(ftype)
9224 
      elif fid == 1:
9225 
        if ftype == TType.STRUCT:
559 chandransh 9226 
          self.scx = ShoppingCartException()
9227 
          self.scx.read(iprot)
94 ashish 9228 
        else:
9229 
          iprot.skip(ftype)
9230 
      else:
9231 
        iprot.skip(ftype)
9232 
      iprot.readFieldEnd()
9233 
    iprot.readStructEnd()
9234 
 
9235 
  def write(self, oprot):
9236 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9237 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9238 
      return
559 chandransh 9239 
    oprot.writeStructBegin('getCurrentCart_result')
94 ashish 9240 
    if self.success != None:
559 chandransh 9241 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9242 
      self.success.write(oprot)
94 ashish 9243 
      oprot.writeFieldEnd()
559 chandransh 9244 
    if self.scx != None:
9245 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9246 
      self.scx.write(oprot)
94 ashish 9247 
      oprot.writeFieldEnd()
9248 
    oprot.writeFieldStop()
9249 
    oprot.writeStructEnd()
9250 
 
9251 
  def __repr__(self):
9252 
    L = ['%s=%r' % (key, value)
9253 
      for key, value in self.__dict__.iteritems()]
9254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9255 
 
9256 
  def __eq__(self, other):
9257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9258 
 
9259 
  def __ne__(self, other):
9260 
    return not (self == other)
9261 
 
559 chandransh 9262 
class getCart_args:
504 rajveer 9263 
  """
9264 
  Attributes:
559 chandransh 9265 
   - cartId
504 rajveer 9266 
  """
9267 
 
9268 
  thrift_spec = (
9269 
    None, # 0
559 chandransh 9270 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 9271 
  )
9272 
 
559 chandransh 9273 
  def __init__(self, cartId=None,):
9274 
    self.cartId = cartId
504 rajveer 9275 
 
9276 
  def read(self, iprot):
9277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9279 
      return
9280 
    iprot.readStructBegin()
9281 
    while True:
9282 
      (fname, ftype, fid) = iprot.readFieldBegin()
9283 
      if ftype == TType.STOP:
9284 
        break
9285 
      if fid == 1:
9286 
        if ftype == TType.I64:
559 chandransh 9287 
          self.cartId = iprot.readI64();
504 rajveer 9288 
        else:
9289 
          iprot.skip(ftype)
9290 
      else:
9291 
        iprot.skip(ftype)
9292 
      iprot.readFieldEnd()
9293 
    iprot.readStructEnd()
9294 
 
9295 
  def write(self, oprot):
9296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9298 
      return
559 chandransh 9299 
    oprot.writeStructBegin('getCart_args')
9300 
    if self.cartId != None:
9301 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9302 
      oprot.writeI64(self.cartId)
504 rajveer 9303 
      oprot.writeFieldEnd()
9304 
    oprot.writeFieldStop()
9305 
    oprot.writeStructEnd()
9306 
 
9307 
  def __repr__(self):
9308 
    L = ['%s=%r' % (key, value)
9309 
      for key, value in self.__dict__.iteritems()]
9310 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9311 
 
9312 
  def __eq__(self, other):
9313 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9314 
 
9315 
  def __ne__(self, other):
9316 
    return not (self == other)
9317 
 
559 chandransh 9318 
class getCart_result:
504 rajveer 9319 
  """
9320 
  Attributes:
9321 
   - success
559 chandransh 9322 
   - scx
504 rajveer 9323 
  """
9324 
 
9325 
  thrift_spec = (
559 chandransh 9326 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9327 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 9328 
  )
9329 
 
559 chandransh 9330 
  def __init__(self, success=None, scx=None,):
504 rajveer 9331 
    self.success = success
559 chandransh 9332 
    self.scx = scx
504 rajveer 9333 
 
9334 
  def read(self, iprot):
9335 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9336 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9337 
      return
9338 
    iprot.readStructBegin()
9339 
    while True:
9340 
      (fname, ftype, fid) = iprot.readFieldBegin()
9341 
      if ftype == TType.STOP:
9342 
        break
9343 
      if fid == 0:
559 chandransh 9344 
        if ftype == TType.STRUCT:
9345 
          self.success = Cart()
9346 
          self.success.read(iprot)
504 rajveer 9347 
        else:
9348 
          iprot.skip(ftype)
9349 
      elif fid == 1:
9350 
        if ftype == TType.STRUCT:
559 chandransh 9351 
          self.scx = ShoppingCartException()
9352 
          self.scx.read(iprot)
504 rajveer 9353 
        else:
9354 
          iprot.skip(ftype)
9355 
      else:
9356 
        iprot.skip(ftype)
9357 
      iprot.readFieldEnd()
9358 
    iprot.readStructEnd()
9359 
 
9360 
  def write(self, oprot):
9361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9363 
      return
559 chandransh 9364 
    oprot.writeStructBegin('getCart_result')
504 rajveer 9365 
    if self.success != None:
559 chandransh 9366 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9367 
      self.success.write(oprot)
504 rajveer 9368 
      oprot.writeFieldEnd()
559 chandransh 9369 
    if self.scx != None:
9370 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9371 
      self.scx.write(oprot)
504 rajveer 9372 
      oprot.writeFieldEnd()
9373 
    oprot.writeFieldStop()
9374 
    oprot.writeStructEnd()
9375 
 
9376 
  def __repr__(self):
9377 
    L = ['%s=%r' % (key, value)
9378 
      for key, value in self.__dict__.iteritems()]
9379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9380 
 
9381 
  def __eq__(self, other):
9382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9383 
 
9384 
  def __ne__(self, other):
9385 
    return not (self == other)
9386 
 
559 chandransh 9387 
class getCartsForUser_args:
94 ashish 9388 
  """
9389 
  Attributes:
559 chandransh 9390 
   - userId
9391 
   - status
94 ashish 9392 
  """
9393 
 
9394 
  thrift_spec = (
9395 
    None, # 0
559 chandransh 9396 
    (1, TType.I64, 'userId', None, None, ), # 1
9397 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 9398 
  )
9399 
 
559 chandransh 9400 
  def __init__(self, userId=None, status=None,):
9401 
    self.userId = userId
9402 
    self.status = status
94 ashish 9403 
 
9404 
  def read(self, iprot):
9405 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9406 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9407 
      return
9408 
    iprot.readStructBegin()
9409 
    while True:
9410 
      (fname, ftype, fid) = iprot.readFieldBegin()
9411 
      if ftype == TType.STOP:
9412 
        break
9413 
      if fid == 1:
9414 
        if ftype == TType.I64:
559 chandransh 9415 
          self.userId = iprot.readI64();
94 ashish 9416 
        else:
9417 
          iprot.skip(ftype)
9418 
      elif fid == 2:
559 chandransh 9419 
        if ftype == TType.I32:
9420 
          self.status = iprot.readI32();
94 ashish 9421 
        else:
9422 
          iprot.skip(ftype)
9423 
      else:
9424 
        iprot.skip(ftype)
9425 
      iprot.readFieldEnd()
9426 
    iprot.readStructEnd()
9427 
 
9428 
  def write(self, oprot):
9429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9431 
      return
559 chandransh 9432 
    oprot.writeStructBegin('getCartsForUser_args')
9433 
    if self.userId != None:
9434 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9435 
      oprot.writeI64(self.userId)
94 ashish 9436 
      oprot.writeFieldEnd()
559 chandransh 9437 
    if self.status != None:
9438 
      oprot.writeFieldBegin('status', TType.I32, 2)
9439 
      oprot.writeI32(self.status)
94 ashish 9440 
      oprot.writeFieldEnd()
9441 
    oprot.writeFieldStop()
9442 
    oprot.writeStructEnd()
9443 
 
9444 
  def __repr__(self):
9445 
    L = ['%s=%r' % (key, value)
9446 
      for key, value in self.__dict__.iteritems()]
9447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9448 
 
9449 
  def __eq__(self, other):
9450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9451 
 
9452 
  def __ne__(self, other):
9453 
    return not (self == other)
9454 
 
559 chandransh 9455 
class getCartsForUser_result:
94 ashish 9456 
  """
9457 
  Attributes:
9458 
   - success
559 chandransh 9459 
   - scx
94 ashish 9460 
  """
9461 
 
9462 
  thrift_spec = (
559 chandransh 9463 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9464 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9465 
  )
9466 
 
559 chandransh 9467 
  def __init__(self, success=None, scx=None,):
94 ashish 9468 
    self.success = success
559 chandransh 9469 
    self.scx = scx
94 ashish 9470 
 
9471 
  def read(self, iprot):
9472 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9473 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9474 
      return
9475 
    iprot.readStructBegin()
9476 
    while True:
9477 
      (fname, ftype, fid) = iprot.readFieldBegin()
9478 
      if ftype == TType.STOP:
9479 
        break
9480 
      if fid == 0:
559 chandransh 9481 
        if ftype == TType.LIST:
9482 
          self.success = []
2981 rajveer 9483 
          (_etype87, _size84) = iprot.readListBegin()
9484 
          for _i88 in xrange(_size84):
9485 
            _elem89 = Cart()
9486 
            _elem89.read(iprot)
9487 
            self.success.append(_elem89)
559 chandransh 9488 
          iprot.readListEnd()
94 ashish 9489 
        else:
9490 
          iprot.skip(ftype)
9491 
      elif fid == 1:
9492 
        if ftype == TType.STRUCT:
559 chandransh 9493 
          self.scx = ShoppingCartException()
9494 
          self.scx.read(iprot)
94 ashish 9495 
        else:
9496 
          iprot.skip(ftype)
9497 
      else:
9498 
        iprot.skip(ftype)
9499 
      iprot.readFieldEnd()
9500 
    iprot.readStructEnd()
9501 
 
9502 
  def write(self, oprot):
9503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9505 
      return
559 chandransh 9506 
    oprot.writeStructBegin('getCartsForUser_result')
94 ashish 9507 
    if self.success != None:
559 chandransh 9508 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9509 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 9510 
      for iter90 in self.success:
9511 
        iter90.write(oprot)
559 chandransh 9512 
      oprot.writeListEnd()
94 ashish 9513 
      oprot.writeFieldEnd()
559 chandransh 9514 
    if self.scx != None:
9515 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9516 
      self.scx.write(oprot)
94 ashish 9517 
      oprot.writeFieldEnd()
9518 
    oprot.writeFieldStop()
9519 
    oprot.writeStructEnd()
9520 
 
9521 
  def __repr__(self):
9522 
    L = ['%s=%r' % (key, value)
9523 
      for key, value in self.__dict__.iteritems()]
9524 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9525 
 
9526 
  def __eq__(self, other):
9527 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9528 
 
9529 
  def __ne__(self, other):
9530 
    return not (self == other)
9531 
 
559 chandransh 9532 
class getCartsByStatus_args:
94 ashish 9533 
  """
9534 
  Attributes:
559 chandransh 9535 
   - status
94 ashish 9536 
  """
9537 
 
9538 
  thrift_spec = (
9539 
    None, # 0
559 chandransh 9540 
    (1, TType.I32, 'status', None, None, ), # 1
94 ashish 9541 
  )
9542 
 
559 chandransh 9543 
  def __init__(self, status=None,):
9544 
    self.status = status
94 ashish 9545 
 
9546 
  def read(self, iprot):
9547 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9548 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9549 
      return
9550 
    iprot.readStructBegin()
9551 
    while True:
9552 
      (fname, ftype, fid) = iprot.readFieldBegin()
9553 
      if ftype == TType.STOP:
9554 
        break
9555 
      if fid == 1:
559 chandransh 9556 
        if ftype == TType.I32:
9557 
          self.status = iprot.readI32();
9558 
        else:
9559 
          iprot.skip(ftype)
9560 
      else:
9561 
        iprot.skip(ftype)
9562 
      iprot.readFieldEnd()
9563 
    iprot.readStructEnd()
9564 
 
9565 
  def write(self, oprot):
9566 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9567 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9568 
      return
9569 
    oprot.writeStructBegin('getCartsByStatus_args')
9570 
    if self.status != None:
9571 
      oprot.writeFieldBegin('status', TType.I32, 1)
9572 
      oprot.writeI32(self.status)
9573 
      oprot.writeFieldEnd()
9574 
    oprot.writeFieldStop()
9575 
    oprot.writeStructEnd()
9576 
 
9577 
  def __repr__(self):
9578 
    L = ['%s=%r' % (key, value)
9579 
      for key, value in self.__dict__.iteritems()]
9580 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9581 
 
9582 
  def __eq__(self, other):
9583 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9584 
 
9585 
  def __ne__(self, other):
9586 
    return not (self == other)
9587 
 
9588 
class getCartsByStatus_result:
9589 
  """
9590 
  Attributes:
9591 
   - success
9592 
   - scx
9593 
  """
9594 
 
9595 
  thrift_spec = (
9596 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9597 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9598 
  )
9599 
 
9600 
  def __init__(self, success=None, scx=None,):
9601 
    self.success = success
9602 
    self.scx = scx
9603 
 
9604 
  def read(self, iprot):
9605 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9606 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9607 
      return
9608 
    iprot.readStructBegin()
9609 
    while True:
9610 
      (fname, ftype, fid) = iprot.readFieldBegin()
9611 
      if ftype == TType.STOP:
9612 
        break
9613 
      if fid == 0:
9614 
        if ftype == TType.LIST:
9615 
          self.success = []
2981 rajveer 9616 
          (_etype94, _size91) = iprot.readListBegin()
9617 
          for _i95 in xrange(_size91):
9618 
            _elem96 = Cart()
9619 
            _elem96.read(iprot)
9620 
            self.success.append(_elem96)
559 chandransh 9621 
          iprot.readListEnd()
9622 
        else:
9623 
          iprot.skip(ftype)
9624 
      elif fid == 1:
9625 
        if ftype == TType.STRUCT:
9626 
          self.scx = ShoppingCartException()
9627 
          self.scx.read(iprot)
9628 
        else:
9629 
          iprot.skip(ftype)
9630 
      else:
9631 
        iprot.skip(ftype)
9632 
      iprot.readFieldEnd()
9633 
    iprot.readStructEnd()
9634 
 
9635 
  def write(self, oprot):
9636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9638 
      return
9639 
    oprot.writeStructBegin('getCartsByStatus_result')
9640 
    if self.success != None:
9641 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9642 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 9643 
      for iter97 in self.success:
9644 
        iter97.write(oprot)
559 chandransh 9645 
      oprot.writeListEnd()
9646 
      oprot.writeFieldEnd()
9647 
    if self.scx != None:
9648 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9649 
      self.scx.write(oprot)
9650 
      oprot.writeFieldEnd()
9651 
    oprot.writeFieldStop()
9652 
    oprot.writeStructEnd()
9653 
 
9654 
  def __repr__(self):
9655 
    L = ['%s=%r' % (key, value)
9656 
      for key, value in self.__dict__.iteritems()]
9657 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9658 
 
9659 
  def __eq__(self, other):
9660 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9661 
 
9662 
  def __ne__(self, other):
9663 
    return not (self == other)
9664 
 
9665 
class getCartsByTime_args:
9666 
  """
9667 
  Attributes:
9668 
   - from_time
9669 
   - to_time
9670 
   - status
9671 
  """
9672 
 
9673 
  thrift_spec = (
9674 
    None, # 0
9675 
    (1, TType.I64, 'from_time', None, None, ), # 1
9676 
    (2, TType.I64, 'to_time', None, None, ), # 2
9677 
    (3, TType.I32, 'status', None, None, ), # 3
9678 
  )
9679 
 
9680 
  def __init__(self, from_time=None, to_time=None, status=None,):
9681 
    self.from_time = from_time
9682 
    self.to_time = to_time
9683 
    self.status = status
9684 
 
9685 
  def read(self, iprot):
9686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9688 
      return
9689 
    iprot.readStructBegin()
9690 
    while True:
9691 
      (fname, ftype, fid) = iprot.readFieldBegin()
9692 
      if ftype == TType.STOP:
9693 
        break
9694 
      if fid == 1:
94 ashish 9695 
        if ftype == TType.I64:
559 chandransh 9696 
          self.from_time = iprot.readI64();
94 ashish 9697 
        else:
9698 
          iprot.skip(ftype)
122 ashish 9699 
      elif fid == 2:
559 chandransh 9700 
        if ftype == TType.I64:
9701 
          self.to_time = iprot.readI64();
122 ashish 9702 
        else:
9703 
          iprot.skip(ftype)
559 chandransh 9704 
      elif fid == 3:
9705 
        if ftype == TType.I32:
9706 
          self.status = iprot.readI32();
9707 
        else:
9708 
          iprot.skip(ftype)
94 ashish 9709 
      else:
9710 
        iprot.skip(ftype)
9711 
      iprot.readFieldEnd()
9712 
    iprot.readStructEnd()
9713 
 
9714 
  def write(self, oprot):
9715 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9716 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9717 
      return
559 chandransh 9718 
    oprot.writeStructBegin('getCartsByTime_args')
9719 
    if self.from_time != None:
9720 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
9721 
      oprot.writeI64(self.from_time)
94 ashish 9722 
      oprot.writeFieldEnd()
559 chandransh 9723 
    if self.to_time != None:
9724 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
9725 
      oprot.writeI64(self.to_time)
122 ashish 9726 
      oprot.writeFieldEnd()
559 chandransh 9727 
    if self.status != None:
9728 
      oprot.writeFieldBegin('status', TType.I32, 3)
9729 
      oprot.writeI32(self.status)
9730 
      oprot.writeFieldEnd()
94 ashish 9731 
    oprot.writeFieldStop()
9732 
    oprot.writeStructEnd()
9733 
 
9734 
  def __repr__(self):
9735 
    L = ['%s=%r' % (key, value)
9736 
      for key, value in self.__dict__.iteritems()]
9737 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9738 
 
9739 
  def __eq__(self, other):
9740 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9741 
 
9742 
  def __ne__(self, other):
9743 
    return not (self == other)
9744 
 
559 chandransh 9745 
class getCartsByTime_result:
94 ashish 9746 
  """
9747 
  Attributes:
9748 
   - success
559 chandransh 9749 
   - scx
94 ashish 9750 
  """
9751 
 
9752 
  thrift_spec = (
559 chandransh 9753 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9754 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9755 
  )
9756 
 
559 chandransh 9757 
  def __init__(self, success=None, scx=None,):
94 ashish 9758 
    self.success = success
559 chandransh 9759 
    self.scx = scx
94 ashish 9760 
 
9761 
  def read(self, iprot):
9762 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9763 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9764 
      return
9765 
    iprot.readStructBegin()
9766 
    while True:
9767 
      (fname, ftype, fid) = iprot.readFieldBegin()
9768 
      if ftype == TType.STOP:
9769 
        break
9770 
      if fid == 0:
559 chandransh 9771 
        if ftype == TType.LIST:
9772 
          self.success = []
2981 rajveer 9773 
          (_etype101, _size98) = iprot.readListBegin()
9774 
          for _i102 in xrange(_size98):
9775 
            _elem103 = Cart()
9776 
            _elem103.read(iprot)
9777 
            self.success.append(_elem103)
559 chandransh 9778 
          iprot.readListEnd()
94 ashish 9779 
        else:
9780 
          iprot.skip(ftype)
9781 
      elif fid == 1:
9782 
        if ftype == TType.STRUCT:
559 chandransh 9783 
          self.scx = ShoppingCartException()
9784 
          self.scx.read(iprot)
94 ashish 9785 
        else:
9786 
          iprot.skip(ftype)
9787 
      else:
9788 
        iprot.skip(ftype)
9789 
      iprot.readFieldEnd()
9790 
    iprot.readStructEnd()
9791 
 
9792 
  def write(self, oprot):
9793 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9794 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9795 
      return
559 chandransh 9796 
    oprot.writeStructBegin('getCartsByTime_result')
94 ashish 9797 
    if self.success != None:
559 chandransh 9798 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9799 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
2981 rajveer 9800 
      for iter104 in self.success:
9801 
        iter104.write(oprot)
559 chandransh 9802 
      oprot.writeListEnd()
94 ashish 9803 
      oprot.writeFieldEnd()
559 chandransh 9804 
    if self.scx != None:
9805 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9806 
      self.scx.write(oprot)
94 ashish 9807 
      oprot.writeFieldEnd()
9808 
    oprot.writeFieldStop()
9809 
    oprot.writeStructEnd()
9810 
 
9811 
  def __repr__(self):
9812 
    L = ['%s=%r' % (key, value)
9813 
      for key, value in self.__dict__.iteritems()]
9814 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9815 
 
9816 
  def __eq__(self, other):
9817 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9818 
 
9819 
  def __ne__(self, other):
9820 
    return not (self == other)
9821 
 
559 chandransh 9822 
class changeCartStatus_args:
94 ashish 9823 
  """
9824 
  Attributes:
559 chandransh 9825 
   - cartId
9826 
   - status
94 ashish 9827 
  """
9828 
 
9829 
  thrift_spec = (
9830 
    None, # 0
559 chandransh 9831 
    (1, TType.I64, 'cartId', None, None, ), # 1
9832 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 9833 
  )
9834 
 
559 chandransh 9835 
  def __init__(self, cartId=None, status=None,):
9836 
    self.cartId = cartId
9837 
    self.status = status
94 ashish 9838 
 
9839 
  def read(self, iprot):
9840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9842 
      return
9843 
    iprot.readStructBegin()
9844 
    while True:
9845 
      (fname, ftype, fid) = iprot.readFieldBegin()
9846 
      if ftype == TType.STOP:
9847 
        break
9848 
      if fid == 1:
9849 
        if ftype == TType.I64:
559 chandransh 9850 
          self.cartId = iprot.readI64();
94 ashish 9851 
        else:
9852 
          iprot.skip(ftype)
559 chandransh 9853 
      elif fid == 2:
9854 
        if ftype == TType.I32:
9855 
          self.status = iprot.readI32();
9856 
        else:
9857 
          iprot.skip(ftype)
94 ashish 9858 
      else:
9859 
        iprot.skip(ftype)
9860 
      iprot.readFieldEnd()
9861 
    iprot.readStructEnd()
9862 
 
9863 
  def write(self, oprot):
9864 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9865 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9866 
      return
559 chandransh 9867 
    oprot.writeStructBegin('changeCartStatus_args')
9868 
    if self.cartId != None:
9869 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9870 
      oprot.writeI64(self.cartId)
94 ashish 9871 
      oprot.writeFieldEnd()
559 chandransh 9872 
    if self.status != None:
9873 
      oprot.writeFieldBegin('status', TType.I32, 2)
9874 
      oprot.writeI32(self.status)
9875 
      oprot.writeFieldEnd()
94 ashish 9876 
    oprot.writeFieldStop()
9877 
    oprot.writeStructEnd()
9878 
 
9879 
  def __repr__(self):
9880 
    L = ['%s=%r' % (key, value)
9881 
      for key, value in self.__dict__.iteritems()]
9882 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9883 
 
9884 
  def __eq__(self, other):
9885 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9886 
 
9887 
  def __ne__(self, other):
9888 
    return not (self == other)
9889 
 
559 chandransh 9890 
class changeCartStatus_result:
94 ashish 9891 
  """
9892 
  Attributes:
559 chandransh 9893 
   - scx
9894 
  """
9895 
 
9896 
  thrift_spec = (
9897 
    None, # 0
9898 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9899 
  )
9900 
 
9901 
  def __init__(self, scx=None,):
9902 
    self.scx = scx
9903 
 
9904 
  def read(self, iprot):
9905 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9906 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9907 
      return
9908 
    iprot.readStructBegin()
9909 
    while True:
9910 
      (fname, ftype, fid) = iprot.readFieldBegin()
9911 
      if ftype == TType.STOP:
9912 
        break
9913 
      if fid == 1:
9914 
        if ftype == TType.STRUCT:
9915 
          self.scx = ShoppingCartException()
9916 
          self.scx.read(iprot)
9917 
        else:
9918 
          iprot.skip(ftype)
9919 
      else:
9920 
        iprot.skip(ftype)
9921 
      iprot.readFieldEnd()
9922 
    iprot.readStructEnd()
9923 
 
9924 
  def write(self, oprot):
9925 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9926 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9927 
      return
9928 
    oprot.writeStructBegin('changeCartStatus_result')
9929 
    if self.scx != None:
9930 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9931 
      self.scx.write(oprot)
9932 
      oprot.writeFieldEnd()
9933 
    oprot.writeFieldStop()
9934 
    oprot.writeStructEnd()
9935 
 
9936 
  def __repr__(self):
9937 
    L = ['%s=%r' % (key, value)
9938 
      for key, value in self.__dict__.iteritems()]
9939 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9940 
 
9941 
  def __eq__(self, other):
9942 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9943 
 
9944 
  def __ne__(self, other):
9945 
    return not (self == other)
9946 
 
9947 
class addItemToCart_args:
9948 
  """
9949 
  Attributes:
9950 
   - cartId
9951 
   - itemId
9952 
   - quantity
9953 
  """
9954 
 
9955 
  thrift_spec = (
9956 
    None, # 0
9957 
    (1, TType.I64, 'cartId', None, None, ), # 1
9958 
    (2, TType.I64, 'itemId', None, None, ), # 2
9959 
    (3, TType.I64, 'quantity', None, None, ), # 3
9960 
  )
9961 
 
9962 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
9963 
    self.cartId = cartId
9964 
    self.itemId = itemId
9965 
    self.quantity = quantity
9966 
 
9967 
  def read(self, iprot):
9968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9970 
      return
9971 
    iprot.readStructBegin()
9972 
    while True:
9973 
      (fname, ftype, fid) = iprot.readFieldBegin()
9974 
      if ftype == TType.STOP:
9975 
        break
9976 
      if fid == 1:
9977 
        if ftype == TType.I64:
9978 
          self.cartId = iprot.readI64();
9979 
        else:
9980 
          iprot.skip(ftype)
9981 
      elif fid == 2:
9982 
        if ftype == TType.I64:
9983 
          self.itemId = iprot.readI64();
9984 
        else:
9985 
          iprot.skip(ftype)
9986 
      elif fid == 3:
9987 
        if ftype == TType.I64:
9988 
          self.quantity = iprot.readI64();
9989 
        else:
9990 
          iprot.skip(ftype)
9991 
      else:
9992 
        iprot.skip(ftype)
9993 
      iprot.readFieldEnd()
9994 
    iprot.readStructEnd()
9995 
 
9996 
  def write(self, oprot):
9997 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9998 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9999 
      return
10000 
    oprot.writeStructBegin('addItemToCart_args')
10001 
    if self.cartId != None:
10002 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10003 
      oprot.writeI64(self.cartId)
10004 
      oprot.writeFieldEnd()
10005 
    if self.itemId != None:
10006 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10007 
      oprot.writeI64(self.itemId)
10008 
      oprot.writeFieldEnd()
10009 
    if self.quantity != None:
10010 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10011 
      oprot.writeI64(self.quantity)
10012 
      oprot.writeFieldEnd()
10013 
    oprot.writeFieldStop()
10014 
    oprot.writeStructEnd()
10015 
 
10016 
  def __repr__(self):
10017 
    L = ['%s=%r' % (key, value)
10018 
      for key, value in self.__dict__.iteritems()]
10019 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10020 
 
10021 
  def __eq__(self, other):
10022 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10023 
 
10024 
  def __ne__(self, other):
10025 
    return not (self == other)
10026 
 
10027 
class addItemToCart_result:
10028 
  """
10029 
  Attributes:
2035 rajveer 10030 
   - success
559 chandransh 10031 
   - scx
10032 
  """
10033 
 
10034 
  thrift_spec = (
2035 rajveer 10035 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 10036 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10037 
  )
10038 
 
2035 rajveer 10039 
  def __init__(self, success=None, scx=None,):
10040 
    self.success = success
559 chandransh 10041 
    self.scx = scx
10042 
 
10043 
  def read(self, iprot):
10044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10046 
      return
10047 
    iprot.readStructBegin()
10048 
    while True:
10049 
      (fname, ftype, fid) = iprot.readFieldBegin()
10050 
      if ftype == TType.STOP:
10051 
        break
2035 rajveer 10052 
      if fid == 0:
10053 
        if ftype == TType.STRING:
10054 
          self.success = iprot.readString();
10055 
        else:
10056 
          iprot.skip(ftype)
10057 
      elif fid == 1:
559 chandransh 10058 
        if ftype == TType.STRUCT:
10059 
          self.scx = ShoppingCartException()
10060 
          self.scx.read(iprot)
10061 
        else:
10062 
          iprot.skip(ftype)
10063 
      else:
10064 
        iprot.skip(ftype)
10065 
      iprot.readFieldEnd()
10066 
    iprot.readStructEnd()
10067 
 
10068 
  def write(self, oprot):
10069 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10070 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10071 
      return
10072 
    oprot.writeStructBegin('addItemToCart_result')
2035 rajveer 10073 
    if self.success != None:
10074 
      oprot.writeFieldBegin('success', TType.STRING, 0)
10075 
      oprot.writeString(self.success)
10076 
      oprot.writeFieldEnd()
559 chandransh 10077 
    if self.scx != None:
10078 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10079 
      self.scx.write(oprot)
10080 
      oprot.writeFieldEnd()
10081 
    oprot.writeFieldStop()
10082 
    oprot.writeStructEnd()
10083 
 
10084 
  def __repr__(self):
10085 
    L = ['%s=%r' % (key, value)
10086 
      for key, value in self.__dict__.iteritems()]
10087 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10088 
 
10089 
  def __eq__(self, other):
10090 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10091 
 
10092 
  def __ne__(self, other):
10093 
    return not (self == other)
10094 
 
10095 
class deleteItemFromCart_args:
10096 
  """
10097 
  Attributes:
10098 
   - cartId
10099 
   - itemId
10100 
  """
10101 
 
10102 
  thrift_spec = (
10103 
    None, # 0
10104 
    (1, TType.I64, 'cartId', None, None, ), # 1
10105 
    (2, TType.I64, 'itemId', None, None, ), # 2
10106 
  )
10107 
 
10108 
  def __init__(self, cartId=None, itemId=None,):
10109 
    self.cartId = cartId
10110 
    self.itemId = itemId
10111 
 
10112 
  def read(self, iprot):
10113 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10114 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10115 
      return
10116 
    iprot.readStructBegin()
10117 
    while True:
10118 
      (fname, ftype, fid) = iprot.readFieldBegin()
10119 
      if ftype == TType.STOP:
10120 
        break
10121 
      if fid == 1:
10122 
        if ftype == TType.I64:
10123 
          self.cartId = iprot.readI64();
10124 
        else:
10125 
          iprot.skip(ftype)
10126 
      elif fid == 2:
10127 
        if ftype == TType.I64:
10128 
          self.itemId = iprot.readI64();
10129 
        else:
10130 
          iprot.skip(ftype)
10131 
      else:
10132 
        iprot.skip(ftype)
10133 
      iprot.readFieldEnd()
10134 
    iprot.readStructEnd()
10135 
 
10136 
  def write(self, oprot):
10137 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10138 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10139 
      return
10140 
    oprot.writeStructBegin('deleteItemFromCart_args')
10141 
    if self.cartId != None:
10142 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10143 
      oprot.writeI64(self.cartId)
10144 
      oprot.writeFieldEnd()
10145 
    if self.itemId != None:
10146 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10147 
      oprot.writeI64(self.itemId)
10148 
      oprot.writeFieldEnd()
10149 
    oprot.writeFieldStop()
10150 
    oprot.writeStructEnd()
10151 
 
10152 
  def __repr__(self):
10153 
    L = ['%s=%r' % (key, value)
10154 
      for key, value in self.__dict__.iteritems()]
10155 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10156 
 
10157 
  def __eq__(self, other):
10158 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10159 
 
10160 
  def __ne__(self, other):
10161 
    return not (self == other)
10162 
 
10163 
class deleteItemFromCart_result:
10164 
  """
10165 
  Attributes:
10166 
   - scx
10167 
  """
10168 
 
10169 
  thrift_spec = (
10170 
    None, # 0
10171 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10172 
  )
10173 
 
10174 
  def __init__(self, scx=None,):
10175 
    self.scx = scx
10176 
 
10177 
  def read(self, iprot):
10178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10180 
      return
10181 
    iprot.readStructBegin()
10182 
    while True:
10183 
      (fname, ftype, fid) = iprot.readFieldBegin()
10184 
      if ftype == TType.STOP:
10185 
        break
10186 
      if fid == 1:
10187 
        if ftype == TType.STRUCT:
10188 
          self.scx = ShoppingCartException()
10189 
          self.scx.read(iprot)
10190 
        else:
10191 
          iprot.skip(ftype)
10192 
      else:
10193 
        iprot.skip(ftype)
10194 
      iprot.readFieldEnd()
10195 
    iprot.readStructEnd()
10196 
 
10197 
  def write(self, oprot):
10198 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10199 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10200 
      return
10201 
    oprot.writeStructBegin('deleteItemFromCart_result')
10202 
    if self.scx != None:
10203 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10204 
      self.scx.write(oprot)
10205 
      oprot.writeFieldEnd()
10206 
    oprot.writeFieldStop()
10207 
    oprot.writeStructEnd()
10208 
 
10209 
  def __repr__(self):
10210 
    L = ['%s=%r' % (key, value)
10211 
      for key, value in self.__dict__.iteritems()]
10212 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10213 
 
10214 
  def __eq__(self, other):
10215 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10216 
 
10217 
  def __ne__(self, other):
10218 
    return not (self == other)
10219 
 
10220 
class changeQuantity_args:
10221 
  """
10222 
  Attributes:
10223 
   - cartId
10224 
   - itemId
10225 
   - quantity
10226 
  """
10227 
 
10228 
  thrift_spec = (
10229 
    None, # 0
10230 
    (1, TType.I64, 'cartId', None, None, ), # 1
10231 
    (2, TType.I64, 'itemId', None, None, ), # 2
10232 
    (3, TType.I64, 'quantity', None, None, ), # 3
10233 
  )
10234 
 
10235 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
10236 
    self.cartId = cartId
10237 
    self.itemId = itemId
10238 
    self.quantity = quantity
10239 
 
10240 
  def read(self, iprot):
10241 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10242 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10243 
      return
10244 
    iprot.readStructBegin()
10245 
    while True:
10246 
      (fname, ftype, fid) = iprot.readFieldBegin()
10247 
      if ftype == TType.STOP:
10248 
        break
10249 
      if fid == 1:
10250 
        if ftype == TType.I64:
10251 
          self.cartId = iprot.readI64();
10252 
        else:
10253 
          iprot.skip(ftype)
10254 
      elif fid == 2:
10255 
        if ftype == TType.I64:
10256 
          self.itemId = iprot.readI64();
10257 
        else:
10258 
          iprot.skip(ftype)
10259 
      elif fid == 3:
10260 
        if ftype == TType.I64:
10261 
          self.quantity = iprot.readI64();
10262 
        else:
10263 
          iprot.skip(ftype)
10264 
      else:
10265 
        iprot.skip(ftype)
10266 
      iprot.readFieldEnd()
10267 
    iprot.readStructEnd()
10268 
 
10269 
  def write(self, oprot):
10270 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10271 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10272 
      return
10273 
    oprot.writeStructBegin('changeQuantity_args')
10274 
    if self.cartId != None:
10275 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10276 
      oprot.writeI64(self.cartId)
10277 
      oprot.writeFieldEnd()
10278 
    if self.itemId != None:
10279 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10280 
      oprot.writeI64(self.itemId)
10281 
      oprot.writeFieldEnd()
10282 
    if self.quantity != None:
10283 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10284 
      oprot.writeI64(self.quantity)
10285 
      oprot.writeFieldEnd()
10286 
    oprot.writeFieldStop()
10287 
    oprot.writeStructEnd()
10288 
 
10289 
  def __repr__(self):
10290 
    L = ['%s=%r' % (key, value)
10291 
      for key, value in self.__dict__.iteritems()]
10292 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10293 
 
10294 
  def __eq__(self, other):
10295 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10296 
 
10297 
  def __ne__(self, other):
10298 
    return not (self == other)
10299 
 
10300 
class changeQuantity_result:
10301 
  """
10302 
  Attributes:
10303 
   - scx
10304 
  """
10305 
 
10306 
  thrift_spec = (
10307 
    None, # 0
10308 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10309 
  )
10310 
 
10311 
  def __init__(self, scx=None,):
10312 
    self.scx = scx
10313 
 
10314 
  def read(self, iprot):
10315 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10316 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10317 
      return
10318 
    iprot.readStructBegin()
10319 
    while True:
10320 
      (fname, ftype, fid) = iprot.readFieldBegin()
10321 
      if ftype == TType.STOP:
10322 
        break
10323 
      if fid == 1:
10324 
        if ftype == TType.STRUCT:
10325 
          self.scx = ShoppingCartException()
10326 
          self.scx.read(iprot)
10327 
        else:
10328 
          iprot.skip(ftype)
10329 
      else:
10330 
        iprot.skip(ftype)
10331 
      iprot.readFieldEnd()
10332 
    iprot.readStructEnd()
10333 
 
10334 
  def write(self, oprot):
10335 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10336 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10337 
      return
10338 
    oprot.writeStructBegin('changeQuantity_result')
10339 
    if self.scx != None:
10340 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10341 
      self.scx.write(oprot)
10342 
      oprot.writeFieldEnd()
10343 
    oprot.writeFieldStop()
10344 
    oprot.writeStructEnd()
10345 
 
10346 
  def __repr__(self):
10347 
    L = ['%s=%r' % (key, value)
10348 
      for key, value in self.__dict__.iteritems()]
10349 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10350 
 
10351 
  def __eq__(self, other):
10352 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10353 
 
10354 
  def __ne__(self, other):
10355 
    return not (self == other)
10356 
 
10357 
class changeItemStatus_args:
10358 
  """
10359 
  Attributes:
10360 
   - cartId
10361 
   - itemId
10362 
   - status
10363 
  """
10364 
 
10365 
  thrift_spec = (
10366 
    None, # 0
10367 
    (1, TType.I64, 'cartId', None, None, ), # 1
10368 
    (2, TType.I64, 'itemId', None, None, ), # 2
10369 
    (3, TType.I32, 'status', None, None, ), # 3
10370 
  )
10371 
 
10372 
  def __init__(self, cartId=None, itemId=None, status=None,):
10373 
    self.cartId = cartId
10374 
    self.itemId = itemId
10375 
    self.status = status
10376 
 
10377 
  def read(self, iprot):
10378 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10379 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10380 
      return
10381 
    iprot.readStructBegin()
10382 
    while True:
10383 
      (fname, ftype, fid) = iprot.readFieldBegin()
10384 
      if ftype == TType.STOP:
10385 
        break
10386 
      if fid == 1:
10387 
        if ftype == TType.I64:
10388 
          self.cartId = iprot.readI64();
10389 
        else:
10390 
          iprot.skip(ftype)
10391 
      elif fid == 2:
10392 
        if ftype == TType.I64:
10393 
          self.itemId = iprot.readI64();
10394 
        else:
10395 
          iprot.skip(ftype)
10396 
      elif fid == 3:
10397 
        if ftype == TType.I32:
10398 
          self.status = iprot.readI32();
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('changeItemStatus_args')
10411 
    if self.cartId != None:
10412 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10413 
      oprot.writeI64(self.cartId)
10414 
      oprot.writeFieldEnd()
10415 
    if self.itemId != None:
10416 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10417 
      oprot.writeI64(self.itemId)
10418 
      oprot.writeFieldEnd()
10419 
    if self.status != None:
10420 
      oprot.writeFieldBegin('status', TType.I32, 3)
10421 
      oprot.writeI32(self.status)
10422 
      oprot.writeFieldEnd()
10423 
    oprot.writeFieldStop()
10424 
    oprot.writeStructEnd()
10425 
 
10426 
  def __repr__(self):
10427 
    L = ['%s=%r' % (key, value)
10428 
      for key, value in self.__dict__.iteritems()]
10429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10430 
 
10431 
  def __eq__(self, other):
10432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10433 
 
10434 
  def __ne__(self, other):
10435 
    return not (self == other)
10436 
 
10437 
class changeItemStatus_result:
10438 
  """
10439 
  Attributes:
10440 
   - scx
10441 
  """
10442 
 
10443 
  thrift_spec = (
10444 
    None, # 0
10445 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10446 
  )
10447 
 
10448 
  def __init__(self, scx=None,):
10449 
    self.scx = scx
10450 
 
10451 
  def read(self, iprot):
10452 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10453 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10454 
      return
10455 
    iprot.readStructBegin()
10456 
    while True:
10457 
      (fname, ftype, fid) = iprot.readFieldBegin()
10458 
      if ftype == TType.STOP:
10459 
        break
10460 
      if fid == 1:
10461 
        if ftype == TType.STRUCT:
10462 
          self.scx = ShoppingCartException()
10463 
          self.scx.read(iprot)
10464 
        else:
10465 
          iprot.skip(ftype)
10466 
      else:
10467 
        iprot.skip(ftype)
10468 
      iprot.readFieldEnd()
10469 
    iprot.readStructEnd()
10470 
 
10471 
  def write(self, oprot):
10472 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10473 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10474 
      return
10475 
    oprot.writeStructBegin('changeItemStatus_result')
10476 
    if self.scx != None:
10477 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10478 
      self.scx.write(oprot)
10479 
      oprot.writeFieldEnd()
10480 
    oprot.writeFieldStop()
10481 
    oprot.writeStructEnd()
10482 
 
10483 
  def __repr__(self):
10484 
    L = ['%s=%r' % (key, value)
10485 
      for key, value in self.__dict__.iteritems()]
10486 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10487 
 
10488 
  def __eq__(self, other):
10489 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10490 
 
10491 
  def __ne__(self, other):
10492 
    return not (self == other)
10493 
 
10494 
class addAddressToCart_args:
10495 
  """
10496 
  Attributes:
10497 
   - cartId
10498 
   - addressId
10499 
  """
10500 
 
10501 
  thrift_spec = (
10502 
    None, # 0
10503 
    (1, TType.I64, 'cartId', None, None, ), # 1
10504 
    (2, TType.I64, 'addressId', None, None, ), # 2
10505 
  )
10506 
 
10507 
  def __init__(self, cartId=None, addressId=None,):
10508 
    self.cartId = cartId
10509 
    self.addressId = addressId
10510 
 
10511 
  def read(self, iprot):
10512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10514 
      return
10515 
    iprot.readStructBegin()
10516 
    while True:
10517 
      (fname, ftype, fid) = iprot.readFieldBegin()
10518 
      if ftype == TType.STOP:
10519 
        break
10520 
      if fid == 1:
10521 
        if ftype == TType.I64:
10522 
          self.cartId = iprot.readI64();
10523 
        else:
10524 
          iprot.skip(ftype)
10525 
      elif fid == 2:
10526 
        if ftype == TType.I64:
10527 
          self.addressId = iprot.readI64();
10528 
        else:
10529 
          iprot.skip(ftype)
10530 
      else:
10531 
        iprot.skip(ftype)
10532 
      iprot.readFieldEnd()
10533 
    iprot.readStructEnd()
10534 
 
10535 
  def write(self, oprot):
10536 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10537 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10538 
      return
10539 
    oprot.writeStructBegin('addAddressToCart_args')
10540 
    if self.cartId != None:
10541 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10542 
      oprot.writeI64(self.cartId)
10543 
      oprot.writeFieldEnd()
10544 
    if self.addressId != None:
10545 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
10546 
      oprot.writeI64(self.addressId)
10547 
      oprot.writeFieldEnd()
10548 
    oprot.writeFieldStop()
10549 
    oprot.writeStructEnd()
10550 
 
10551 
  def __repr__(self):
10552 
    L = ['%s=%r' % (key, value)
10553 
      for key, value in self.__dict__.iteritems()]
10554 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10555 
 
10556 
  def __eq__(self, other):
10557 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10558 
 
10559 
  def __ne__(self, other):
10560 
    return not (self == other)
10561 
 
10562 
class addAddressToCart_result:
575 chandransh 10563 
  """
10564 
  Attributes:
10565 
   - scx
10566 
  """
559 chandransh 10567 
 
10568 
  thrift_spec = (
575 chandransh 10569 
    None, # 0
10570 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 10571 
  )
10572 
 
575 chandransh 10573 
  def __init__(self, scx=None,):
10574 
    self.scx = scx
10575 
 
559 chandransh 10576 
  def read(self, iprot):
10577 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10578 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10579 
      return
10580 
    iprot.readStructBegin()
10581 
    while True:
10582 
      (fname, ftype, fid) = iprot.readFieldBegin()
10583 
      if ftype == TType.STOP:
10584 
        break
575 chandransh 10585 
      if fid == 1:
10586 
        if ftype == TType.STRUCT:
10587 
          self.scx = ShoppingCartException()
10588 
          self.scx.read(iprot)
10589 
        else:
10590 
          iprot.skip(ftype)
559 chandransh 10591 
      else:
10592 
        iprot.skip(ftype)
10593 
      iprot.readFieldEnd()
10594 
    iprot.readStructEnd()
10595 
 
10596 
  def write(self, oprot):
10597 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10598 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10599 
      return
10600 
    oprot.writeStructBegin('addAddressToCart_result')
575 chandransh 10601 
    if self.scx != None:
10602 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10603 
      self.scx.write(oprot)
10604 
      oprot.writeFieldEnd()
559 chandransh 10605 
    oprot.writeFieldStop()
10606 
    oprot.writeStructEnd()
10607 
 
10608 
  def __repr__(self):
10609 
    L = ['%s=%r' % (key, value)
10610 
      for key, value in self.__dict__.iteritems()]
10611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10612 
 
10613 
  def __eq__(self, other):
10614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10615 
 
10616 
  def __ne__(self, other):
10617 
    return not (self == other)
10618 
 
1976 varun.gupt 10619 
class applyCouponToCart_args:
10620 
  """
10621 
  Attributes:
10622 
   - cartId
10623 
   - couponCode
10624 
   - totalPrice
10625 
   - discountedPrice
10626 
  """
10627 
 
10628 
  thrift_spec = (
10629 
    None, # 0
10630 
    (1, TType.I64, 'cartId', None, None, ), # 1
10631 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
10632 
    (3, TType.DOUBLE, 'totalPrice', None, None, ), # 3
10633 
    (4, TType.DOUBLE, 'discountedPrice', None, None, ), # 4
10634 
  )
10635 
 
10636 
  def __init__(self, cartId=None, couponCode=None, totalPrice=None, discountedPrice=None,):
10637 
    self.cartId = cartId
10638 
    self.couponCode = couponCode
10639 
    self.totalPrice = totalPrice
10640 
    self.discountedPrice = discountedPrice
10641 
 
10642 
  def read(self, iprot):
10643 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10644 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10645 
      return
10646 
    iprot.readStructBegin()
10647 
    while True:
10648 
      (fname, ftype, fid) = iprot.readFieldBegin()
10649 
      if ftype == TType.STOP:
10650 
        break
10651 
      if fid == 1:
10652 
        if ftype == TType.I64:
10653 
          self.cartId = iprot.readI64();
10654 
        else:
10655 
          iprot.skip(ftype)
10656 
      elif fid == 2:
10657 
        if ftype == TType.STRING:
10658 
          self.couponCode = iprot.readString();
10659 
        else:
10660 
          iprot.skip(ftype)
10661 
      elif fid == 3:
10662 
        if ftype == TType.DOUBLE:
10663 
          self.totalPrice = iprot.readDouble();
10664 
        else:
10665 
          iprot.skip(ftype)
10666 
      elif fid == 4:
10667 
        if ftype == TType.DOUBLE:
10668 
          self.discountedPrice = iprot.readDouble();
10669 
        else:
10670 
          iprot.skip(ftype)
10671 
      else:
10672 
        iprot.skip(ftype)
10673 
      iprot.readFieldEnd()
10674 
    iprot.readStructEnd()
10675 
 
10676 
  def write(self, oprot):
10677 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10678 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10679 
      return
10680 
    oprot.writeStructBegin('applyCouponToCart_args')
10681 
    if self.cartId != None:
10682 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10683 
      oprot.writeI64(self.cartId)
10684 
      oprot.writeFieldEnd()
10685 
    if self.couponCode != None:
10686 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
10687 
      oprot.writeString(self.couponCode)
10688 
      oprot.writeFieldEnd()
10689 
    if self.totalPrice != None:
10690 
      oprot.writeFieldBegin('totalPrice', TType.DOUBLE, 3)
10691 
      oprot.writeDouble(self.totalPrice)
10692 
      oprot.writeFieldEnd()
10693 
    if self.discountedPrice != None:
10694 
      oprot.writeFieldBegin('discountedPrice', TType.DOUBLE, 4)
10695 
      oprot.writeDouble(self.discountedPrice)
10696 
      oprot.writeFieldEnd()
10697 
    oprot.writeFieldStop()
10698 
    oprot.writeStructEnd()
10699 
 
10700 
  def __repr__(self):
10701 
    L = ['%s=%r' % (key, value)
10702 
      for key, value in self.__dict__.iteritems()]
10703 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10704 
 
10705 
  def __eq__(self, other):
10706 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10707 
 
10708 
  def __ne__(self, other):
10709 
    return not (self == other)
10710 
 
10711 
class applyCouponToCart_result:
10712 
  """
10713 
  Attributes:
10714 
   - scx
10715 
  """
10716 
 
10717 
  thrift_spec = (
10718 
    None, # 0
10719 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10720 
  )
10721 
 
10722 
  def __init__(self, scx=None,):
10723 
    self.scx = scx
10724 
 
10725 
  def read(self, iprot):
10726 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10727 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10728 
      return
10729 
    iprot.readStructBegin()
10730 
    while True:
10731 
      (fname, ftype, fid) = iprot.readFieldBegin()
10732 
      if ftype == TType.STOP:
10733 
        break
10734 
      if fid == 1:
10735 
        if ftype == TType.STRUCT:
10736 
          self.scx = ShoppingCartException()
10737 
          self.scx.read(iprot)
10738 
        else:
10739 
          iprot.skip(ftype)
10740 
      else:
10741 
        iprot.skip(ftype)
10742 
      iprot.readFieldEnd()
10743 
    iprot.readStructEnd()
10744 
 
10745 
  def write(self, oprot):
10746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10748 
      return
10749 
    oprot.writeStructBegin('applyCouponToCart_result')
10750 
    if self.scx != None:
10751 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10752 
      self.scx.write(oprot)
10753 
      oprot.writeFieldEnd()
10754 
    oprot.writeFieldStop()
10755 
    oprot.writeStructEnd()
10756 
 
10757 
  def __repr__(self):
10758 
    L = ['%s=%r' % (key, value)
10759 
      for key, value in self.__dict__.iteritems()]
10760 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10761 
 
10762 
  def __eq__(self, other):
10763 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10764 
 
10765 
  def __ne__(self, other):
10766 
    return not (self == other)
10767 
 
10768 
class removeCoupon_args:
10769 
  """
10770 
  Attributes:
10771 
   - cartId
10772 
  """
10773 
 
10774 
  thrift_spec = (
10775 
    None, # 0
10776 
    (1, TType.I64, 'cartId', None, None, ), # 1
10777 
  )
10778 
 
10779 
  def __init__(self, cartId=None,):
10780 
    self.cartId = cartId
10781 
 
10782 
  def read(self, iprot):
10783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10785 
      return
10786 
    iprot.readStructBegin()
10787 
    while True:
10788 
      (fname, ftype, fid) = iprot.readFieldBegin()
10789 
      if ftype == TType.STOP:
10790 
        break
10791 
      if fid == 1:
10792 
        if ftype == TType.I64:
10793 
          self.cartId = iprot.readI64();
10794 
        else:
10795 
          iprot.skip(ftype)
10796 
      else:
10797 
        iprot.skip(ftype)
10798 
      iprot.readFieldEnd()
10799 
    iprot.readStructEnd()
10800 
 
10801 
  def write(self, oprot):
10802 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10803 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10804 
      return
10805 
    oprot.writeStructBegin('removeCoupon_args')
10806 
    if self.cartId != None:
10807 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10808 
      oprot.writeI64(self.cartId)
10809 
      oprot.writeFieldEnd()
10810 
    oprot.writeFieldStop()
10811 
    oprot.writeStructEnd()
10812 
 
10813 
  def __repr__(self):
10814 
    L = ['%s=%r' % (key, value)
10815 
      for key, value in self.__dict__.iteritems()]
10816 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10817 
 
10818 
  def __eq__(self, other):
10819 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10820 
 
10821 
  def __ne__(self, other):
10822 
    return not (self == other)
10823 
 
10824 
class removeCoupon_result:
10825 
  """
10826 
  Attributes:
10827 
   - scx
10828 
  """
10829 
 
10830 
  thrift_spec = (
10831 
    None, # 0
10832 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10833 
  )
10834 
 
10835 
  def __init__(self, scx=None,):
10836 
    self.scx = scx
10837 
 
10838 
  def read(self, iprot):
10839 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10840 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10841 
      return
10842 
    iprot.readStructBegin()
10843 
    while True:
10844 
      (fname, ftype, fid) = iprot.readFieldBegin()
10845 
      if ftype == TType.STOP:
10846 
        break
10847 
      if fid == 1:
10848 
        if ftype == TType.STRUCT:
10849 
          self.scx = ShoppingCartException()
10850 
          self.scx.read(iprot)
10851 
        else:
10852 
          iprot.skip(ftype)
10853 
      else:
10854 
        iprot.skip(ftype)
10855 
      iprot.readFieldEnd()
10856 
    iprot.readStructEnd()
10857 
 
10858 
  def write(self, oprot):
10859 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10860 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10861 
      return
10862 
    oprot.writeStructBegin('removeCoupon_result')
10863 
    if self.scx != None:
10864 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10865 
      self.scx.write(oprot)
10866 
      oprot.writeFieldEnd()
10867 
    oprot.writeFieldStop()
10868 
    oprot.writeStructEnd()
10869 
 
10870 
  def __repr__(self):
10871 
    L = ['%s=%r' % (key, value)
10872 
      for key, value in self.__dict__.iteritems()]
10873 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10874 
 
10875 
  def __eq__(self, other):
10876 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10877 
 
10878 
  def __ne__(self, other):
10879 
    return not (self == other)
10880 
 
690 chandransh 10881 
class createOrders_args:
559 chandransh 10882 
  """
10883 
  Attributes:
10884 
   - cartId
2815 vikas 10885 
   - sessionSource
10886 
   - sessionStartTime
559 chandransh 10887 
  """
10888 
 
10889 
  thrift_spec = (
10890 
    None, # 0
10891 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 10892 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
10893 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
559 chandransh 10894 
  )
10895 
 
2815 vikas 10896 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None,):
559 chandransh 10897 
    self.cartId = cartId
2815 vikas 10898 
    self.sessionSource = sessionSource
10899 
    self.sessionStartTime = sessionStartTime
559 chandransh 10900 
 
10901 
  def read(self, iprot):
10902 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10903 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10904 
      return
10905 
    iprot.readStructBegin()
10906 
    while True:
10907 
      (fname, ftype, fid) = iprot.readFieldBegin()
10908 
      if ftype == TType.STOP:
10909 
        break
10910 
      if fid == 1:
10911 
        if ftype == TType.I64:
10912 
          self.cartId = iprot.readI64();
10913 
        else:
10914 
          iprot.skip(ftype)
2815 vikas 10915 
      elif fid == 2:
10916 
        if ftype == TType.STRING:
10917 
          self.sessionSource = iprot.readString();
10918 
        else:
10919 
          iprot.skip(ftype)
10920 
      elif fid == 3:
10921 
        if ftype == TType.I64:
10922 
          self.sessionStartTime = iprot.readI64();
10923 
        else:
10924 
          iprot.skip(ftype)
559 chandransh 10925 
      else:
10926 
        iprot.skip(ftype)
10927 
      iprot.readFieldEnd()
10928 
    iprot.readStructEnd()
10929 
 
10930 
  def write(self, oprot):
10931 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10932 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10933 
      return
690 chandransh 10934 
    oprot.writeStructBegin('createOrders_args')
559 chandransh 10935 
    if self.cartId != None:
10936 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10937 
      oprot.writeI64(self.cartId)
10938 
      oprot.writeFieldEnd()
2815 vikas 10939 
    if self.sessionSource != None:
10940 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
10941 
      oprot.writeString(self.sessionSource)
10942 
      oprot.writeFieldEnd()
10943 
    if self.sessionStartTime != None:
10944 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
10945 
      oprot.writeI64(self.sessionStartTime)
10946 
      oprot.writeFieldEnd()
559 chandransh 10947 
    oprot.writeFieldStop()
10948 
    oprot.writeStructEnd()
10949 
 
10950 
  def __repr__(self):
10951 
    L = ['%s=%r' % (key, value)
10952 
      for key, value in self.__dict__.iteritems()]
10953 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10954 
 
10955 
  def __eq__(self, other):
10956 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10957 
 
10958 
  def __ne__(self, other):
10959 
    return not (self == other)
10960 
 
690 chandransh 10961 
class createOrders_result:
559 chandransh 10962 
  """
10963 
  Attributes:
94 ashish 10964 
   - success
559 chandransh 10965 
   - scx
94 ashish 10966 
  """
10967 
 
10968 
  thrift_spec = (
575 chandransh 10969 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 10970 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10971 
  )
10972 
 
559 chandransh 10973 
  def __init__(self, success=None, scx=None,):
94 ashish 10974 
    self.success = success
559 chandransh 10975 
    self.scx = scx
94 ashish 10976 
 
10977 
  def read(self, iprot):
10978 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10979 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10980 
      return
10981 
    iprot.readStructBegin()
10982 
    while True:
10983 
      (fname, ftype, fid) = iprot.readFieldBegin()
10984 
      if ftype == TType.STOP:
10985 
        break
10986 
      if fid == 0:
575 chandransh 10987 
        if ftype == TType.I64:
10988 
          self.success = iprot.readI64();
94 ashish 10989 
        else:
10990 
          iprot.skip(ftype)
10991 
      elif fid == 1:
10992 
        if ftype == TType.STRUCT:
559 chandransh 10993 
          self.scx = ShoppingCartException()
10994 
          self.scx.read(iprot)
94 ashish 10995 
        else:
10996 
          iprot.skip(ftype)
10997 
      else:
10998 
        iprot.skip(ftype)
10999 
      iprot.readFieldEnd()
11000 
    iprot.readStructEnd()
11001 
 
11002 
  def write(self, oprot):
11003 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11004 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11005 
      return
690 chandransh 11006 
    oprot.writeStructBegin('createOrders_result')
94 ashish 11007 
    if self.success != None:
575 chandransh 11008 
      oprot.writeFieldBegin('success', TType.I64, 0)
11009 
      oprot.writeI64(self.success)
94 ashish 11010 
      oprot.writeFieldEnd()
559 chandransh 11011 
    if self.scx != None:
11012 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11013 
      self.scx.write(oprot)
94 ashish 11014 
      oprot.writeFieldEnd()
11015 
    oprot.writeFieldStop()
11016 
    oprot.writeStructEnd()
11017 
 
11018 
  def __repr__(self):
11019 
    L = ['%s=%r' % (key, value)
11020 
      for key, value in self.__dict__.iteritems()]
11021 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11022 
 
11023 
  def __eq__(self, other):
11024 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11025 
 
11026 
  def __ne__(self, other):
11027 
    return not (self == other)
11028 
 
559 chandransh 11029 
class validateCart_args:
94 ashish 11030 
  """
11031 
  Attributes:
559 chandransh 11032 
   - cartId
94 ashish 11033 
  """
11034 
 
11035 
  thrift_spec = (
11036 
    None, # 0
559 chandransh 11037 
    (1, TType.I64, 'cartId', None, None, ), # 1
94 ashish 11038 
  )
11039 
 
559 chandransh 11040 
  def __init__(self, cartId=None,):
11041 
    self.cartId = cartId
94 ashish 11042 
 
11043 
  def read(self, iprot):
11044 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11045 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11046 
      return
11047 
    iprot.readStructBegin()
11048 
    while True:
11049 
      (fname, ftype, fid) = iprot.readFieldBegin()
11050 
      if ftype == TType.STOP:
11051 
        break
11052 
      if fid == 1:
11053 
        if ftype == TType.I64:
559 chandransh 11054 
          self.cartId = iprot.readI64();
94 ashish 11055 
        else:
11056 
          iprot.skip(ftype)
11057 
      else:
11058 
        iprot.skip(ftype)
11059 
      iprot.readFieldEnd()
11060 
    iprot.readStructEnd()
11061 
 
11062 
  def write(self, oprot):
11063 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11064 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11065 
      return
559 chandransh 11066 
    oprot.writeStructBegin('validateCart_args')
11067 
    if self.cartId != None:
11068 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11069 
      oprot.writeI64(self.cartId)
94 ashish 11070 
      oprot.writeFieldEnd()
11071 
    oprot.writeFieldStop()
11072 
    oprot.writeStructEnd()
11073 
 
11074 
  def __repr__(self):
11075 
    L = ['%s=%r' % (key, value)
11076 
      for key, value in self.__dict__.iteritems()]
11077 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11078 
 
11079 
  def __eq__(self, other):
11080 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11081 
 
11082 
  def __ne__(self, other):
11083 
    return not (self == other)
11084 
 
559 chandransh 11085 
class validateCart_result:
94 ashish 11086 
  """
11087 
  Attributes:
11088 
   - success
575 chandransh 11089 
   - scex
94 ashish 11090 
  """
11091 
 
11092 
  thrift_spec = (
1466 ankur.sing 11093 
    (0, TType.STRING, 'success', None, None, ), # 0
575 chandransh 11094 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11095 
  )
11096 
 
575 chandransh 11097 
  def __init__(self, success=None, scex=None,):
94 ashish 11098 
    self.success = success
575 chandransh 11099 
    self.scex = scex
94 ashish 11100 
 
11101 
  def read(self, iprot):
11102 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11103 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11104 
      return
11105 
    iprot.readStructBegin()
11106 
    while True:
11107 
      (fname, ftype, fid) = iprot.readFieldBegin()
11108 
      if ftype == TType.STOP:
11109 
        break
11110 
      if fid == 0:
1466 ankur.sing 11111 
        if ftype == TType.STRING:
11112 
          self.success = iprot.readString();
94 ashish 11113 
        else:
11114 
          iprot.skip(ftype)
575 chandransh 11115 
      elif fid == 1:
11116 
        if ftype == TType.STRUCT:
11117 
          self.scex = ShoppingCartException()
11118 
          self.scex.read(iprot)
11119 
        else:
11120 
          iprot.skip(ftype)
94 ashish 11121 
      else:
11122 
        iprot.skip(ftype)
11123 
      iprot.readFieldEnd()
11124 
    iprot.readStructEnd()
11125 
 
11126 
  def write(self, oprot):
11127 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11128 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11129 
      return
559 chandransh 11130 
    oprot.writeStructBegin('validateCart_result')
94 ashish 11131 
    if self.success != None:
1466 ankur.sing 11132 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11133 
      oprot.writeString(self.success)
94 ashish 11134 
      oprot.writeFieldEnd()
575 chandransh 11135 
    if self.scex != None:
11136 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11137 
      self.scex.write(oprot)
11138 
      oprot.writeFieldEnd()
559 chandransh 11139 
    oprot.writeFieldStop()
11140 
    oprot.writeStructEnd()
11141 
 
11142 
  def __repr__(self):
11143 
    L = ['%s=%r' % (key, value)
11144 
      for key, value in self.__dict__.iteritems()]
11145 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11146 
 
11147 
  def __eq__(self, other):
11148 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11149 
 
11150 
  def __ne__(self, other):
11151 
    return not (self == other)
11152 
 
690 chandransh 11153 
class mergeCart_args:
575 chandransh 11154 
  """
11155 
  Attributes:
690 chandransh 11156 
   - fromCartId
11157 
   - toCartId
11158 
  """
11159 
 
11160 
  thrift_spec = (
11161 
    None, # 0
11162 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
11163 
    (2, TType.I64, 'toCartId', None, None, ), # 2
11164 
  )
11165 
 
11166 
  def __init__(self, fromCartId=None, toCartId=None,):
11167 
    self.fromCartId = fromCartId
11168 
    self.toCartId = toCartId
11169 
 
11170 
  def read(self, iprot):
11171 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11172 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11173 
      return
11174 
    iprot.readStructBegin()
11175 
    while True:
11176 
      (fname, ftype, fid) = iprot.readFieldBegin()
11177 
      if ftype == TType.STOP:
11178 
        break
11179 
      if fid == 1:
11180 
        if ftype == TType.I64:
11181 
          self.fromCartId = iprot.readI64();
11182 
        else:
11183 
          iprot.skip(ftype)
11184 
      elif fid == 2:
11185 
        if ftype == TType.I64:
11186 
          self.toCartId = iprot.readI64();
11187 
        else:
11188 
          iprot.skip(ftype)
11189 
      else:
11190 
        iprot.skip(ftype)
11191 
      iprot.readFieldEnd()
11192 
    iprot.readStructEnd()
11193 
 
11194 
  def write(self, oprot):
11195 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11196 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11197 
      return
11198 
    oprot.writeStructBegin('mergeCart_args')
11199 
    if self.fromCartId != None:
11200 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
11201 
      oprot.writeI64(self.fromCartId)
11202 
      oprot.writeFieldEnd()
11203 
    if self.toCartId != None:
11204 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
11205 
      oprot.writeI64(self.toCartId)
11206 
      oprot.writeFieldEnd()
11207 
    oprot.writeFieldStop()
11208 
    oprot.writeStructEnd()
11209 
 
11210 
  def __repr__(self):
11211 
    L = ['%s=%r' % (key, value)
11212 
      for key, value in self.__dict__.iteritems()]
11213 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11214 
 
11215 
  def __eq__(self, other):
11216 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11217 
 
11218 
  def __ne__(self, other):
11219 
    return not (self == other)
11220 
 
11221 
class mergeCart_result:
11222 
 
11223 
  thrift_spec = (
11224 
  )
11225 
 
11226 
  def read(self, iprot):
11227 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11228 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11229 
      return
11230 
    iprot.readStructBegin()
11231 
    while True:
11232 
      (fname, ftype, fid) = iprot.readFieldBegin()
11233 
      if ftype == TType.STOP:
11234 
        break
11235 
      else:
11236 
        iprot.skip(ftype)
11237 
      iprot.readFieldEnd()
11238 
    iprot.readStructEnd()
11239 
 
11240 
  def write(self, oprot):
11241 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11242 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11243 
      return
11244 
    oprot.writeStructBegin('mergeCart_result')
11245 
    oprot.writeFieldStop()
11246 
    oprot.writeStructEnd()
11247 
 
11248 
  def __repr__(self):
11249 
    L = ['%s=%r' % (key, value)
11250 
      for key, value in self.__dict__.iteritems()]
11251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11252 
 
11253 
  def __eq__(self, other):
11254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11255 
 
11256 
  def __ne__(self, other):
11257 
    return not (self == other)
11258 
 
11259 
class checkOut_args:
11260 
  """
11261 
  Attributes:
575 chandransh 11262 
   - cartId
11263 
  """
11264 
 
11265 
  thrift_spec = (
11266 
    None, # 0
11267 
    (1, TType.I64, 'cartId', None, None, ), # 1
11268 
  )
11269 
 
11270 
  def __init__(self, cartId=None,):
11271 
    self.cartId = cartId
11272 
 
11273 
  def read(self, iprot):
11274 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11275 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11276 
      return
11277 
    iprot.readStructBegin()
11278 
    while True:
11279 
      (fname, ftype, fid) = iprot.readFieldBegin()
11280 
      if ftype == TType.STOP:
11281 
        break
11282 
      if fid == 1:
11283 
        if ftype == TType.I64:
11284 
          self.cartId = iprot.readI64();
11285 
        else:
11286 
          iprot.skip(ftype)
11287 
      else:
11288 
        iprot.skip(ftype)
11289 
      iprot.readFieldEnd()
11290 
    iprot.readStructEnd()
11291 
 
11292 
  def write(self, oprot):
11293 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11294 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11295 
      return
690 chandransh 11296 
    oprot.writeStructBegin('checkOut_args')
575 chandransh 11297 
    if self.cartId != None:
11298 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11299 
      oprot.writeI64(self.cartId)
11300 
      oprot.writeFieldEnd()
11301 
    oprot.writeFieldStop()
11302 
    oprot.writeStructEnd()
11303 
 
11304 
  def __repr__(self):
11305 
    L = ['%s=%r' % (key, value)
11306 
      for key, value in self.__dict__.iteritems()]
11307 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11308 
 
11309 
  def __eq__(self, other):
11310 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11311 
 
11312 
  def __ne__(self, other):
11313 
    return not (self == other)
11314 
 
690 chandransh 11315 
class checkOut_result:
575 chandransh 11316 
  """
11317 
  Attributes:
11318 
   - success
11319 
   - scex
11320 
  """
11321 
 
11322 
  thrift_spec = (
11323 
    (0, TType.BOOL, 'success', None, None, ), # 0
11324 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11325 
  )
11326 
 
11327 
  def __init__(self, success=None, scex=None,):
11328 
    self.success = success
11329 
    self.scex = scex
11330 
 
11331 
  def read(self, iprot):
11332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11334 
      return
11335 
    iprot.readStructBegin()
11336 
    while True:
11337 
      (fname, ftype, fid) = iprot.readFieldBegin()
11338 
      if ftype == TType.STOP:
11339 
        break
11340 
      if fid == 0:
11341 
        if ftype == TType.BOOL:
11342 
          self.success = iprot.readBool();
11343 
        else:
11344 
          iprot.skip(ftype)
11345 
      elif fid == 1:
11346 
        if ftype == TType.STRUCT:
11347 
          self.scex = ShoppingCartException()
11348 
          self.scex.read(iprot)
11349 
        else:
11350 
          iprot.skip(ftype)
11351 
      else:
11352 
        iprot.skip(ftype)
11353 
      iprot.readFieldEnd()
11354 
    iprot.readStructEnd()
11355 
 
11356 
  def write(self, oprot):
11357 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11358 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11359 
      return
690 chandransh 11360 
    oprot.writeStructBegin('checkOut_result')
575 chandransh 11361 
    if self.success != None:
11362 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11363 
      oprot.writeBool(self.success)
11364 
      oprot.writeFieldEnd()
11365 
    if self.scex != None:
11366 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11367 
      self.scex.write(oprot)
11368 
      oprot.writeFieldEnd()
11369 
    oprot.writeFieldStop()
11370 
    oprot.writeStructEnd()
11371 
 
11372 
  def __repr__(self):
11373 
    L = ['%s=%r' % (key, value)
11374 
      for key, value in self.__dict__.iteritems()]
11375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11376 
 
11377 
  def __eq__(self, other):
11378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11379 
 
11380 
  def __ne__(self, other):
11381 
    return not (self == other)
11382 
 
690 chandransh 11383 
class resetCart_args:
559 chandransh 11384 
  """
11385 
  Attributes:
690 chandransh 11386 
   - cartId
11387 
   - items
559 chandransh 11388 
  """
11389 
 
11390 
  thrift_spec = (
11391 
    None, # 0
690 chandransh 11392 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 11393 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 11394 
  )
11395 
 
690 chandransh 11396 
  def __init__(self, cartId=None, items=None,):
11397 
    self.cartId = cartId
11398 
    self.items = items
559 chandransh 11399 
 
11400 
  def read(self, iprot):
11401 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11402 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11403 
      return
11404 
    iprot.readStructBegin()
11405 
    while True:
11406 
      (fname, ftype, fid) = iprot.readFieldBegin()
11407 
      if ftype == TType.STOP:
11408 
        break
11409 
      if fid == 1:
11410 
        if ftype == TType.I64:
690 chandransh 11411 
          self.cartId = iprot.readI64();
559 chandransh 11412 
        else:
11413 
          iprot.skip(ftype)
11414 
      elif fid == 2:
690 chandransh 11415 
        if ftype == TType.MAP:
11416 
          self.items = {}
2981 rajveer 11417 
          (_ktype106, _vtype107, _size105 ) = iprot.readMapBegin()
11418 
          for _i109 in xrange(_size105):
11419 
            _key110 = iprot.readI64();
11420 
            _val111 = iprot.readDouble();
11421 
            self.items[_key110] = _val111
690 chandransh 11422 
          iprot.readMapEnd()
559 chandransh 11423 
        else:
11424 
          iprot.skip(ftype)
11425 
      else:
11426 
        iprot.skip(ftype)
11427 
      iprot.readFieldEnd()
11428 
    iprot.readStructEnd()
11429 
 
11430 
  def write(self, oprot):
11431 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11432 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11433 
      return
690 chandransh 11434 
    oprot.writeStructBegin('resetCart_args')
11435 
    if self.cartId != None:
11436 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11437 
      oprot.writeI64(self.cartId)
94 ashish 11438 
      oprot.writeFieldEnd()
690 chandransh 11439 
    if self.items != None:
11440 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 11441 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
2981 rajveer 11442 
      for kiter112,viter113 in self.items.items():
11443 
        oprot.writeI64(kiter112)
11444 
        oprot.writeDouble(viter113)
690 chandransh 11445 
      oprot.writeMapEnd()
559 chandransh 11446 
      oprot.writeFieldEnd()
94 ashish 11447 
    oprot.writeFieldStop()
11448 
    oprot.writeStructEnd()
11449 
 
11450 
  def __repr__(self):
11451 
    L = ['%s=%r' % (key, value)
11452 
      for key, value in self.__dict__.iteritems()]
11453 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11454 
 
11455 
  def __eq__(self, other):
11456 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11457 
 
11458 
  def __ne__(self, other):
11459 
    return not (self == other)
11460 
 
690 chandransh 11461 
class resetCart_result:
11462 
  """
11463 
  Attributes:
11464 
   - success
11465 
   - scex
11466 
  """
559 chandransh 11467 
 
11468 
  thrift_spec = (
690 chandransh 11469 
    (0, TType.BOOL, 'success', None, None, ), # 0
11470 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11471 
  )
11472 
 
690 chandransh 11473 
  def __init__(self, success=None, scex=None,):
11474 
    self.success = success
11475 
    self.scex = scex
11476 
 
559 chandransh 11477 
  def read(self, iprot):
11478 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11479 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11480 
      return
11481 
    iprot.readStructBegin()
11482 
    while True:
11483 
      (fname, ftype, fid) = iprot.readFieldBegin()
11484 
      if ftype == TType.STOP:
11485 
        break
690 chandransh 11486 
      if fid == 0:
11487 
        if ftype == TType.BOOL:
11488 
          self.success = iprot.readBool();
11489 
        else:
11490 
          iprot.skip(ftype)
11491 
      elif fid == 1:
11492 
        if ftype == TType.STRUCT:
11493 
          self.scex = ShoppingCartException()
11494 
          self.scex.read(iprot)
11495 
        else:
11496 
          iprot.skip(ftype)
559 chandransh 11497 
      else:
11498 
        iprot.skip(ftype)
11499 
      iprot.readFieldEnd()
11500 
    iprot.readStructEnd()
11501 
 
11502 
  def write(self, oprot):
11503 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11504 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11505 
      return
690 chandransh 11506 
    oprot.writeStructBegin('resetCart_result')
11507 
    if self.success != None:
11508 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11509 
      oprot.writeBool(self.success)
11510 
      oprot.writeFieldEnd()
11511 
    if self.scex != None:
11512 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11513 
      self.scex.write(oprot)
11514 
      oprot.writeFieldEnd()
559 chandransh 11515 
    oprot.writeFieldStop()
11516 
    oprot.writeStructEnd()
11517 
 
11518 
  def __repr__(self):
11519 
    L = ['%s=%r' % (key, value)
11520 
      for key, value in self.__dict__.iteritems()]
11521 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11522 
 
11523 
  def __eq__(self, other):
11524 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11525 
 
11526 
  def __ne__(self, other):
11527 
    return not (self == other)
11528 
 
2981 rajveer 11529 
class getUserCount_args:
94 ashish 11530 
  """
11531 
  Attributes:
2981 rajveer 11532 
   - userType
559 chandransh 11533 
  """
11534 
 
11535 
  thrift_spec = (
11536 
    None, # 0
2981 rajveer 11537 
    (1, TType.I32, 'userType', None, None, ), # 1
559 chandransh 11538 
  )
11539 
 
2981 rajveer 11540 
  def __init__(self, userType=None,):
11541 
    self.userType = userType
559 chandransh 11542 
 
11543 
  def read(self, iprot):
11544 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11545 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11546 
      return
11547 
    iprot.readStructBegin()
11548 
    while True:
11549 
      (fname, ftype, fid) = iprot.readFieldBegin()
11550 
      if ftype == TType.STOP:
11551 
        break
11552 
      if fid == 1:
2981 rajveer 11553 
        if ftype == TType.I32:
11554 
          self.userType = iprot.readI32();
559 chandransh 11555 
        else:
11556 
          iprot.skip(ftype)
11557 
      else:
11558 
        iprot.skip(ftype)
11559 
      iprot.readFieldEnd()
11560 
    iprot.readStructEnd()
11561 
 
11562 
  def write(self, oprot):
11563 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11564 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11565 
      return
2981 rajveer 11566 
    oprot.writeStructBegin('getUserCount_args')
11567 
    if self.userType != None:
11568 
      oprot.writeFieldBegin('userType', TType.I32, 1)
11569 
      oprot.writeI32(self.userType)
559 chandransh 11570 
      oprot.writeFieldEnd()
11571 
    oprot.writeFieldStop()
11572 
    oprot.writeStructEnd()
11573 
 
11574 
  def __repr__(self):
11575 
    L = ['%s=%r' % (key, value)
11576 
      for key, value in self.__dict__.iteritems()]
11577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11578 
 
11579 
  def __eq__(self, other):
11580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11581 
 
11582 
  def __ne__(self, other):
11583 
    return not (self == other)
11584 
 
2981 rajveer 11585 
class getUserCount_result:
94 ashish 11586 
  """
11587 
  Attributes:
11588 
   - success
11589 
  """
11590 
 
11591 
  thrift_spec = (
2981 rajveer 11592 
    (0, TType.I64, 'success', None, None, ), # 0
94 ashish 11593 
  )
11594 
 
2981 rajveer 11595 
  def __init__(self, success=None,):
94 ashish 11596 
    self.success = success
11597 
 
11598 
  def read(self, iprot):
11599 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11600 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11601 
      return
11602 
    iprot.readStructBegin()
11603 
    while True:
11604 
      (fname, ftype, fid) = iprot.readFieldBegin()
11605 
      if ftype == TType.STOP:
11606 
        break
11607 
      if fid == 0:
2981 rajveer 11608 
        if ftype == TType.I64:
11609 
          self.success = iprot.readI64();
94 ashish 11610 
        else:
11611 
          iprot.skip(ftype)
11612 
      else:
11613 
        iprot.skip(ftype)
11614 
      iprot.readFieldEnd()
11615 
    iprot.readStructEnd()
11616 
 
11617 
  def write(self, oprot):
11618 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11619 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11620 
      return
2981 rajveer 11621 
    oprot.writeStructBegin('getUserCount_result')
94 ashish 11622 
    if self.success != None:
2981 rajveer 11623 
      oprot.writeFieldBegin('success', TType.I64, 0)
11624 
      oprot.writeI64(self.success)
94 ashish 11625 
      oprot.writeFieldEnd()
11626 
    oprot.writeFieldStop()
11627 
    oprot.writeStructEnd()
11628 
 
11629 
  def __repr__(self):
11630 
    L = ['%s=%r' % (key, value)
11631 
      for key, value in self.__dict__.iteritems()]
11632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11633 
 
11634 
  def __eq__(self, other):
11635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11636 
 
11637 
  def __ne__(self, other):
11638 
    return not (self == other)
11639 
 
2981 rajveer 11640 
class getAllUsers_args:
94 ashish 11641 
  """
11642 
  Attributes:
2981 rajveer 11643 
   - userType
11644 
   - startDate
11645 
   - endDate
94 ashish 11646 
  """
11647 
 
11648 
  thrift_spec = (
11649 
    None, # 0
2981 rajveer 11650 
    (1, TType.I32, 'userType', None, None, ), # 1
11651 
    (2, TType.I64, 'startDate', None, None, ), # 2
11652 
    (3, TType.I64, 'endDate', None, None, ), # 3
94 ashish 11653 
  )
11654 
 
2981 rajveer 11655 
  def __init__(self, userType=None, startDate=None, endDate=None,):
11656 
    self.userType = userType
11657 
    self.startDate = startDate
11658 
    self.endDate = endDate
94 ashish 11659 
 
11660 
  def read(self, iprot):
11661 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11662 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11663 
      return
11664 
    iprot.readStructBegin()
11665 
    while True:
11666 
      (fname, ftype, fid) = iprot.readFieldBegin()
11667 
      if ftype == TType.STOP:
11668 
        break
11669 
      if fid == 1:
2981 rajveer 11670 
        if ftype == TType.I32:
11671 
          self.userType = iprot.readI32();
94 ashish 11672 
        else:
11673 
          iprot.skip(ftype)
11674 
      elif fid == 2:
559 chandransh 11675 
        if ftype == TType.I64:
2981 rajveer 11676 
          self.startDate = iprot.readI64();
94 ashish 11677 
        else:
11678 
          iprot.skip(ftype)
2981 rajveer 11679 
      elif fid == 3:
11680 
        if ftype == TType.I64:
11681 
          self.endDate = iprot.readI64();
11682 
        else:
11683 
          iprot.skip(ftype)
94 ashish 11684 
      else:
11685 
        iprot.skip(ftype)
11686 
      iprot.readFieldEnd()
11687 
    iprot.readStructEnd()
11688 
 
11689 
  def write(self, oprot):
11690 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11691 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11692 
      return
2981 rajveer 11693 
    oprot.writeStructBegin('getAllUsers_args')
11694 
    if self.userType != None:
11695 
      oprot.writeFieldBegin('userType', TType.I32, 1)
11696 
      oprot.writeI32(self.userType)
94 ashish 11697 
      oprot.writeFieldEnd()
2981 rajveer 11698 
    if self.startDate != None:
11699 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
11700 
      oprot.writeI64(self.startDate)
94 ashish 11701 
      oprot.writeFieldEnd()
2981 rajveer 11702 
    if self.endDate != None:
11703 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
11704 
      oprot.writeI64(self.endDate)
11705 
      oprot.writeFieldEnd()
94 ashish 11706 
    oprot.writeFieldStop()
11707 
    oprot.writeStructEnd()
11708 
 
11709 
  def __repr__(self):
11710 
    L = ['%s=%r' % (key, value)
11711 
      for key, value in self.__dict__.iteritems()]
11712 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11713 
 
11714 
  def __eq__(self, other):
11715 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11716 
 
11717 
  def __ne__(self, other):
11718 
    return not (self == other)
11719 
 
2981 rajveer 11720 
class getAllUsers_result:
94 ashish 11721 
  """
11722 
  Attributes:
11723 
   - success
11724 
  """
11725 
 
11726 
  thrift_spec = (
2981 rajveer 11727 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
94 ashish 11728 
  )
11729 
 
2981 rajveer 11730 
  def __init__(self, success=None,):
94 ashish 11731 
    self.success = success
11732 
 
11733 
  def read(self, iprot):
11734 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11735 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11736 
      return
11737 
    iprot.readStructBegin()
11738 
    while True:
11739 
      (fname, ftype, fid) = iprot.readFieldBegin()
11740 
      if ftype == TType.STOP:
11741 
        break
11742 
      if fid == 0:
2981 rajveer 11743 
        if ftype == TType.LIST:
11744 
          self.success = []
11745 
          (_etype117, _size114) = iprot.readListBegin()
11746 
          for _i118 in xrange(_size114):
11747 
            _elem119 = User()
11748 
            _elem119.read(iprot)
11749 
            self.success.append(_elem119)
11750 
          iprot.readListEnd()
94 ashish 11751 
        else:
11752 
          iprot.skip(ftype)
11753 
      else:
11754 
        iprot.skip(ftype)
11755 
      iprot.readFieldEnd()
11756 
    iprot.readStructEnd()
11757 
 
11758 
  def write(self, oprot):
11759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11761 
      return
2981 rajveer 11762 
    oprot.writeStructBegin('getAllUsers_result')
94 ashish 11763 
    if self.success != None:
2981 rajveer 11764 
      oprot.writeFieldBegin('success', TType.LIST, 0)
11765 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
11766 
      for iter120 in self.success:
11767 
        iter120.write(oprot)
11768 
      oprot.writeListEnd()
94 ashish 11769 
      oprot.writeFieldEnd()
11770 
    oprot.writeFieldStop()
11771 
    oprot.writeStructEnd()
11772 
 
11773 
  def __repr__(self):
11774 
    L = ['%s=%r' % (key, value)
11775 
      for key, value in self.__dict__.iteritems()]
11776 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11777 
 
11778 
  def __eq__(self, other):
11779 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11780 
 
11781 
  def __ne__(self, other):
11782 
    return not (self == other)
11783 
 
2981 rajveer 11784 
class putUserNote_args:
130 ashish 11785 
  """
11786 
  Attributes:
2981 rajveer 11787 
   - user_id
11788 
   - entity_id
11789 
   - slide
11790 
   - note
130 ashish 11791 
  """
94 ashish 11792 
 
130 ashish 11793 
  thrift_spec = (
11794 
    None, # 0
2981 rajveer 11795 
    (1, TType.I64, 'user_id', None, None, ), # 1
11796 
    (2, TType.I64, 'entity_id', None, None, ), # 2
11797 
    (3, TType.STRING, 'slide', None, None, ), # 3
11798 
    (4, TType.STRING, 'note', None, None, ), # 4
130 ashish 11799 
  )
11800 
 
2981 rajveer 11801 
  def __init__(self, user_id=None, entity_id=None, slide=None, note=None,):
11802 
    self.user_id = user_id
11803 
    self.entity_id = entity_id
11804 
    self.slide = slide
11805 
    self.note = note
130 ashish 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 == 1:
11817 
        if ftype == TType.I64:
2981 rajveer 11818 
          self.user_id = iprot.readI64();
130 ashish 11819 
        else:
11820 
          iprot.skip(ftype)
559 chandransh 11821 
      elif fid == 2:
11822 
        if ftype == TType.I64:
2981 rajveer 11823 
          self.entity_id = iprot.readI64();
559 chandransh 11824 
        else:
11825 
          iprot.skip(ftype)
2981 rajveer 11826 
      elif fid == 3:
11827 
        if ftype == TType.STRING:
11828 
          self.slide = iprot.readString();
11829 
        else:
11830 
          iprot.skip(ftype)
11831 
      elif fid == 4:
11832 
        if ftype == TType.STRING:
11833 
          self.note = iprot.readString();
11834 
        else:
11835 
          iprot.skip(ftype)
130 ashish 11836 
      else:
11837 
        iprot.skip(ftype)
11838 
      iprot.readFieldEnd()
11839 
    iprot.readStructEnd()
11840 
 
11841 
  def write(self, oprot):
11842 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11843 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11844 
      return
2981 rajveer 11845 
    oprot.writeStructBegin('putUserNote_args')
11846 
    if self.user_id != None:
11847 
      oprot.writeFieldBegin('user_id', TType.I64, 1)
11848 
      oprot.writeI64(self.user_id)
130 ashish 11849 
      oprot.writeFieldEnd()
2981 rajveer 11850 
    if self.entity_id != None:
11851 
      oprot.writeFieldBegin('entity_id', TType.I64, 2)
11852 
      oprot.writeI64(self.entity_id)
559 chandransh 11853 
      oprot.writeFieldEnd()
2981 rajveer 11854 
    if self.slide != None:
11855 
      oprot.writeFieldBegin('slide', TType.STRING, 3)
11856 
      oprot.writeString(self.slide)
11857 
      oprot.writeFieldEnd()
11858 
    if self.note != None:
11859 
      oprot.writeFieldBegin('note', TType.STRING, 4)
11860 
      oprot.writeString(self.note)
11861 
      oprot.writeFieldEnd()
130 ashish 11862 
    oprot.writeFieldStop()
11863 
    oprot.writeStructEnd()
11864 
 
11865 
  def __repr__(self):
11866 
    L = ['%s=%r' % (key, value)
11867 
      for key, value in self.__dict__.iteritems()]
11868 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11869 
 
11870 
  def __eq__(self, other):
11871 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11872 
 
11873 
  def __ne__(self, other):
11874 
    return not (self == other)
11875 
 
2981 rajveer 11876 
class putUserNote_result:
559 chandransh 11877 
 
11878 
  thrift_spec = (
11879 
  )
11880 
 
11881 
  def read(self, iprot):
11882 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11883 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11884 
      return
11885 
    iprot.readStructBegin()
11886 
    while True:
11887 
      (fname, ftype, fid) = iprot.readFieldBegin()
11888 
      if ftype == TType.STOP:
11889 
        break
11890 
      else:
11891 
        iprot.skip(ftype)
11892 
      iprot.readFieldEnd()
11893 
    iprot.readStructEnd()
11894 
 
11895 
  def write(self, oprot):
11896 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11897 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11898 
      return
2981 rajveer 11899 
    oprot.writeStructBegin('putUserNote_result')
559 chandransh 11900 
    oprot.writeFieldStop()
11901 
    oprot.writeStructEnd()
11902 
 
11903 
  def __repr__(self):
11904 
    L = ['%s=%r' % (key, value)
11905 
      for key, value in self.__dict__.iteritems()]
11906 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11907 
 
11908 
  def __eq__(self, other):
11909 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11910 
 
11911 
  def __ne__(self, other):
11912 
    return not (self == other)
11913 
 
2981 rajveer 11914 
class getUserNotes_args:
559 chandransh 11915 
  """
11916 
  Attributes:
2981 rajveer 11917 
   - user_id
11918 
   - entity_id
559 chandransh 11919 
  """
11920 
 
11921 
  thrift_spec = (
11922 
    None, # 0
2981 rajveer 11923 
    (1, TType.I64, 'user_id', None, None, ), # 1
11924 
    (2, TType.I64, 'entity_id', None, None, ), # 2
559 chandransh 11925 
  )
11926 
 
2981 rajveer 11927 
  def __init__(self, user_id=None, entity_id=None,):
11928 
    self.user_id = user_id
11929 
    self.entity_id = entity_id
559 chandransh 11930 
 
11931 
  def read(self, iprot):
11932 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11933 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11934 
      return
11935 
    iprot.readStructBegin()
11936 
    while True:
11937 
      (fname, ftype, fid) = iprot.readFieldBegin()
11938 
      if ftype == TType.STOP:
11939 
        break
11940 
      if fid == 1:
11941 
        if ftype == TType.I64:
2981 rajveer 11942 
          self.user_id = iprot.readI64();
559 chandransh 11943 
        else:
11944 
          iprot.skip(ftype)
11945 
      elif fid == 2:
11946 
        if ftype == TType.I64:
2981 rajveer 11947 
          self.entity_id = iprot.readI64();
559 chandransh 11948 
        else:
11949 
          iprot.skip(ftype)
11950 
      else:
11951 
        iprot.skip(ftype)
11952 
      iprot.readFieldEnd()
11953 
    iprot.readStructEnd()
11954 
 
11955 
  def write(self, oprot):
11956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11958 
      return
2981 rajveer 11959 
    oprot.writeStructBegin('getUserNotes_args')
11960 
    if self.user_id != None:
11961 
      oprot.writeFieldBegin('user_id', TType.I64, 1)
11962 
      oprot.writeI64(self.user_id)
559 chandransh 11963 
      oprot.writeFieldEnd()
2981 rajveer 11964 
    if self.entity_id != None:
11965 
      oprot.writeFieldBegin('entity_id', TType.I64, 2)
11966 
      oprot.writeI64(self.entity_id)
559 chandransh 11967 
      oprot.writeFieldEnd()
11968 
    oprot.writeFieldStop()
11969 
    oprot.writeStructEnd()
11970 
 
11971 
  def __repr__(self):
11972 
    L = ['%s=%r' % (key, value)
11973 
      for key, value in self.__dict__.iteritems()]
11974 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11975 
 
11976 
  def __eq__(self, other):
11977 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11978 
 
11979 
  def __ne__(self, other):
11980 
    return not (self == other)
11981 
 
2981 rajveer 11982 
class getUserNotes_result:
11983 
  """
11984 
  Attributes:
11985 
   - success
11986 
  """
559 chandransh 11987 
 
11988 
  thrift_spec = (
2981 rajveer 11989 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserNote, UserNote.thrift_spec)), None, ), # 0
559 chandransh 11990 
  )
11991 
 
2981 rajveer 11992 
  def __init__(self, success=None,):
11993 
    self.success = success
11994 
 
559 chandransh 11995 
  def read(self, iprot):
11996 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11997 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11998 
      return
11999 
    iprot.readStructBegin()
12000 
    while True:
12001 
      (fname, ftype, fid) = iprot.readFieldBegin()
12002 
      if ftype == TType.STOP:
12003 
        break
2981 rajveer 12004 
      if fid == 0:
12005 
        if ftype == TType.LIST:
12006 
          self.success = []
12007 
          (_etype124, _size121) = iprot.readListBegin()
12008 
          for _i125 in xrange(_size121):
12009 
            _elem126 = UserNote()
12010 
            _elem126.read(iprot)
12011 
            self.success.append(_elem126)
12012 
          iprot.readListEnd()
12013 
        else:
12014 
          iprot.skip(ftype)
559 chandransh 12015 
      else:
12016 
        iprot.skip(ftype)
12017 
      iprot.readFieldEnd()
12018 
    iprot.readStructEnd()
12019 
 
12020 
  def write(self, oprot):
12021 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12022 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12023 
      return
2981 rajveer 12024 
    oprot.writeStructBegin('getUserNotes_result')
12025 
    if self.success != None:
12026 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12027 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
12028 
      for iter127 in self.success:
12029 
        iter127.write(oprot)
12030 
      oprot.writeListEnd()
12031 
      oprot.writeFieldEnd()
559 chandransh 12032 
    oprot.writeFieldStop()
12033 
    oprot.writeStructEnd()
12034 
 
12035 
  def __repr__(self):
12036 
    L = ['%s=%r' % (key, value)
12037 
      for key, value in self.__dict__.iteritems()]
12038 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12039 
 
12040 
  def __eq__(self, other):
12041 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12042 
 
12043 
  def __ne__(self, other):
12044 
    return not (self == other)
12045 
 
2981 rajveer 12046 
class getMyResearchItems_args:
559 chandransh 12047 
  """
12048 
  Attributes:
772 rajveer 12049 
   - userId
559 chandransh 12050 
  """
12051 
 
12052 
  thrift_spec = (
12053 
    None, # 0
772 rajveer 12054 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 12055 
  )
12056 
 
772 rajveer 12057 
  def __init__(self, userId=None,):
12058 
    self.userId = userId
559 chandransh 12059 
 
12060 
  def read(self, iprot):
12061 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12062 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12063 
      return
12064 
    iprot.readStructBegin()
12065 
    while True:
12066 
      (fname, ftype, fid) = iprot.readFieldBegin()
12067 
      if ftype == TType.STOP:
12068 
        break
12069 
      if fid == 1:
12070 
        if ftype == TType.I64:
772 rajveer 12071 
          self.userId = iprot.readI64();
559 chandransh 12072 
        else:
12073 
          iprot.skip(ftype)
12074 
      else:
12075 
        iprot.skip(ftype)
12076 
      iprot.readFieldEnd()
12077 
    iprot.readStructEnd()
12078 
 
12079 
  def write(self, oprot):
12080 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12081 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12082 
      return
2981 rajveer 12083 
    oprot.writeStructBegin('getMyResearchItems_args')
772 rajveer 12084 
    if self.userId != None:
12085 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12086 
      oprot.writeI64(self.userId)
559 chandransh 12087 
      oprot.writeFieldEnd()
12088 
    oprot.writeFieldStop()
12089 
    oprot.writeStructEnd()
12090 
 
12091 
  def __repr__(self):
12092 
    L = ['%s=%r' % (key, value)
12093 
      for key, value in self.__dict__.iteritems()]
12094 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12095 
 
12096 
  def __eq__(self, other):
12097 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12098 
 
12099 
  def __ne__(self, other):
12100 
    return not (self == other)
12101 
 
2981 rajveer 12102 
class getMyResearchItems_result:
559 chandransh 12103 
  """
12104 
  Attributes:
130 ashish 12105 
   - success
559 chandransh 12106 
   - scx
130 ashish 12107 
  """
12108 
 
12109 
  thrift_spec = (
2981 rajveer 12110 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
559 chandransh 12111 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 12112 
  )
12113 
 
559 chandransh 12114 
  def __init__(self, success=None, scx=None,):
130 ashish 12115 
    self.success = success
559 chandransh 12116 
    self.scx = scx
130 ashish 12117 
 
12118 
  def read(self, iprot):
12119 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12120 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12121 
      return
12122 
    iprot.readStructBegin()
12123 
    while True:
12124 
      (fname, ftype, fid) = iprot.readFieldBegin()
12125 
      if ftype == TType.STOP:
12126 
        break
12127 
      if fid == 0:
2981 rajveer 12128 
        if ftype == TType.LIST:
12129 
          self.success = []
12130 
          (_etype131, _size128) = iprot.readListBegin()
12131 
          for _i132 in xrange(_size128):
12132 
            _elem133 = iprot.readI64();
12133 
            self.success.append(_elem133)
12134 
          iprot.readListEnd()
130 ashish 12135 
        else:
12136 
          iprot.skip(ftype)
12137 
      elif fid == 1:
12138 
        if ftype == TType.STRUCT:
559 chandransh 12139 
          self.scx = WidgetException()
12140 
          self.scx.read(iprot)
130 ashish 12141 
        else:
12142 
          iprot.skip(ftype)
12143 
      else:
12144 
        iprot.skip(ftype)
12145 
      iprot.readFieldEnd()
12146 
    iprot.readStructEnd()
12147 
 
12148 
  def write(self, oprot):
12149 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12150 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12151 
      return
2981 rajveer 12152 
    oprot.writeStructBegin('getMyResearchItems_result')
130 ashish 12153 
    if self.success != None:
2981 rajveer 12154 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12155 
      oprot.writeListBegin(TType.I64, len(self.success))
12156 
      for iter134 in self.success:
12157 
        oprot.writeI64(iter134)
12158 
      oprot.writeListEnd()
130 ashish 12159 
      oprot.writeFieldEnd()
559 chandransh 12160 
    if self.scx != None:
12161 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12162 
      self.scx.write(oprot)
130 ashish 12163 
      oprot.writeFieldEnd()
12164 
    oprot.writeFieldStop()
12165 
    oprot.writeStructEnd()
12166 
 
12167 
  def __repr__(self):
12168 
    L = ['%s=%r' % (key, value)
12169 
      for key, value in self.__dict__.iteritems()]
12170 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12171 
 
12172 
  def __eq__(self, other):
12173 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12174 
 
12175 
  def __ne__(self, other):
12176 
    return not (self == other)
12177 
 
2981 rajveer 12178 
class updateMyResearch_args:
130 ashish 12179 
  """
12180 
  Attributes:
2981 rajveer 12181 
   - userId
12182 
   - itemId
130 ashish 12183 
  """
12184 
 
12185 
  thrift_spec = (
12186 
    None, # 0
2981 rajveer 12187 
    (1, TType.I64, 'userId', None, None, ), # 1
12188 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 12189 
  )
12190 
 
2981 rajveer 12191 
  def __init__(self, userId=None, itemId=None,):
12192 
    self.userId = userId
12193 
    self.itemId = itemId
130 ashish 12194 
 
12195 
  def read(self, iprot):
12196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12198 
      return
12199 
    iprot.readStructBegin()
12200 
    while True:
12201 
      (fname, ftype, fid) = iprot.readFieldBegin()
12202 
      if ftype == TType.STOP:
12203 
        break
12204 
      if fid == 1:
559 chandransh 12205 
        if ftype == TType.I64:
2981 rajveer 12206 
          self.userId = iprot.readI64();
130 ashish 12207 
        else:
12208 
          iprot.skip(ftype)
12209 
      elif fid == 2:
559 chandransh 12210 
        if ftype == TType.I64:
2981 rajveer 12211 
          self.itemId = iprot.readI64();
559 chandransh 12212 
        else:
12213 
          iprot.skip(ftype)
130 ashish 12214 
      else:
12215 
        iprot.skip(ftype)
12216 
      iprot.readFieldEnd()
12217 
    iprot.readStructEnd()
12218 
 
12219 
  def write(self, oprot):
12220 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12221 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12222 
      return
2981 rajveer 12223 
    oprot.writeStructBegin('updateMyResearch_args')
12224 
    if self.userId != None:
12225 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12226 
      oprot.writeI64(self.userId)
130 ashish 12227 
      oprot.writeFieldEnd()
2981 rajveer 12228 
    if self.itemId != None:
12229 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12230 
      oprot.writeI64(self.itemId)
130 ashish 12231 
      oprot.writeFieldEnd()
12232 
    oprot.writeFieldStop()
12233 
    oprot.writeStructEnd()
12234 
 
12235 
  def __repr__(self):
12236 
    L = ['%s=%r' % (key, value)
12237 
      for key, value in self.__dict__.iteritems()]
12238 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12239 
 
12240 
  def __eq__(self, other):
12241 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12242 
 
12243 
  def __ne__(self, other):
12244 
    return not (self == other)
12245 
 
2981 rajveer 12246 
class updateMyResearch_result:
12247 
  """
12248 
  Attributes:
12249 
   - success
12250 
   - scx
12251 
  """
559 chandransh 12252 
 
12253 
  thrift_spec = (
2981 rajveer 12254 
    (0, TType.BOOL, 'success', None, None, ), # 0
12255 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
559 chandransh 12256 
  )
12257 
 
2981 rajveer 12258 
  def __init__(self, success=None, scx=None,):
12259 
    self.success = success
12260 
    self.scx = scx
12261 
 
559 chandransh 12262 
  def read(self, iprot):
12263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12265 
      return
12266 
    iprot.readStructBegin()
12267 
    while True:
12268 
      (fname, ftype, fid) = iprot.readFieldBegin()
12269 
      if ftype == TType.STOP:
12270 
        break
2981 rajveer 12271 
      if fid == 0:
12272 
        if ftype == TType.BOOL:
12273 
          self.success = iprot.readBool();
12274 
        else:
12275 
          iprot.skip(ftype)
12276 
      elif fid == 1:
12277 
        if ftype == TType.STRUCT:
12278 
          self.scx = WidgetException()
12279 
          self.scx.read(iprot)
12280 
        else:
12281 
          iprot.skip(ftype)
559 chandransh 12282 
      else:
12283 
        iprot.skip(ftype)
12284 
      iprot.readFieldEnd()
12285 
    iprot.readStructEnd()
12286 
 
12287 
  def write(self, oprot):
12288 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12289 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12290 
      return
2981 rajveer 12291 
    oprot.writeStructBegin('updateMyResearch_result')
12292 
    if self.success != None:
12293 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
12294 
      oprot.writeBool(self.success)
12295 
      oprot.writeFieldEnd()
12296 
    if self.scx != None:
12297 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12298 
      self.scx.write(oprot)
12299 
      oprot.writeFieldEnd()
559 chandransh 12300 
    oprot.writeFieldStop()
12301 
    oprot.writeStructEnd()
12302 
 
12303 
  def __repr__(self):
12304 
    L = ['%s=%r' % (key, value)
12305 
      for key, value in self.__dict__.iteritems()]
12306 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12307 
 
12308 
  def __eq__(self, other):
12309 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12310 
 
12311 
  def __ne__(self, other):
12312 
    return not (self == other)
12313 
 
2981 rajveer 12314 
class deleteItemFromMyResearch_args:
1596 ankur.sing 12315 
  """
12316 
  Attributes:
2981 rajveer 12317 
   - userId
12318 
   - itemId
1596 ankur.sing 12319 
  """
559 chandransh 12320 
 
1596 ankur.sing 12321 
  thrift_spec = (
12322 
    None, # 0
2981 rajveer 12323 
    (1, TType.I64, 'userId', None, None, ), # 1
12324 
    (2, TType.I64, 'itemId', None, None, ), # 2
1596 ankur.sing 12325 
  )
12326 
 
2981 rajveer 12327 
  def __init__(self, userId=None, itemId=None,):
12328 
    self.userId = userId
12329 
    self.itemId = itemId
1596 ankur.sing 12330 
 
12331 
  def read(self, iprot):
12332 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12333 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12334 
      return
12335 
    iprot.readStructBegin()
12336 
    while True:
12337 
      (fname, ftype, fid) = iprot.readFieldBegin()
12338 
      if ftype == TType.STOP:
12339 
        break
12340 
      if fid == 1:
2981 rajveer 12341 
        if ftype == TType.I64:
12342 
          self.userId = iprot.readI64();
1596 ankur.sing 12343 
        else:
12344 
          iprot.skip(ftype)
2981 rajveer 12345 
      elif fid == 2:
12346 
        if ftype == TType.I64:
12347 
          self.itemId = iprot.readI64();
12348 
        else:
12349 
          iprot.skip(ftype)
1596 ankur.sing 12350 
      else:
12351 
        iprot.skip(ftype)
12352 
      iprot.readFieldEnd()
12353 
    iprot.readStructEnd()
12354 
 
12355 
  def write(self, oprot):
12356 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12357 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12358 
      return
2981 rajveer 12359 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
12360 
    if self.userId != None:
12361 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12362 
      oprot.writeI64(self.userId)
1596 ankur.sing 12363 
      oprot.writeFieldEnd()
2981 rajveer 12364 
    if self.itemId != None:
12365 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12366 
      oprot.writeI64(self.itemId)
12367 
      oprot.writeFieldEnd()
1596 ankur.sing 12368 
    oprot.writeFieldStop()
12369 
    oprot.writeStructEnd()
12370 
 
12371 
  def __repr__(self):
12372 
    L = ['%s=%r' % (key, value)
12373 
      for key, value in self.__dict__.iteritems()]
12374 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12375 
 
12376 
  def __eq__(self, other):
12377 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12378 
 
12379 
  def __ne__(self, other):
12380 
    return not (self == other)
12381 
 
2981 rajveer 12382 
class deleteItemFromMyResearch_result:
1596 ankur.sing 12383 
  """
12384 
  Attributes:
2981 rajveer 12385 
   - scx
1596 ankur.sing 12386 
  """
12387 
 
12388 
  thrift_spec = (
2981 rajveer 12389 
    None, # 0
12390 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1596 ankur.sing 12391 
  )
12392 
 
2981 rajveer 12393 
  def __init__(self, scx=None,):
12394 
    self.scx = scx
1596 ankur.sing 12395 
 
12396 
  def read(self, iprot):
12397 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12398 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12399 
      return
12400 
    iprot.readStructBegin()
12401 
    while True:
12402 
      (fname, ftype, fid) = iprot.readFieldBegin()
12403 
      if ftype == TType.STOP:
12404 
        break
2981 rajveer 12405 
      if fid == 1:
12406 
        if ftype == TType.STRUCT:
12407 
          self.scx = WidgetException()
12408 
          self.scx.read(iprot)
1596 ankur.sing 12409 
        else:
12410 
          iprot.skip(ftype)
12411 
      else:
12412 
        iprot.skip(ftype)
12413 
      iprot.readFieldEnd()
12414 
    iprot.readStructEnd()
12415 
 
12416 
  def write(self, oprot):
12417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12419 
      return
2981 rajveer 12420 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
12421 
    if self.scx != None:
12422 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12423 
      self.scx.write(oprot)
1596 ankur.sing 12424 
      oprot.writeFieldEnd()
12425 
    oprot.writeFieldStop()
12426 
    oprot.writeStructEnd()
12427 
 
12428 
  def __repr__(self):
12429 
    L = ['%s=%r' % (key, value)
12430 
      for key, value in self.__dict__.iteritems()]
12431 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12432 
 
12433 
  def __eq__(self, other):
12434 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12435 
 
12436 
  def __ne__(self, other):
12437 
    return not (self == other)
12438 
 
2981 rajveer 12439 
class getBrowseHistoryItems_args:
1673 ankur.sing 12440 
  """
12441 
  Attributes:
2981 rajveer 12442 
   - userId
1673 ankur.sing 12443 
  """
1596 ankur.sing 12444 
 
1673 ankur.sing 12445 
  thrift_spec = (
12446 
    None, # 0
2981 rajveer 12447 
    (1, TType.I64, 'userId', None, None, ), # 1
1673 ankur.sing 12448 
  )
12449 
 
2981 rajveer 12450 
  def __init__(self, userId=None,):
12451 
    self.userId = userId
1673 ankur.sing 12452 
 
12453 
  def read(self, iprot):
12454 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12455 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12456 
      return
12457 
    iprot.readStructBegin()
12458 
    while True:
12459 
      (fname, ftype, fid) = iprot.readFieldBegin()
12460 
      if ftype == TType.STOP:
12461 
        break
12462 
      if fid == 1:
1891 ankur.sing 12463 
        if ftype == TType.I64:
2981 rajveer 12464 
          self.userId = iprot.readI64();
1891 ankur.sing 12465 
        else:
12466 
          iprot.skip(ftype)
1673 ankur.sing 12467 
      else:
12468 
        iprot.skip(ftype)
12469 
      iprot.readFieldEnd()
12470 
    iprot.readStructEnd()
12471 
 
12472 
  def write(self, oprot):
12473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12475 
      return
2981 rajveer 12476 
    oprot.writeStructBegin('getBrowseHistoryItems_args')
12477 
    if self.userId != None:
12478 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12479 
      oprot.writeI64(self.userId)
1673 ankur.sing 12480 
      oprot.writeFieldEnd()
12481 
    oprot.writeFieldStop()
12482 
    oprot.writeStructEnd()
12483 
 
12484 
  def __repr__(self):
12485 
    L = ['%s=%r' % (key, value)
12486 
      for key, value in self.__dict__.iteritems()]
12487 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12488 
 
12489 
  def __eq__(self, other):
12490 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12491 
 
12492 
  def __ne__(self, other):
12493 
    return not (self == other)
12494 
 
2981 rajveer 12495 
class getBrowseHistoryItems_result:
1673 ankur.sing 12496 
  """
12497 
  Attributes:
12498 
   - success
2981 rajveer 12499 
   - scx
1673 ankur.sing 12500 
  """
12501 
 
12502 
  thrift_spec = (
2981 rajveer 12503 
    (0, TType.LIST, 'success', (TType.I64,None), None, ), # 0
12504 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
1673 ankur.sing 12505 
  )
12506 
 
2981 rajveer 12507 
  def __init__(self, success=None, scx=None,):
1673 ankur.sing 12508 
    self.success = success
2981 rajveer 12509 
    self.scx = scx
1673 ankur.sing 12510 
 
12511 
  def read(self, iprot):
12512 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12513 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12514 
      return
12515 
    iprot.readStructBegin()
12516 
    while True:
12517 
      (fname, ftype, fid) = iprot.readFieldBegin()
12518 
      if ftype == TType.STOP:
12519 
        break
12520 
      if fid == 0:
12521 
        if ftype == TType.LIST:
12522 
          self.success = []
2981 rajveer 12523 
          (_etype138, _size135) = iprot.readListBegin()
12524 
          for _i139 in xrange(_size135):
12525 
            _elem140 = iprot.readI64();
12526 
            self.success.append(_elem140)
1673 ankur.sing 12527 
          iprot.readListEnd()
12528 
        else:
12529 
          iprot.skip(ftype)
2981 rajveer 12530 
      elif fid == 1:
12531 
        if ftype == TType.STRUCT:
12532 
          self.scx = WidgetException()
12533 
          self.scx.read(iprot)
12534 
        else:
12535 
          iprot.skip(ftype)
1673 ankur.sing 12536 
      else:
12537 
        iprot.skip(ftype)
12538 
      iprot.readFieldEnd()
12539 
    iprot.readStructEnd()
12540 
 
12541 
  def write(self, oprot):
12542 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12543 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12544 
      return
2981 rajveer 12545 
    oprot.writeStructBegin('getBrowseHistoryItems_result')
1673 ankur.sing 12546 
    if self.success != None:
12547 
      oprot.writeFieldBegin('success', TType.LIST, 0)
2981 rajveer 12548 
      oprot.writeListBegin(TType.I64, len(self.success))
12549 
      for iter141 in self.success:
12550 
        oprot.writeI64(iter141)
1673 ankur.sing 12551 
      oprot.writeListEnd()
12552 
      oprot.writeFieldEnd()
2981 rajveer 12553 
    if self.scx != None:
12554 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12555 
      self.scx.write(oprot)
2642 varun.gupt 12556 
      oprot.writeFieldEnd()
12557 
    oprot.writeFieldStop()
12558 
    oprot.writeStructEnd()
12559 
 
12560 
  def __repr__(self):
12561 
    L = ['%s=%r' % (key, value)
12562 
      for key, value in self.__dict__.iteritems()]
12563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12564 
 
12565 
  def __eq__(self, other):
12566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12567 
 
12568 
  def __ne__(self, other):
12569 
    return not (self == other)
12570 
 
2981 rajveer 12571 
class updateBrowseHistory_args:
2642 varun.gupt 12572 
  """
12573 
  Attributes:
2981 rajveer 12574 
   - userId
12575 
   - itemId
2642 varun.gupt 12576 
  """
12577 
 
12578 
  thrift_spec = (
12579 
    None, # 0
2981 rajveer 12580 
    (1, TType.I64, 'userId', None, None, ), # 1
12581 
    (2, TType.I64, 'itemId', None, None, ), # 2
2642 varun.gupt 12582 
  )
12583 
 
2981 rajveer 12584 
  def __init__(self, userId=None, itemId=None,):
12585 
    self.userId = userId
12586 
    self.itemId = itemId
2642 varun.gupt 12587 
 
12588 
  def read(self, iprot):
12589 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12590 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12591 
      return
12592 
    iprot.readStructBegin()
12593 
    while True:
12594 
      (fname, ftype, fid) = iprot.readFieldBegin()
12595 
      if ftype == TType.STOP:
12596 
        break
12597 
      if fid == 1:
12598 
        if ftype == TType.I64:
2981 rajveer 12599 
          self.userId = iprot.readI64();
2642 varun.gupt 12600 
        else:
12601 
          iprot.skip(ftype)
12602 
      elif fid == 2:
12603 
        if ftype == TType.I64:
2981 rajveer 12604 
          self.itemId = iprot.readI64();
2642 varun.gupt 12605 
        else:
12606 
          iprot.skip(ftype)
12607 
      else:
12608 
        iprot.skip(ftype)
12609 
      iprot.readFieldEnd()
12610 
    iprot.readStructEnd()
12611 
 
12612 
  def write(self, oprot):
12613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12615 
      return
2981 rajveer 12616 
    oprot.writeStructBegin('updateBrowseHistory_args')
12617 
    if self.userId != None:
12618 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12619 
      oprot.writeI64(self.userId)
2642 varun.gupt 12620 
      oprot.writeFieldEnd()
2981 rajveer 12621 
    if self.itemId != None:
12622 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12623 
      oprot.writeI64(self.itemId)
2642 varun.gupt 12624 
      oprot.writeFieldEnd()
12625 
    oprot.writeFieldStop()
12626 
    oprot.writeStructEnd()
12627 
 
12628 
  def __repr__(self):
12629 
    L = ['%s=%r' % (key, value)
12630 
      for key, value in self.__dict__.iteritems()]
12631 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12632 
 
12633 
  def __eq__(self, other):
12634 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12635 
 
12636 
  def __ne__(self, other):
12637 
    return not (self == other)
12638 
 
2981 rajveer 12639 
class updateBrowseHistory_result:
2642 varun.gupt 12640 
 
12641 
  thrift_spec = (
12642 
  )
12643 
 
12644 
  def read(self, iprot):
12645 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12646 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12647 
      return
12648 
    iprot.readStructBegin()
12649 
    while True:
12650 
      (fname, ftype, fid) = iprot.readFieldBegin()
12651 
      if ftype == TType.STOP:
12652 
        break
12653 
      else:
12654 
        iprot.skip(ftype)
12655 
      iprot.readFieldEnd()
12656 
    iprot.readStructEnd()
12657 
 
12658 
  def write(self, oprot):
12659 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12660 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12661 
      return
2981 rajveer 12662 
    oprot.writeStructBegin('updateBrowseHistory_result')
2642 varun.gupt 12663 
    oprot.writeFieldStop()
12664 
    oprot.writeStructEnd()
12665 
 
12666 
  def __repr__(self):
12667 
    L = ['%s=%r' % (key, value)
12668 
      for key, value in self.__dict__.iteritems()]
12669 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12670 
 
12671 
  def __eq__(self, other):
12672 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12673 
 
12674 
  def __ne__(self, other):
12675 
    return not (self == other)
12676 
 
12677