Subversion Repositories SmartDukaan

Rev

Rev 2642 | Rev 2815 | 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 
 
690 chandransh 427 
  def createOrders(self, cartId):
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
433 
    """
434 
    pass
435 
 
436 
  def validateCart(self, cartId):
437 
    """
690 chandransh 438 
    Validates that:
439 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 440 
    2. All of the lines in the cart are active items.
690 chandransh 441 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 442 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 443 
 
559 chandransh 444 
    Parameters:
445 
     - cartId
446 
    """
447 
    pass
448 
 
690 chandransh 449 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 450 
    """
690 chandransh 451 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
452 
 
575 chandransh 453 
    Parameters:
690 chandransh 454 
     - fromCartId
455 
     - toCartId
456 
    """
457 
    pass
458 
 
459 
  def checkOut(self, cartId):
460 
    """
461 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
462 
 
463 
    Parameters:
575 chandransh 464 
     - cartId
465 
    """
466 
    pass
467 
 
690 chandransh 468 
  def resetCart(self, cartId, items):
559 chandransh 469 
    """
690 chandransh 470 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
471 
    This methods removes the specified quantiry of the specified item from the cart.
472 
 
559 chandransh 473 
    Parameters:
690 chandransh 474 
     - cartId
475 
     - items
559 chandransh 476 
    """
477 
    pass
478 
 
772 rajveer 479 
  def getMyResearch(self, userId):
559 chandransh 480 
    """
772 rajveer 481 
    Widgets
482 
 
559 chandransh 483 
    Parameters:
772 rajveer 484 
     - userId
559 chandransh 485 
    """
486 
    pass
487 
 
772 rajveer 488 
  def updateMyResearch(self, userId, itemId):
559 chandransh 489 
    """
490 
    Parameters:
772 rajveer 491 
     - userId
492 
     - itemId
559 chandransh 493 
    """
494 
    pass
495 
 
772 rajveer 496 
  def deleteItemFromMyResearch(self, userId, itemId):
559 chandransh 497 
    """
498 
    Parameters:
772 rajveer 499 
     - userId
500 
     - itemId
559 chandransh 501 
    """
502 
    pass
503 
 
772 rajveer 504 
  def updateBrowseHistory(self, userId, itemId):
559 chandransh 505 
    """
506 
    Parameters:
772 rajveer 507 
     - userId
508 
     - itemId
559 chandransh 509 
    """
510 
    pass
511 
 
772 rajveer 512 
  def getBrowseHistory(self, userId):
559 chandransh 513 
    """
514 
    Parameters:
515 
     - userId
516 
    """
517 
    pass
518 
 
772 rajveer 519 
  def mergeBrowseHistory(self, fromUserId, toUserId):
559 chandransh 520 
    """
521 
    Parameters:
772 rajveer 522 
     - fromUserId
523 
     - toUserId
559 chandransh 524 
    """
525 
    pass
526 
 
1596 ankur.sing 527 
  def getUserCount(self, userType):
528 
    """
529 
    Returns number of registered users.
530 
    If userType = null, then it returns count of all users, including anonymous
531 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
532 
    If userType = UserType.USER, then it returns count of non-anonymous users only
533 
 
534 
    Parameters:
535 
     - userType
536 
    """
537 
    pass
559 chandransh 538 
 
1891 ankur.sing 539 
  def getAllUsers(self, userType, startDate, endDate):
1673 ankur.sing 540 
    """
1891 ankur.sing 541 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
542 
    If any of startDate or endDate is -1, then that filter is ignored.
543 
    If userType is null, then returns all the users, irrespective of anonymous flag
1673 ankur.sing 544 
 
1891 ankur.sing 545 
 
1673 ankur.sing 546 
    Parameters:
547 
     - userType
1891 ankur.sing 548 
     - startDate
549 
     - endDate
1673 ankur.sing 550 
    """
551 
    pass
1596 ankur.sing 552 
 
2717 varun.gupt 553 
  def putUserNote(self, user_id, entity_id, slide, note):
2642 varun.gupt 554 
    """
555 
    Masking right now. May be used later.
556 
    void addWidget(1:Widget widget) throws (1:WidgetException scx),
557 
    void addItemToWidget(1:i64 widget_id, 2:list<i64> items) throws (1:WidgetException scx),
558 
    void deleteItemFromWidget(1:i64 widget_id, 2:i64 item_id) throws (1:WidgetException scx),
559 
    void updateWidget(1:i64 widgetId, 2:bool enable) throws (1:WidgetException scx),
560 
    void updateWidgetItem(1:i64 widgetId, 2:bool enable) throws (1:WidgetException scx),
561 
    Widget getWidget(1:WidgetType type, 2:i64 userId, 3:bool onlyEnabled) throws (1:WidgetException scx),
562 
 
563 
    Parameters:
564 
     - user_id
565 
     - entity_id
2717 varun.gupt 566 
     - slide
2642 varun.gupt 567 
     - note
568 
    """
569 
    pass
1673 ankur.sing 570 
 
2642 varun.gupt 571 
  def getUserNotes(self, user_id, entity_id):
572 
    """
573 
    Parameters:
574 
     - user_id
575 
     - entity_id
576 
    """
577 
    pass
578 
 
579 
 
94 ashish 580 
class Client(Iface):
581 
  """
582 
  service
583 
  """
584 
  def __init__(self, iprot, oprot=None):
585 
    self._iprot = self._oprot = iprot
586 
    if oprot != None:
587 
      self._oprot = oprot
588 
    self._seqid = 0
589 
 
765 rajveer 590 
  def closeSession(self, ):
591 
    """
592 
    For closing the open session in sqlalchemy
593 
    """
594 
    self.send_closeSession()
595 
    self.recv_closeSession()
596 
 
597 
  def send_closeSession(self, ):
598 
    self._oprot.writeMessageBegin('closeSession', TMessageType.CALL, self._seqid)
599 
    args = closeSession_args()
600 
    args.write(self._oprot)
601 
    self._oprot.writeMessageEnd()
602 
    self._oprot.trans.flush()
603 
 
604 
  def recv_closeSession(self, ):
605 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
606 
    if mtype == TMessageType.EXCEPTION:
607 
      x = TApplicationException()
608 
      x.read(self._iprot)
609 
      self._iprot.readMessageEnd()
610 
      raise x
611 
    result = closeSession_result()
612 
    result.read(self._iprot)
613 
    self._iprot.readMessageEnd()
614 
    return
615 
 
559 chandransh 616 
  def createAnonymousUser(self, jsessionId):
94 ashish 617 
    """
618 
    Parameters:
559 chandransh 619 
     - jsessionId
94 ashish 620 
    """
559 chandransh 621 
    self.send_createAnonymousUser(jsessionId)
622 
    return self.recv_createAnonymousUser()
94 ashish 623 
 
559 chandransh 624 
  def send_createAnonymousUser(self, jsessionId):
625 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
626 
    args = createAnonymousUser_args()
627 
    args.jsessionId = jsessionId
94 ashish 628 
    args.write(self._oprot)
629 
    self._oprot.writeMessageEnd()
630 
    self._oprot.trans.flush()
631 
 
559 chandransh 632 
  def recv_createAnonymousUser(self, ):
94 ashish 633 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
634 
    if mtype == TMessageType.EXCEPTION:
635 
      x = TApplicationException()
636 
      x.read(self._iprot)
637 
      self._iprot.readMessageEnd()
638 
      raise x
559 chandransh 639 
    result = createAnonymousUser_result()
94 ashish 640 
    result.read(self._iprot)
641 
    self._iprot.readMessageEnd()
642 
    if result.success != None:
643 
      return result.success
559 chandransh 644 
    if result.ucex != None:
645 
      raise result.ucex
646 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 647 
 
559 chandransh 648 
  def getUserById(self, userId):
94 ashish 649 
    """
650 
    Parameters:
651 
     - userId
652 
    """
559 chandransh 653 
    self.send_getUserById(userId)
654 
    return self.recv_getUserById()
94 ashish 655 
 
559 chandransh 656 
  def send_getUserById(self, userId):
657 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
658 
    args = getUserById_args()
94 ashish 659 
    args.userId = userId
660 
    args.write(self._oprot)
661 
    self._oprot.writeMessageEnd()
662 
    self._oprot.trans.flush()
663 
 
559 chandransh 664 
  def recv_getUserById(self, ):
94 ashish 665 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
666 
    if mtype == TMessageType.EXCEPTION:
667 
      x = TApplicationException()
668 
      x.read(self._iprot)
669 
      self._iprot.readMessageEnd()
670 
      raise x
559 chandransh 671 
    result = getUserById_result()
94 ashish 672 
    result.read(self._iprot)
673 
    self._iprot.readMessageEnd()
674 
    if result.success != None:
675 
      return result.success
559 chandransh 676 
    if result.ucex != None:
677 
      raise result.ucex
678 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 679 
 
1491 vikas 680 
  def getUserByEmail(self, email):
681 
    """
682 
    Parameters:
683 
     - email
684 
    """
685 
    self.send_getUserByEmail(email)
686 
    return self.recv_getUserByEmail()
687 
 
688 
  def send_getUserByEmail(self, email):
689 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
690 
    args = getUserByEmail_args()
691 
    args.email = email
692 
    args.write(self._oprot)
693 
    self._oprot.writeMessageEnd()
694 
    self._oprot.trans.flush()
695 
 
696 
  def recv_getUserByEmail(self, ):
697 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
698 
    if mtype == TMessageType.EXCEPTION:
699 
      x = TApplicationException()
700 
      x.read(self._iprot)
701 
      self._iprot.readMessageEnd()
702 
      raise x
703 
    result = getUserByEmail_result()
704 
    result.read(self._iprot)
705 
    self._iprot.readMessageEnd()
706 
    if result.success != None:
707 
      return result.success
708 
    if result.ucex != None:
709 
      raise result.ucex
710 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
711 
 
559 chandransh 712 
  def createUser(self, user):
94 ashish 713 
    """
714 
    Parameters:
559 chandransh 715 
     - user
94 ashish 716 
    """
559 chandransh 717 
    self.send_createUser(user)
718 
    return self.recv_createUser()
94 ashish 719 
 
559 chandransh 720 
  def send_createUser(self, user):
721 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
722 
    args = createUser_args()
723 
    args.user = user
94 ashish 724 
    args.write(self._oprot)
725 
    self._oprot.writeMessageEnd()
726 
    self._oprot.trans.flush()
727 
 
559 chandransh 728 
  def recv_createUser(self, ):
94 ashish 729 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
730 
    if mtype == TMessageType.EXCEPTION:
731 
      x = TApplicationException()
732 
      x.read(self._iprot)
733 
      self._iprot.readMessageEnd()
734 
      raise x
559 chandransh 735 
    result = createUser_result()
94 ashish 736 
    result.read(self._iprot)
737 
    self._iprot.readMessageEnd()
738 
    if result.success != None:
739 
      return result.success
559 chandransh 740 
    if result.ucex != None:
741 
      raise result.ucex
742 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 743 
 
559 chandransh 744 
  def updateUser(self, user):
94 ashish 745 
    """
746 
    Parameters:
559 chandransh 747 
     - user
94 ashish 748 
    """
559 chandransh 749 
    self.send_updateUser(user)
750 
    return self.recv_updateUser()
94 ashish 751 
 
559 chandransh 752 
  def send_updateUser(self, user):
753 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
754 
    args = updateUser_args()
755 
    args.user = user
94 ashish 756 
    args.write(self._oprot)
757 
    self._oprot.writeMessageEnd()
758 
    self._oprot.trans.flush()
759 
 
559 chandransh 760 
  def recv_updateUser(self, ):
94 ashish 761 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
762 
    if mtype == TMessageType.EXCEPTION:
763 
      x = TApplicationException()
764 
      x.read(self._iprot)
765 
      self._iprot.readMessageEnd()
766 
      raise x
559 chandransh 767 
    result = updateUser_result()
94 ashish 768 
    result.read(self._iprot)
769 
    self._iprot.readMessageEnd()
770 
    if result.success != None:
771 
      return result.success
559 chandransh 772 
    if result.ucex != None:
773 
      raise result.ucex
774 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 775 
 
559 chandransh 776 
  def deleteUser(self, userId):
94 ashish 777 
    """
778 
    Parameters:
779 
     - userId
780 
    """
559 chandransh 781 
    self.send_deleteUser(userId)
782 
    return self.recv_deleteUser()
94 ashish 783 
 
559 chandransh 784 
  def send_deleteUser(self, userId):
785 
    self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
786 
    args = deleteUser_args()
94 ashish 787 
    args.userId = userId
788 
    args.write(self._oprot)
789 
    self._oprot.writeMessageEnd()
790 
    self._oprot.trans.flush()
791 
 
559 chandransh 792 
  def recv_deleteUser(self, ):
94 ashish 793 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
794 
    if mtype == TMessageType.EXCEPTION:
795 
      x = TApplicationException()
796 
      x.read(self._iprot)
797 
      self._iprot.readMessageEnd()
798 
      raise x
559 chandransh 799 
    result = deleteUser_result()
94 ashish 800 
    result.read(self._iprot)
801 
    self._iprot.readMessageEnd()
802 
    if result.success != None:
803 
      return result.success
559 chandransh 804 
    if result.ucex != None:
805 
      raise result.ucex
806 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
94 ashish 807 
 
559 chandransh 808 
  def getUserState(self, userId):
94 ashish 809 
    """
810 
    Parameters:
811 
     - userId
812 
    """
559 chandransh 813 
    self.send_getUserState(userId)
814 
    return self.recv_getUserState()
94 ashish 815 
 
559 chandransh 816 
  def send_getUserState(self, userId):
817 
    self._oprot.writeMessageBegin('getUserState', TMessageType.CALL, self._seqid)
818 
    args = getUserState_args()
94 ashish 819 
    args.userId = userId
820 
    args.write(self._oprot)
821 
    self._oprot.writeMessageEnd()
822 
    self._oprot.trans.flush()
823 
 
559 chandransh 824 
  def recv_getUserState(self, ):
94 ashish 825 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
826 
    if mtype == TMessageType.EXCEPTION:
827 
      x = TApplicationException()
828 
      x.read(self._iprot)
829 
      self._iprot.readMessageEnd()
830 
      raise x
559 chandransh 831 
    result = getUserState_result()
94 ashish 832 
    result.read(self._iprot)
833 
    self._iprot.readMessageEnd()
834 
    if result.success != None:
835 
      return result.success
559 chandransh 836 
    if result.ucex != None:
837 
      raise result.ucex
838 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserState failed: unknown result");
94 ashish 839 
 
559 chandransh 840 
  def authenticateUser(self, email, password):
94 ashish 841 
    """
842 
    Parameters:
843 
     - email
844 
     - password
845 
    """
559 chandransh 846 
    self.send_authenticateUser(email, password)
122 ashish 847 
    return self.recv_authenticateUser()
848 
 
559 chandransh 849 
  def send_authenticateUser(self, email, password):
122 ashish 850 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
851 
    args = authenticateUser_args()
559 chandransh 852 
    args.email = email
122 ashish 853 
    args.password = password
854 
    args.write(self._oprot)
855 
    self._oprot.writeMessageEnd()
856 
    self._oprot.trans.flush()
857 
 
858 
  def recv_authenticateUser(self, ):
859 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
860 
    if mtype == TMessageType.EXCEPTION:
861 
      x = TApplicationException()
862 
      x.read(self._iprot)
863 
      self._iprot.readMessageEnd()
864 
      raise x
865 
    result = authenticateUser_result()
866 
    result.read(self._iprot)
867 
    self._iprot.readMessageEnd()
868 
    if result.success != None:
869 
      return result.success
559 chandransh 870 
    if result.auex != None:
871 
      raise result.auex
122 ashish 872 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
873 
 
94 ashish 874 
  def userExists(self, email):
875 
    """
876 
    Parameters:
877 
     - email
878 
    """
879 
    self.send_userExists(email)
880 
    return self.recv_userExists()
881 
 
882 
  def send_userExists(self, email):
883 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
884 
    args = userExists_args()
885 
    args.email = email
886 
    args.write(self._oprot)
887 
    self._oprot.writeMessageEnd()
888 
    self._oprot.trans.flush()
889 
 
890 
  def recv_userExists(self, ):
891 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
892 
    if mtype == TMessageType.EXCEPTION:
893 
      x = TApplicationException()
894 
      x.read(self._iprot)
895 
      self._iprot.readMessageEnd()
896 
      raise x
897 
    result = userExists_result()
898 
    result.read(self._iprot)
899 
    self._iprot.readMessageEnd()
900 
    if result.success != None:
901 
      return result.success
902 
    if result.ucx != None:
903 
      raise result.ucx
904 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
905 
 
567 rajveer 906 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 907 
    """
908 
    Parameters:
909 
     - userId
910 
     - address
513 rajveer 911 
     - setDefault
94 ashish 912 
    """
567 rajveer 913 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 914 
    return self.recv_addAddressForUser()
915 
 
567 rajveer 916 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 917 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
918 
    args = addAddressForUser_args()
559 chandransh 919 
    args.userId = userId
94 ashish 920 
    args.address = address
513 rajveer 921 
    args.setDefault = setDefault
94 ashish 922 
    args.write(self._oprot)
923 
    self._oprot.writeMessageEnd()
924 
    self._oprot.trans.flush()
925 
 
926 
  def recv_addAddressForUser(self, ):
927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
928 
    if mtype == TMessageType.EXCEPTION:
929 
      x = TApplicationException()
930 
      x.read(self._iprot)
931 
      self._iprot.readMessageEnd()
932 
      raise x
933 
    result = addAddressForUser_result()
934 
    result.read(self._iprot)
935 
    self._iprot.readMessageEnd()
936 
    if result.success != None:
937 
      return result.success
938 
    if result.ucx != None:
939 
      raise result.ucx
940 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
941 
 
942 
  def removeAddressForUser(self, userid, addressId):
943 
    """
944 
    Parameters:
945 
     - userid
946 
     - addressId
947 
    """
948 
    self.send_removeAddressForUser(userid, addressId)
949 
    return self.recv_removeAddressForUser()
950 
 
951 
  def send_removeAddressForUser(self, userid, addressId):
952 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
953 
    args = removeAddressForUser_args()
954 
    args.userid = userid
955 
    args.addressId = addressId
956 
    args.write(self._oprot)
957 
    self._oprot.writeMessageEnd()
958 
    self._oprot.trans.flush()
959 
 
960 
  def recv_removeAddressForUser(self, ):
961 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
962 
    if mtype == TMessageType.EXCEPTION:
963 
      x = TApplicationException()
964 
      x.read(self._iprot)
965 
      self._iprot.readMessageEnd()
966 
      raise x
967 
    result = removeAddressForUser_result()
968 
    result.read(self._iprot)
969 
    self._iprot.readMessageEnd()
970 
    if result.success != None:
971 
      return result.success
972 
    if result.ucx != None:
973 
      raise result.ucx
974 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
975 
 
976 
  def setUserAsLoggedIn(self, userId, timestamp):
977 
    """
978 
    Parameters:
979 
     - userId
980 
     - timestamp
981 
    """
982 
    self.send_setUserAsLoggedIn(userId, timestamp)
983 
    return self.recv_setUserAsLoggedIn()
984 
 
985 
  def send_setUserAsLoggedIn(self, userId, timestamp):
986 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
987 
    args = setUserAsLoggedIn_args()
988 
    args.userId = userId
989 
    args.timestamp = timestamp
990 
    args.write(self._oprot)
991 
    self._oprot.writeMessageEnd()
992 
    self._oprot.trans.flush()
993 
 
994 
  def recv_setUserAsLoggedIn(self, ):
995 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
996 
    if mtype == TMessageType.EXCEPTION:
997 
      x = TApplicationException()
998 
      x.read(self._iprot)
999 
      self._iprot.readMessageEnd()
1000 
      raise x
1001 
    result = setUserAsLoggedIn_result()
1002 
    result.read(self._iprot)
1003 
    self._iprot.readMessageEnd()
1004 
    if result.success != None:
1005 
      return result.success
1006 
    if result.ucx != None:
1007 
      raise result.ucx
1008 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1009 
 
1010 
  def setUserAsLoggedOut(self, userid, timestamp):
1011 
    """
1012 
    Parameters:
1013 
     - userid
1014 
     - timestamp
1015 
    """
1016 
    self.send_setUserAsLoggedOut(userid, timestamp)
1017 
    return self.recv_setUserAsLoggedOut()
1018 
 
1019 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1020 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1021 
    args = setUserAsLoggedOut_args()
1022 
    args.userid = userid
1023 
    args.timestamp = timestamp
1024 
    args.write(self._oprot)
1025 
    self._oprot.writeMessageEnd()
1026 
    self._oprot.trans.flush()
1027 
 
1028 
  def recv_setUserAsLoggedOut(self, ):
1029 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1030 
    if mtype == TMessageType.EXCEPTION:
1031 
      x = TApplicationException()
1032 
      x.read(self._iprot)
1033 
      self._iprot.readMessageEnd()
1034 
      raise x
1035 
    result = setUserAsLoggedOut_result()
1036 
    result.read(self._iprot)
1037 
    self._iprot.readMessageEnd()
1038 
    if result.success != None:
1039 
      return result.success
1040 
    if result.ucx != None:
1041 
      raise result.ucx
1042 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1043 
 
504 rajveer 1044 
  def setDefaultAddress(self, userid, addressId):
1045 
    """
1046 
    Parameters:
1047 
     - userid
1048 
     - addressId
1049 
    """
1050 
    self.send_setDefaultAddress(userid, addressId)
1051 
    return self.recv_setDefaultAddress()
1052 
 
1053 
  def send_setDefaultAddress(self, userid, addressId):
1054 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1055 
    args = setDefaultAddress_args()
1056 
    args.userid = userid
1057 
    args.addressId = addressId
1058 
    args.write(self._oprot)
1059 
    self._oprot.writeMessageEnd()
1060 
    self._oprot.trans.flush()
1061 
 
1062 
  def recv_setDefaultAddress(self, ):
1063 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1064 
    if mtype == TMessageType.EXCEPTION:
1065 
      x = TApplicationException()
1066 
      x.read(self._iprot)
1067 
      self._iprot.readMessageEnd()
1068 
      raise x
1069 
    result = setDefaultAddress_result()
1070 
    result.read(self._iprot)
1071 
    self._iprot.readMessageEnd()
1072 
    if result.success != None:
1073 
      return result.success
1074 
    if result.ucx != None:
1075 
      raise result.ucx
1076 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1077 
 
594 rajveer 1078 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1079 
    """
1080 
    Parameters:
1081 
     - userid
594 rajveer 1082 
     - oldPassword
1083 
     - newPassword
94 ashish 1084 
    """
594 rajveer 1085 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1086 
    return self.recv_updatePassword()
1087 
 
594 rajveer 1088 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1089 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1090 
    args = updatePassword_args()
1091 
    args.userid = userid
594 rajveer 1092 
    args.oldPassword = oldPassword
1093 
    args.newPassword = newPassword
94 ashish 1094 
    args.write(self._oprot)
1095 
    self._oprot.writeMessageEnd()
1096 
    self._oprot.trans.flush()
1097 
 
1098 
  def recv_updatePassword(self, ):
1099 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1100 
    if mtype == TMessageType.EXCEPTION:
1101 
      x = TApplicationException()
1102 
      x.read(self._iprot)
1103 
      self._iprot.readMessageEnd()
1104 
      raise x
1105 
    result = updatePassword_result()
1106 
    result.read(self._iprot)
1107 
    self._iprot.readMessageEnd()
1108 
    if result.success != None:
1109 
      return result.success
1110 
    if result.ucx != None:
1111 
      raise result.ucx
1112 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1113 
 
884 rajveer 1114 
  def forgotPassword(self, email, newPassword):
581 rajveer 1115 
    """
1116 
    Parameters:
1117 
     - email
884 rajveer 1118 
     - newPassword
581 rajveer 1119 
    """
884 rajveer 1120 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1121 
    return self.recv_forgotPassword()
1122 
 
884 rajveer 1123 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1124 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1125 
    args = forgotPassword_args()
1126 
    args.email = email
884 rajveer 1127 
    args.newPassword = newPassword
581 rajveer 1128 
    args.write(self._oprot)
1129 
    self._oprot.writeMessageEnd()
1130 
    self._oprot.trans.flush()
1131 
 
1132 
  def recv_forgotPassword(self, ):
1133 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1134 
    if mtype == TMessageType.EXCEPTION:
1135 
      x = TApplicationException()
1136 
      x.read(self._iprot)
1137 
      self._iprot.readMessageEnd()
1138 
      raise x
1139 
    result = forgotPassword_result()
1140 
    result.read(self._iprot)
1141 
    self._iprot.readMessageEnd()
1142 
    if result.success != None:
1143 
      return result.success
1144 
    if result.ucx != None:
1145 
      raise result.ucx
1146 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1147 
 
594 rajveer 1148 
  def getAllAddressesForUser(self, userId):
1149 
    """
1150 
    Parameters:
1151 
     - userId
1152 
    """
1153 
    self.send_getAllAddressesForUser(userId)
1154 
    return self.recv_getAllAddressesForUser()
1155 
 
1156 
  def send_getAllAddressesForUser(self, userId):
1157 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1158 
    args = getAllAddressesForUser_args()
1159 
    args.userId = userId
1160 
    args.write(self._oprot)
1161 
    self._oprot.writeMessageEnd()
1162 
    self._oprot.trans.flush()
1163 
 
1164 
  def recv_getAllAddressesForUser(self, ):
1165 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1166 
    if mtype == TMessageType.EXCEPTION:
1167 
      x = TApplicationException()
1168 
      x.read(self._iprot)
1169 
      self._iprot.readMessageEnd()
1170 
      raise x
1171 
    result = getAllAddressesForUser_result()
1172 
    result.read(self._iprot)
1173 
    self._iprot.readMessageEnd()
1174 
    if result.success != None:
1175 
      return result.success
1176 
    if result.ucx != None:
1177 
      raise result.ucx
1178 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1179 
 
1894 vikas 1180 
  def getAddressById(self, addressId):
1181 
    """
1182 
    Parameters:
1183 
     - addressId
1184 
    """
1185 
    self.send_getAddressById(addressId)
1186 
    return self.recv_getAddressById()
1187 
 
1188 
  def send_getAddressById(self, addressId):
1189 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1190 
    args = getAddressById_args()
1191 
    args.addressId = addressId
1192 
    args.write(self._oprot)
1193 
    self._oprot.writeMessageEnd()
1194 
    self._oprot.trans.flush()
1195 
 
1196 
  def recv_getAddressById(self, ):
1197 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1198 
    if mtype == TMessageType.EXCEPTION:
1199 
      x = TApplicationException()
1200 
      x.read(self._iprot)
1201 
      self._iprot.readMessageEnd()
1202 
      raise x
1203 
    result = getAddressById_result()
1204 
    result.read(self._iprot)
1205 
    self._iprot.readMessageEnd()
1206 
    if result.success != None:
1207 
      return result.success
1208 
    if result.ucx != None:
1209 
      raise result.ucx
1210 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1211 
 
594 rajveer 1212 
  def getDefaultAddressId(self, userId):
1213 
    """
1214 
    Parameters:
1215 
     - userId
1216 
    """
1217 
    self.send_getDefaultAddressId(userId)
1218 
    return self.recv_getDefaultAddressId()
1219 
 
1220 
  def send_getDefaultAddressId(self, userId):
1221 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1222 
    args = getDefaultAddressId_args()
1223 
    args.userId = userId
1224 
    args.write(self._oprot)
1225 
    self._oprot.writeMessageEnd()
1226 
    self._oprot.trans.flush()
1227 
 
1228 
  def recv_getDefaultAddressId(self, ):
1229 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1230 
    if mtype == TMessageType.EXCEPTION:
1231 
      x = TApplicationException()
1232 
      x.read(self._iprot)
1233 
      self._iprot.readMessageEnd()
1234 
      raise x
1235 
    result = getDefaultAddressId_result()
1236 
    result.read(self._iprot)
1237 
    self._iprot.readMessageEnd()
1238 
    if result.success != None:
1239 
      return result.success
1240 
    if result.ucx != None:
1241 
      raise result.ucx
1242 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1243 
 
785 rajveer 1244 
  def getDefaultPincode(self, userId):
1245 
    """
1246 
    Parameters:
1247 
     - userId
1248 
    """
1249 
    self.send_getDefaultPincode(userId)
1250 
    return self.recv_getDefaultPincode()
1251 
 
1252 
  def send_getDefaultPincode(self, userId):
1253 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1254 
    args = getDefaultPincode_args()
1255 
    args.userId = userId
1256 
    args.write(self._oprot)
1257 
    self._oprot.writeMessageEnd()
1258 
    self._oprot.trans.flush()
1259 
 
1260 
  def recv_getDefaultPincode(self, ):
1261 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1262 
    if mtype == TMessageType.EXCEPTION:
1263 
      x = TApplicationException()
1264 
      x.read(self._iprot)
1265 
      self._iprot.readMessageEnd()
1266 
      raise x
1267 
    result = getDefaultPincode_result()
1268 
    result.read(self._iprot)
1269 
    self._iprot.readMessageEnd()
1270 
    if result.success != None:
1271 
      return result.success
1272 
    if result.ucx != None:
1273 
      raise result.ucx
1274 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1275 
 
1274 varun.gupt 1276 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1277 
    """
1278 
    Parameters:
1279 
     - userId
1280 
     - replyTo
1281 
     - communicationType
1282 
     - orderId
1283 
     - airwaybillNo
1284 
     - productName
1285 
     - subject
1286 
     - message
1287 
    """
1288 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1289 
    return self.recv_saveUserCommunication()
1290 
 
1291 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1292 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1293 
    args = saveUserCommunication_args()
1294 
    args.userId = userId
1295 
    args.replyTo = replyTo
1296 
    args.communicationType = communicationType
1297 
    args.orderId = orderId
1298 
    args.airwaybillNo = airwaybillNo
1299 
    args.productName = productName
1300 
    args.subject = subject
1301 
    args.message = message
1302 
    args.write(self._oprot)
1303 
    self._oprot.writeMessageEnd()
1304 
    self._oprot.trans.flush()
1305 
 
1306 
  def recv_saveUserCommunication(self, ):
1307 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1308 
    if mtype == TMessageType.EXCEPTION:
1309 
      x = TApplicationException()
1310 
      x.read(self._iprot)
1311 
      self._iprot.readMessageEnd()
1312 
      raise x
1313 
    result = saveUserCommunication_result()
1314 
    result.read(self._iprot)
1315 
    self._iprot.readMessageEnd()
1316 
    if result.success != None:
1317 
      return result.success
1318 
    if result.ucx != None:
1319 
      raise result.ucx
1320 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1321 
 
1590 varun.gupt 1322 
  def getUserCommunicationById(self, id):
1323 
    """
1324 
    Parameters:
1325 
     - id
1326 
    """
1327 
    self.send_getUserCommunicationById(id)
1328 
    return self.recv_getUserCommunicationById()
1329 
 
1330 
  def send_getUserCommunicationById(self, id):
1331 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1332 
    args = getUserCommunicationById_args()
1333 
    args.id = id
1334 
    args.write(self._oprot)
1335 
    self._oprot.writeMessageEnd()
1336 
    self._oprot.trans.flush()
1337 
 
1338 
  def recv_getUserCommunicationById(self, ):
1339 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1340 
    if mtype == TMessageType.EXCEPTION:
1341 
      x = TApplicationException()
1342 
      x.read(self._iprot)
1343 
      self._iprot.readMessageEnd()
1344 
      raise x
1345 
    result = getUserCommunicationById_result()
1346 
    result.read(self._iprot)
1347 
    self._iprot.readMessageEnd()
1348 
    if result.success != None:
1349 
      return result.success
1350 
    if result.ucx != None:
1351 
      raise result.ucx
1352 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1353 
 
1354 
  def getUserCommunicationByUser(self, userId):
1355 
    """
1356 
    Parameters:
1357 
     - userId
1358 
    """
1359 
    self.send_getUserCommunicationByUser(userId)
1360 
    return self.recv_getUserCommunicationByUser()
1361 
 
1362 
  def send_getUserCommunicationByUser(self, userId):
1363 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1364 
    args = getUserCommunicationByUser_args()
1365 
    args.userId = userId
1366 
    args.write(self._oprot)
1367 
    self._oprot.writeMessageEnd()
1368 
    self._oprot.trans.flush()
1369 
 
1370 
  def recv_getUserCommunicationByUser(self, ):
1371 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1372 
    if mtype == TMessageType.EXCEPTION:
1373 
      x = TApplicationException()
1374 
      x.read(self._iprot)
1375 
      self._iprot.readMessageEnd()
1376 
      raise x
1377 
    result = getUserCommunicationByUser_result()
1378 
    result.read(self._iprot)
1379 
    self._iprot.readMessageEnd()
1380 
    if result.success != None:
1381 
      return result.success
1382 
    if result.ucx != None:
1383 
      raise result.ucx
1384 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1385 
 
1386 
  def getAllUserCommunications(self, ):
1387 
    self.send_getAllUserCommunications()
1388 
    return self.recv_getAllUserCommunications()
1389 
 
1390 
  def send_getAllUserCommunications(self, ):
1391 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1392 
    args = getAllUserCommunications_args()
1393 
    args.write(self._oprot)
1394 
    self._oprot.writeMessageEnd()
1395 
    self._oprot.trans.flush()
1396 
 
1397 
  def recv_getAllUserCommunications(self, ):
1398 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1399 
    if mtype == TMessageType.EXCEPTION:
1400 
      x = TApplicationException()
1401 
      x.read(self._iprot)
1402 
      self._iprot.readMessageEnd()
1403 
      raise x
1404 
    result = getAllUserCommunications_result()
1405 
    result.read(self._iprot)
1406 
    self._iprot.readMessageEnd()
1407 
    if result.success != None:
1408 
      return result.success
1409 
    if result.ucx != None:
1410 
      raise result.ucx
1411 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1412 
 
1859 vikas 1413 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1414 
    """
1415 
    Parameters:
1416 
     - name
1859 vikas 1417 
     - addedOn
1845 vikas 1418 
    """
1859 vikas 1419 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1420 
    return self.recv_createMasterAffiliate()
1421 
 
1859 vikas 1422 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1423 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1424 
    args = createMasterAffiliate_args()
1425 
    args.name = name
1859 vikas 1426 
    args.addedOn = addedOn
1845 vikas 1427 
    args.write(self._oprot)
1428 
    self._oprot.writeMessageEnd()
1429 
    self._oprot.trans.flush()
1430 
 
1431 
  def recv_createMasterAffiliate(self, ):
1432 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1433 
    if mtype == TMessageType.EXCEPTION:
1434 
      x = TApplicationException()
1435 
      x.read(self._iprot)
1436 
      self._iprot.readMessageEnd()
1437 
      raise x
1438 
    result = createMasterAffiliate_result()
1439 
    result.read(self._iprot)
1440 
    self._iprot.readMessageEnd()
1441 
    if result.success != None:
1442 
      return result.success
1443 
    if result.utx != None:
1444 
      raise result.utx
1445 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1446 
 
1899 vikas 1447 
  def getAllMasterAffiliates(self, ):
1448 
    self.send_getAllMasterAffiliates()
1449 
    return self.recv_getAllMasterAffiliates()
1450 
 
1451 
  def send_getAllMasterAffiliates(self, ):
1452 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1453 
    args = getAllMasterAffiliates_args()
1454 
    args.write(self._oprot)
1455 
    self._oprot.writeMessageEnd()
1456 
    self._oprot.trans.flush()
1457 
 
1458 
  def recv_getAllMasterAffiliates(self, ):
1459 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1460 
    if mtype == TMessageType.EXCEPTION:
1461 
      x = TApplicationException()
1462 
      x.read(self._iprot)
1463 
      self._iprot.readMessageEnd()
1464 
      raise x
1465 
    result = getAllMasterAffiliates_result()
1466 
    result.read(self._iprot)
1467 
    self._iprot.readMessageEnd()
1468 
    if result.success != None:
1469 
      return result.success
1470 
    if result.utx != None:
1471 
      raise result.utx
1472 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1473 
 
1845 vikas 1474 
  def getMasterAffiliateById(self, id):
1475 
    """
1476 
    Parameters:
1477 
     - id
1478 
    """
1479 
    self.send_getMasterAffiliateById(id)
1480 
    return self.recv_getMasterAffiliateById()
1481 
 
1482 
  def send_getMasterAffiliateById(self, id):
1483 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1484 
    args = getMasterAffiliateById_args()
1485 
    args.id = id
1486 
    args.write(self._oprot)
1487 
    self._oprot.writeMessageEnd()
1488 
    self._oprot.trans.flush()
1489 
 
1490 
  def recv_getMasterAffiliateById(self, ):
1491 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1492 
    if mtype == TMessageType.EXCEPTION:
1493 
      x = TApplicationException()
1494 
      x.read(self._iprot)
1495 
      self._iprot.readMessageEnd()
1496 
      raise x
1497 
    result = getMasterAffiliateById_result()
1498 
    result.read(self._iprot)
1499 
    self._iprot.readMessageEnd()
1500 
    if result.success != None:
1501 
      return result.success
1502 
    if result.utx != None:
1503 
      raise result.utx
1504 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1505 
 
1506 
  def getMasterAffiliateByName(self, name):
1507 
    """
1508 
    Parameters:
1509 
     - name
1510 
    """
1511 
    self.send_getMasterAffiliateByName(name)
1512 
    return self.recv_getMasterAffiliateByName()
1513 
 
1514 
  def send_getMasterAffiliateByName(self, name):
1515 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1516 
    args = getMasterAffiliateByName_args()
1517 
    args.name = name
1518 
    args.write(self._oprot)
1519 
    self._oprot.writeMessageEnd()
1520 
    self._oprot.trans.flush()
1521 
 
1522 
  def recv_getMasterAffiliateByName(self, ):
1523 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1524 
    if mtype == TMessageType.EXCEPTION:
1525 
      x = TApplicationException()
1526 
      x.read(self._iprot)
1527 
      self._iprot.readMessageEnd()
1528 
      raise x
1529 
    result = getMasterAffiliateByName_result()
1530 
    result.read(self._iprot)
1531 
    self._iprot.readMessageEnd()
1532 
    if result.success != None:
1533 
      return result.success
1534 
    if result.utx != None:
1535 
      raise result.utx
1536 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1537 
 
1859 vikas 1538 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1539 
    """
1540 
    Parameters:
1541 
     - name
1542 
     - url
1543 
     - masterAffiliateId
1859 vikas 1544 
     - addedOn
1845 vikas 1545 
    """
1859 vikas 1546 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1547 
    return self.recv_createAffiliate()
1548 
 
1859 vikas 1549 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1550 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1551 
    args = createAffiliate_args()
1552 
    args.name = name
1553 
    args.url = url
1554 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1555 
    args.addedOn = addedOn
1845 vikas 1556 
    args.write(self._oprot)
1557 
    self._oprot.writeMessageEnd()
1558 
    self._oprot.trans.flush()
1559 
 
1560 
  def recv_createAffiliate(self, ):
1561 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1562 
    if mtype == TMessageType.EXCEPTION:
1563 
      x = TApplicationException()
1564 
      x.read(self._iprot)
1565 
      self._iprot.readMessageEnd()
1566 
      raise x
1567 
    result = createAffiliate_result()
1568 
    result.read(self._iprot)
1569 
    self._iprot.readMessageEnd()
1570 
    if result.success != None:
1571 
      return result.success
1572 
    if result.utx != None:
1573 
      raise result.utx
1574 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1575 
 
1576 
  def getAffiliateById(self, id):
1577 
    """
1578 
    Parameters:
1579 
     - id
1580 
    """
1581 
    self.send_getAffiliateById(id)
1582 
    return self.recv_getAffiliateById()
1583 
 
1584 
  def send_getAffiliateById(self, id):
1585 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1586 
    args = getAffiliateById_args()
1587 
    args.id = id
1588 
    args.write(self._oprot)
1589 
    self._oprot.writeMessageEnd()
1590 
    self._oprot.trans.flush()
1591 
 
1592 
  def recv_getAffiliateById(self, ):
1593 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1594 
    if mtype == TMessageType.EXCEPTION:
1595 
      x = TApplicationException()
1596 
      x.read(self._iprot)
1597 
      self._iprot.readMessageEnd()
1598 
      raise x
1599 
    result = getAffiliateById_result()
1600 
    result.read(self._iprot)
1601 
    self._iprot.readMessageEnd()
1602 
    if result.success != None:
1603 
      return result.success
1604 
    if result.utx != None:
1605 
      raise result.utx
1606 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1607 
 
1608 
  def getAffiliateByName(self, name):
1609 
    """
1610 
    Parameters:
1611 
     - name
1612 
    """
1613 
    self.send_getAffiliateByName(name)
1614 
    return self.recv_getAffiliateByName()
1615 
 
1616 
  def send_getAffiliateByName(self, name):
1617 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1618 
    args = getAffiliateByName_args()
1619 
    args.name = name
1620 
    args.write(self._oprot)
1621 
    self._oprot.writeMessageEnd()
1622 
    self._oprot.trans.flush()
1623 
 
1624 
  def recv_getAffiliateByName(self, ):
1625 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1626 
    if mtype == TMessageType.EXCEPTION:
1627 
      x = TApplicationException()
1628 
      x.read(self._iprot)
1629 
      self._iprot.readMessageEnd()
1630 
      raise x
1631 
    result = getAffiliateByName_result()
1632 
    result.read(self._iprot)
1633 
    self._iprot.readMessageEnd()
1634 
    if result.success != None:
1635 
      return result.success
1636 
    if result.utx != None:
1637 
      raise result.utx
1638 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1639 
 
1996 vikas 1640 
  def getTrackerById(self, id):
1845 vikas 1641 
    """
1642 
    Parameters:
1643 
     - id
1644 
    """
1996 vikas 1645 
    self.send_getTrackerById(id)
1845 vikas 1646 
    return self.recv_getTrackerById()
1647 
 
1996 vikas 1648 
  def send_getTrackerById(self, id):
1845 vikas 1649 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1650 
    args = getTrackerById_args()
1996 vikas 1651 
    args.id = id
1845 vikas 1652 
    args.write(self._oprot)
1653 
    self._oprot.writeMessageEnd()
1654 
    self._oprot.trans.flush()
1655 
 
1656 
  def recv_getTrackerById(self, ):
1657 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1658 
    if mtype == TMessageType.EXCEPTION:
1659 
      x = TApplicationException()
1660 
      x.read(self._iprot)
1661 
      self._iprot.readMessageEnd()
1662 
      raise x
1663 
    result = getTrackerById_result()
1664 
    result.read(self._iprot)
1665 
    self._iprot.readMessageEnd()
1666 
    if result.success != None:
1667 
      return result.success
1668 
    if result.utx != None:
1669 
      raise result.utx
1670 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1671 
 
1996 vikas 1672 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1673 
    """
1674 
    Parameters:
1996 vikas 1675 
     - id
1845 vikas 1676 
    """
1996 vikas 1677 
    self.send_getAffiliatesByMasterAffiliate(id)
1678 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1679 
 
1996 vikas 1680 
  def send_getAffiliatesByMasterAffiliate(self, id):
1681 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1682 
    args = getAffiliatesByMasterAffiliate_args()
1683 
    args.id = id
1845 vikas 1684 
    args.write(self._oprot)
1685 
    self._oprot.writeMessageEnd()
1686 
    self._oprot.trans.flush()
1687 
 
1996 vikas 1688 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1689 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1690 
    if mtype == TMessageType.EXCEPTION:
1691 
      x = TApplicationException()
1692 
      x.read(self._iprot)
1693 
      self._iprot.readMessageEnd()
1694 
      raise x
1996 vikas 1695 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1696 
    result.read(self._iprot)
1697 
    self._iprot.readMessageEnd()
1698 
    if result.success != None:
1699 
      return result.success
1700 
    if result.utx != None:
1701 
      raise result.utx
1996 vikas 1702 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1703 
 
1996 vikas 1704 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1705 
    """
1706 
    Parameters:
1996 vikas 1707 
     - affiliateId
1845 vikas 1708 
     - userId
1709 
     - event
1710 
     - url
1711 
     - data
1859 vikas 1712 
     - addedOn
1845 vikas 1713 
    """
1996 vikas 1714 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1715 
    return self.recv_addTrackLog()
1716 
 
1996 vikas 1717 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1718 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1719 
    args = addTrackLog_args()
1996 vikas 1720 
    args.affiliateId = affiliateId
1845 vikas 1721 
    args.userId = userId
1722 
    args.event = event
1723 
    args.url = url
1724 
    args.data = data
1859 vikas 1725 
    args.addedOn = addedOn
1845 vikas 1726 
    args.write(self._oprot)
1727 
    self._oprot.writeMessageEnd()
1728 
    self._oprot.trans.flush()
1729 
 
1730 
  def recv_addTrackLog(self, ):
1731 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1732 
    if mtype == TMessageType.EXCEPTION:
1733 
      x = TApplicationException()
1734 
      x.read(self._iprot)
1735 
      self._iprot.readMessageEnd()
1736 
      raise x
1737 
    result = addTrackLog_result()
1738 
    result.read(self._iprot)
1739 
    self._iprot.readMessageEnd()
1740 
    if result.success != None:
1741 
      return result.success
1742 
    if result.utx != None:
1743 
      raise result.utx
1744 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1745 
 
1746 
  def getTrackLogById(self, id):
1747 
    """
1748 
    Parameters:
1749 
     - id
1750 
    """
1751 
    self.send_getTrackLogById(id)
1752 
    return self.recv_getTrackLogById()
1753 
 
1754 
  def send_getTrackLogById(self, id):
1755 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1756 
    args = getTrackLogById_args()
1757 
    args.id = id
1758 
    args.write(self._oprot)
1759 
    self._oprot.writeMessageEnd()
1760 
    self._oprot.trans.flush()
1761 
 
1762 
  def recv_getTrackLogById(self, ):
1763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1764 
    if mtype == TMessageType.EXCEPTION:
1765 
      x = TApplicationException()
1766 
      x.read(self._iprot)
1767 
      self._iprot.readMessageEnd()
1768 
      raise x
1769 
    result = getTrackLogById_result()
1770 
    result.read(self._iprot)
1771 
    self._iprot.readMessageEnd()
1772 
    if result.success != None:
1773 
      return result.success
1774 
    if result.utx != None:
1775 
      raise result.utx
1776 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1777 
 
1996 vikas 1778 
  def getTrackLogsByAffiliate(self, affiliateId):
1845 vikas 1779 
    """
1780 
    Parameters:
1996 vikas 1781 
     - affiliateId
1845 vikas 1782 
    """
1996 vikas 1783 
    self.send_getTrackLogsByAffiliate(affiliateId)
1784 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 1785 
 
1996 vikas 1786 
  def send_getTrackLogsByAffiliate(self, affiliateId):
1787 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
1788 
    args = getTrackLogsByAffiliate_args()
1789 
    args.affiliateId = affiliateId
1845 vikas 1790 
    args.write(self._oprot)
1791 
    self._oprot.writeMessageEnd()
1792 
    self._oprot.trans.flush()
1793 
 
1996 vikas 1794 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 1795 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1796 
    if mtype == TMessageType.EXCEPTION:
1797 
      x = TApplicationException()
1798 
      x.read(self._iprot)
1799 
      self._iprot.readMessageEnd()
1800 
      raise x
1996 vikas 1801 
    result = getTrackLogsByAffiliate_result()
1845 vikas 1802 
    result.read(self._iprot)
1803 
    self._iprot.readMessageEnd()
1804 
    if result.success != None:
1805 
      return result.success
1806 
    if result.utx != None:
1807 
      raise result.utx
1996 vikas 1808 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 1809 
 
1810 
  def getTrackLogsByUser(self, userId):
1811 
    """
1812 
    Parameters:
1813 
     - userId
1814 
    """
1815 
    self.send_getTrackLogsByUser(userId)
1816 
    return self.recv_getTrackLogsByUser()
1817 
 
1818 
  def send_getTrackLogsByUser(self, userId):
1819 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
1820 
    args = getTrackLogsByUser_args()
1821 
    args.userId = userId
1822 
    args.write(self._oprot)
1823 
    self._oprot.writeMessageEnd()
1824 
    self._oprot.trans.flush()
1825 
 
1826 
  def recv_getTrackLogsByUser(self, ):
1827 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1828 
    if mtype == TMessageType.EXCEPTION:
1829 
      x = TApplicationException()
1830 
      x.read(self._iprot)
1831 
      self._iprot.readMessageEnd()
1832 
      raise x
1833 
    result = getTrackLogsByUser_result()
1834 
    result.read(self._iprot)
1835 
    self._iprot.readMessageEnd()
1836 
    if result.success != None:
1837 
      return result.success
1838 
    if result.utx != None:
1839 
      raise result.utx
1840 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
1841 
 
1996 vikas 1842 
  def getTrackLogs(self, userId, event, url):
1845 vikas 1843 
    """
1844 
    Parameters:
1845 
     - userId
1846 
     - event
1847 
     - url
1848 
    """
1996 vikas 1849 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 1850 
    return self.recv_getTrackLogs()
1851 
 
1996 vikas 1852 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 1853 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
1854 
    args = getTrackLogs_args()
1855 
    args.userId = userId
1856 
    args.event = event
1857 
    args.url = url
1858 
    args.write(self._oprot)
1859 
    self._oprot.writeMessageEnd()
1860 
    self._oprot.trans.flush()
1861 
 
1862 
  def recv_getTrackLogs(self, ):
1863 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1864 
    if mtype == TMessageType.EXCEPTION:
1865 
      x = TApplicationException()
1866 
      x.read(self._iprot)
1867 
      self._iprot.readMessageEnd()
1868 
      raise x
1869 
    result = getTrackLogs_result()
1870 
    result.read(self._iprot)
1871 
    self._iprot.readMessageEnd()
1872 
    if result.success != None:
1873 
      return result.success
1874 
    if result.utx != None:
1875 
      raise result.utx
1876 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
1877 
 
559 chandransh 1878 
  def createCart(self, userId):
94 ashish 1879 
    """
1880 
    Parameters:
559 chandransh 1881 
     - userId
94 ashish 1882 
    """
559 chandransh 1883 
    self.send_createCart(userId)
1884 
    return self.recv_createCart()
94 ashish 1885 
 
559 chandransh 1886 
  def send_createCart(self, userId):
1887 
    self._oprot.writeMessageBegin('createCart', TMessageType.CALL, self._seqid)
1888 
    args = createCart_args()
1889 
    args.userId = userId
94 ashish 1890 
    args.write(self._oprot)
1891 
    self._oprot.writeMessageEnd()
1892 
    self._oprot.trans.flush()
1893 
 
559 chandransh 1894 
  def recv_createCart(self, ):
94 ashish 1895 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1896 
    if mtype == TMessageType.EXCEPTION:
1897 
      x = TApplicationException()
1898 
      x.read(self._iprot)
1899 
      self._iprot.readMessageEnd()
1900 
      raise x
559 chandransh 1901 
    result = createCart_result()
94 ashish 1902 
    result.read(self._iprot)
1903 
    self._iprot.readMessageEnd()
1904 
    if result.success != None:
1905 
      return result.success
559 chandransh 1906 
    if result.scx != None:
1907 
      raise result.scx
1908 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createCart failed: unknown result");
94 ashish 1909 
 
559 chandransh 1910 
  def getCurrentCart(self, userId):
94 ashish 1911 
    """
1912 
    Parameters:
559 chandransh 1913 
     - userId
94 ashish 1914 
    """
559 chandransh 1915 
    self.send_getCurrentCart(userId)
1916 
    return self.recv_getCurrentCart()
94 ashish 1917 
 
559 chandransh 1918 
  def send_getCurrentCart(self, userId):
1919 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
1920 
    args = getCurrentCart_args()
1921 
    args.userId = userId
94 ashish 1922 
    args.write(self._oprot)
1923 
    self._oprot.writeMessageEnd()
1924 
    self._oprot.trans.flush()
1925 
 
559 chandransh 1926 
  def recv_getCurrentCart(self, ):
94 ashish 1927 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1928 
    if mtype == TMessageType.EXCEPTION:
1929 
      x = TApplicationException()
1930 
      x.read(self._iprot)
1931 
      self._iprot.readMessageEnd()
1932 
      raise x
559 chandransh 1933 
    result = getCurrentCart_result()
94 ashish 1934 
    result.read(self._iprot)
1935 
    self._iprot.readMessageEnd()
1936 
    if result.success != None:
1937 
      return result.success
559 chandransh 1938 
    if result.scx != None:
1939 
      raise result.scx
1940 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 1941 
 
559 chandransh 1942 
  def getCart(self, cartId):
94 ashish 1943 
    """
1944 
    Parameters:
559 chandransh 1945 
     - cartId
94 ashish 1946 
    """
559 chandransh 1947 
    self.send_getCart(cartId)
1948 
    return self.recv_getCart()
94 ashish 1949 
 
559 chandransh 1950 
  def send_getCart(self, cartId):
1951 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
1952 
    args = getCart_args()
1953 
    args.cartId = cartId
94 ashish 1954 
    args.write(self._oprot)
1955 
    self._oprot.writeMessageEnd()
1956 
    self._oprot.trans.flush()
1957 
 
559 chandransh 1958 
  def recv_getCart(self, ):
94 ashish 1959 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1960 
    if mtype == TMessageType.EXCEPTION:
1961 
      x = TApplicationException()
1962 
      x.read(self._iprot)
1963 
      self._iprot.readMessageEnd()
1964 
      raise x
559 chandransh 1965 
    result = getCart_result()
94 ashish 1966 
    result.read(self._iprot)
1967 
    self._iprot.readMessageEnd()
1968 
    if result.success != None:
1969 
      return result.success
559 chandransh 1970 
    if result.scx != None:
1971 
      raise result.scx
1972 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 1973 
 
559 chandransh 1974 
  def getCartsForUser(self, userId, status):
94 ashish 1975 
    """
1976 
    Parameters:
559 chandransh 1977 
     - userId
1978 
     - status
94 ashish 1979 
    """
559 chandransh 1980 
    self.send_getCartsForUser(userId, status)
1981 
    return self.recv_getCartsForUser()
94 ashish 1982 
 
559 chandransh 1983 
  def send_getCartsForUser(self, userId, status):
1984 
    self._oprot.writeMessageBegin('getCartsForUser', TMessageType.CALL, self._seqid)
1985 
    args = getCartsForUser_args()
1986 
    args.userId = userId
1987 
    args.status = status
94 ashish 1988 
    args.write(self._oprot)
1989 
    self._oprot.writeMessageEnd()
1990 
    self._oprot.trans.flush()
1991 
 
559 chandransh 1992 
  def recv_getCartsForUser(self, ):
94 ashish 1993 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1994 
    if mtype == TMessageType.EXCEPTION:
1995 
      x = TApplicationException()
1996 
      x.read(self._iprot)
1997 
      self._iprot.readMessageEnd()
1998 
      raise x
559 chandransh 1999 
    result = getCartsForUser_result()
94 ashish 2000 
    result.read(self._iprot)
2001 
    self._iprot.readMessageEnd()
2002 
    if result.success != None:
2003 
      return result.success
559 chandransh 2004 
    if result.scx != None:
2005 
      raise result.scx
2006 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsForUser failed: unknown result");
94 ashish 2007 
 
559 chandransh 2008 
  def getCartsByStatus(self, status):
94 ashish 2009 
    """
2010 
    Parameters:
559 chandransh 2011 
     - status
94 ashish 2012 
    """
559 chandransh 2013 
    self.send_getCartsByStatus(status)
2014 
    return self.recv_getCartsByStatus()
94 ashish 2015 
 
559 chandransh 2016 
  def send_getCartsByStatus(self, status):
2017 
    self._oprot.writeMessageBegin('getCartsByStatus', TMessageType.CALL, self._seqid)
2018 
    args = getCartsByStatus_args()
2019 
    args.status = status
94 ashish 2020 
    args.write(self._oprot)
2021 
    self._oprot.writeMessageEnd()
2022 
    self._oprot.trans.flush()
2023 
 
559 chandransh 2024 
  def recv_getCartsByStatus(self, ):
94 ashish 2025 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2026 
    if mtype == TMessageType.EXCEPTION:
2027 
      x = TApplicationException()
2028 
      x.read(self._iprot)
2029 
      self._iprot.readMessageEnd()
2030 
      raise x
559 chandransh 2031 
    result = getCartsByStatus_result()
94 ashish 2032 
    result.read(self._iprot)
2033 
    self._iprot.readMessageEnd()
2034 
    if result.success != None:
2035 
      return result.success
559 chandransh 2036 
    if result.scx != None:
2037 
      raise result.scx
2038 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByStatus failed: unknown result");
94 ashish 2039 
 
559 chandransh 2040 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2041 
    """
2042 
    Parameters:
559 chandransh 2043 
     - from_time
2044 
     - to_time
2045 
     - status
94 ashish 2046 
    """
559 chandransh 2047 
    self.send_getCartsByTime(from_time, to_time, status)
2048 
    return self.recv_getCartsByTime()
94 ashish 2049 
 
559 chandransh 2050 
  def send_getCartsByTime(self, from_time, to_time, status):
2051 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2052 
    args = getCartsByTime_args()
2053 
    args.from_time = from_time
2054 
    args.to_time = to_time
2055 
    args.status = status
94 ashish 2056 
    args.write(self._oprot)
2057 
    self._oprot.writeMessageEnd()
2058 
    self._oprot.trans.flush()
2059 
 
559 chandransh 2060 
  def recv_getCartsByTime(self, ):
94 ashish 2061 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2062 
    if mtype == TMessageType.EXCEPTION:
2063 
      x = TApplicationException()
2064 
      x.read(self._iprot)
2065 
      self._iprot.readMessageEnd()
2066 
      raise x
559 chandransh 2067 
    result = getCartsByTime_result()
94 ashish 2068 
    result.read(self._iprot)
2069 
    self._iprot.readMessageEnd()
2070 
    if result.success != None:
2071 
      return result.success
559 chandransh 2072 
    if result.scx != None:
2073 
      raise result.scx
2074 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2075 
 
559 chandransh 2076 
  def changeCartStatus(self, cartId, status):
130 ashish 2077 
    """
2078 
    Parameters:
559 chandransh 2079 
     - cartId
2080 
     - status
130 ashish 2081 
    """
559 chandransh 2082 
    self.send_changeCartStatus(cartId, status)
2083 
    self.recv_changeCartStatus()
94 ashish 2084 
 
559 chandransh 2085 
  def send_changeCartStatus(self, cartId, status):
2086 
    self._oprot.writeMessageBegin('changeCartStatus', TMessageType.CALL, self._seqid)
2087 
    args = changeCartStatus_args()
2088 
    args.cartId = cartId
2089 
    args.status = status
130 ashish 2090 
    args.write(self._oprot)
2091 
    self._oprot.writeMessageEnd()
2092 
    self._oprot.trans.flush()
2093 
 
559 chandransh 2094 
  def recv_changeCartStatus(self, ):
130 ashish 2095 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2096 
    if mtype == TMessageType.EXCEPTION:
2097 
      x = TApplicationException()
2098 
      x.read(self._iprot)
2099 
      self._iprot.readMessageEnd()
2100 
      raise x
559 chandransh 2101 
    result = changeCartStatus_result()
130 ashish 2102 
    result.read(self._iprot)
2103 
    self._iprot.readMessageEnd()
559 chandransh 2104 
    if result.scx != None:
2105 
      raise result.scx
2106 
    return
2107 
 
2108 
  def addItemToCart(self, cartId, itemId, quantity):
2109 
    """
2110 
    Parameters:
2111 
     - cartId
2112 
     - itemId
2113 
     - quantity
2114 
    """
2115 
    self.send_addItemToCart(cartId, itemId, quantity)
2035 rajveer 2116 
    return self.recv_addItemToCart()
559 chandransh 2117 
 
2118 
  def send_addItemToCart(self, cartId, itemId, quantity):
2119 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2120 
    args = addItemToCart_args()
2121 
    args.cartId = cartId
2122 
    args.itemId = itemId
2123 
    args.quantity = quantity
2124 
    args.write(self._oprot)
2125 
    self._oprot.writeMessageEnd()
2126 
    self._oprot.trans.flush()
2127 
 
2128 
  def recv_addItemToCart(self, ):
2129 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2130 
    if mtype == TMessageType.EXCEPTION:
2131 
      x = TApplicationException()
2132 
      x.read(self._iprot)
2133 
      self._iprot.readMessageEnd()
2134 
      raise x
2135 
    result = addItemToCart_result()
2136 
    result.read(self._iprot)
2137 
    self._iprot.readMessageEnd()
2035 rajveer 2138 
    if result.success != None:
2139 
      return result.success
559 chandransh 2140 
    if result.scx != None:
2141 
      raise result.scx
2035 rajveer 2142 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2143 
 
2144 
  def deleteItemFromCart(self, cartId, itemId):
2145 
    """
2146 
    Parameters:
2147 
     - cartId
2148 
     - itemId
2149 
    """
2150 
    self.send_deleteItemFromCart(cartId, itemId)
2151 
    self.recv_deleteItemFromCart()
2152 
 
2153 
  def send_deleteItemFromCart(self, cartId, itemId):
2154 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2155 
    args = deleteItemFromCart_args()
2156 
    args.cartId = cartId
2157 
    args.itemId = itemId
2158 
    args.write(self._oprot)
2159 
    self._oprot.writeMessageEnd()
2160 
    self._oprot.trans.flush()
2161 
 
2162 
  def recv_deleteItemFromCart(self, ):
2163 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2164 
    if mtype == TMessageType.EXCEPTION:
2165 
      x = TApplicationException()
2166 
      x.read(self._iprot)
2167 
      self._iprot.readMessageEnd()
2168 
      raise x
2169 
    result = deleteItemFromCart_result()
2170 
    result.read(self._iprot)
2171 
    self._iprot.readMessageEnd()
2172 
    if result.scx != None:
2173 
      raise result.scx
2174 
    return
2175 
 
2176 
  def changeQuantity(self, cartId, itemId, quantity):
2177 
    """
2178 
    Parameters:
2179 
     - cartId
2180 
     - itemId
2181 
     - quantity
2182 
    """
2183 
    self.send_changeQuantity(cartId, itemId, quantity)
2184 
    self.recv_changeQuantity()
2185 
 
2186 
  def send_changeQuantity(self, cartId, itemId, quantity):
2187 
    self._oprot.writeMessageBegin('changeQuantity', TMessageType.CALL, self._seqid)
2188 
    args = changeQuantity_args()
2189 
    args.cartId = cartId
2190 
    args.itemId = itemId
2191 
    args.quantity = quantity
2192 
    args.write(self._oprot)
2193 
    self._oprot.writeMessageEnd()
2194 
    self._oprot.trans.flush()
2195 
 
2196 
  def recv_changeQuantity(self, ):
2197 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2198 
    if mtype == TMessageType.EXCEPTION:
2199 
      x = TApplicationException()
2200 
      x.read(self._iprot)
2201 
      self._iprot.readMessageEnd()
2202 
      raise x
2203 
    result = changeQuantity_result()
2204 
    result.read(self._iprot)
2205 
    self._iprot.readMessageEnd()
2206 
    if result.scx != None:
2207 
      raise result.scx
2208 
    return
2209 
 
2210 
  def changeItemStatus(self, cartId, itemId, status):
2211 
    """
2212 
    Parameters:
2213 
     - cartId
2214 
     - itemId
2215 
     - status
2216 
    """
2217 
    self.send_changeItemStatus(cartId, itemId, status)
2218 
    self.recv_changeItemStatus()
2219 
 
2220 
  def send_changeItemStatus(self, cartId, itemId, status):
2221 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
2222 
    args = changeItemStatus_args()
2223 
    args.cartId = cartId
2224 
    args.itemId = itemId
2225 
    args.status = status
2226 
    args.write(self._oprot)
2227 
    self._oprot.writeMessageEnd()
2228 
    self._oprot.trans.flush()
2229 
 
2230 
  def recv_changeItemStatus(self, ):
2231 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2232 
    if mtype == TMessageType.EXCEPTION:
2233 
      x = TApplicationException()
2234 
      x.read(self._iprot)
2235 
      self._iprot.readMessageEnd()
2236 
      raise x
2237 
    result = changeItemStatus_result()
2238 
    result.read(self._iprot)
2239 
    self._iprot.readMessageEnd()
2240 
    if result.scx != None:
2241 
      raise result.scx
2242 
    return
2243 
 
2244 
  def addAddressToCart(self, cartId, addressId):
2245 
    """
2246 
    Parameters:
2247 
     - cartId
2248 
     - addressId
2249 
    """
2250 
    self.send_addAddressToCart(cartId, addressId)
2251 
    self.recv_addAddressToCart()
2252 
 
2253 
  def send_addAddressToCart(self, cartId, addressId):
2254 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2255 
    args = addAddressToCart_args()
2256 
    args.cartId = cartId
2257 
    args.addressId = addressId
2258 
    args.write(self._oprot)
2259 
    self._oprot.writeMessageEnd()
2260 
    self._oprot.trans.flush()
2261 
 
2262 
  def recv_addAddressToCart(self, ):
2263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2264 
    if mtype == TMessageType.EXCEPTION:
2265 
      x = TApplicationException()
2266 
      x.read(self._iprot)
2267 
      self._iprot.readMessageEnd()
2268 
      raise x
2269 
    result = addAddressToCart_result()
2270 
    result.read(self._iprot)
2271 
    self._iprot.readMessageEnd()
575 chandransh 2272 
    if result.scx != None:
2273 
      raise result.scx
559 chandransh 2274 
    return
2275 
 
1976 varun.gupt 2276 
  def applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
2277 
    """
2278 
    Parameters:
2279 
     - cartId
2280 
     - couponCode
2281 
     - totalPrice
2282 
     - discountedPrice
2283 
    """
2284 
    self.send_applyCouponToCart(cartId, couponCode, totalPrice, discountedPrice)
2285 
    self.recv_applyCouponToCart()
2286 
 
2287 
  def send_applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
2288 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2289 
    args = applyCouponToCart_args()
2290 
    args.cartId = cartId
2291 
    args.couponCode = couponCode
2292 
    args.totalPrice = totalPrice
2293 
    args.discountedPrice = discountedPrice
2294 
    args.write(self._oprot)
2295 
    self._oprot.writeMessageEnd()
2296 
    self._oprot.trans.flush()
2297 
 
2298 
  def recv_applyCouponToCart(self, ):
2299 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2300 
    if mtype == TMessageType.EXCEPTION:
2301 
      x = TApplicationException()
2302 
      x.read(self._iprot)
2303 
      self._iprot.readMessageEnd()
2304 
      raise x
2305 
    result = applyCouponToCart_result()
2306 
    result.read(self._iprot)
2307 
    self._iprot.readMessageEnd()
2308 
    if result.scx != None:
2309 
      raise result.scx
2310 
    return
2311 
 
2312 
  def removeCoupon(self, cartId):
2313 
    """
2314 
    Parameters:
2315 
     - cartId
2316 
    """
2317 
    self.send_removeCoupon(cartId)
2318 
    self.recv_removeCoupon()
2319 
 
2320 
  def send_removeCoupon(self, cartId):
2321 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2322 
    args = removeCoupon_args()
2323 
    args.cartId = cartId
2324 
    args.write(self._oprot)
2325 
    self._oprot.writeMessageEnd()
2326 
    self._oprot.trans.flush()
2327 
 
2328 
  def recv_removeCoupon(self, ):
2329 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2330 
    if mtype == TMessageType.EXCEPTION:
2331 
      x = TApplicationException()
2332 
      x.read(self._iprot)
2333 
      self._iprot.readMessageEnd()
2334 
      raise x
2335 
    result = removeCoupon_result()
2336 
    result.read(self._iprot)
2337 
    self._iprot.readMessageEnd()
2338 
    if result.scx != None:
2339 
      raise result.scx
2340 
    return
2341 
 
690 chandransh 2342 
  def createOrders(self, cartId):
559 chandransh 2343 
    """
690 chandransh 2344 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
2345 
 
559 chandransh 2346 
    Parameters:
2347 
     - cartId
2348 
    """
690 chandransh 2349 
    self.send_createOrders(cartId)
2350 
    return self.recv_createOrders()
559 chandransh 2351 
 
690 chandransh 2352 
  def send_createOrders(self, cartId):
2353 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2354 
    args = createOrders_args()
559 chandransh 2355 
    args.cartId = cartId
2356 
    args.write(self._oprot)
2357 
    self._oprot.writeMessageEnd()
2358 
    self._oprot.trans.flush()
2359 
 
690 chandransh 2360 
  def recv_createOrders(self, ):
559 chandransh 2361 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2362 
    if mtype == TMessageType.EXCEPTION:
2363 
      x = TApplicationException()
2364 
      x.read(self._iprot)
2365 
      self._iprot.readMessageEnd()
2366 
      raise x
690 chandransh 2367 
    result = createOrders_result()
559 chandransh 2368 
    result.read(self._iprot)
2369 
    self._iprot.readMessageEnd()
130 ashish 2370 
    if result.success != None:
2371 
      return result.success
559 chandransh 2372 
    if result.scx != None:
2373 
      raise result.scx
690 chandransh 2374 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2375 
 
559 chandransh 2376 
  def validateCart(self, cartId):
130 ashish 2377 
    """
690 chandransh 2378 
    Validates that:
2379 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2380 
    2. All of the lines in the cart are active items.
690 chandransh 2381 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2382 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 2383 
 
130 ashish 2384 
    Parameters:
559 chandransh 2385 
     - cartId
130 ashish 2386 
    """
559 chandransh 2387 
    self.send_validateCart(cartId)
2388 
    return self.recv_validateCart()
130 ashish 2389 
 
559 chandransh 2390 
  def send_validateCart(self, cartId):
2391 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2392 
    args = validateCart_args()
2393 
    args.cartId = cartId
130 ashish 2394 
    args.write(self._oprot)
2395 
    self._oprot.writeMessageEnd()
2396 
    self._oprot.trans.flush()
2397 
 
559 chandransh 2398 
  def recv_validateCart(self, ):
130 ashish 2399 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2400 
    if mtype == TMessageType.EXCEPTION:
2401 
      x = TApplicationException()
2402 
      x.read(self._iprot)
2403 
      self._iprot.readMessageEnd()
2404 
      raise x
559 chandransh 2405 
    result = validateCart_result()
130 ashish 2406 
    result.read(self._iprot)
2407 
    self._iprot.readMessageEnd()
2408 
    if result.success != None:
2409 
      return result.success
575 chandransh 2410 
    if result.scex != None:
2411 
      raise result.scex
559 chandransh 2412 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2413 
 
690 chandransh 2414 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2415 
    """
690 chandransh 2416 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
2417 
 
575 chandransh 2418 
    Parameters:
690 chandransh 2419 
     - fromCartId
2420 
     - toCartId
2421 
    """
2422 
    self.send_mergeCart(fromCartId, toCartId)
2423 
    self.recv_mergeCart()
2424 
 
2425 
  def send_mergeCart(self, fromCartId, toCartId):
2426 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2427 
    args = mergeCart_args()
2428 
    args.fromCartId = fromCartId
2429 
    args.toCartId = toCartId
2430 
    args.write(self._oprot)
2431 
    self._oprot.writeMessageEnd()
2432 
    self._oprot.trans.flush()
2433 
 
2434 
  def recv_mergeCart(self, ):
2435 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2436 
    if mtype == TMessageType.EXCEPTION:
2437 
      x = TApplicationException()
2438 
      x.read(self._iprot)
2439 
      self._iprot.readMessageEnd()
2440 
      raise x
2441 
    result = mergeCart_result()
2442 
    result.read(self._iprot)
2443 
    self._iprot.readMessageEnd()
2444 
    return
2445 
 
2446 
  def checkOut(self, cartId):
2447 
    """
2448 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
2449 
 
2450 
    Parameters:
575 chandransh 2451 
     - cartId
2452 
    """
690 chandransh 2453 
    self.send_checkOut(cartId)
2454 
    return self.recv_checkOut()
575 chandransh 2455 
 
690 chandransh 2456 
  def send_checkOut(self, cartId):
2457 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2458 
    args = checkOut_args()
575 chandransh 2459 
    args.cartId = cartId
2460 
    args.write(self._oprot)
2461 
    self._oprot.writeMessageEnd()
2462 
    self._oprot.trans.flush()
2463 
 
690 chandransh 2464 
  def recv_checkOut(self, ):
575 chandransh 2465 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2466 
    if mtype == TMessageType.EXCEPTION:
2467 
      x = TApplicationException()
2468 
      x.read(self._iprot)
2469 
      self._iprot.readMessageEnd()
2470 
      raise x
690 chandransh 2471 
    result = checkOut_result()
575 chandransh 2472 
    result.read(self._iprot)
2473 
    self._iprot.readMessageEnd()
2474 
    if result.success != None:
2475 
      return result.success
2476 
    if result.scex != None:
2477 
      raise result.scex
690 chandransh 2478 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2479 
 
690 chandransh 2480 
  def resetCart(self, cartId, items):
559 chandransh 2481 
    """
690 chandransh 2482 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2483 
    This methods removes the specified quantiry of the specified item from the cart.
2484 
 
559 chandransh 2485 
    Parameters:
690 chandransh 2486 
     - cartId
2487 
     - items
559 chandransh 2488 
    """
690 chandransh 2489 
    self.send_resetCart(cartId, items)
2490 
    return self.recv_resetCart()
130 ashish 2491 
 
690 chandransh 2492 
  def send_resetCart(self, cartId, items):
2493 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2494 
    args = resetCart_args()
2495 
    args.cartId = cartId
2496 
    args.items = items
559 chandransh 2497 
    args.write(self._oprot)
2498 
    self._oprot.writeMessageEnd()
2499 
    self._oprot.trans.flush()
2500 
 
690 chandransh 2501 
  def recv_resetCart(self, ):
559 chandransh 2502 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2503 
    if mtype == TMessageType.EXCEPTION:
2504 
      x = TApplicationException()
2505 
      x.read(self._iprot)
2506 
      self._iprot.readMessageEnd()
2507 
      raise x
690 chandransh 2508 
    result = resetCart_result()
559 chandransh 2509 
    result.read(self._iprot)
2510 
    self._iprot.readMessageEnd()
690 chandransh 2511 
    if result.success != None:
2512 
      return result.success
2513 
    if result.scex != None:
2514 
      raise result.scex
2515 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2516 
 
772 rajveer 2517 
  def getMyResearch(self, userId):
559 chandransh 2518 
    """
772 rajveer 2519 
    Widgets
2520 
 
559 chandransh 2521 
    Parameters:
2522 
     - userId
2523 
    """
772 rajveer 2524 
    self.send_getMyResearch(userId)
559 chandransh 2525 
    return self.recv_getMyResearch()
2526 
 
772 rajveer 2527 
  def send_getMyResearch(self, userId):
559 chandransh 2528 
    self._oprot.writeMessageBegin('getMyResearch', TMessageType.CALL, self._seqid)
2529 
    args = getMyResearch_args()
772 rajveer 2530 
    args.userId = userId
559 chandransh 2531 
    args.write(self._oprot)
2532 
    self._oprot.writeMessageEnd()
2533 
    self._oprot.trans.flush()
2534 
 
2535 
  def recv_getMyResearch(self, ):
2536 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2537 
    if mtype == TMessageType.EXCEPTION:
2538 
      x = TApplicationException()
2539 
      x.read(self._iprot)
2540 
      self._iprot.readMessageEnd()
2541 
      raise x
2542 
    result = getMyResearch_result()
2543 
    result.read(self._iprot)
2544 
    self._iprot.readMessageEnd()
2545 
    if result.success != None:
2546 
      return result.success
2547 
    if result.scx != None:
2548 
      raise result.scx
2549 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearch failed: unknown result");
2550 
 
772 rajveer 2551 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2552 
    """
2553 
    Parameters:
772 rajveer 2554 
     - userId
2555 
     - itemId
559 chandransh 2556 
    """
772 rajveer 2557 
    self.send_updateMyResearch(userId, itemId)
559 chandransh 2558 
    return self.recv_updateMyResearch()
2559 
 
772 rajveer 2560 
  def send_updateMyResearch(self, userId, itemId):
559 chandransh 2561 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2562 
    args = updateMyResearch_args()
772 rajveer 2563 
    args.userId = userId
2564 
    args.itemId = itemId
559 chandransh 2565 
    args.write(self._oprot)
2566 
    self._oprot.writeMessageEnd()
2567 
    self._oprot.trans.flush()
2568 
 
2569 
  def recv_updateMyResearch(self, ):
2570 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2571 
    if mtype == TMessageType.EXCEPTION:
2572 
      x = TApplicationException()
2573 
      x.read(self._iprot)
2574 
      self._iprot.readMessageEnd()
2575 
      raise x
2576 
    result = updateMyResearch_result()
2577 
    result.read(self._iprot)
2578 
    self._iprot.readMessageEnd()
2579 
    if result.success != None:
2580 
      return result.success
2581 
    if result.scx != None:
2582 
      raise result.scx
2583 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
2584 
 
772 rajveer 2585 
  def deleteItemFromMyResearch(self, userId, itemId):
559 chandransh 2586 
    """
2587 
    Parameters:
772 rajveer 2588 
     - userId
2589 
     - itemId
559 chandransh 2590 
    """
772 rajveer 2591 
    self.send_deleteItemFromMyResearch(userId, itemId)
559 chandransh 2592 
    self.recv_deleteItemFromMyResearch()
2593 
 
772 rajveer 2594 
  def send_deleteItemFromMyResearch(self, userId, itemId):
559 chandransh 2595 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2596 
    args = deleteItemFromMyResearch_args()
772 rajveer 2597 
    args.userId = userId
2598 
    args.itemId = itemId
559 chandransh 2599 
    args.write(self._oprot)
2600 
    self._oprot.writeMessageEnd()
2601 
    self._oprot.trans.flush()
2602 
 
2603 
  def recv_deleteItemFromMyResearch(self, ):
2604 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2605 
    if mtype == TMessageType.EXCEPTION:
2606 
      x = TApplicationException()
2607 
      x.read(self._iprot)
2608 
      self._iprot.readMessageEnd()
2609 
      raise x
2610 
    result = deleteItemFromMyResearch_result()
2611 
    result.read(self._iprot)
2612 
    self._iprot.readMessageEnd()
2613 
    if result.scx != None:
2614 
      raise result.scx
2615 
    return
2616 
 
772 rajveer 2617 
  def updateBrowseHistory(self, userId, itemId):
559 chandransh 2618 
    """
2619 
    Parameters:
772 rajveer 2620 
     - userId
2621 
     - itemId
559 chandransh 2622 
    """
772 rajveer 2623 
    self.send_updateBrowseHistory(userId, itemId)
2624 
    self.recv_updateBrowseHistory()
559 chandransh 2625 
 
772 rajveer 2626 
  def send_updateBrowseHistory(self, userId, itemId):
2627 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2628 
    args = updateBrowseHistory_args()
2629 
    args.userId = userId
2630 
    args.itemId = itemId
559 chandransh 2631 
    args.write(self._oprot)
2632 
    self._oprot.writeMessageEnd()
2633 
    self._oprot.trans.flush()
2634 
 
772 rajveer 2635 
  def recv_updateBrowseHistory(self, ):
559 chandransh 2636 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2637 
    if mtype == TMessageType.EXCEPTION:
2638 
      x = TApplicationException()
2639 
      x.read(self._iprot)
2640 
      self._iprot.readMessageEnd()
2641 
      raise x
772 rajveer 2642 
    result = updateBrowseHistory_result()
559 chandransh 2643 
    result.read(self._iprot)
2644 
    self._iprot.readMessageEnd()
2645 
    return
2646 
 
772 rajveer 2647 
  def getBrowseHistory(self, userId):
559 chandransh 2648 
    """
2649 
    Parameters:
772 rajveer 2650 
     - userId
559 chandransh 2651 
    """
772 rajveer 2652 
    self.send_getBrowseHistory(userId)
2653 
    return self.recv_getBrowseHistory()
559 chandransh 2654 
 
772 rajveer 2655 
  def send_getBrowseHistory(self, userId):
2656 
    self._oprot.writeMessageBegin('getBrowseHistory', TMessageType.CALL, self._seqid)
2657 
    args = getBrowseHistory_args()
2658 
    args.userId = userId
559 chandransh 2659 
    args.write(self._oprot)
2660 
    self._oprot.writeMessageEnd()
2661 
    self._oprot.trans.flush()
2662 
 
772 rajveer 2663 
  def recv_getBrowseHistory(self, ):
559 chandransh 2664 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2665 
    if mtype == TMessageType.EXCEPTION:
2666 
      x = TApplicationException()
2667 
      x.read(self._iprot)
2668 
      self._iprot.readMessageEnd()
2669 
      raise x
772 rajveer 2670 
    result = getBrowseHistory_result()
559 chandransh 2671 
    result.read(self._iprot)
2672 
    self._iprot.readMessageEnd()
2673 
    if result.success != None:
2674 
      return result.success
2675 
    if result.scx != None:
2676 
      raise result.scx
772 rajveer 2677 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistory failed: unknown result");
559 chandransh 2678 
 
772 rajveer 2679 
  def mergeBrowseHistory(self, fromUserId, toUserId):
559 chandransh 2680 
    """
2681 
    Parameters:
772 rajveer 2682 
     - fromUserId
2683 
     - toUserId
559 chandransh 2684 
    """
772 rajveer 2685 
    self.send_mergeBrowseHistory(fromUserId, toUserId)
2686 
    self.recv_mergeBrowseHistory()
559 chandransh 2687 
 
772 rajveer 2688 
  def send_mergeBrowseHistory(self, fromUserId, toUserId):
2689 
    self._oprot.writeMessageBegin('mergeBrowseHistory', TMessageType.CALL, self._seqid)
2690 
    args = mergeBrowseHistory_args()
2691 
    args.fromUserId = fromUserId
2692 
    args.toUserId = toUserId
559 chandransh 2693 
    args.write(self._oprot)
2694 
    self._oprot.writeMessageEnd()
2695 
    self._oprot.trans.flush()
2696 
 
772 rajveer 2697 
  def recv_mergeBrowseHistory(self, ):
559 chandransh 2698 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2699 
    if mtype == TMessageType.EXCEPTION:
2700 
      x = TApplicationException()
2701 
      x.read(self._iprot)
2702 
      self._iprot.readMessageEnd()
2703 
      raise x
772 rajveer 2704 
    result = mergeBrowseHistory_result()
559 chandransh 2705 
    result.read(self._iprot)
2706 
    self._iprot.readMessageEnd()
2707 
    return
2708 
 
1596 ankur.sing 2709 
  def getUserCount(self, userType):
2710 
    """
2711 
    Returns number of registered users.
2712 
    If userType = null, then it returns count of all users, including anonymous
2713 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2714 
    If userType = UserType.USER, then it returns count of non-anonymous users only
2715 
 
2716 
    Parameters:
2717 
     - userType
2718 
    """
2719 
    self.send_getUserCount(userType)
2720 
    return self.recv_getUserCount()
559 chandransh 2721 
 
1596 ankur.sing 2722 
  def send_getUserCount(self, userType):
2723 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2724 
    args = getUserCount_args()
2725 
    args.userType = userType
2726 
    args.write(self._oprot)
2727 
    self._oprot.writeMessageEnd()
2728 
    self._oprot.trans.flush()
2729 
 
2730 
  def recv_getUserCount(self, ):
2731 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2732 
    if mtype == TMessageType.EXCEPTION:
2733 
      x = TApplicationException()
2734 
      x.read(self._iprot)
2735 
      self._iprot.readMessageEnd()
2736 
      raise x
2737 
    result = getUserCount_result()
2738 
    result.read(self._iprot)
2739 
    self._iprot.readMessageEnd()
2740 
    if result.success != None:
2741 
      return result.success
2742 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
2743 
 
1891 ankur.sing 2744 
  def getAllUsers(self, userType, startDate, endDate):
1673 ankur.sing 2745 
    """
1891 ankur.sing 2746 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2747 
    If any of startDate or endDate is -1, then that filter is ignored.
2748 
    If userType is null, then returns all the users, irrespective of anonymous flag
1673 ankur.sing 2749 
 
1891 ankur.sing 2750 
 
1673 ankur.sing 2751 
    Parameters:
2752 
     - userType
1891 ankur.sing 2753 
     - startDate
2754 
     - endDate
1673 ankur.sing 2755 
    """
1891 ankur.sing 2756 
    self.send_getAllUsers(userType, startDate, endDate)
1673 ankur.sing 2757 
    return self.recv_getAllUsers()
1596 ankur.sing 2758 
 
1891 ankur.sing 2759 
  def send_getAllUsers(self, userType, startDate, endDate):
1673 ankur.sing 2760 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2761 
    args = getAllUsers_args()
2762 
    args.userType = userType
1891 ankur.sing 2763 
    args.startDate = startDate
2764 
    args.endDate = endDate
1673 ankur.sing 2765 
    args.write(self._oprot)
2766 
    self._oprot.writeMessageEnd()
2767 
    self._oprot.trans.flush()
2768 
 
2769 
  def recv_getAllUsers(self, ):
2770 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2771 
    if mtype == TMessageType.EXCEPTION:
2772 
      x = TApplicationException()
2773 
      x.read(self._iprot)
2774 
      self._iprot.readMessageEnd()
2775 
      raise x
2776 
    result = getAllUsers_result()
2777 
    result.read(self._iprot)
2778 
    self._iprot.readMessageEnd()
2779 
    if result.success != None:
2780 
      return result.success
2781 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
2782 
 
2717 varun.gupt 2783 
  def putUserNote(self, user_id, entity_id, slide, note):
2642 varun.gupt 2784 
    """
2785 
    Masking right now. May be used later.
2786 
    void addWidget(1:Widget widget) throws (1:WidgetException scx),
2787 
    void addItemToWidget(1:i64 widget_id, 2:list<i64> items) throws (1:WidgetException scx),
2788 
    void deleteItemFromWidget(1:i64 widget_id, 2:i64 item_id) throws (1:WidgetException scx),
2789 
    void updateWidget(1:i64 widgetId, 2:bool enable) throws (1:WidgetException scx),
2790 
    void updateWidgetItem(1:i64 widgetId, 2:bool enable) throws (1:WidgetException scx),
2791 
    Widget getWidget(1:WidgetType type, 2:i64 userId, 3:bool onlyEnabled) throws (1:WidgetException scx),
2792 
 
2793 
    Parameters:
2794 
     - user_id
2795 
     - entity_id
2717 varun.gupt 2796 
     - slide
2642 varun.gupt 2797 
     - note
2798 
    """
2717 varun.gupt 2799 
    self.send_putUserNote(user_id, entity_id, slide, note)
2642 varun.gupt 2800 
    self.recv_putUserNote()
1673 ankur.sing 2801 
 
2717 varun.gupt 2802 
  def send_putUserNote(self, user_id, entity_id, slide, note):
2642 varun.gupt 2803 
    self._oprot.writeMessageBegin('putUserNote', TMessageType.CALL, self._seqid)
2804 
    args = putUserNote_args()
2805 
    args.user_id = user_id
2806 
    args.entity_id = entity_id
2717 varun.gupt 2807 
    args.slide = slide
2642 varun.gupt 2808 
    args.note = note
2809 
    args.write(self._oprot)
2810 
    self._oprot.writeMessageEnd()
2811 
    self._oprot.trans.flush()
2812 
 
2813 
  def recv_putUserNote(self, ):
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
2820 
    result = putUserNote_result()
2821 
    result.read(self._iprot)
2822 
    self._iprot.readMessageEnd()
2823 
    return
2824 
 
2825 
  def getUserNotes(self, user_id, entity_id):
2826 
    """
2827 
    Parameters:
2828 
     - user_id
2829 
     - entity_id
2830 
    """
2831 
    self.send_getUserNotes(user_id, entity_id)
2832 
    return self.recv_getUserNotes()
2833 
 
2834 
  def send_getUserNotes(self, user_id, entity_id):
2835 
    self._oprot.writeMessageBegin('getUserNotes', TMessageType.CALL, self._seqid)
2836 
    args = getUserNotes_args()
2837 
    args.user_id = user_id
2838 
    args.entity_id = entity_id
2839 
    args.write(self._oprot)
2840 
    self._oprot.writeMessageEnd()
2841 
    self._oprot.trans.flush()
2842 
 
2843 
  def recv_getUserNotes(self, ):
2844 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2845 
    if mtype == TMessageType.EXCEPTION:
2846 
      x = TApplicationException()
2847 
      x.read(self._iprot)
2848 
      self._iprot.readMessageEnd()
2849 
      raise x
2850 
    result = getUserNotes_result()
2851 
    result.read(self._iprot)
2852 
    self._iprot.readMessageEnd()
2853 
    if result.success != None:
2854 
      return result.success
2855 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserNotes failed: unknown result");
2856 
 
2857 
 
94 ashish 2858 
class Processor(Iface, TProcessor):
2859 
  def __init__(self, handler):
2860 
    self._handler = handler
2861 
    self._processMap = {}
765 rajveer 2862 
    self._processMap["closeSession"] = Processor.process_closeSession
559 chandransh 2863 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
2864 
    self._processMap["getUserById"] = Processor.process_getUserById
1491 vikas 2865 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
559 chandransh 2866 
    self._processMap["createUser"] = Processor.process_createUser
2867 
    self._processMap["updateUser"] = Processor.process_updateUser
2868 
    self._processMap["deleteUser"] = Processor.process_deleteUser
2869 
    self._processMap["getUserState"] = Processor.process_getUserState
122 ashish 2870 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 2871 
    self._processMap["userExists"] = Processor.process_userExists
2872 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
2873 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
2874 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
2875 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 2876 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 2877 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 2878 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 2879 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 2880 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 2881 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 2882 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 2883 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 2884 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
2885 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
2886 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
1845 vikas 2887 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 2888 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 2889 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
2890 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
2891 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
2892 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
2893 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 2894 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 2895 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
2896 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
2897 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 2898 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 2899 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
2900 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 2901 
    self._processMap["createCart"] = Processor.process_createCart
2902 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
2903 
    self._processMap["getCart"] = Processor.process_getCart
2904 
    self._processMap["getCartsForUser"] = Processor.process_getCartsForUser
2905 
    self._processMap["getCartsByStatus"] = Processor.process_getCartsByStatus
2906 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
2907 
    self._processMap["changeCartStatus"] = Processor.process_changeCartStatus
2908 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
2909 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
2910 
    self._processMap["changeQuantity"] = Processor.process_changeQuantity
2911 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
2912 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
1976 varun.gupt 2913 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
2914 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
690 chandransh 2915 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 2916 
    self._processMap["validateCart"] = Processor.process_validateCart
2917 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 2918 
    self._processMap["checkOut"] = Processor.process_checkOut
2919 
    self._processMap["resetCart"] = Processor.process_resetCart
559 chandransh 2920 
    self._processMap["getMyResearch"] = Processor.process_getMyResearch
2921 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
2922 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
2923 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
2924 
    self._processMap["getBrowseHistory"] = Processor.process_getBrowseHistory
772 rajveer 2925 
    self._processMap["mergeBrowseHistory"] = Processor.process_mergeBrowseHistory
1596 ankur.sing 2926 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 2927 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2642 varun.gupt 2928 
    self._processMap["putUserNote"] = Processor.process_putUserNote
2929 
    self._processMap["getUserNotes"] = Processor.process_getUserNotes
94 ashish 2930 
 
2931 
  def process(self, iprot, oprot):
2932 
    (name, type, seqid) = iprot.readMessageBegin()
2933 
    if name not in self._processMap:
2934 
      iprot.skip(TType.STRUCT)
2935 
      iprot.readMessageEnd()
2936 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
2937 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
2938 
      x.write(oprot)
2939 
      oprot.writeMessageEnd()
2940 
      oprot.trans.flush()
2941 
      return
2942 
    else:
2943 
      self._processMap[name](self, seqid, iprot, oprot)
2944 
    return True
2945 
 
765 rajveer 2946 
  def process_closeSession(self, seqid, iprot, oprot):
2947 
    args = closeSession_args()
2948 
    args.read(iprot)
2949 
    iprot.readMessageEnd()
2950 
    result = closeSession_result()
2951 
    self._handler.closeSession()
2952 
    oprot.writeMessageBegin("closeSession", TMessageType.REPLY, seqid)
2953 
    result.write(oprot)
2954 
    oprot.writeMessageEnd()
2955 
    oprot.trans.flush()
2956 
 
559 chandransh 2957 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
2958 
    args = createAnonymousUser_args()
94 ashish 2959 
    args.read(iprot)
2960 
    iprot.readMessageEnd()
559 chandransh 2961 
    result = createAnonymousUser_result()
94 ashish 2962 
    try:
559 chandransh 2963 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
2964 
    except UserContextException, ucex:
2965 
      result.ucex = ucex
2966 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 2967 
    result.write(oprot)
2968 
    oprot.writeMessageEnd()
2969 
    oprot.trans.flush()
2970 
 
559 chandransh 2971 
  def process_getUserById(self, seqid, iprot, oprot):
2972 
    args = getUserById_args()
94 ashish 2973 
    args.read(iprot)
2974 
    iprot.readMessageEnd()
559 chandransh 2975 
    result = getUserById_result()
94 ashish 2976 
    try:
559 chandransh 2977 
      result.success = self._handler.getUserById(args.userId)
2978 
    except UserContextException, ucex:
2979 
      result.ucex = ucex
2980 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 2981 
    result.write(oprot)
2982 
    oprot.writeMessageEnd()
2983 
    oprot.trans.flush()
2984 
 
1491 vikas 2985 
  def process_getUserByEmail(self, seqid, iprot, oprot):
2986 
    args = getUserByEmail_args()
2987 
    args.read(iprot)
2988 
    iprot.readMessageEnd()
2989 
    result = getUserByEmail_result()
2990 
    try:
2991 
      result.success = self._handler.getUserByEmail(args.email)
2992 
    except UserContextException, ucex:
2993 
      result.ucex = ucex
2994 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
2995 
    result.write(oprot)
2996 
    oprot.writeMessageEnd()
2997 
    oprot.trans.flush()
2998 
 
559 chandransh 2999 
  def process_createUser(self, seqid, iprot, oprot):
3000 
    args = createUser_args()
94 ashish 3001 
    args.read(iprot)
3002 
    iprot.readMessageEnd()
559 chandransh 3003 
    result = createUser_result()
94 ashish 3004 
    try:
559 chandransh 3005 
      result.success = self._handler.createUser(args.user)
3006 
    except UserContextException, ucex:
3007 
      result.ucex = ucex
3008 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 3009 
    result.write(oprot)
3010 
    oprot.writeMessageEnd()
3011 
    oprot.trans.flush()
3012 
 
559 chandransh 3013 
  def process_updateUser(self, seqid, iprot, oprot):
3014 
    args = updateUser_args()
94 ashish 3015 
    args.read(iprot)
3016 
    iprot.readMessageEnd()
559 chandransh 3017 
    result = updateUser_result()
94 ashish 3018 
    try:
559 chandransh 3019 
      result.success = self._handler.updateUser(args.user)
3020 
    except UserContextException, ucex:
3021 
      result.ucex = ucex
3022 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 3023 
    result.write(oprot)
3024 
    oprot.writeMessageEnd()
3025 
    oprot.trans.flush()
3026 
 
559 chandransh 3027 
  def process_deleteUser(self, seqid, iprot, oprot):
3028 
    args = deleteUser_args()
94 ashish 3029 
    args.read(iprot)
3030 
    iprot.readMessageEnd()
559 chandransh 3031 
    result = deleteUser_result()
94 ashish 3032 
    try:
559 chandransh 3033 
      result.success = self._handler.deleteUser(args.userId)
3034 
    except UserContextException, ucex:
3035 
      result.ucex = ucex
3036 
    oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
94 ashish 3037 
    result.write(oprot)
3038 
    oprot.writeMessageEnd()
3039 
    oprot.trans.flush()
3040 
 
559 chandransh 3041 
  def process_getUserState(self, seqid, iprot, oprot):
3042 
    args = getUserState_args()
94 ashish 3043 
    args.read(iprot)
3044 
    iprot.readMessageEnd()
559 chandransh 3045 
    result = getUserState_result()
94 ashish 3046 
    try:
559 chandransh 3047 
      result.success = self._handler.getUserState(args.userId)
3048 
    except UserContextException, ucex:
3049 
      result.ucex = ucex
3050 
    oprot.writeMessageBegin("getUserState", TMessageType.REPLY, seqid)
94 ashish 3051 
    result.write(oprot)
3052 
    oprot.writeMessageEnd()
3053 
    oprot.trans.flush()
3054 
 
122 ashish 3055 
  def process_authenticateUser(self, seqid, iprot, oprot):
3056 
    args = authenticateUser_args()
3057 
    args.read(iprot)
3058 
    iprot.readMessageEnd()
3059 
    result = authenticateUser_result()
3060 
    try:
559 chandransh 3061 
      result.success = self._handler.authenticateUser(args.email, args.password)
3062 
    except AuthenticationException, auex:
3063 
      result.auex = auex
122 ashish 3064 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
3065 
    result.write(oprot)
3066 
    oprot.writeMessageEnd()
3067 
    oprot.trans.flush()
3068 
 
94 ashish 3069 
  def process_userExists(self, seqid, iprot, oprot):
3070 
    args = userExists_args()
3071 
    args.read(iprot)
3072 
    iprot.readMessageEnd()
3073 
    result = userExists_result()
3074 
    try:
3075 
      result.success = self._handler.userExists(args.email)
3076 
    except UserContextException, ucx:
3077 
      result.ucx = ucx
3078 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
3079 
    result.write(oprot)
3080 
    oprot.writeMessageEnd()
3081 
    oprot.trans.flush()
3082 
 
3083 
  def process_addAddressForUser(self, seqid, iprot, oprot):
3084 
    args = addAddressForUser_args()
3085 
    args.read(iprot)
3086 
    iprot.readMessageEnd()
3087 
    result = addAddressForUser_result()
3088 
    try:
567 rajveer 3089 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 3090 
    except UserContextException, ucx:
3091 
      result.ucx = ucx
3092 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
3093 
    result.write(oprot)
3094 
    oprot.writeMessageEnd()
3095 
    oprot.trans.flush()
3096 
 
3097 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
3098 
    args = removeAddressForUser_args()
3099 
    args.read(iprot)
3100 
    iprot.readMessageEnd()
3101 
    result = removeAddressForUser_result()
3102 
    try:
3103 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
3104 
    except UserContextException, ucx:
3105 
      result.ucx = ucx
3106 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
3107 
    result.write(oprot)
3108 
    oprot.writeMessageEnd()
3109 
    oprot.trans.flush()
3110 
 
3111 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
3112 
    args = setUserAsLoggedIn_args()
3113 
    args.read(iprot)
3114 
    iprot.readMessageEnd()
3115 
    result = setUserAsLoggedIn_result()
3116 
    try:
3117 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
3118 
    except UserContextException, ucx:
3119 
      result.ucx = ucx
3120 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
3121 
    result.write(oprot)
3122 
    oprot.writeMessageEnd()
3123 
    oprot.trans.flush()
3124 
 
3125 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
3126 
    args = setUserAsLoggedOut_args()
3127 
    args.read(iprot)
3128 
    iprot.readMessageEnd()
3129 
    result = setUserAsLoggedOut_result()
3130 
    try:
3131 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
3132 
    except UserContextException, ucx:
3133 
      result.ucx = ucx
3134 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
3135 
    result.write(oprot)
3136 
    oprot.writeMessageEnd()
3137 
    oprot.trans.flush()
3138 
 
504 rajveer 3139 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
3140 
    args = setDefaultAddress_args()
3141 
    args.read(iprot)
3142 
    iprot.readMessageEnd()
3143 
    result = setDefaultAddress_result()
3144 
    try:
3145 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
3146 
    except UserContextException, ucx:
3147 
      result.ucx = ucx
3148 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
3149 
    result.write(oprot)
3150 
    oprot.writeMessageEnd()
3151 
    oprot.trans.flush()
3152 
 
94 ashish 3153 
  def process_updatePassword(self, seqid, iprot, oprot):
3154 
    args = updatePassword_args()
3155 
    args.read(iprot)
3156 
    iprot.readMessageEnd()
3157 
    result = updatePassword_result()
3158 
    try:
594 rajveer 3159 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 3160 
    except UserContextException, ucx:
3161 
      result.ucx = ucx
3162 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
3163 
    result.write(oprot)
3164 
    oprot.writeMessageEnd()
3165 
    oprot.trans.flush()
3166 
 
581 rajveer 3167 
  def process_forgotPassword(self, seqid, iprot, oprot):
3168 
    args = forgotPassword_args()
3169 
    args.read(iprot)
3170 
    iprot.readMessageEnd()
3171 
    result = forgotPassword_result()
3172 
    try:
884 rajveer 3173 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 3174 
    except UserContextException, ucx:
3175 
      result.ucx = ucx
3176 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
3177 
    result.write(oprot)
3178 
    oprot.writeMessageEnd()
3179 
    oprot.trans.flush()
3180 
 
594 rajveer 3181 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
3182 
    args = getAllAddressesForUser_args()
3183 
    args.read(iprot)
3184 
    iprot.readMessageEnd()
3185 
    result = getAllAddressesForUser_result()
3186 
    try:
3187 
      result.success = self._handler.getAllAddressesForUser(args.userId)
3188 
    except UserContextException, ucx:
3189 
      result.ucx = ucx
3190 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
3191 
    result.write(oprot)
3192 
    oprot.writeMessageEnd()
3193 
    oprot.trans.flush()
3194 
 
1894 vikas 3195 
  def process_getAddressById(self, seqid, iprot, oprot):
3196 
    args = getAddressById_args()
3197 
    args.read(iprot)
3198 
    iprot.readMessageEnd()
3199 
    result = getAddressById_result()
3200 
    try:
3201 
      result.success = self._handler.getAddressById(args.addressId)
3202 
    except UserContextException, ucx:
3203 
      result.ucx = ucx
3204 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
3205 
    result.write(oprot)
3206 
    oprot.writeMessageEnd()
3207 
    oprot.trans.flush()
3208 
 
594 rajveer 3209 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
3210 
    args = getDefaultAddressId_args()
3211 
    args.read(iprot)
3212 
    iprot.readMessageEnd()
3213 
    result = getDefaultAddressId_result()
3214 
    try:
3215 
      result.success = self._handler.getDefaultAddressId(args.userId)
3216 
    except UserContextException, ucx:
3217 
      result.ucx = ucx
3218 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
3219 
    result.write(oprot)
3220 
    oprot.writeMessageEnd()
3221 
    oprot.trans.flush()
3222 
 
785 rajveer 3223 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
3224 
    args = getDefaultPincode_args()
3225 
    args.read(iprot)
3226 
    iprot.readMessageEnd()
3227 
    result = getDefaultPincode_result()
3228 
    try:
3229 
      result.success = self._handler.getDefaultPincode(args.userId)
3230 
    except UserContextException, ucx:
3231 
      result.ucx = ucx
3232 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
3233 
    result.write(oprot)
3234 
    oprot.writeMessageEnd()
3235 
    oprot.trans.flush()
3236 
 
1274 varun.gupt 3237 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
3238 
    args = saveUserCommunication_args()
3239 
    args.read(iprot)
3240 
    iprot.readMessageEnd()
3241 
    result = saveUserCommunication_result()
3242 
    try:
3243 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
3244 
    except UserCommunicationException, ucx:
3245 
      result.ucx = ucx
3246 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
3247 
    result.write(oprot)
3248 
    oprot.writeMessageEnd()
3249 
    oprot.trans.flush()
3250 
 
1590 varun.gupt 3251 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
3252 
    args = getUserCommunicationById_args()
3253 
    args.read(iprot)
3254 
    iprot.readMessageEnd()
3255 
    result = getUserCommunicationById_result()
3256 
    try:
3257 
      result.success = self._handler.getUserCommunicationById(args.id)
3258 
    except UserCommunicationException, ucx:
3259 
      result.ucx = ucx
3260 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
3261 
    result.write(oprot)
3262 
    oprot.writeMessageEnd()
3263 
    oprot.trans.flush()
3264 
 
3265 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
3266 
    args = getUserCommunicationByUser_args()
3267 
    args.read(iprot)
3268 
    iprot.readMessageEnd()
3269 
    result = getUserCommunicationByUser_result()
3270 
    try:
3271 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
3272 
    except UserCommunicationException, ucx:
3273 
      result.ucx = ucx
3274 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
3275 
    result.write(oprot)
3276 
    oprot.writeMessageEnd()
3277 
    oprot.trans.flush()
3278 
 
3279 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
3280 
    args = getAllUserCommunications_args()
3281 
    args.read(iprot)
3282 
    iprot.readMessageEnd()
3283 
    result = getAllUserCommunications_result()
3284 
    try:
3285 
      result.success = self._handler.getAllUserCommunications()
3286 
    except UserCommunicationException, ucx:
3287 
      result.ucx = ucx
3288 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
3289 
    result.write(oprot)
3290 
    oprot.writeMessageEnd()
3291 
    oprot.trans.flush()
3292 
 
1845 vikas 3293 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
3294 
    args = createMasterAffiliate_args()
3295 
    args.read(iprot)
3296 
    iprot.readMessageEnd()
3297 
    result = createMasterAffiliate_result()
3298 
    try:
1859 vikas 3299 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 3300 
    except UserAffiliateException, utx:
1845 vikas 3301 
      result.utx = utx
3302 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
3303 
    result.write(oprot)
3304 
    oprot.writeMessageEnd()
3305 
    oprot.trans.flush()
3306 
 
1899 vikas 3307 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
3308 
    args = getAllMasterAffiliates_args()
3309 
    args.read(iprot)
3310 
    iprot.readMessageEnd()
3311 
    result = getAllMasterAffiliates_result()
3312 
    try:
3313 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 3314 
    except UserAffiliateException, utx:
1899 vikas 3315 
      result.utx = utx
3316 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
3317 
    result.write(oprot)
3318 
    oprot.writeMessageEnd()
3319 
    oprot.trans.flush()
3320 
 
1845 vikas 3321 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
3322 
    args = getMasterAffiliateById_args()
3323 
    args.read(iprot)
3324 
    iprot.readMessageEnd()
3325 
    result = getMasterAffiliateById_result()
3326 
    try:
3327 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 3328 
    except UserAffiliateException, utx:
1845 vikas 3329 
      result.utx = utx
3330 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
3331 
    result.write(oprot)
3332 
    oprot.writeMessageEnd()
3333 
    oprot.trans.flush()
3334 
 
3335 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
3336 
    args = getMasterAffiliateByName_args()
3337 
    args.read(iprot)
3338 
    iprot.readMessageEnd()
3339 
    result = getMasterAffiliateByName_result()
3340 
    try:
3341 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 3342 
    except UserAffiliateException, utx:
1845 vikas 3343 
      result.utx = utx
3344 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
3345 
    result.write(oprot)
3346 
    oprot.writeMessageEnd()
3347 
    oprot.trans.flush()
3348 
 
3349 
  def process_createAffiliate(self, seqid, iprot, oprot):
3350 
    args = createAffiliate_args()
3351 
    args.read(iprot)
3352 
    iprot.readMessageEnd()
3353 
    result = createAffiliate_result()
3354 
    try:
1859 vikas 3355 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 3356 
    except UserAffiliateException, utx:
1845 vikas 3357 
      result.utx = utx
3358 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
3359 
    result.write(oprot)
3360 
    oprot.writeMessageEnd()
3361 
    oprot.trans.flush()
3362 
 
3363 
  def process_getAffiliateById(self, seqid, iprot, oprot):
3364 
    args = getAffiliateById_args()
3365 
    args.read(iprot)
3366 
    iprot.readMessageEnd()
3367 
    result = getAffiliateById_result()
3368 
    try:
3369 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 3370 
    except UserAffiliateException, utx:
1845 vikas 3371 
      result.utx = utx
3372 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
3373 
    result.write(oprot)
3374 
    oprot.writeMessageEnd()
3375 
    oprot.trans.flush()
3376 
 
3377 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
3378 
    args = getAffiliateByName_args()
3379 
    args.read(iprot)
3380 
    iprot.readMessageEnd()
3381 
    result = getAffiliateByName_result()
3382 
    try:
3383 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 3384 
    except UserAffiliateException, utx:
1845 vikas 3385 
      result.utx = utx
3386 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
3387 
    result.write(oprot)
3388 
    oprot.writeMessageEnd()
3389 
    oprot.trans.flush()
3390 
 
3391 
  def process_getTrackerById(self, seqid, iprot, oprot):
3392 
    args = getTrackerById_args()
3393 
    args.read(iprot)
3394 
    iprot.readMessageEnd()
3395 
    result = getTrackerById_result()
3396 
    try:
1996 vikas 3397 
      result.success = self._handler.getTrackerById(args.id)
3398 
    except UserAffiliateException, utx:
1845 vikas 3399 
      result.utx = utx
3400 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
3401 
    result.write(oprot)
3402 
    oprot.writeMessageEnd()
3403 
    oprot.trans.flush()
3404 
 
1996 vikas 3405 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
3406 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 3407 
    args.read(iprot)
3408 
    iprot.readMessageEnd()
1996 vikas 3409 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 3410 
    try:
1996 vikas 3411 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
3412 
    except UserAffiliateException, utx:
1845 vikas 3413 
      result.utx = utx
1996 vikas 3414 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3415 
    result.write(oprot)
3416 
    oprot.writeMessageEnd()
3417 
    oprot.trans.flush()
3418 
 
3419 
  def process_addTrackLog(self, seqid, iprot, oprot):
3420 
    args = addTrackLog_args()
3421 
    args.read(iprot)
3422 
    iprot.readMessageEnd()
3423 
    result = addTrackLog_result()
3424 
    try:
1996 vikas 3425 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
3426 
    except UserAffiliateException, utx:
1845 vikas 3427 
      result.utx = utx
3428 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
3429 
    result.write(oprot)
3430 
    oprot.writeMessageEnd()
3431 
    oprot.trans.flush()
3432 
 
3433 
  def process_getTrackLogById(self, seqid, iprot, oprot):
3434 
    args = getTrackLogById_args()
3435 
    args.read(iprot)
3436 
    iprot.readMessageEnd()
3437 
    result = getTrackLogById_result()
3438 
    try:
3439 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 3440 
    except UserAffiliateException, utx:
1845 vikas 3441 
      result.utx = utx
3442 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
3443 
    result.write(oprot)
3444 
    oprot.writeMessageEnd()
3445 
    oprot.trans.flush()
3446 
 
1996 vikas 3447 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
3448 
    args = getTrackLogsByAffiliate_args()
1845 vikas 3449 
    args.read(iprot)
3450 
    iprot.readMessageEnd()
1996 vikas 3451 
    result = getTrackLogsByAffiliate_result()
1845 vikas 3452 
    try:
1996 vikas 3453 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId)
3454 
    except UserAffiliateException, utx:
1845 vikas 3455 
      result.utx = utx
1996 vikas 3456 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3457 
    result.write(oprot)
3458 
    oprot.writeMessageEnd()
3459 
    oprot.trans.flush()
3460 
 
3461 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
3462 
    args = getTrackLogsByUser_args()
3463 
    args.read(iprot)
3464 
    iprot.readMessageEnd()
3465 
    result = getTrackLogsByUser_result()
3466 
    try:
3467 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 3468 
    except UserAffiliateException, utx:
1845 vikas 3469 
      result.utx = utx
3470 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
3471 
    result.write(oprot)
3472 
    oprot.writeMessageEnd()
3473 
    oprot.trans.flush()
3474 
 
3475 
  def process_getTrackLogs(self, seqid, iprot, oprot):
3476 
    args = getTrackLogs_args()
3477 
    args.read(iprot)
3478 
    iprot.readMessageEnd()
3479 
    result = getTrackLogs_result()
3480 
    try:
1996 vikas 3481 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
3482 
    except UserAffiliateException, utx:
1845 vikas 3483 
      result.utx = utx
3484 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
3485 
    result.write(oprot)
3486 
    oprot.writeMessageEnd()
3487 
    oprot.trans.flush()
3488 
 
559 chandransh 3489 
  def process_createCart(self, seqid, iprot, oprot):
3490 
    args = createCart_args()
94 ashish 3491 
    args.read(iprot)
3492 
    iprot.readMessageEnd()
559 chandransh 3493 
    result = createCart_result()
94 ashish 3494 
    try:
559 chandransh 3495 
      result.success = self._handler.createCart(args.userId)
3496 
    except ShoppingCartException, scx:
3497 
      result.scx = scx
3498 
    oprot.writeMessageBegin("createCart", TMessageType.REPLY, seqid)
94 ashish 3499 
    result.write(oprot)
3500 
    oprot.writeMessageEnd()
3501 
    oprot.trans.flush()
3502 
 
559 chandransh 3503 
  def process_getCurrentCart(self, seqid, iprot, oprot):
3504 
    args = getCurrentCart_args()
94 ashish 3505 
    args.read(iprot)
3506 
    iprot.readMessageEnd()
559 chandransh 3507 
    result = getCurrentCart_result()
94 ashish 3508 
    try:
559 chandransh 3509 
      result.success = self._handler.getCurrentCart(args.userId)
3510 
    except ShoppingCartException, scx:
3511 
      result.scx = scx
3512 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 3513 
    result.write(oprot)
3514 
    oprot.writeMessageEnd()
3515 
    oprot.trans.flush()
3516 
 
559 chandransh 3517 
  def process_getCart(self, seqid, iprot, oprot):
3518 
    args = getCart_args()
94 ashish 3519 
    args.read(iprot)
3520 
    iprot.readMessageEnd()
559 chandransh 3521 
    result = getCart_result()
94 ashish 3522 
    try:
559 chandransh 3523 
      result.success = self._handler.getCart(args.cartId)
3524 
    except ShoppingCartException, scx:
3525 
      result.scx = scx
3526 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 3527 
    result.write(oprot)
3528 
    oprot.writeMessageEnd()
3529 
    oprot.trans.flush()
3530 
 
559 chandransh 3531 
  def process_getCartsForUser(self, seqid, iprot, oprot):
3532 
    args = getCartsForUser_args()
94 ashish 3533 
    args.read(iprot)
3534 
    iprot.readMessageEnd()
559 chandransh 3535 
    result = getCartsForUser_result()
94 ashish 3536 
    try:
559 chandransh 3537 
      result.success = self._handler.getCartsForUser(args.userId, args.status)
3538 
    except ShoppingCartException, scx:
3539 
      result.scx = scx
3540 
    oprot.writeMessageBegin("getCartsForUser", TMessageType.REPLY, seqid)
94 ashish 3541 
    result.write(oprot)
3542 
    oprot.writeMessageEnd()
3543 
    oprot.trans.flush()
3544 
 
559 chandransh 3545 
  def process_getCartsByStatus(self, seqid, iprot, oprot):
3546 
    args = getCartsByStatus_args()
94 ashish 3547 
    args.read(iprot)
3548 
    iprot.readMessageEnd()
559 chandransh 3549 
    result = getCartsByStatus_result()
94 ashish 3550 
    try:
559 chandransh 3551 
      result.success = self._handler.getCartsByStatus(args.status)
3552 
    except ShoppingCartException, scx:
3553 
      result.scx = scx
3554 
    oprot.writeMessageBegin("getCartsByStatus", TMessageType.REPLY, seqid)
94 ashish 3555 
    result.write(oprot)
3556 
    oprot.writeMessageEnd()
3557 
    oprot.trans.flush()
3558 
 
559 chandransh 3559 
  def process_getCartsByTime(self, seqid, iprot, oprot):
3560 
    args = getCartsByTime_args()
94 ashish 3561 
    args.read(iprot)
3562 
    iprot.readMessageEnd()
559 chandransh 3563 
    result = getCartsByTime_result()
94 ashish 3564 
    try:
559 chandransh 3565 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
3566 
    except ShoppingCartException, scx:
3567 
      result.scx = scx
3568 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 3569 
    result.write(oprot)
3570 
    oprot.writeMessageEnd()
3571 
    oprot.trans.flush()
3572 
 
559 chandransh 3573 
  def process_changeCartStatus(self, seqid, iprot, oprot):
3574 
    args = changeCartStatus_args()
130 ashish 3575 
    args.read(iprot)
3576 
    iprot.readMessageEnd()
559 chandransh 3577 
    result = changeCartStatus_result()
130 ashish 3578 
    try:
559 chandransh 3579 
      self._handler.changeCartStatus(args.cartId, args.status)
3580 
    except ShoppingCartException, scx:
3581 
      result.scx = scx
3582 
    oprot.writeMessageBegin("changeCartStatus", TMessageType.REPLY, seqid)
130 ashish 3583 
    result.write(oprot)
3584 
    oprot.writeMessageEnd()
3585 
    oprot.trans.flush()
94 ashish 3586 
 
559 chandransh 3587 
  def process_addItemToCart(self, seqid, iprot, oprot):
3588 
    args = addItemToCart_args()
130 ashish 3589 
    args.read(iprot)
3590 
    iprot.readMessageEnd()
559 chandransh 3591 
    result = addItemToCart_result()
130 ashish 3592 
    try:
2035 rajveer 3593 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity)
559 chandransh 3594 
    except ShoppingCartException, scx:
3595 
      result.scx = scx
3596 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 3597 
    result.write(oprot)
3598 
    oprot.writeMessageEnd()
3599 
    oprot.trans.flush()
3600 
 
559 chandransh 3601 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
3602 
    args = deleteItemFromCart_args()
3603 
    args.read(iprot)
3604 
    iprot.readMessageEnd()
3605 
    result = deleteItemFromCart_result()
3606 
    try:
3607 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
3608 
    except ShoppingCartException, scx:
3609 
      result.scx = scx
3610 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
3611 
    result.write(oprot)
3612 
    oprot.writeMessageEnd()
3613 
    oprot.trans.flush()
130 ashish 3614 
 
559 chandransh 3615 
  def process_changeQuantity(self, seqid, iprot, oprot):
3616 
    args = changeQuantity_args()
3617 
    args.read(iprot)
3618 
    iprot.readMessageEnd()
3619 
    result = changeQuantity_result()
3620 
    try:
3621 
      self._handler.changeQuantity(args.cartId, args.itemId, args.quantity)
3622 
    except ShoppingCartException, scx:
3623 
      result.scx = scx
3624 
    oprot.writeMessageBegin("changeQuantity", TMessageType.REPLY, seqid)
3625 
    result.write(oprot)
3626 
    oprot.writeMessageEnd()
3627 
    oprot.trans.flush()
3628 
 
3629 
  def process_changeItemStatus(self, seqid, iprot, oprot):
3630 
    args = changeItemStatus_args()
3631 
    args.read(iprot)
3632 
    iprot.readMessageEnd()
3633 
    result = changeItemStatus_result()
3634 
    try:
3635 
      self._handler.changeItemStatus(args.cartId, args.itemId, args.status)
3636 
    except ShoppingCartException, scx:
3637 
      result.scx = scx
3638 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
3639 
    result.write(oprot)
3640 
    oprot.writeMessageEnd()
3641 
    oprot.trans.flush()
3642 
 
3643 
  def process_addAddressToCart(self, seqid, iprot, oprot):
3644 
    args = addAddressToCart_args()
3645 
    args.read(iprot)
3646 
    iprot.readMessageEnd()
3647 
    result = addAddressToCart_result()
575 chandransh 3648 
    try:
3649 
      self._handler.addAddressToCart(args.cartId, args.addressId)
3650 
    except ShoppingCartException, scx:
3651 
      result.scx = scx
559 chandransh 3652 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
3653 
    result.write(oprot)
3654 
    oprot.writeMessageEnd()
3655 
    oprot.trans.flush()
3656 
 
1976 varun.gupt 3657 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
3658 
    args = applyCouponToCart_args()
3659 
    args.read(iprot)
3660 
    iprot.readMessageEnd()
3661 
    result = applyCouponToCart_result()
3662 
    try:
3663 
      self._handler.applyCouponToCart(args.cartId, args.couponCode, args.totalPrice, args.discountedPrice)
3664 
    except ShoppingCartException, scx:
3665 
      result.scx = scx
3666 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
3667 
    result.write(oprot)
3668 
    oprot.writeMessageEnd()
3669 
    oprot.trans.flush()
3670 
 
3671 
  def process_removeCoupon(self, seqid, iprot, oprot):
3672 
    args = removeCoupon_args()
3673 
    args.read(iprot)
3674 
    iprot.readMessageEnd()
3675 
    result = removeCoupon_result()
3676 
    try:
3677 
      self._handler.removeCoupon(args.cartId)
3678 
    except ShoppingCartException, scx:
3679 
      result.scx = scx
3680 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
3681 
    result.write(oprot)
3682 
    oprot.writeMessageEnd()
3683 
    oprot.trans.flush()
3684 
 
690 chandransh 3685 
  def process_createOrders(self, seqid, iprot, oprot):
3686 
    args = createOrders_args()
559 chandransh 3687 
    args.read(iprot)
3688 
    iprot.readMessageEnd()
690 chandransh 3689 
    result = createOrders_result()
559 chandransh 3690 
    try:
690 chandransh 3691 
      result.success = self._handler.createOrders(args.cartId)
559 chandransh 3692 
    except ShoppingCartException, scx:
3693 
      result.scx = scx
690 chandransh 3694 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 3695 
    result.write(oprot)
3696 
    oprot.writeMessageEnd()
3697 
    oprot.trans.flush()
3698 
 
3699 
  def process_validateCart(self, seqid, iprot, oprot):
3700 
    args = validateCart_args()
3701 
    args.read(iprot)
3702 
    iprot.readMessageEnd()
3703 
    result = validateCart_result()
575 chandransh 3704 
    try:
3705 
      result.success = self._handler.validateCart(args.cartId)
3706 
    except ShoppingCartException, scex:
3707 
      result.scex = scex
559 chandransh 3708 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
3709 
    result.write(oprot)
3710 
    oprot.writeMessageEnd()
3711 
    oprot.trans.flush()
3712 
 
690 chandransh 3713 
  def process_mergeCart(self, seqid, iprot, oprot):
3714 
    args = mergeCart_args()
575 chandransh 3715 
    args.read(iprot)
3716 
    iprot.readMessageEnd()
690 chandransh 3717 
    result = mergeCart_result()
3718 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
3719 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
3720 
    result.write(oprot)
3721 
    oprot.writeMessageEnd()
3722 
    oprot.trans.flush()
3723 
 
3724 
  def process_checkOut(self, seqid, iprot, oprot):
3725 
    args = checkOut_args()
3726 
    args.read(iprot)
3727 
    iprot.readMessageEnd()
3728 
    result = checkOut_result()
575 chandransh 3729 
    try:
690 chandransh 3730 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 3731 
    except ShoppingCartException, scex:
3732 
      result.scex = scex
690 chandransh 3733 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 3734 
    result.write(oprot)
3735 
    oprot.writeMessageEnd()
3736 
    oprot.trans.flush()
3737 
 
690 chandransh 3738 
  def process_resetCart(self, seqid, iprot, oprot):
3739 
    args = resetCart_args()
559 chandransh 3740 
    args.read(iprot)
3741 
    iprot.readMessageEnd()
690 chandransh 3742 
    result = resetCart_result()
3743 
    try:
3744 
      result.success = self._handler.resetCart(args.cartId, args.items)
3745 
    except ShoppingCartException, scex:
3746 
      result.scex = scex
3747 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 3748 
    result.write(oprot)
3749 
    oprot.writeMessageEnd()
3750 
    oprot.trans.flush()
3751 
 
3752 
  def process_getMyResearch(self, seqid, iprot, oprot):
3753 
    args = getMyResearch_args()
3754 
    args.read(iprot)
3755 
    iprot.readMessageEnd()
3756 
    result = getMyResearch_result()
3757 
    try:
772 rajveer 3758 
      result.success = self._handler.getMyResearch(args.userId)
559 chandransh 3759 
    except WidgetException, scx:
3760 
      result.scx = scx
3761 
    oprot.writeMessageBegin("getMyResearch", TMessageType.REPLY, seqid)
3762 
    result.write(oprot)
3763 
    oprot.writeMessageEnd()
3764 
    oprot.trans.flush()
3765 
 
3766 
  def process_updateMyResearch(self, seqid, iprot, oprot):
3767 
    args = updateMyResearch_args()
3768 
    args.read(iprot)
3769 
    iprot.readMessageEnd()
3770 
    result = updateMyResearch_result()
3771 
    try:
772 rajveer 3772 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
559 chandransh 3773 
    except WidgetException, scx:
3774 
      result.scx = scx
3775 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
3776 
    result.write(oprot)
3777 
    oprot.writeMessageEnd()
3778 
    oprot.trans.flush()
3779 
 
3780 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
3781 
    args = deleteItemFromMyResearch_args()
3782 
    args.read(iprot)
3783 
    iprot.readMessageEnd()
3784 
    result = deleteItemFromMyResearch_result()
3785 
    try:
772 rajveer 3786 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
559 chandransh 3787 
    except WidgetException, scx:
3788 
      result.scx = scx
3789 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
3790 
    result.write(oprot)
3791 
    oprot.writeMessageEnd()
3792 
    oprot.trans.flush()
3793 
 
3794 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
3795 
    args = updateBrowseHistory_args()
3796 
    args.read(iprot)
3797 
    iprot.readMessageEnd()
3798 
    result = updateBrowseHistory_result()
772 rajveer 3799 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
559 chandransh 3800 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
3801 
    result.write(oprot)
3802 
    oprot.writeMessageEnd()
3803 
    oprot.trans.flush()
3804 
 
3805 
  def process_getBrowseHistory(self, seqid, iprot, oprot):
3806 
    args = getBrowseHistory_args()
3807 
    args.read(iprot)
3808 
    iprot.readMessageEnd()
3809 
    result = getBrowseHistory_result()
3810 
    try:
772 rajveer 3811 
      result.success = self._handler.getBrowseHistory(args.userId)
559 chandransh 3812 
    except WidgetException, scx:
3813 
      result.scx = scx
3814 
    oprot.writeMessageBegin("getBrowseHistory", TMessageType.REPLY, seqid)
3815 
    result.write(oprot)
3816 
    oprot.writeMessageEnd()
3817 
    oprot.trans.flush()
3818 
 
772 rajveer 3819 
  def process_mergeBrowseHistory(self, seqid, iprot, oprot):
3820 
    args = mergeBrowseHistory_args()
3821 
    args.read(iprot)
3822 
    iprot.readMessageEnd()
3823 
    result = mergeBrowseHistory_result()
3824 
    self._handler.mergeBrowseHistory(args.fromUserId, args.toUserId)
3825 
    oprot.writeMessageBegin("mergeBrowseHistory", TMessageType.REPLY, seqid)
3826 
    result.write(oprot)
3827 
    oprot.writeMessageEnd()
3828 
    oprot.trans.flush()
559 chandransh 3829 
 
1596 ankur.sing 3830 
  def process_getUserCount(self, seqid, iprot, oprot):
3831 
    args = getUserCount_args()
3832 
    args.read(iprot)
3833 
    iprot.readMessageEnd()
3834 
    result = getUserCount_result()
3835 
    result.success = self._handler.getUserCount(args.userType)
3836 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
3837 
    result.write(oprot)
3838 
    oprot.writeMessageEnd()
3839 
    oprot.trans.flush()
772 rajveer 3840 
 
1673 ankur.sing 3841 
  def process_getAllUsers(self, seqid, iprot, oprot):
3842 
    args = getAllUsers_args()
3843 
    args.read(iprot)
3844 
    iprot.readMessageEnd()
3845 
    result = getAllUsers_result()
1891 ankur.sing 3846 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
1673 ankur.sing 3847 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
3848 
    result.write(oprot)
3849 
    oprot.writeMessageEnd()
3850 
    oprot.trans.flush()
1596 ankur.sing 3851 
 
2642 varun.gupt 3852 
  def process_putUserNote(self, seqid, iprot, oprot):
3853 
    args = putUserNote_args()
3854 
    args.read(iprot)
3855 
    iprot.readMessageEnd()
3856 
    result = putUserNote_result()
2717 varun.gupt 3857 
    self._handler.putUserNote(args.user_id, args.entity_id, args.slide, args.note)
2642 varun.gupt 3858 
    oprot.writeMessageBegin("putUserNote", TMessageType.REPLY, seqid)
3859 
    result.write(oprot)
3860 
    oprot.writeMessageEnd()
3861 
    oprot.trans.flush()
1673 ankur.sing 3862 
 
2642 varun.gupt 3863 
  def process_getUserNotes(self, seqid, iprot, oprot):
3864 
    args = getUserNotes_args()
3865 
    args.read(iprot)
3866 
    iprot.readMessageEnd()
3867 
    result = getUserNotes_result()
3868 
    result.success = self._handler.getUserNotes(args.user_id, args.entity_id)
3869 
    oprot.writeMessageBegin("getUserNotes", TMessageType.REPLY, seqid)
3870 
    result.write(oprot)
3871 
    oprot.writeMessageEnd()
3872 
    oprot.trans.flush()
3873 
 
3874 
 
94 ashish 3875 
# HELPER FUNCTIONS AND STRUCTURES
3876 
 
765 rajveer 3877 
class closeSession_args:
3878 
 
3879 
  thrift_spec = (
3880 
  )
3881 
 
3882 
  def read(self, iprot):
3883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3885 
      return
3886 
    iprot.readStructBegin()
3887 
    while True:
3888 
      (fname, ftype, fid) = iprot.readFieldBegin()
3889 
      if ftype == TType.STOP:
3890 
        break
3891 
      else:
3892 
        iprot.skip(ftype)
3893 
      iprot.readFieldEnd()
3894 
    iprot.readStructEnd()
3895 
 
3896 
  def write(self, oprot):
3897 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3898 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3899 
      return
3900 
    oprot.writeStructBegin('closeSession_args')
3901 
    oprot.writeFieldStop()
3902 
    oprot.writeStructEnd()
3903 
 
3904 
  def __repr__(self):
3905 
    L = ['%s=%r' % (key, value)
3906 
      for key, value in self.__dict__.iteritems()]
3907 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3908 
 
3909 
  def __eq__(self, other):
3910 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3911 
 
3912 
  def __ne__(self, other):
3913 
    return not (self == other)
3914 
 
3915 
class closeSession_result:
3916 
 
3917 
  thrift_spec = (
3918 
  )
3919 
 
3920 
  def read(self, iprot):
3921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3923 
      return
3924 
    iprot.readStructBegin()
3925 
    while True:
3926 
      (fname, ftype, fid) = iprot.readFieldBegin()
3927 
      if ftype == TType.STOP:
3928 
        break
3929 
      else:
3930 
        iprot.skip(ftype)
3931 
      iprot.readFieldEnd()
3932 
    iprot.readStructEnd()
3933 
 
3934 
  def write(self, oprot):
3935 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3936 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3937 
      return
3938 
    oprot.writeStructBegin('closeSession_result')
3939 
    oprot.writeFieldStop()
3940 
    oprot.writeStructEnd()
3941 
 
3942 
  def __repr__(self):
3943 
    L = ['%s=%r' % (key, value)
3944 
      for key, value in self.__dict__.iteritems()]
3945 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3946 
 
3947 
  def __eq__(self, other):
3948 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3949 
 
3950 
  def __ne__(self, other):
3951 
    return not (self == other)
3952 
 
559 chandransh 3953 
class createAnonymousUser_args:
94 ashish 3954 
  """
3955 
  Attributes:
559 chandransh 3956 
   - jsessionId
94 ashish 3957 
  """
3958 
 
3959 
  thrift_spec = (
3960 
    None, # 0
559 chandransh 3961 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 3962 
  )
3963 
 
559 chandransh 3964 
  def __init__(self, jsessionId=None,):
3965 
    self.jsessionId = jsessionId
94 ashish 3966 
 
3967 
  def read(self, iprot):
3968 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3969 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3970 
      return
3971 
    iprot.readStructBegin()
3972 
    while True:
3973 
      (fname, ftype, fid) = iprot.readFieldBegin()
3974 
      if ftype == TType.STOP:
3975 
        break
3976 
      if fid == 1:
559 chandransh 3977 
        if ftype == TType.STRING:
3978 
          self.jsessionId = iprot.readString();
94 ashish 3979 
        else:
3980 
          iprot.skip(ftype)
3981 
      else:
3982 
        iprot.skip(ftype)
3983 
      iprot.readFieldEnd()
3984 
    iprot.readStructEnd()
3985 
 
3986 
  def write(self, oprot):
3987 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3988 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3989 
      return
559 chandransh 3990 
    oprot.writeStructBegin('createAnonymousUser_args')
3991 
    if self.jsessionId != None:
3992 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
3993 
      oprot.writeString(self.jsessionId)
94 ashish 3994 
      oprot.writeFieldEnd()
3995 
    oprot.writeFieldStop()
3996 
    oprot.writeStructEnd()
3997 
 
3998 
  def __repr__(self):
3999 
    L = ['%s=%r' % (key, value)
4000 
      for key, value in self.__dict__.iteritems()]
4001 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4002 
 
4003 
  def __eq__(self, other):
4004 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4005 
 
4006 
  def __ne__(self, other):
4007 
    return not (self == other)
4008 
 
559 chandransh 4009 
class createAnonymousUser_result:
94 ashish 4010 
  """
4011 
  Attributes:
4012 
   - success
559 chandransh 4013 
   - ucex
94 ashish 4014 
  """
4015 
 
4016 
  thrift_spec = (
559 chandransh 4017 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4018 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4019 
  )
4020 
 
559 chandransh 4021 
  def __init__(self, success=None, ucex=None,):
94 ashish 4022 
    self.success = success
559 chandransh 4023 
    self.ucex = ucex
94 ashish 4024 
 
4025 
  def read(self, iprot):
4026 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4027 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4028 
      return
4029 
    iprot.readStructBegin()
4030 
    while True:
4031 
      (fname, ftype, fid) = iprot.readFieldBegin()
4032 
      if ftype == TType.STOP:
4033 
        break
4034 
      if fid == 0:
4035 
        if ftype == TType.STRUCT:
559 chandransh 4036 
          self.success = User()
94 ashish 4037 
          self.success.read(iprot)
4038 
        else:
4039 
          iprot.skip(ftype)
4040 
      elif fid == 1:
4041 
        if ftype == TType.STRUCT:
559 chandransh 4042 
          self.ucex = UserContextException()
4043 
          self.ucex.read(iprot)
94 ashish 4044 
        else:
4045 
          iprot.skip(ftype)
4046 
      else:
4047 
        iprot.skip(ftype)
4048 
      iprot.readFieldEnd()
4049 
    iprot.readStructEnd()
4050 
 
4051 
  def write(self, oprot):
4052 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4053 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4054 
      return
559 chandransh 4055 
    oprot.writeStructBegin('createAnonymousUser_result')
94 ashish 4056 
    if self.success != None:
4057 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4058 
      self.success.write(oprot)
4059 
      oprot.writeFieldEnd()
559 chandransh 4060 
    if self.ucex != None:
4061 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4062 
      self.ucex.write(oprot)
94 ashish 4063 
      oprot.writeFieldEnd()
4064 
    oprot.writeFieldStop()
4065 
    oprot.writeStructEnd()
4066 
 
4067 
  def __repr__(self):
4068 
    L = ['%s=%r' % (key, value)
4069 
      for key, value in self.__dict__.iteritems()]
4070 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4071 
 
4072 
  def __eq__(self, other):
4073 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4074 
 
4075 
  def __ne__(self, other):
4076 
    return not (self == other)
4077 
 
559 chandransh 4078 
class getUserById_args:
94 ashish 4079 
  """
4080 
  Attributes:
4081 
   - userId
4082 
  """
4083 
 
4084 
  thrift_spec = (
4085 
    None, # 0
4086 
    (1, TType.I64, 'userId', None, None, ), # 1
4087 
  )
4088 
 
559 chandransh 4089 
  def __init__(self, userId=None,):
94 ashish 4090 
    self.userId = userId
4091 
 
4092 
  def read(self, iprot):
4093 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4094 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4095 
      return
4096 
    iprot.readStructBegin()
4097 
    while True:
4098 
      (fname, ftype, fid) = iprot.readFieldBegin()
4099 
      if ftype == TType.STOP:
4100 
        break
4101 
      if fid == 1:
4102 
        if ftype == TType.I64:
4103 
          self.userId = iprot.readI64();
4104 
        else:
4105 
          iprot.skip(ftype)
4106 
      else:
4107 
        iprot.skip(ftype)
4108 
      iprot.readFieldEnd()
4109 
    iprot.readStructEnd()
4110 
 
4111 
  def write(self, oprot):
4112 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4113 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4114 
      return
559 chandransh 4115 
    oprot.writeStructBegin('getUserById_args')
94 ashish 4116 
    if self.userId != None:
4117 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4118 
      oprot.writeI64(self.userId)
4119 
      oprot.writeFieldEnd()
4120 
    oprot.writeFieldStop()
4121 
    oprot.writeStructEnd()
4122 
 
4123 
  def __repr__(self):
4124 
    L = ['%s=%r' % (key, value)
4125 
      for key, value in self.__dict__.iteritems()]
4126 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4127 
 
4128 
  def __eq__(self, other):
4129 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4130 
 
4131 
  def __ne__(self, other):
4132 
    return not (self == other)
4133 
 
559 chandransh 4134 
class getUserById_result:
94 ashish 4135 
  """
4136 
  Attributes:
4137 
   - success
559 chandransh 4138 
   - ucex
94 ashish 4139 
  """
4140 
 
4141 
  thrift_spec = (
559 chandransh 4142 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4143 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4144 
  )
4145 
 
559 chandransh 4146 
  def __init__(self, success=None, ucex=None,):
94 ashish 4147 
    self.success = success
559 chandransh 4148 
    self.ucex = ucex
94 ashish 4149 
 
4150 
  def read(self, iprot):
4151 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4152 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4153 
      return
4154 
    iprot.readStructBegin()
4155 
    while True:
4156 
      (fname, ftype, fid) = iprot.readFieldBegin()
4157 
      if ftype == TType.STOP:
4158 
        break
4159 
      if fid == 0:
4160 
        if ftype == TType.STRUCT:
559 chandransh 4161 
          self.success = User()
94 ashish 4162 
          self.success.read(iprot)
4163 
        else:
4164 
          iprot.skip(ftype)
4165 
      elif fid == 1:
4166 
        if ftype == TType.STRUCT:
559 chandransh 4167 
          self.ucex = UserContextException()
4168 
          self.ucex.read(iprot)
94 ashish 4169 
        else:
4170 
          iprot.skip(ftype)
4171 
      else:
4172 
        iprot.skip(ftype)
4173 
      iprot.readFieldEnd()
4174 
    iprot.readStructEnd()
4175 
 
4176 
  def write(self, oprot):
4177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4179 
      return
559 chandransh 4180 
    oprot.writeStructBegin('getUserById_result')
94 ashish 4181 
    if self.success != None:
4182 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4183 
      self.success.write(oprot)
4184 
      oprot.writeFieldEnd()
559 chandransh 4185 
    if self.ucex != None:
4186 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4187 
      self.ucex.write(oprot)
94 ashish 4188 
      oprot.writeFieldEnd()
4189 
    oprot.writeFieldStop()
4190 
    oprot.writeStructEnd()
4191 
 
4192 
  def __repr__(self):
4193 
    L = ['%s=%r' % (key, value)
4194 
      for key, value in self.__dict__.iteritems()]
4195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4196 
 
4197 
  def __eq__(self, other):
4198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4199 
 
4200 
  def __ne__(self, other):
4201 
    return not (self == other)
4202 
 
1491 vikas 4203 
class getUserByEmail_args:
4204 
  """
4205 
  Attributes:
4206 
   - email
4207 
  """
4208 
 
4209 
  thrift_spec = (
4210 
    None, # 0
4211 
    (1, TType.STRING, 'email', None, None, ), # 1
4212 
  )
4213 
 
4214 
  def __init__(self, email=None,):
4215 
    self.email = email
4216 
 
4217 
  def read(self, iprot):
4218 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4219 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4220 
      return
4221 
    iprot.readStructBegin()
4222 
    while True:
4223 
      (fname, ftype, fid) = iprot.readFieldBegin()
4224 
      if ftype == TType.STOP:
4225 
        break
4226 
      if fid == 1:
4227 
        if ftype == TType.STRING:
4228 
          self.email = iprot.readString();
4229 
        else:
4230 
          iprot.skip(ftype)
4231 
      else:
4232 
        iprot.skip(ftype)
4233 
      iprot.readFieldEnd()
4234 
    iprot.readStructEnd()
4235 
 
4236 
  def write(self, oprot):
4237 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4238 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4239 
      return
4240 
    oprot.writeStructBegin('getUserByEmail_args')
4241 
    if self.email != None:
4242 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4243 
      oprot.writeString(self.email)
4244 
      oprot.writeFieldEnd()
4245 
    oprot.writeFieldStop()
4246 
    oprot.writeStructEnd()
4247 
 
4248 
  def __repr__(self):
4249 
    L = ['%s=%r' % (key, value)
4250 
      for key, value in self.__dict__.iteritems()]
4251 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4252 
 
4253 
  def __eq__(self, other):
4254 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4255 
 
4256 
  def __ne__(self, other):
4257 
    return not (self == other)
4258 
 
4259 
class getUserByEmail_result:
4260 
  """
4261 
  Attributes:
4262 
   - success
4263 
   - ucex
4264 
  """
4265 
 
4266 
  thrift_spec = (
4267 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4268 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4269 
  )
4270 
 
4271 
  def __init__(self, success=None, ucex=None,):
4272 
    self.success = success
4273 
    self.ucex = ucex
4274 
 
4275 
  def read(self, iprot):
4276 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4277 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4278 
      return
4279 
    iprot.readStructBegin()
4280 
    while True:
4281 
      (fname, ftype, fid) = iprot.readFieldBegin()
4282 
      if ftype == TType.STOP:
4283 
        break
4284 
      if fid == 0:
4285 
        if ftype == TType.STRUCT:
4286 
          self.success = User()
4287 
          self.success.read(iprot)
4288 
        else:
4289 
          iprot.skip(ftype)
4290 
      elif fid == 1:
4291 
        if ftype == TType.STRUCT:
4292 
          self.ucex = UserContextException()
4293 
          self.ucex.read(iprot)
4294 
        else:
4295 
          iprot.skip(ftype)
4296 
      else:
4297 
        iprot.skip(ftype)
4298 
      iprot.readFieldEnd()
4299 
    iprot.readStructEnd()
4300 
 
4301 
  def write(self, oprot):
4302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4304 
      return
4305 
    oprot.writeStructBegin('getUserByEmail_result')
4306 
    if self.success != None:
4307 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4308 
      self.success.write(oprot)
4309 
      oprot.writeFieldEnd()
4310 
    if self.ucex != None:
4311 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4312 
      self.ucex.write(oprot)
4313 
      oprot.writeFieldEnd()
4314 
    oprot.writeFieldStop()
4315 
    oprot.writeStructEnd()
4316 
 
4317 
  def __repr__(self):
4318 
    L = ['%s=%r' % (key, value)
4319 
      for key, value in self.__dict__.iteritems()]
4320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4321 
 
4322 
  def __eq__(self, other):
4323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4324 
 
4325 
  def __ne__(self, other):
4326 
    return not (self == other)
4327 
 
559 chandransh 4328 
class createUser_args:
94 ashish 4329 
  """
4330 
  Attributes:
559 chandransh 4331 
   - user
94 ashish 4332 
  """
4333 
 
4334 
  thrift_spec = (
4335 
    None, # 0
559 chandransh 4336 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4337 
  )
4338 
 
559 chandransh 4339 
  def __init__(self, user=None,):
4340 
    self.user = user
94 ashish 4341 
 
4342 
  def read(self, iprot):
4343 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4344 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4345 
      return
4346 
    iprot.readStructBegin()
4347 
    while True:
4348 
      (fname, ftype, fid) = iprot.readFieldBegin()
4349 
      if ftype == TType.STOP:
4350 
        break
4351 
      if fid == 1:
559 chandransh 4352 
        if ftype == TType.STRUCT:
4353 
          self.user = User()
4354 
          self.user.read(iprot)
94 ashish 4355 
        else:
4356 
          iprot.skip(ftype)
4357 
      else:
4358 
        iprot.skip(ftype)
4359 
      iprot.readFieldEnd()
4360 
    iprot.readStructEnd()
4361 
 
4362 
  def write(self, oprot):
4363 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4364 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4365 
      return
559 chandransh 4366 
    oprot.writeStructBegin('createUser_args')
4367 
    if self.user != None:
4368 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4369 
      self.user.write(oprot)
94 ashish 4370 
      oprot.writeFieldEnd()
4371 
    oprot.writeFieldStop()
4372 
    oprot.writeStructEnd()
4373 
 
4374 
  def __repr__(self):
4375 
    L = ['%s=%r' % (key, value)
4376 
      for key, value in self.__dict__.iteritems()]
4377 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4378 
 
4379 
  def __eq__(self, other):
4380 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4381 
 
4382 
  def __ne__(self, other):
4383 
    return not (self == other)
4384 
 
559 chandransh 4385 
class createUser_result:
94 ashish 4386 
  """
4387 
  Attributes:
4388 
   - success
559 chandransh 4389 
   - ucex
94 ashish 4390 
  """
4391 
 
4392 
  thrift_spec = (
559 chandransh 4393 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4394 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4395 
  )
4396 
 
559 chandransh 4397 
  def __init__(self, success=None, ucex=None,):
94 ashish 4398 
    self.success = success
559 chandransh 4399 
    self.ucex = ucex
94 ashish 4400 
 
4401 
  def read(self, iprot):
4402 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4403 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4404 
      return
4405 
    iprot.readStructBegin()
4406 
    while True:
4407 
      (fname, ftype, fid) = iprot.readFieldBegin()
4408 
      if ftype == TType.STOP:
4409 
        break
4410 
      if fid == 0:
4411 
        if ftype == TType.STRUCT:
559 chandransh 4412 
          self.success = User()
94 ashish 4413 
          self.success.read(iprot)
4414 
        else:
4415 
          iprot.skip(ftype)
4416 
      elif fid == 1:
4417 
        if ftype == TType.STRUCT:
559 chandransh 4418 
          self.ucex = UserContextException()
4419 
          self.ucex.read(iprot)
94 ashish 4420 
        else:
4421 
          iprot.skip(ftype)
4422 
      else:
4423 
        iprot.skip(ftype)
4424 
      iprot.readFieldEnd()
4425 
    iprot.readStructEnd()
4426 
 
4427 
  def write(self, oprot):
4428 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4429 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4430 
      return
559 chandransh 4431 
    oprot.writeStructBegin('createUser_result')
94 ashish 4432 
    if self.success != None:
4433 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4434 
      self.success.write(oprot)
4435 
      oprot.writeFieldEnd()
559 chandransh 4436 
    if self.ucex != None:
4437 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4438 
      self.ucex.write(oprot)
94 ashish 4439 
      oprot.writeFieldEnd()
4440 
    oprot.writeFieldStop()
4441 
    oprot.writeStructEnd()
4442 
 
4443 
  def __repr__(self):
4444 
    L = ['%s=%r' % (key, value)
4445 
      for key, value in self.__dict__.iteritems()]
4446 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4447 
 
4448 
  def __eq__(self, other):
4449 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4450 
 
4451 
  def __ne__(self, other):
4452 
    return not (self == other)
4453 
 
559 chandransh 4454 
class updateUser_args:
94 ashish 4455 
  """
4456 
  Attributes:
559 chandransh 4457 
   - user
94 ashish 4458 
  """
4459 
 
4460 
  thrift_spec = (
4461 
    None, # 0
559 chandransh 4462 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4463 
  )
4464 
 
559 chandransh 4465 
  def __init__(self, user=None,):
4466 
    self.user = user
94 ashish 4467 
 
4468 
  def read(self, iprot):
4469 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4470 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4471 
      return
4472 
    iprot.readStructBegin()
4473 
    while True:
4474 
      (fname, ftype, fid) = iprot.readFieldBegin()
4475 
      if ftype == TType.STOP:
4476 
        break
4477 
      if fid == 1:
559 chandransh 4478 
        if ftype == TType.STRUCT:
4479 
          self.user = User()
4480 
          self.user.read(iprot)
94 ashish 4481 
        else:
4482 
          iprot.skip(ftype)
4483 
      else:
4484 
        iprot.skip(ftype)
4485 
      iprot.readFieldEnd()
4486 
    iprot.readStructEnd()
4487 
 
4488 
  def write(self, oprot):
4489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4491 
      return
559 chandransh 4492 
    oprot.writeStructBegin('updateUser_args')
4493 
    if self.user != None:
4494 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4495 
      self.user.write(oprot)
94 ashish 4496 
      oprot.writeFieldEnd()
4497 
    oprot.writeFieldStop()
4498 
    oprot.writeStructEnd()
4499 
 
4500 
  def __repr__(self):
4501 
    L = ['%s=%r' % (key, value)
4502 
      for key, value in self.__dict__.iteritems()]
4503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4504 
 
4505 
  def __eq__(self, other):
4506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4507 
 
4508 
  def __ne__(self, other):
4509 
    return not (self == other)
4510 
 
559 chandransh 4511 
class updateUser_result:
94 ashish 4512 
  """
4513 
  Attributes:
4514 
   - success
559 chandransh 4515 
   - ucex
94 ashish 4516 
  """
4517 
 
4518 
  thrift_spec = (
559 chandransh 4519 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4520 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4521 
  )
4522 
 
559 chandransh 4523 
  def __init__(self, success=None, ucex=None,):
94 ashish 4524 
    self.success = success
559 chandransh 4525 
    self.ucex = ucex
94 ashish 4526 
 
4527 
  def read(self, iprot):
4528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4530 
      return
4531 
    iprot.readStructBegin()
4532 
    while True:
4533 
      (fname, ftype, fid) = iprot.readFieldBegin()
4534 
      if ftype == TType.STOP:
4535 
        break
4536 
      if fid == 0:
4537 
        if ftype == TType.STRUCT:
559 chandransh 4538 
          self.success = User()
94 ashish 4539 
          self.success.read(iprot)
4540 
        else:
4541 
          iprot.skip(ftype)
4542 
      elif fid == 1:
4543 
        if ftype == TType.STRUCT:
559 chandransh 4544 
          self.ucex = UserContextException()
4545 
          self.ucex.read(iprot)
94 ashish 4546 
        else:
4547 
          iprot.skip(ftype)
4548 
      else:
4549 
        iprot.skip(ftype)
4550 
      iprot.readFieldEnd()
4551 
    iprot.readStructEnd()
4552 
 
4553 
  def write(self, oprot):
4554 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4555 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4556 
      return
559 chandransh 4557 
    oprot.writeStructBegin('updateUser_result')
94 ashish 4558 
    if self.success != None:
4559 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4560 
      self.success.write(oprot)
4561 
      oprot.writeFieldEnd()
559 chandransh 4562 
    if self.ucex != None:
4563 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4564 
      self.ucex.write(oprot)
94 ashish 4565 
      oprot.writeFieldEnd()
4566 
    oprot.writeFieldStop()
4567 
    oprot.writeStructEnd()
4568 
 
4569 
  def __repr__(self):
4570 
    L = ['%s=%r' % (key, value)
4571 
      for key, value in self.__dict__.iteritems()]
4572 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4573 
 
4574 
  def __eq__(self, other):
4575 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4576 
 
4577 
  def __ne__(self, other):
4578 
    return not (self == other)
4579 
 
559 chandransh 4580 
class deleteUser_args:
94 ashish 4581 
  """
4582 
  Attributes:
4583 
   - userId
4584 
  """
4585 
 
4586 
  thrift_spec = (
4587 
    None, # 0
4588 
    (1, TType.I64, 'userId', None, None, ), # 1
4589 
  )
4590 
 
559 chandransh 4591 
  def __init__(self, userId=None,):
94 ashish 4592 
    self.userId = userId
4593 
 
4594 
  def read(self, iprot):
4595 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4596 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4597 
      return
4598 
    iprot.readStructBegin()
4599 
    while True:
4600 
      (fname, ftype, fid) = iprot.readFieldBegin()
4601 
      if ftype == TType.STOP:
4602 
        break
4603 
      if fid == 1:
4604 
        if ftype == TType.I64:
4605 
          self.userId = iprot.readI64();
4606 
        else:
4607 
          iprot.skip(ftype)
4608 
      else:
4609 
        iprot.skip(ftype)
4610 
      iprot.readFieldEnd()
4611 
    iprot.readStructEnd()
4612 
 
4613 
  def write(self, oprot):
4614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4616 
      return
559 chandransh 4617 
    oprot.writeStructBegin('deleteUser_args')
94 ashish 4618 
    if self.userId != None:
4619 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4620 
      oprot.writeI64(self.userId)
4621 
      oprot.writeFieldEnd()
4622 
    oprot.writeFieldStop()
4623 
    oprot.writeStructEnd()
4624 
 
4625 
  def __repr__(self):
4626 
    L = ['%s=%r' % (key, value)
4627 
      for key, value in self.__dict__.iteritems()]
4628 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4629 
 
4630 
  def __eq__(self, other):
4631 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4632 
 
4633 
  def __ne__(self, other):
4634 
    return not (self == other)
4635 
 
559 chandransh 4636 
class deleteUser_result:
94 ashish 4637 
  """
4638 
  Attributes:
4639 
   - success
559 chandransh 4640 
   - ucex
94 ashish 4641 
  """
4642 
 
4643 
  thrift_spec = (
559 chandransh 4644 
    (0, TType.BOOL, 'success', None, None, ), # 0
4645 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4646 
  )
4647 
 
559 chandransh 4648 
  def __init__(self, success=None, ucex=None,):
94 ashish 4649 
    self.success = success
559 chandransh 4650 
    self.ucex = ucex
94 ashish 4651 
 
4652 
  def read(self, iprot):
4653 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4654 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4655 
      return
4656 
    iprot.readStructBegin()
4657 
    while True:
4658 
      (fname, ftype, fid) = iprot.readFieldBegin()
4659 
      if ftype == TType.STOP:
4660 
        break
4661 
      if fid == 0:
559 chandransh 4662 
        if ftype == TType.BOOL:
4663 
          self.success = iprot.readBool();
94 ashish 4664 
        else:
4665 
          iprot.skip(ftype)
4666 
      elif fid == 1:
4667 
        if ftype == TType.STRUCT:
559 chandransh 4668 
          self.ucex = UserContextException()
4669 
          self.ucex.read(iprot)
94 ashish 4670 
        else:
4671 
          iprot.skip(ftype)
4672 
      else:
4673 
        iprot.skip(ftype)
4674 
      iprot.readFieldEnd()
4675 
    iprot.readStructEnd()
4676 
 
4677 
  def write(self, oprot):
4678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4680 
      return
559 chandransh 4681 
    oprot.writeStructBegin('deleteUser_result')
94 ashish 4682 
    if self.success != None:
559 chandransh 4683 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4684 
      oprot.writeBool(self.success)
94 ashish 4685 
      oprot.writeFieldEnd()
559 chandransh 4686 
    if self.ucex != None:
4687 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4688 
      self.ucex.write(oprot)
94 ashish 4689 
      oprot.writeFieldEnd()
4690 
    oprot.writeFieldStop()
4691 
    oprot.writeStructEnd()
4692 
 
4693 
  def __repr__(self):
4694 
    L = ['%s=%r' % (key, value)
4695 
      for key, value in self.__dict__.iteritems()]
4696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4697 
 
4698 
  def __eq__(self, other):
4699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4700 
 
4701 
  def __ne__(self, other):
4702 
    return not (self == other)
4703 
 
559 chandransh 4704 
class getUserState_args:
94 ashish 4705 
  """
4706 
  Attributes:
4707 
   - userId
4708 
  """
4709 
 
4710 
  thrift_spec = (
4711 
    None, # 0
4712 
    (1, TType.I64, 'userId', None, None, ), # 1
4713 
  )
4714 
 
559 chandransh 4715 
  def __init__(self, userId=None,):
94 ashish 4716 
    self.userId = userId
4717 
 
4718 
  def read(self, iprot):
4719 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4720 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4721 
      return
4722 
    iprot.readStructBegin()
4723 
    while True:
4724 
      (fname, ftype, fid) = iprot.readFieldBegin()
4725 
      if ftype == TType.STOP:
4726 
        break
4727 
      if fid == 1:
4728 
        if ftype == TType.I64:
4729 
          self.userId = iprot.readI64();
4730 
        else:
4731 
          iprot.skip(ftype)
4732 
      else:
4733 
        iprot.skip(ftype)
4734 
      iprot.readFieldEnd()
4735 
    iprot.readStructEnd()
4736 
 
4737 
  def write(self, oprot):
4738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4740 
      return
559 chandransh 4741 
    oprot.writeStructBegin('getUserState_args')
94 ashish 4742 
    if self.userId != None:
4743 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4744 
      oprot.writeI64(self.userId)
4745 
      oprot.writeFieldEnd()
4746 
    oprot.writeFieldStop()
4747 
    oprot.writeStructEnd()
4748 
 
4749 
  def __repr__(self):
4750 
    L = ['%s=%r' % (key, value)
4751 
      for key, value in self.__dict__.iteritems()]
4752 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4753 
 
4754 
  def __eq__(self, other):
4755 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4756 
 
4757 
  def __ne__(self, other):
4758 
    return not (self == other)
4759 
 
559 chandransh 4760 
class getUserState_result:
94 ashish 4761 
  """
4762 
  Attributes:
4763 
   - success
559 chandransh 4764 
   - ucex
94 ashish 4765 
  """
4766 
 
4767 
  thrift_spec = (
559 chandransh 4768 
    (0, TType.STRUCT, 'success', (UserState, UserState.thrift_spec), None, ), # 0
4769 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4770 
  )
4771 
 
559 chandransh 4772 
  def __init__(self, success=None, ucex=None,):
94 ashish 4773 
    self.success = success
559 chandransh 4774 
    self.ucex = ucex
94 ashish 4775 
 
4776 
  def read(self, iprot):
4777 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4778 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4779 
      return
4780 
    iprot.readStructBegin()
4781 
    while True:
4782 
      (fname, ftype, fid) = iprot.readFieldBegin()
4783 
      if ftype == TType.STOP:
4784 
        break
4785 
      if fid == 0:
4786 
        if ftype == TType.STRUCT:
559 chandransh 4787 
          self.success = UserState()
94 ashish 4788 
          self.success.read(iprot)
4789 
        else:
4790 
          iprot.skip(ftype)
4791 
      elif fid == 1:
4792 
        if ftype == TType.STRUCT:
559 chandransh 4793 
          self.ucex = UserContextException()
4794 
          self.ucex.read(iprot)
94 ashish 4795 
        else:
4796 
          iprot.skip(ftype)
4797 
      else:
4798 
        iprot.skip(ftype)
4799 
      iprot.readFieldEnd()
4800 
    iprot.readStructEnd()
4801 
 
4802 
  def write(self, oprot):
4803 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4804 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4805 
      return
559 chandransh 4806 
    oprot.writeStructBegin('getUserState_result')
94 ashish 4807 
    if self.success != None:
4808 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4809 
      self.success.write(oprot)
4810 
      oprot.writeFieldEnd()
559 chandransh 4811 
    if self.ucex != None:
4812 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4813 
      self.ucex.write(oprot)
94 ashish 4814 
      oprot.writeFieldEnd()
4815 
    oprot.writeFieldStop()
4816 
    oprot.writeStructEnd()
4817 
 
4818 
  def __repr__(self):
4819 
    L = ['%s=%r' % (key, value)
4820 
      for key, value in self.__dict__.iteritems()]
4821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4822 
 
4823 
  def __eq__(self, other):
4824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4825 
 
4826 
  def __ne__(self, other):
4827 
    return not (self == other)
4828 
 
559 chandransh 4829 
class authenticateUser_args:
94 ashish 4830 
  """
4831 
  Attributes:
4832 
   - email
4833 
   - password
4834 
  """
4835 
 
4836 
  thrift_spec = (
4837 
    None, # 0
4838 
    (1, TType.STRING, 'email', None, None, ), # 1
4839 
    (2, TType.STRING, 'password', None, None, ), # 2
4840 
  )
4841 
 
4842 
  def __init__(self, email=None, password=None,):
4843 
    self.email = email
4844 
    self.password = password
4845 
 
4846 
  def read(self, iprot):
4847 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4848 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4849 
      return
4850 
    iprot.readStructBegin()
4851 
    while True:
4852 
      (fname, ftype, fid) = iprot.readFieldBegin()
4853 
      if ftype == TType.STOP:
4854 
        break
4855 
      if fid == 1:
4856 
        if ftype == TType.STRING:
4857 
          self.email = iprot.readString();
4858 
        else:
4859 
          iprot.skip(ftype)
4860 
      elif fid == 2:
4861 
        if ftype == TType.STRING:
4862 
          self.password = iprot.readString();
4863 
        else:
4864 
          iprot.skip(ftype)
4865 
      else:
4866 
        iprot.skip(ftype)
4867 
      iprot.readFieldEnd()
4868 
    iprot.readStructEnd()
4869 
 
4870 
  def write(self, oprot):
4871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4873 
      return
559 chandransh 4874 
    oprot.writeStructBegin('authenticateUser_args')
94 ashish 4875 
    if self.email != None:
4876 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4877 
      oprot.writeString(self.email)
4878 
      oprot.writeFieldEnd()
4879 
    if self.password != None:
4880 
      oprot.writeFieldBegin('password', TType.STRING, 2)
4881 
      oprot.writeString(self.password)
4882 
      oprot.writeFieldEnd()
4883 
    oprot.writeFieldStop()
4884 
    oprot.writeStructEnd()
4885 
 
4886 
  def __repr__(self):
4887 
    L = ['%s=%r' % (key, value)
4888 
      for key, value in self.__dict__.iteritems()]
4889 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4890 
 
4891 
  def __eq__(self, other):
4892 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4893 
 
4894 
  def __ne__(self, other):
4895 
    return not (self == other)
4896 
 
559 chandransh 4897 
class authenticateUser_result:
94 ashish 4898 
  """
4899 
  Attributes:
4900 
   - success
559 chandransh 4901 
   - auex
94 ashish 4902 
  """
4903 
 
4904 
  thrift_spec = (
559 chandransh 4905 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4906 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 4907 
  )
4908 
 
559 chandransh 4909 
  def __init__(self, success=None, auex=None,):
94 ashish 4910 
    self.success = success
559 chandransh 4911 
    self.auex = auex
94 ashish 4912 
 
4913 
  def read(self, iprot):
4914 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4915 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4916 
      return
4917 
    iprot.readStructBegin()
4918 
    while True:
4919 
      (fname, ftype, fid) = iprot.readFieldBegin()
4920 
      if ftype == TType.STOP:
4921 
        break
4922 
      if fid == 0:
4923 
        if ftype == TType.STRUCT:
559 chandransh 4924 
          self.success = User()
94 ashish 4925 
          self.success.read(iprot)
4926 
        else:
4927 
          iprot.skip(ftype)
4928 
      elif fid == 1:
4929 
        if ftype == TType.STRUCT:
559 chandransh 4930 
          self.auex = AuthenticationException()
4931 
          self.auex.read(iprot)
94 ashish 4932 
        else:
4933 
          iprot.skip(ftype)
4934 
      else:
4935 
        iprot.skip(ftype)
4936 
      iprot.readFieldEnd()
4937 
    iprot.readStructEnd()
4938 
 
4939 
  def write(self, oprot):
4940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4942 
      return
559 chandransh 4943 
    oprot.writeStructBegin('authenticateUser_result')
94 ashish 4944 
    if self.success != None:
4945 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4946 
      self.success.write(oprot)
4947 
      oprot.writeFieldEnd()
559 chandransh 4948 
    if self.auex != None:
4949 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
4950 
      self.auex.write(oprot)
94 ashish 4951 
      oprot.writeFieldEnd()
4952 
    oprot.writeFieldStop()
4953 
    oprot.writeStructEnd()
4954 
 
4955 
  def __repr__(self):
4956 
    L = ['%s=%r' % (key, value)
4957 
      for key, value in self.__dict__.iteritems()]
4958 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4959 
 
4960 
  def __eq__(self, other):
4961 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4962 
 
4963 
  def __ne__(self, other):
4964 
    return not (self == other)
4965 
 
559 chandransh 4966 
class userExists_args:
122 ashish 4967 
  """
4968 
  Attributes:
559 chandransh 4969 
   - email
122 ashish 4970 
  """
4971 
 
4972 
  thrift_spec = (
4973 
    None, # 0
559 chandransh 4974 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 4975 
  )
4976 
 
559 chandransh 4977 
  def __init__(self, email=None,):
4978 
    self.email = email
122 ashish 4979 
 
4980 
  def read(self, iprot):
4981 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4982 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4983 
      return
4984 
    iprot.readStructBegin()
4985 
    while True:
4986 
      (fname, ftype, fid) = iprot.readFieldBegin()
4987 
      if ftype == TType.STOP:
4988 
        break
4989 
      if fid == 1:
4990 
        if ftype == TType.STRING:
559 chandransh 4991 
          self.email = iprot.readString();
122 ashish 4992 
        else:
4993 
          iprot.skip(ftype)
559 chandransh 4994 
      else:
4995 
        iprot.skip(ftype)
4996 
      iprot.readFieldEnd()
4997 
    iprot.readStructEnd()
4998 
 
4999 
  def write(self, oprot):
5000 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5001 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5002 
      return
5003 
    oprot.writeStructBegin('userExists_args')
5004 
    if self.email != None:
5005 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5006 
      oprot.writeString(self.email)
5007 
      oprot.writeFieldEnd()
5008 
    oprot.writeFieldStop()
5009 
    oprot.writeStructEnd()
5010 
 
5011 
  def __repr__(self):
5012 
    L = ['%s=%r' % (key, value)
5013 
      for key, value in self.__dict__.iteritems()]
5014 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5015 
 
5016 
  def __eq__(self, other):
5017 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5018 
 
5019 
  def __ne__(self, other):
5020 
    return not (self == other)
5021 
 
5022 
class userExists_result:
5023 
  """
5024 
  Attributes:
5025 
   - success
5026 
   - ucx
5027 
  """
5028 
 
5029 
  thrift_spec = (
5030 
    (0, TType.BOOL, 'success', None, None, ), # 0
5031 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5032 
  )
5033 
 
5034 
  def __init__(self, success=None, ucx=None,):
5035 
    self.success = success
5036 
    self.ucx = ucx
5037 
 
5038 
  def read(self, iprot):
5039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5041 
      return
5042 
    iprot.readStructBegin()
5043 
    while True:
5044 
      (fname, ftype, fid) = iprot.readFieldBegin()
5045 
      if ftype == TType.STOP:
5046 
        break
5047 
      if fid == 0:
5048 
        if ftype == TType.BOOL:
5049 
          self.success = iprot.readBool();
5050 
        else:
5051 
          iprot.skip(ftype)
5052 
      elif fid == 1:
5053 
        if ftype == TType.STRUCT:
5054 
          self.ucx = UserContextException()
5055 
          self.ucx.read(iprot)
5056 
        else:
5057 
          iprot.skip(ftype)
5058 
      else:
5059 
        iprot.skip(ftype)
5060 
      iprot.readFieldEnd()
5061 
    iprot.readStructEnd()
5062 
 
5063 
  def write(self, oprot):
5064 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5065 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5066 
      return
5067 
    oprot.writeStructBegin('userExists_result')
5068 
    if self.success != None:
5069 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5070 
      oprot.writeBool(self.success)
5071 
      oprot.writeFieldEnd()
5072 
    if self.ucx != None:
5073 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5074 
      self.ucx.write(oprot)
5075 
      oprot.writeFieldEnd()
5076 
    oprot.writeFieldStop()
5077 
    oprot.writeStructEnd()
5078 
 
5079 
  def __repr__(self):
5080 
    L = ['%s=%r' % (key, value)
5081 
      for key, value in self.__dict__.iteritems()]
5082 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5083 
 
5084 
  def __eq__(self, other):
5085 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5086 
 
5087 
  def __ne__(self, other):
5088 
    return not (self == other)
5089 
 
5090 
class addAddressForUser_args:
5091 
  """
5092 
  Attributes:
5093 
   - userId
5094 
   - address
5095 
   - setDefault
5096 
  """
5097 
 
5098 
  thrift_spec = (
5099 
    None, # 0
5100 
    (1, TType.I64, 'userId', None, None, ), # 1
5101 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 5102 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 5103 
  )
5104 
 
567 rajveer 5105 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 5106 
    self.userId = userId
5107 
    self.address = address
5108 
    self.setDefault = setDefault
5109 
 
5110 
  def read(self, iprot):
5111 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5112 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5113 
      return
5114 
    iprot.readStructBegin()
5115 
    while True:
5116 
      (fname, ftype, fid) = iprot.readFieldBegin()
5117 
      if ftype == TType.STOP:
5118 
        break
5119 
      if fid == 1:
5120 
        if ftype == TType.I64:
5121 
          self.userId = iprot.readI64();
5122 
        else:
5123 
          iprot.skip(ftype)
122 ashish 5124 
      elif fid == 2:
559 chandransh 5125 
        if ftype == TType.STRUCT:
5126 
          self.address = Address()
5127 
          self.address.read(iprot)
122 ashish 5128 
        else:
5129 
          iprot.skip(ftype)
5130 
      elif fid == 3:
5131 
        if ftype == TType.BOOL:
559 chandransh 5132 
          self.setDefault = iprot.readBool();
122 ashish 5133 
        else:
5134 
          iprot.skip(ftype)
5135 
      else:
5136 
        iprot.skip(ftype)
5137 
      iprot.readFieldEnd()
5138 
    iprot.readStructEnd()
5139 
 
5140 
  def write(self, oprot):
5141 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5142 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5143 
      return
559 chandransh 5144 
    oprot.writeStructBegin('addAddressForUser_args')
5145 
    if self.userId != None:
5146 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5147 
      oprot.writeI64(self.userId)
122 ashish 5148 
      oprot.writeFieldEnd()
559 chandransh 5149 
    if self.address != None:
5150 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
5151 
      self.address.write(oprot)
122 ashish 5152 
      oprot.writeFieldEnd()
559 chandransh 5153 
    if self.setDefault != None:
567 rajveer 5154 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 5155 
      oprot.writeBool(self.setDefault)
5156 
      oprot.writeFieldEnd()
122 ashish 5157 
    oprot.writeFieldStop()
5158 
    oprot.writeStructEnd()
5159 
 
5160 
  def __repr__(self):
5161 
    L = ['%s=%r' % (key, value)
5162 
      for key, value in self.__dict__.iteritems()]
5163 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5164 
 
5165 
  def __eq__(self, other):
5166 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5167 
 
5168 
  def __ne__(self, other):
5169 
    return not (self == other)
5170 
 
559 chandransh 5171 
class addAddressForUser_result:
122 ashish 5172 
  """
5173 
  Attributes:
5174 
   - success
559 chandransh 5175 
   - ucx
122 ashish 5176 
  """
5177 
 
5178 
  thrift_spec = (
567 rajveer 5179 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 5180 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 5181 
  )
5182 
 
559 chandransh 5183 
  def __init__(self, success=None, ucx=None,):
122 ashish 5184 
    self.success = success
559 chandransh 5185 
    self.ucx = ucx
122 ashish 5186 
 
5187 
  def read(self, iprot):
5188 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5189 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5190 
      return
5191 
    iprot.readStructBegin()
5192 
    while True:
5193 
      (fname, ftype, fid) = iprot.readFieldBegin()
5194 
      if ftype == TType.STOP:
5195 
        break
5196 
      if fid == 0:
567 rajveer 5197 
        if ftype == TType.I64:
5198 
          self.success = iprot.readI64();
122 ashish 5199 
        else:
5200 
          iprot.skip(ftype)
5201 
      elif fid == 1:
5202 
        if ftype == TType.STRUCT:
559 chandransh 5203 
          self.ucx = UserContextException()
5204 
          self.ucx.read(iprot)
122 ashish 5205 
        else:
5206 
          iprot.skip(ftype)
5207 
      else:
5208 
        iprot.skip(ftype)
5209 
      iprot.readFieldEnd()
5210 
    iprot.readStructEnd()
5211 
 
5212 
  def write(self, oprot):
5213 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5214 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5215 
      return
559 chandransh 5216 
    oprot.writeStructBegin('addAddressForUser_result')
122 ashish 5217 
    if self.success != None:
567 rajveer 5218 
      oprot.writeFieldBegin('success', TType.I64, 0)
5219 
      oprot.writeI64(self.success)
122 ashish 5220 
      oprot.writeFieldEnd()
559 chandransh 5221 
    if self.ucx != None:
5222 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5223 
      self.ucx.write(oprot)
122 ashish 5224 
      oprot.writeFieldEnd()
5225 
    oprot.writeFieldStop()
5226 
    oprot.writeStructEnd()
5227 
 
5228 
  def __repr__(self):
5229 
    L = ['%s=%r' % (key, value)
5230 
      for key, value in self.__dict__.iteritems()]
5231 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5232 
 
5233 
  def __eq__(self, other):
5234 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5235 
 
5236 
  def __ne__(self, other):
5237 
    return not (self == other)
5238 
 
559 chandransh 5239 
class removeAddressForUser_args:
94 ashish 5240 
  """
5241 
  Attributes:
559 chandransh 5242 
   - userid
5243 
   - addressId
94 ashish 5244 
  """
5245 
 
5246 
  thrift_spec = (
5247 
    None, # 0
559 chandransh 5248 
    (1, TType.I64, 'userid', None, None, ), # 1
5249 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 5250 
  )
5251 
 
559 chandransh 5252 
  def __init__(self, userid=None, addressId=None,):
5253 
    self.userid = userid
5254 
    self.addressId = addressId
94 ashish 5255 
 
5256 
  def read(self, iprot):
5257 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5258 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5259 
      return
5260 
    iprot.readStructBegin()
5261 
    while True:
5262 
      (fname, ftype, fid) = iprot.readFieldBegin()
5263 
      if ftype == TType.STOP:
5264 
        break
5265 
      if fid == 1:
559 chandransh 5266 
        if ftype == TType.I64:
5267 
          self.userid = iprot.readI64();
94 ashish 5268 
        else:
5269 
          iprot.skip(ftype)
559 chandransh 5270 
      elif fid == 2:
5271 
        if ftype == TType.I64:
5272 
          self.addressId = iprot.readI64();
5273 
        else:
5274 
          iprot.skip(ftype)
94 ashish 5275 
      else:
5276 
        iprot.skip(ftype)
5277 
      iprot.readFieldEnd()
5278 
    iprot.readStructEnd()
5279 
 
5280 
  def write(self, oprot):
5281 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5282 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5283 
      return
559 chandransh 5284 
    oprot.writeStructBegin('removeAddressForUser_args')
5285 
    if self.userid != None:
5286 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5287 
      oprot.writeI64(self.userid)
94 ashish 5288 
      oprot.writeFieldEnd()
559 chandransh 5289 
    if self.addressId != None:
5290 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5291 
      oprot.writeI64(self.addressId)
5292 
      oprot.writeFieldEnd()
94 ashish 5293 
    oprot.writeFieldStop()
5294 
    oprot.writeStructEnd()
5295 
 
5296 
  def __repr__(self):
5297 
    L = ['%s=%r' % (key, value)
5298 
      for key, value in self.__dict__.iteritems()]
5299 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5300 
 
5301 
  def __eq__(self, other):
5302 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5303 
 
5304 
  def __ne__(self, other):
5305 
    return not (self == other)
5306 
 
559 chandransh 5307 
class removeAddressForUser_result:
94 ashish 5308 
  """
5309 
  Attributes:
5310 
   - success
5311 
   - ucx
5312 
  """
5313 
 
5314 
  thrift_spec = (
5315 
    (0, TType.BOOL, 'success', None, None, ), # 0
5316 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5317 
  )
5318 
 
5319 
  def __init__(self, success=None, ucx=None,):
5320 
    self.success = success
5321 
    self.ucx = ucx
5322 
 
5323 
  def read(self, iprot):
5324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5326 
      return
5327 
    iprot.readStructBegin()
5328 
    while True:
5329 
      (fname, ftype, fid) = iprot.readFieldBegin()
5330 
      if ftype == TType.STOP:
5331 
        break
5332 
      if fid == 0:
5333 
        if ftype == TType.BOOL:
5334 
          self.success = iprot.readBool();
5335 
        else:
5336 
          iprot.skip(ftype)
5337 
      elif fid == 1:
5338 
        if ftype == TType.STRUCT:
5339 
          self.ucx = UserContextException()
5340 
          self.ucx.read(iprot)
5341 
        else:
5342 
          iprot.skip(ftype)
5343 
      else:
5344 
        iprot.skip(ftype)
5345 
      iprot.readFieldEnd()
5346 
    iprot.readStructEnd()
5347 
 
5348 
  def write(self, oprot):
5349 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5350 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5351 
      return
559 chandransh 5352 
    oprot.writeStructBegin('removeAddressForUser_result')
94 ashish 5353 
    if self.success != None:
5354 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5355 
      oprot.writeBool(self.success)
5356 
      oprot.writeFieldEnd()
5357 
    if self.ucx != None:
5358 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5359 
      self.ucx.write(oprot)
5360 
      oprot.writeFieldEnd()
5361 
    oprot.writeFieldStop()
5362 
    oprot.writeStructEnd()
5363 
 
5364 
  def __repr__(self):
5365 
    L = ['%s=%r' % (key, value)
5366 
      for key, value in self.__dict__.iteritems()]
5367 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5368 
 
5369 
  def __eq__(self, other):
5370 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5371 
 
5372 
  def __ne__(self, other):
5373 
    return not (self == other)
5374 
 
559 chandransh 5375 
class setUserAsLoggedIn_args:
94 ashish 5376 
  """
5377 
  Attributes:
559 chandransh 5378 
   - userId
94 ashish 5379 
   - timestamp
5380 
  """
5381 
 
5382 
  thrift_spec = (
5383 
    None, # 0
559 chandransh 5384 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 5385 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5386 
  )
5387 
 
559 chandransh 5388 
  def __init__(self, userId=None, timestamp=None,):
5389 
    self.userId = userId
94 ashish 5390 
    self.timestamp = timestamp
5391 
 
5392 
  def read(self, iprot):
5393 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5394 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5395 
      return
5396 
    iprot.readStructBegin()
5397 
    while True:
5398 
      (fname, ftype, fid) = iprot.readFieldBegin()
5399 
      if ftype == TType.STOP:
5400 
        break
5401 
      if fid == 1:
559 chandransh 5402 
        if ftype == TType.I64:
5403 
          self.userId = iprot.readI64();
94 ashish 5404 
        else:
5405 
          iprot.skip(ftype)
5406 
      elif fid == 2:
5407 
        if ftype == TType.I64:
5408 
          self.timestamp = iprot.readI64();
5409 
        else:
5410 
          iprot.skip(ftype)
5411 
      else:
5412 
        iprot.skip(ftype)
5413 
      iprot.readFieldEnd()
5414 
    iprot.readStructEnd()
5415 
 
5416 
  def write(self, oprot):
5417 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5418 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5419 
      return
559 chandransh 5420 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
5421 
    if self.userId != None:
5422 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5423 
      oprot.writeI64(self.userId)
94 ashish 5424 
      oprot.writeFieldEnd()
5425 
    if self.timestamp != None:
5426 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5427 
      oprot.writeI64(self.timestamp)
5428 
      oprot.writeFieldEnd()
5429 
    oprot.writeFieldStop()
5430 
    oprot.writeStructEnd()
5431 
 
5432 
  def __repr__(self):
5433 
    L = ['%s=%r' % (key, value)
5434 
      for key, value in self.__dict__.iteritems()]
5435 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5436 
 
5437 
  def __eq__(self, other):
5438 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5439 
 
5440 
  def __ne__(self, other):
5441 
    return not (self == other)
5442 
 
559 chandransh 5443 
class setUserAsLoggedIn_result:
94 ashish 5444 
  """
5445 
  Attributes:
5446 
   - success
5447 
   - ucx
5448 
  """
5449 
 
5450 
  thrift_spec = (
5451 
    (0, TType.BOOL, 'success', None, None, ), # 0
5452 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5453 
  )
5454 
 
5455 
  def __init__(self, success=None, ucx=None,):
5456 
    self.success = success
5457 
    self.ucx = ucx
5458 
 
5459 
  def read(self, iprot):
5460 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5461 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5462 
      return
5463 
    iprot.readStructBegin()
5464 
    while True:
5465 
      (fname, ftype, fid) = iprot.readFieldBegin()
5466 
      if ftype == TType.STOP:
5467 
        break
5468 
      if fid == 0:
5469 
        if ftype == TType.BOOL:
5470 
          self.success = iprot.readBool();
5471 
        else:
5472 
          iprot.skip(ftype)
5473 
      elif fid == 1:
5474 
        if ftype == TType.STRUCT:
5475 
          self.ucx = UserContextException()
5476 
          self.ucx.read(iprot)
5477 
        else:
5478 
          iprot.skip(ftype)
5479 
      else:
5480 
        iprot.skip(ftype)
5481 
      iprot.readFieldEnd()
5482 
    iprot.readStructEnd()
5483 
 
5484 
  def write(self, oprot):
5485 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5486 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5487 
      return
559 chandransh 5488 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
94 ashish 5489 
    if self.success != None:
5490 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5491 
      oprot.writeBool(self.success)
5492 
      oprot.writeFieldEnd()
5493 
    if self.ucx != None:
5494 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5495 
      self.ucx.write(oprot)
5496 
      oprot.writeFieldEnd()
5497 
    oprot.writeFieldStop()
5498 
    oprot.writeStructEnd()
5499 
 
5500 
  def __repr__(self):
5501 
    L = ['%s=%r' % (key, value)
5502 
      for key, value in self.__dict__.iteritems()]
5503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5504 
 
5505 
  def __eq__(self, other):
5506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5507 
 
5508 
  def __ne__(self, other):
5509 
    return not (self == other)
5510 
 
559 chandransh 5511 
class setUserAsLoggedOut_args:
94 ashish 5512 
  """
5513 
  Attributes:
5514 
   - userid
5515 
   - timestamp
5516 
  """
5517 
 
5518 
  thrift_spec = (
5519 
    None, # 0
559 chandransh 5520 
    (1, TType.I64, 'userid', None, None, ), # 1
5521 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 5522 
  )
5523 
 
559 chandransh 5524 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 5525 
    self.userid = userid
5526 
    self.timestamp = timestamp
5527 
 
5528 
  def read(self, iprot):
5529 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5530 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5531 
      return
5532 
    iprot.readStructBegin()
5533 
    while True:
5534 
      (fname, ftype, fid) = iprot.readFieldBegin()
5535 
      if ftype == TType.STOP:
5536 
        break
5537 
      if fid == 1:
5538 
        if ftype == TType.I64:
5539 
          self.userid = iprot.readI64();
5540 
        else:
5541 
          iprot.skip(ftype)
559 chandransh 5542 
      elif fid == 2:
94 ashish 5543 
        if ftype == TType.I64:
5544 
          self.timestamp = iprot.readI64();
5545 
        else:
5546 
          iprot.skip(ftype)
5547 
      else:
5548 
        iprot.skip(ftype)
5549 
      iprot.readFieldEnd()
5550 
    iprot.readStructEnd()
5551 
 
5552 
  def write(self, oprot):
5553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5555 
      return
559 chandransh 5556 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
94 ashish 5557 
    if self.userid != None:
559 chandransh 5558 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 5559 
      oprot.writeI64(self.userid)
5560 
      oprot.writeFieldEnd()
5561 
    if self.timestamp != None:
559 chandransh 5562 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 5563 
      oprot.writeI64(self.timestamp)
5564 
      oprot.writeFieldEnd()
5565 
    oprot.writeFieldStop()
5566 
    oprot.writeStructEnd()
5567 
 
5568 
  def __repr__(self):
5569 
    L = ['%s=%r' % (key, value)
5570 
      for key, value in self.__dict__.iteritems()]
5571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5572 
 
5573 
  def __eq__(self, other):
5574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5575 
 
5576 
  def __ne__(self, other):
5577 
    return not (self == other)
5578 
 
559 chandransh 5579 
class setUserAsLoggedOut_result:
94 ashish 5580 
  """
5581 
  Attributes:
5582 
   - success
5583 
   - ucx
5584 
  """
5585 
 
5586 
  thrift_spec = (
5587 
    (0, TType.BOOL, 'success', None, None, ), # 0
5588 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5589 
  )
5590 
 
5591 
  def __init__(self, success=None, ucx=None,):
5592 
    self.success = success
5593 
    self.ucx = ucx
5594 
 
5595 
  def read(self, iprot):
5596 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5597 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5598 
      return
5599 
    iprot.readStructBegin()
5600 
    while True:
5601 
      (fname, ftype, fid) = iprot.readFieldBegin()
5602 
      if ftype == TType.STOP:
5603 
        break
5604 
      if fid == 0:
5605 
        if ftype == TType.BOOL:
5606 
          self.success = iprot.readBool();
5607 
        else:
5608 
          iprot.skip(ftype)
5609 
      elif fid == 1:
5610 
        if ftype == TType.STRUCT:
5611 
          self.ucx = UserContextException()
5612 
          self.ucx.read(iprot)
5613 
        else:
5614 
          iprot.skip(ftype)
5615 
      else:
5616 
        iprot.skip(ftype)
5617 
      iprot.readFieldEnd()
5618 
    iprot.readStructEnd()
5619 
 
5620 
  def write(self, oprot):
5621 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5622 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5623 
      return
559 chandransh 5624 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
94 ashish 5625 
    if self.success != None:
5626 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5627 
      oprot.writeBool(self.success)
5628 
      oprot.writeFieldEnd()
5629 
    if self.ucx != None:
5630 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5631 
      self.ucx.write(oprot)
5632 
      oprot.writeFieldEnd()
5633 
    oprot.writeFieldStop()
5634 
    oprot.writeStructEnd()
5635 
 
5636 
  def __repr__(self):
5637 
    L = ['%s=%r' % (key, value)
5638 
      for key, value in self.__dict__.iteritems()]
5639 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5640 
 
5641 
  def __eq__(self, other):
5642 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5643 
 
5644 
  def __ne__(self, other):
5645 
    return not (self == other)
5646 
 
559 chandransh 5647 
class setDefaultAddress_args:
94 ashish 5648 
  """
5649 
  Attributes:
5650 
   - userid
5651 
   - addressId
5652 
  """
5653 
 
5654 
  thrift_spec = (
5655 
    None, # 0
5656 
    (1, TType.I64, 'userid', None, None, ), # 1
5657 
    (2, TType.I64, 'addressId', None, None, ), # 2
5658 
  )
5659 
 
5660 
  def __init__(self, userid=None, addressId=None,):
5661 
    self.userid = userid
5662 
    self.addressId = addressId
5663 
 
5664 
  def read(self, iprot):
5665 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5666 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5667 
      return
5668 
    iprot.readStructBegin()
5669 
    while True:
5670 
      (fname, ftype, fid) = iprot.readFieldBegin()
5671 
      if ftype == TType.STOP:
5672 
        break
5673 
      if fid == 1:
5674 
        if ftype == TType.I64:
5675 
          self.userid = iprot.readI64();
5676 
        else:
5677 
          iprot.skip(ftype)
5678 
      elif fid == 2:
5679 
        if ftype == TType.I64:
5680 
          self.addressId = iprot.readI64();
5681 
        else:
5682 
          iprot.skip(ftype)
5683 
      else:
5684 
        iprot.skip(ftype)
5685 
      iprot.readFieldEnd()
5686 
    iprot.readStructEnd()
5687 
 
5688 
  def write(self, oprot):
5689 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5690 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5691 
      return
559 chandransh 5692 
    oprot.writeStructBegin('setDefaultAddress_args')
94 ashish 5693 
    if self.userid != None:
5694 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5695 
      oprot.writeI64(self.userid)
5696 
      oprot.writeFieldEnd()
5697 
    if self.addressId != None:
5698 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5699 
      oprot.writeI64(self.addressId)
5700 
      oprot.writeFieldEnd()
5701 
    oprot.writeFieldStop()
5702 
    oprot.writeStructEnd()
5703 
 
5704 
  def __repr__(self):
5705 
    L = ['%s=%r' % (key, value)
5706 
      for key, value in self.__dict__.iteritems()]
5707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5708 
 
5709 
  def __eq__(self, other):
5710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5711 
 
5712 
  def __ne__(self, other):
5713 
    return not (self == other)
5714 
 
559 chandransh 5715 
class setDefaultAddress_result:
94 ashish 5716 
  """
5717 
  Attributes:
5718 
   - success
5719 
   - ucx
5720 
  """
5721 
 
5722 
  thrift_spec = (
5723 
    (0, TType.BOOL, 'success', None, None, ), # 0
5724 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5725 
  )
5726 
 
5727 
  def __init__(self, success=None, ucx=None,):
5728 
    self.success = success
5729 
    self.ucx = ucx
5730 
 
5731 
  def read(self, iprot):
5732 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5733 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5734 
      return
5735 
    iprot.readStructBegin()
5736 
    while True:
5737 
      (fname, ftype, fid) = iprot.readFieldBegin()
5738 
      if ftype == TType.STOP:
5739 
        break
5740 
      if fid == 0:
5741 
        if ftype == TType.BOOL:
5742 
          self.success = iprot.readBool();
5743 
        else:
5744 
          iprot.skip(ftype)
5745 
      elif fid == 1:
5746 
        if ftype == TType.STRUCT:
5747 
          self.ucx = UserContextException()
5748 
          self.ucx.read(iprot)
5749 
        else:
5750 
          iprot.skip(ftype)
5751 
      else:
5752 
        iprot.skip(ftype)
5753 
      iprot.readFieldEnd()
5754 
    iprot.readStructEnd()
5755 
 
5756 
  def write(self, oprot):
5757 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5758 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5759 
      return
559 chandransh 5760 
    oprot.writeStructBegin('setDefaultAddress_result')
94 ashish 5761 
    if self.success != None:
5762 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5763 
      oprot.writeBool(self.success)
5764 
      oprot.writeFieldEnd()
5765 
    if self.ucx != None:
5766 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5767 
      self.ucx.write(oprot)
5768 
      oprot.writeFieldEnd()
5769 
    oprot.writeFieldStop()
5770 
    oprot.writeStructEnd()
5771 
 
5772 
  def __repr__(self):
5773 
    L = ['%s=%r' % (key, value)
5774 
      for key, value in self.__dict__.iteritems()]
5775 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5776 
 
5777 
  def __eq__(self, other):
5778 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5779 
 
5780 
  def __ne__(self, other):
5781 
    return not (self == other)
5782 
 
559 chandransh 5783 
class updatePassword_args:
94 ashish 5784 
  """
5785 
  Attributes:
559 chandransh 5786 
   - userid
594 rajveer 5787 
   - oldPassword
5788 
   - newPassword
94 ashish 5789 
  """
5790 
 
5791 
  thrift_spec = (
5792 
    None, # 0
559 chandransh 5793 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 5794 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
5795 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 5796 
  )
5797 
 
594 rajveer 5798 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 5799 
    self.userid = userid
594 rajveer 5800 
    self.oldPassword = oldPassword
5801 
    self.newPassword = newPassword
94 ashish 5802 
 
5803 
  def read(self, iprot):
5804 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5805 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5806 
      return
5807 
    iprot.readStructBegin()
5808 
    while True:
5809 
      (fname, ftype, fid) = iprot.readFieldBegin()
5810 
      if ftype == TType.STOP:
5811 
        break
5812 
      if fid == 1:
5813 
        if ftype == TType.I64:
559 chandransh 5814 
          self.userid = iprot.readI64();
94 ashish 5815 
        else:
5816 
          iprot.skip(ftype)
5817 
      elif fid == 2:
559 chandransh 5818 
        if ftype == TType.STRING:
594 rajveer 5819 
          self.oldPassword = iprot.readString();
94 ashish 5820 
        else:
5821 
          iprot.skip(ftype)
594 rajveer 5822 
      elif fid == 3:
5823 
        if ftype == TType.STRING:
5824 
          self.newPassword = iprot.readString();
5825 
        else:
5826 
          iprot.skip(ftype)
94 ashish 5827 
      else:
5828 
        iprot.skip(ftype)
5829 
      iprot.readFieldEnd()
5830 
    iprot.readStructEnd()
5831 
 
5832 
  def write(self, oprot):
5833 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5834 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5835 
      return
559 chandransh 5836 
    oprot.writeStructBegin('updatePassword_args')
5837 
    if self.userid != None:
5838 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5839 
      oprot.writeI64(self.userid)
94 ashish 5840 
      oprot.writeFieldEnd()
594 rajveer 5841 
    if self.oldPassword != None:
5842 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
5843 
      oprot.writeString(self.oldPassword)
94 ashish 5844 
      oprot.writeFieldEnd()
594 rajveer 5845 
    if self.newPassword != None:
5846 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
5847 
      oprot.writeString(self.newPassword)
5848 
      oprot.writeFieldEnd()
94 ashish 5849 
    oprot.writeFieldStop()
5850 
    oprot.writeStructEnd()
5851 
 
5852 
  def __repr__(self):
5853 
    L = ['%s=%r' % (key, value)
5854 
      for key, value in self.__dict__.iteritems()]
5855 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5856 
 
5857 
  def __eq__(self, other):
5858 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5859 
 
5860 
  def __ne__(self, other):
5861 
    return not (self == other)
5862 
 
559 chandransh 5863 
class updatePassword_result:
94 ashish 5864 
  """
5865 
  Attributes:
5866 
   - success
5867 
   - ucx
5868 
  """
5869 
 
5870 
  thrift_spec = (
5871 
    (0, TType.BOOL, 'success', None, None, ), # 0
5872 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5873 
  )
5874 
 
5875 
  def __init__(self, success=None, ucx=None,):
5876 
    self.success = success
5877 
    self.ucx = ucx
5878 
 
5879 
  def read(self, iprot):
5880 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5881 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5882 
      return
5883 
    iprot.readStructBegin()
5884 
    while True:
5885 
      (fname, ftype, fid) = iprot.readFieldBegin()
5886 
      if ftype == TType.STOP:
5887 
        break
5888 
      if fid == 0:
5889 
        if ftype == TType.BOOL:
5890 
          self.success = iprot.readBool();
5891 
        else:
5892 
          iprot.skip(ftype)
5893 
      elif fid == 1:
5894 
        if ftype == TType.STRUCT:
5895 
          self.ucx = UserContextException()
5896 
          self.ucx.read(iprot)
5897 
        else:
5898 
          iprot.skip(ftype)
5899 
      else:
5900 
        iprot.skip(ftype)
5901 
      iprot.readFieldEnd()
5902 
    iprot.readStructEnd()
5903 
 
5904 
  def write(self, oprot):
5905 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5906 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5907 
      return
559 chandransh 5908 
    oprot.writeStructBegin('updatePassword_result')
94 ashish 5909 
    if self.success != None:
5910 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5911 
      oprot.writeBool(self.success)
5912 
      oprot.writeFieldEnd()
5913 
    if self.ucx != None:
5914 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5915 
      self.ucx.write(oprot)
5916 
      oprot.writeFieldEnd()
5917 
    oprot.writeFieldStop()
5918 
    oprot.writeStructEnd()
5919 
 
5920 
  def __repr__(self):
5921 
    L = ['%s=%r' % (key, value)
5922 
      for key, value in self.__dict__.iteritems()]
5923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5924 
 
5925 
  def __eq__(self, other):
5926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5927 
 
5928 
  def __ne__(self, other):
5929 
    return not (self == other)
5930 
 
581 rajveer 5931 
class forgotPassword_args:
5932 
  """
5933 
  Attributes:
5934 
   - email
884 rajveer 5935 
   - newPassword
581 rajveer 5936 
  """
5937 
 
5938 
  thrift_spec = (
5939 
    None, # 0
5940 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 5941 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 5942 
  )
5943 
 
884 rajveer 5944 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 5945 
    self.email = email
884 rajveer 5946 
    self.newPassword = newPassword
581 rajveer 5947 
 
5948 
  def read(self, iprot):
5949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5951 
      return
5952 
    iprot.readStructBegin()
5953 
    while True:
5954 
      (fname, ftype, fid) = iprot.readFieldBegin()
5955 
      if ftype == TType.STOP:
5956 
        break
5957 
      if fid == 1:
5958 
        if ftype == TType.STRING:
5959 
          self.email = iprot.readString();
5960 
        else:
5961 
          iprot.skip(ftype)
884 rajveer 5962 
      elif fid == 2:
5963 
        if ftype == TType.STRING:
5964 
          self.newPassword = iprot.readString();
5965 
        else:
5966 
          iprot.skip(ftype)
581 rajveer 5967 
      else:
5968 
        iprot.skip(ftype)
5969 
      iprot.readFieldEnd()
5970 
    iprot.readStructEnd()
5971 
 
5972 
  def write(self, oprot):
5973 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5974 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5975 
      return
5976 
    oprot.writeStructBegin('forgotPassword_args')
5977 
    if self.email != None:
5978 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5979 
      oprot.writeString(self.email)
5980 
      oprot.writeFieldEnd()
884 rajveer 5981 
    if self.newPassword != None:
5982 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
5983 
      oprot.writeString(self.newPassword)
5984 
      oprot.writeFieldEnd()
581 rajveer 5985 
    oprot.writeFieldStop()
5986 
    oprot.writeStructEnd()
5987 
 
5988 
  def __repr__(self):
5989 
    L = ['%s=%r' % (key, value)
5990 
      for key, value in self.__dict__.iteritems()]
5991 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5992 
 
5993 
  def __eq__(self, other):
5994 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5995 
 
5996 
  def __ne__(self, other):
5997 
    return not (self == other)
5998 
 
5999 
class forgotPassword_result:
6000 
  """
6001 
  Attributes:
6002 
   - success
6003 
   - ucx
6004 
  """
6005 
 
6006 
  thrift_spec = (
6007 
    (0, TType.BOOL, 'success', None, None, ), # 0
6008 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6009 
  )
6010 
 
6011 
  def __init__(self, success=None, ucx=None,):
6012 
    self.success = success
6013 
    self.ucx = ucx
6014 
 
6015 
  def read(self, iprot):
6016 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6017 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6018 
      return
6019 
    iprot.readStructBegin()
6020 
    while True:
6021 
      (fname, ftype, fid) = iprot.readFieldBegin()
6022 
      if ftype == TType.STOP:
6023 
        break
6024 
      if fid == 0:
6025 
        if ftype == TType.BOOL:
6026 
          self.success = iprot.readBool();
6027 
        else:
6028 
          iprot.skip(ftype)
6029 
      elif fid == 1:
6030 
        if ftype == TType.STRUCT:
6031 
          self.ucx = UserContextException()
6032 
          self.ucx.read(iprot)
6033 
        else:
6034 
          iprot.skip(ftype)
6035 
      else:
6036 
        iprot.skip(ftype)
6037 
      iprot.readFieldEnd()
6038 
    iprot.readStructEnd()
6039 
 
6040 
  def write(self, oprot):
6041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6043 
      return
6044 
    oprot.writeStructBegin('forgotPassword_result')
6045 
    if self.success != None:
6046 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6047 
      oprot.writeBool(self.success)
6048 
      oprot.writeFieldEnd()
6049 
    if self.ucx != None:
6050 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6051 
      self.ucx.write(oprot)
6052 
      oprot.writeFieldEnd()
6053 
    oprot.writeFieldStop()
6054 
    oprot.writeStructEnd()
6055 
 
6056 
  def __repr__(self):
6057 
    L = ['%s=%r' % (key, value)
6058 
      for key, value in self.__dict__.iteritems()]
6059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6060 
 
6061 
  def __eq__(self, other):
6062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6063 
 
6064 
  def __ne__(self, other):
6065 
    return not (self == other)
6066 
 
594 rajveer 6067 
class getAllAddressesForUser_args:
6068 
  """
6069 
  Attributes:
6070 
   - userId
6071 
  """
6072 
 
6073 
  thrift_spec = (
6074 
    None, # 0
6075 
    (1, TType.I64, 'userId', None, None, ), # 1
6076 
  )
6077 
 
6078 
  def __init__(self, userId=None,):
6079 
    self.userId = userId
6080 
 
6081 
  def read(self, iprot):
6082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6084 
      return
6085 
    iprot.readStructBegin()
6086 
    while True:
6087 
      (fname, ftype, fid) = iprot.readFieldBegin()
6088 
      if ftype == TType.STOP:
6089 
        break
6090 
      if fid == 1:
6091 
        if ftype == TType.I64:
6092 
          self.userId = iprot.readI64();
6093 
        else:
6094 
          iprot.skip(ftype)
6095 
      else:
6096 
        iprot.skip(ftype)
6097 
      iprot.readFieldEnd()
6098 
    iprot.readStructEnd()
6099 
 
6100 
  def write(self, oprot):
6101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6103 
      return
6104 
    oprot.writeStructBegin('getAllAddressesForUser_args')
6105 
    if self.userId != None:
6106 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6107 
      oprot.writeI64(self.userId)
6108 
      oprot.writeFieldEnd()
6109 
    oprot.writeFieldStop()
6110 
    oprot.writeStructEnd()
6111 
 
6112 
  def __repr__(self):
6113 
    L = ['%s=%r' % (key, value)
6114 
      for key, value in self.__dict__.iteritems()]
6115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6116 
 
6117 
  def __eq__(self, other):
6118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6119 
 
6120 
  def __ne__(self, other):
6121 
    return not (self == other)
6122 
 
6123 
class getAllAddressesForUser_result:
6124 
  """
6125 
  Attributes:
6126 
   - success
6127 
   - ucx
6128 
  """
6129 
 
6130 
  thrift_spec = (
6131 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
6132 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6133 
  )
6134 
 
6135 
  def __init__(self, success=None, ucx=None,):
6136 
    self.success = success
6137 
    self.ucx = ucx
6138 
 
6139 
  def read(self, iprot):
6140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6142 
      return
6143 
    iprot.readStructBegin()
6144 
    while True:
6145 
      (fname, ftype, fid) = iprot.readFieldBegin()
6146 
      if ftype == TType.STOP:
6147 
        break
6148 
      if fid == 0:
6149 
        if ftype == TType.LIST:
6150 
          self.success = []
1976 varun.gupt 6151 
          (_etype38, _size35) = iprot.readListBegin()
6152 
          for _i39 in xrange(_size35):
6153 
            _elem40 = Address()
6154 
            _elem40.read(iprot)
6155 
            self.success.append(_elem40)
594 rajveer 6156 
          iprot.readListEnd()
6157 
        else:
6158 
          iprot.skip(ftype)
6159 
      elif fid == 1:
6160 
        if ftype == TType.STRUCT:
6161 
          self.ucx = UserContextException()
6162 
          self.ucx.read(iprot)
6163 
        else:
6164 
          iprot.skip(ftype)
6165 
      else:
6166 
        iprot.skip(ftype)
6167 
      iprot.readFieldEnd()
6168 
    iprot.readStructEnd()
6169 
 
6170 
  def write(self, oprot):
6171 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6172 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6173 
      return
6174 
    oprot.writeStructBegin('getAllAddressesForUser_result')
6175 
    if self.success != None:
6176 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6177 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 6178 
      for iter41 in self.success:
6179 
        iter41.write(oprot)
594 rajveer 6180 
      oprot.writeListEnd()
6181 
      oprot.writeFieldEnd()
6182 
    if self.ucx != None:
6183 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6184 
      self.ucx.write(oprot)
6185 
      oprot.writeFieldEnd()
6186 
    oprot.writeFieldStop()
6187 
    oprot.writeStructEnd()
6188 
 
6189 
  def __repr__(self):
6190 
    L = ['%s=%r' % (key, value)
6191 
      for key, value in self.__dict__.iteritems()]
6192 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6193 
 
6194 
  def __eq__(self, other):
6195 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6196 
 
6197 
  def __ne__(self, other):
6198 
    return not (self == other)
6199 
 
1894 vikas 6200 
class getAddressById_args:
6201 
  """
6202 
  Attributes:
6203 
   - addressId
6204 
  """
6205 
 
6206 
  thrift_spec = (
6207 
    None, # 0
6208 
    (1, TType.I64, 'addressId', None, None, ), # 1
6209 
  )
6210 
 
6211 
  def __init__(self, addressId=None,):
6212 
    self.addressId = addressId
6213 
 
6214 
  def read(self, iprot):
6215 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6216 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6217 
      return
6218 
    iprot.readStructBegin()
6219 
    while True:
6220 
      (fname, ftype, fid) = iprot.readFieldBegin()
6221 
      if ftype == TType.STOP:
6222 
        break
6223 
      if fid == 1:
6224 
        if ftype == TType.I64:
6225 
          self.addressId = iprot.readI64();
6226 
        else:
6227 
          iprot.skip(ftype)
6228 
      else:
6229 
        iprot.skip(ftype)
6230 
      iprot.readFieldEnd()
6231 
    iprot.readStructEnd()
6232 
 
6233 
  def write(self, oprot):
6234 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6235 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6236 
      return
6237 
    oprot.writeStructBegin('getAddressById_args')
6238 
    if self.addressId != None:
6239 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
6240 
      oprot.writeI64(self.addressId)
6241 
      oprot.writeFieldEnd()
6242 
    oprot.writeFieldStop()
6243 
    oprot.writeStructEnd()
6244 
 
6245 
  def __repr__(self):
6246 
    L = ['%s=%r' % (key, value)
6247 
      for key, value in self.__dict__.iteritems()]
6248 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6249 
 
6250 
  def __eq__(self, other):
6251 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6252 
 
6253 
  def __ne__(self, other):
6254 
    return not (self == other)
6255 
 
6256 
class getAddressById_result:
6257 
  """
6258 
  Attributes:
6259 
   - success
6260 
   - ucx
6261 
  """
6262 
 
6263 
  thrift_spec = (
6264 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
6265 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6266 
  )
6267 
 
6268 
  def __init__(self, success=None, ucx=None,):
6269 
    self.success = success
6270 
    self.ucx = ucx
6271 
 
6272 
  def read(self, iprot):
6273 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6274 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6275 
      return
6276 
    iprot.readStructBegin()
6277 
    while True:
6278 
      (fname, ftype, fid) = iprot.readFieldBegin()
6279 
      if ftype == TType.STOP:
6280 
        break
6281 
      if fid == 0:
6282 
        if ftype == TType.STRUCT:
6283 
          self.success = Address()
6284 
          self.success.read(iprot)
6285 
        else:
6286 
          iprot.skip(ftype)
6287 
      elif fid == 1:
6288 
        if ftype == TType.STRUCT:
6289 
          self.ucx = UserContextException()
6290 
          self.ucx.read(iprot)
6291 
        else:
6292 
          iprot.skip(ftype)
6293 
      else:
6294 
        iprot.skip(ftype)
6295 
      iprot.readFieldEnd()
6296 
    iprot.readStructEnd()
6297 
 
6298 
  def write(self, oprot):
6299 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6300 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6301 
      return
6302 
    oprot.writeStructBegin('getAddressById_result')
6303 
    if self.success != None:
6304 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6305 
      self.success.write(oprot)
6306 
      oprot.writeFieldEnd()
6307 
    if self.ucx != None:
6308 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6309 
      self.ucx.write(oprot)
6310 
      oprot.writeFieldEnd()
6311 
    oprot.writeFieldStop()
6312 
    oprot.writeStructEnd()
6313 
 
6314 
  def __repr__(self):
6315 
    L = ['%s=%r' % (key, value)
6316 
      for key, value in self.__dict__.iteritems()]
6317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6318 
 
6319 
  def __eq__(self, other):
6320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6321 
 
6322 
  def __ne__(self, other):
6323 
    return not (self == other)
6324 
 
594 rajveer 6325 
class getDefaultAddressId_args:
6326 
  """
6327 
  Attributes:
6328 
   - userId
6329 
  """
6330 
 
6331 
  thrift_spec = (
6332 
    None, # 0
6333 
    (1, TType.I64, 'userId', None, None, ), # 1
6334 
  )
6335 
 
6336 
  def __init__(self, userId=None,):
6337 
    self.userId = userId
6338 
 
6339 
  def read(self, iprot):
6340 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6341 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6342 
      return
6343 
    iprot.readStructBegin()
6344 
    while True:
6345 
      (fname, ftype, fid) = iprot.readFieldBegin()
6346 
      if ftype == TType.STOP:
6347 
        break
6348 
      if fid == 1:
6349 
        if ftype == TType.I64:
6350 
          self.userId = iprot.readI64();
6351 
        else:
6352 
          iprot.skip(ftype)
6353 
      else:
6354 
        iprot.skip(ftype)
6355 
      iprot.readFieldEnd()
6356 
    iprot.readStructEnd()
6357 
 
6358 
  def write(self, oprot):
6359 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6360 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6361 
      return
6362 
    oprot.writeStructBegin('getDefaultAddressId_args')
6363 
    if self.userId != None:
6364 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6365 
      oprot.writeI64(self.userId)
6366 
      oprot.writeFieldEnd()
6367 
    oprot.writeFieldStop()
6368 
    oprot.writeStructEnd()
6369 
 
6370 
  def __repr__(self):
6371 
    L = ['%s=%r' % (key, value)
6372 
      for key, value in self.__dict__.iteritems()]
6373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6374 
 
6375 
  def __eq__(self, other):
6376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6377 
 
6378 
  def __ne__(self, other):
6379 
    return not (self == other)
6380 
 
6381 
class getDefaultAddressId_result:
6382 
  """
6383 
  Attributes:
6384 
   - success
6385 
   - ucx
6386 
  """
6387 
 
6388 
  thrift_spec = (
6389 
    (0, TType.I64, 'success', None, None, ), # 0
6390 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6391 
  )
6392 
 
6393 
  def __init__(self, success=None, ucx=None,):
6394 
    self.success = success
6395 
    self.ucx = ucx
6396 
 
6397 
  def read(self, iprot):
6398 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6399 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6400 
      return
6401 
    iprot.readStructBegin()
6402 
    while True:
6403 
      (fname, ftype, fid) = iprot.readFieldBegin()
6404 
      if ftype == TType.STOP:
6405 
        break
6406 
      if fid == 0:
6407 
        if ftype == TType.I64:
6408 
          self.success = iprot.readI64();
6409 
        else:
6410 
          iprot.skip(ftype)
6411 
      elif fid == 1:
6412 
        if ftype == TType.STRUCT:
6413 
          self.ucx = UserContextException()
6414 
          self.ucx.read(iprot)
6415 
        else:
6416 
          iprot.skip(ftype)
6417 
      else:
6418 
        iprot.skip(ftype)
6419 
      iprot.readFieldEnd()
6420 
    iprot.readStructEnd()
6421 
 
6422 
  def write(self, oprot):
6423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6425 
      return
6426 
    oprot.writeStructBegin('getDefaultAddressId_result')
6427 
    if self.success != None:
6428 
      oprot.writeFieldBegin('success', TType.I64, 0)
6429 
      oprot.writeI64(self.success)
6430 
      oprot.writeFieldEnd()
6431 
    if self.ucx != None:
6432 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6433 
      self.ucx.write(oprot)
6434 
      oprot.writeFieldEnd()
6435 
    oprot.writeFieldStop()
6436 
    oprot.writeStructEnd()
6437 
 
6438 
  def __repr__(self):
6439 
    L = ['%s=%r' % (key, value)
6440 
      for key, value in self.__dict__.iteritems()]
6441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6442 
 
6443 
  def __eq__(self, other):
6444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6445 
 
6446 
  def __ne__(self, other):
6447 
    return not (self == other)
6448 
 
785 rajveer 6449 
class getDefaultPincode_args:
6450 
  """
6451 
  Attributes:
6452 
   - userId
6453 
  """
6454 
 
6455 
  thrift_spec = (
6456 
    None, # 0
6457 
    (1, TType.I64, 'userId', None, None, ), # 1
6458 
  )
6459 
 
6460 
  def __init__(self, userId=None,):
6461 
    self.userId = userId
6462 
 
6463 
  def read(self, iprot):
6464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6466 
      return
6467 
    iprot.readStructBegin()
6468 
    while True:
6469 
      (fname, ftype, fid) = iprot.readFieldBegin()
6470 
      if ftype == TType.STOP:
6471 
        break
6472 
      if fid == 1:
6473 
        if ftype == TType.I64:
6474 
          self.userId = iprot.readI64();
6475 
        else:
6476 
          iprot.skip(ftype)
6477 
      else:
6478 
        iprot.skip(ftype)
6479 
      iprot.readFieldEnd()
6480 
    iprot.readStructEnd()
6481 
 
6482 
  def write(self, oprot):
6483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6485 
      return
6486 
    oprot.writeStructBegin('getDefaultPincode_args')
6487 
    if self.userId != None:
6488 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6489 
      oprot.writeI64(self.userId)
6490 
      oprot.writeFieldEnd()
6491 
    oprot.writeFieldStop()
6492 
    oprot.writeStructEnd()
6493 
 
6494 
  def __repr__(self):
6495 
    L = ['%s=%r' % (key, value)
6496 
      for key, value in self.__dict__.iteritems()]
6497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6498 
 
6499 
  def __eq__(self, other):
6500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6501 
 
6502 
  def __ne__(self, other):
6503 
    return not (self == other)
6504 
 
6505 
class getDefaultPincode_result:
6506 
  """
6507 
  Attributes:
6508 
   - success
6509 
   - ucx
6510 
  """
6511 
 
6512 
  thrift_spec = (
6513 
    (0, TType.STRING, 'success', None, None, ), # 0
6514 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6515 
  )
6516 
 
6517 
  def __init__(self, success=None, ucx=None,):
6518 
    self.success = success
6519 
    self.ucx = ucx
6520 
 
6521 
  def read(self, iprot):
6522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6524 
      return
6525 
    iprot.readStructBegin()
6526 
    while True:
6527 
      (fname, ftype, fid) = iprot.readFieldBegin()
6528 
      if ftype == TType.STOP:
6529 
        break
6530 
      if fid == 0:
6531 
        if ftype == TType.STRING:
6532 
          self.success = iprot.readString();
6533 
        else:
6534 
          iprot.skip(ftype)
6535 
      elif fid == 1:
6536 
        if ftype == TType.STRUCT:
6537 
          self.ucx = UserContextException()
6538 
          self.ucx.read(iprot)
6539 
        else:
6540 
          iprot.skip(ftype)
6541 
      else:
6542 
        iprot.skip(ftype)
6543 
      iprot.readFieldEnd()
6544 
    iprot.readStructEnd()
6545 
 
6546 
  def write(self, oprot):
6547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6549 
      return
6550 
    oprot.writeStructBegin('getDefaultPincode_result')
6551 
    if self.success != None:
6552 
      oprot.writeFieldBegin('success', TType.STRING, 0)
6553 
      oprot.writeString(self.success)
6554 
      oprot.writeFieldEnd()
6555 
    if self.ucx != None:
6556 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6557 
      self.ucx.write(oprot)
6558 
      oprot.writeFieldEnd()
6559 
    oprot.writeFieldStop()
6560 
    oprot.writeStructEnd()
6561 
 
6562 
  def __repr__(self):
6563 
    L = ['%s=%r' % (key, value)
6564 
      for key, value in self.__dict__.iteritems()]
6565 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6566 
 
6567 
  def __eq__(self, other):
6568 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6569 
 
6570 
  def __ne__(self, other):
6571 
    return not (self == other)
6572 
 
1274 varun.gupt 6573 
class saveUserCommunication_args:
6574 
  """
6575 
  Attributes:
6576 
   - userId
6577 
   - replyTo
6578 
   - communicationType
6579 
   - orderId
6580 
   - airwaybillNo
6581 
   - productName
6582 
   - subject
6583 
   - message
6584 
  """
6585 
 
6586 
  thrift_spec = (
6587 
    None, # 0
6588 
    (1, TType.I64, 'userId', None, None, ), # 1
6589 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
6590 
    (3, TType.I64, 'communicationType', None, None, ), # 3
6591 
    (4, TType.I64, 'orderId', None, None, ), # 4
6592 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
6593 
    (6, TType.STRING, 'productName', None, None, ), # 6
6594 
    (7, TType.STRING, 'subject', None, None, ), # 7
6595 
    (8, TType.STRING, 'message', None, None, ), # 8
6596 
  )
6597 
 
6598 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
6599 
    self.userId = userId
6600 
    self.replyTo = replyTo
6601 
    self.communicationType = communicationType
6602 
    self.orderId = orderId
6603 
    self.airwaybillNo = airwaybillNo
6604 
    self.productName = productName
6605 
    self.subject = subject
6606 
    self.message = message
6607 
 
6608 
  def read(self, iprot):
6609 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6610 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6611 
      return
6612 
    iprot.readStructBegin()
6613 
    while True:
6614 
      (fname, ftype, fid) = iprot.readFieldBegin()
6615 
      if ftype == TType.STOP:
6616 
        break
6617 
      if fid == 1:
6618 
        if ftype == TType.I64:
6619 
          self.userId = iprot.readI64();
6620 
        else:
6621 
          iprot.skip(ftype)
6622 
      elif fid == 2:
6623 
        if ftype == TType.STRING:
6624 
          self.replyTo = iprot.readString();
6625 
        else:
6626 
          iprot.skip(ftype)
6627 
      elif fid == 3:
6628 
        if ftype == TType.I64:
6629 
          self.communicationType = iprot.readI64();
6630 
        else:
6631 
          iprot.skip(ftype)
6632 
      elif fid == 4:
6633 
        if ftype == TType.I64:
6634 
          self.orderId = iprot.readI64();
6635 
        else:
6636 
          iprot.skip(ftype)
6637 
      elif fid == 5:
6638 
        if ftype == TType.STRING:
6639 
          self.airwaybillNo = iprot.readString();
6640 
        else:
6641 
          iprot.skip(ftype)
6642 
      elif fid == 6:
6643 
        if ftype == TType.STRING:
6644 
          self.productName = iprot.readString();
6645 
        else:
6646 
          iprot.skip(ftype)
6647 
      elif fid == 7:
6648 
        if ftype == TType.STRING:
6649 
          self.subject = iprot.readString();
6650 
        else:
6651 
          iprot.skip(ftype)
6652 
      elif fid == 8:
6653 
        if ftype == TType.STRING:
6654 
          self.message = iprot.readString();
6655 
        else:
6656 
          iprot.skip(ftype)
6657 
      else:
6658 
        iprot.skip(ftype)
6659 
      iprot.readFieldEnd()
6660 
    iprot.readStructEnd()
6661 
 
6662 
  def write(self, oprot):
6663 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6664 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6665 
      return
6666 
    oprot.writeStructBegin('saveUserCommunication_args')
6667 
    if self.userId != None:
6668 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6669 
      oprot.writeI64(self.userId)
6670 
      oprot.writeFieldEnd()
6671 
    if self.replyTo != None:
6672 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
6673 
      oprot.writeString(self.replyTo)
6674 
      oprot.writeFieldEnd()
6675 
    if self.communicationType != None:
6676 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
6677 
      oprot.writeI64(self.communicationType)
6678 
      oprot.writeFieldEnd()
6679 
    if self.orderId != None:
6680 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
6681 
      oprot.writeI64(self.orderId)
6682 
      oprot.writeFieldEnd()
6683 
    if self.airwaybillNo != None:
6684 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
6685 
      oprot.writeString(self.airwaybillNo)
6686 
      oprot.writeFieldEnd()
6687 
    if self.productName != None:
6688 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
6689 
      oprot.writeString(self.productName)
6690 
      oprot.writeFieldEnd()
6691 
    if self.subject != None:
6692 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
6693 
      oprot.writeString(self.subject)
6694 
      oprot.writeFieldEnd()
6695 
    if self.message != None:
6696 
      oprot.writeFieldBegin('message', TType.STRING, 8)
6697 
      oprot.writeString(self.message)
6698 
      oprot.writeFieldEnd()
6699 
    oprot.writeFieldStop()
6700 
    oprot.writeStructEnd()
6701 
 
6702 
  def __repr__(self):
6703 
    L = ['%s=%r' % (key, value)
6704 
      for key, value in self.__dict__.iteritems()]
6705 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6706 
 
6707 
  def __eq__(self, other):
6708 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6709 
 
6710 
  def __ne__(self, other):
6711 
    return not (self == other)
6712 
 
6713 
class saveUserCommunication_result:
6714 
  """
6715 
  Attributes:
6716 
   - success
6717 
   - ucx
6718 
  """
6719 
 
6720 
  thrift_spec = (
6721 
    (0, TType.BOOL, 'success', None, None, ), # 0
6722 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6723 
  )
6724 
 
6725 
  def __init__(self, success=None, ucx=None,):
6726 
    self.success = success
6727 
    self.ucx = ucx
6728 
 
6729 
  def read(self, iprot):
6730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6732 
      return
6733 
    iprot.readStructBegin()
6734 
    while True:
6735 
      (fname, ftype, fid) = iprot.readFieldBegin()
6736 
      if ftype == TType.STOP:
6737 
        break
6738 
      if fid == 0:
6739 
        if ftype == TType.BOOL:
6740 
          self.success = iprot.readBool();
6741 
        else:
6742 
          iprot.skip(ftype)
6743 
      elif fid == 1:
6744 
        if ftype == TType.STRUCT:
6745 
          self.ucx = UserCommunicationException()
6746 
          self.ucx.read(iprot)
6747 
        else:
6748 
          iprot.skip(ftype)
6749 
      else:
6750 
        iprot.skip(ftype)
6751 
      iprot.readFieldEnd()
6752 
    iprot.readStructEnd()
6753 
 
6754 
  def write(self, oprot):
6755 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6756 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6757 
      return
6758 
    oprot.writeStructBegin('saveUserCommunication_result')
6759 
    if self.success != None:
6760 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6761 
      oprot.writeBool(self.success)
6762 
      oprot.writeFieldEnd()
6763 
    if self.ucx != None:
6764 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6765 
      self.ucx.write(oprot)
6766 
      oprot.writeFieldEnd()
6767 
    oprot.writeFieldStop()
6768 
    oprot.writeStructEnd()
6769 
 
6770 
  def __repr__(self):
6771 
    L = ['%s=%r' % (key, value)
6772 
      for key, value in self.__dict__.iteritems()]
6773 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6774 
 
6775 
  def __eq__(self, other):
6776 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6777 
 
6778 
  def __ne__(self, other):
6779 
    return not (self == other)
6780 
 
1590 varun.gupt 6781 
class getUserCommunicationById_args:
6782 
  """
6783 
  Attributes:
6784 
   - id
6785 
  """
6786 
 
6787 
  thrift_spec = (
6788 
    None, # 0
6789 
    (1, TType.I64, 'id', None, None, ), # 1
6790 
  )
6791 
 
6792 
  def __init__(self, id=None,):
6793 
    self.id = id
6794 
 
6795 
  def read(self, iprot):
6796 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6797 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6798 
      return
6799 
    iprot.readStructBegin()
6800 
    while True:
6801 
      (fname, ftype, fid) = iprot.readFieldBegin()
6802 
      if ftype == TType.STOP:
6803 
        break
6804 
      if fid == 1:
6805 
        if ftype == TType.I64:
6806 
          self.id = iprot.readI64();
6807 
        else:
6808 
          iprot.skip(ftype)
6809 
      else:
6810 
        iprot.skip(ftype)
6811 
      iprot.readFieldEnd()
6812 
    iprot.readStructEnd()
6813 
 
6814 
  def write(self, oprot):
6815 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6816 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6817 
      return
6818 
    oprot.writeStructBegin('getUserCommunicationById_args')
6819 
    if self.id != None:
6820 
      oprot.writeFieldBegin('id', TType.I64, 1)
6821 
      oprot.writeI64(self.id)
6822 
      oprot.writeFieldEnd()
6823 
    oprot.writeFieldStop()
6824 
    oprot.writeStructEnd()
6825 
 
6826 
  def __repr__(self):
6827 
    L = ['%s=%r' % (key, value)
6828 
      for key, value in self.__dict__.iteritems()]
6829 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6830 
 
6831 
  def __eq__(self, other):
6832 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6833 
 
6834 
  def __ne__(self, other):
6835 
    return not (self == other)
6836 
 
6837 
class getUserCommunicationById_result:
6838 
  """
6839 
  Attributes:
6840 
   - success
6841 
   - ucx
6842 
  """
6843 
 
6844 
  thrift_spec = (
6845 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
6846 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6847 
  )
6848 
 
6849 
  def __init__(self, success=None, ucx=None,):
6850 
    self.success = success
6851 
    self.ucx = ucx
6852 
 
6853 
  def read(self, iprot):
6854 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6855 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6856 
      return
6857 
    iprot.readStructBegin()
6858 
    while True:
6859 
      (fname, ftype, fid) = iprot.readFieldBegin()
6860 
      if ftype == TType.STOP:
6861 
        break
6862 
      if fid == 0:
6863 
        if ftype == TType.STRUCT:
6864 
          self.success = UserCommunication()
6865 
          self.success.read(iprot)
6866 
        else:
6867 
          iprot.skip(ftype)
6868 
      elif fid == 1:
6869 
        if ftype == TType.STRUCT:
6870 
          self.ucx = UserCommunicationException()
6871 
          self.ucx.read(iprot)
6872 
        else:
6873 
          iprot.skip(ftype)
6874 
      else:
6875 
        iprot.skip(ftype)
6876 
      iprot.readFieldEnd()
6877 
    iprot.readStructEnd()
6878 
 
6879 
  def write(self, oprot):
6880 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6881 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6882 
      return
6883 
    oprot.writeStructBegin('getUserCommunicationById_result')
6884 
    if self.success != None:
6885 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6886 
      self.success.write(oprot)
6887 
      oprot.writeFieldEnd()
6888 
    if self.ucx != None:
6889 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6890 
      self.ucx.write(oprot)
6891 
      oprot.writeFieldEnd()
6892 
    oprot.writeFieldStop()
6893 
    oprot.writeStructEnd()
6894 
 
6895 
  def __repr__(self):
6896 
    L = ['%s=%r' % (key, value)
6897 
      for key, value in self.__dict__.iteritems()]
6898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6899 
 
6900 
  def __eq__(self, other):
6901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6902 
 
6903 
  def __ne__(self, other):
6904 
    return not (self == other)
6905 
 
6906 
class getUserCommunicationByUser_args:
6907 
  """
6908 
  Attributes:
6909 
   - userId
6910 
  """
6911 
 
6912 
  thrift_spec = (
6913 
    None, # 0
6914 
    (1, TType.I64, 'userId', None, None, ), # 1
6915 
  )
6916 
 
6917 
  def __init__(self, userId=None,):
6918 
    self.userId = userId
6919 
 
6920 
  def read(self, iprot):
6921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6923 
      return
6924 
    iprot.readStructBegin()
6925 
    while True:
6926 
      (fname, ftype, fid) = iprot.readFieldBegin()
6927 
      if ftype == TType.STOP:
6928 
        break
6929 
      if fid == 1:
6930 
        if ftype == TType.I64:
6931 
          self.userId = iprot.readI64();
6932 
        else:
6933 
          iprot.skip(ftype)
6934 
      else:
6935 
        iprot.skip(ftype)
6936 
      iprot.readFieldEnd()
6937 
    iprot.readStructEnd()
6938 
 
6939 
  def write(self, oprot):
6940 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6941 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6942 
      return
6943 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
6944 
    if self.userId != None:
6945 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6946 
      oprot.writeI64(self.userId)
6947 
      oprot.writeFieldEnd()
6948 
    oprot.writeFieldStop()
6949 
    oprot.writeStructEnd()
6950 
 
6951 
  def __repr__(self):
6952 
    L = ['%s=%r' % (key, value)
6953 
      for key, value in self.__dict__.iteritems()]
6954 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6955 
 
6956 
  def __eq__(self, other):
6957 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6958 
 
6959 
  def __ne__(self, other):
6960 
    return not (self == other)
6961 
 
6962 
class getUserCommunicationByUser_result:
6963 
  """
6964 
  Attributes:
6965 
   - success
6966 
   - ucx
6967 
  """
6968 
 
6969 
  thrift_spec = (
6970 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
6971 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6972 
  )
6973 
 
6974 
  def __init__(self, success=None, ucx=None,):
6975 
    self.success = success
6976 
    self.ucx = ucx
6977 
 
6978 
  def read(self, iprot):
6979 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6980 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6981 
      return
6982 
    iprot.readStructBegin()
6983 
    while True:
6984 
      (fname, ftype, fid) = iprot.readFieldBegin()
6985 
      if ftype == TType.STOP:
6986 
        break
6987 
      if fid == 0:
6988 
        if ftype == TType.LIST:
6989 
          self.success = []
1976 varun.gupt 6990 
          (_etype45, _size42) = iprot.readListBegin()
6991 
          for _i46 in xrange(_size42):
6992 
            _elem47 = UserCommunication()
6993 
            _elem47.read(iprot)
6994 
            self.success.append(_elem47)
1590 varun.gupt 6995 
          iprot.readListEnd()
6996 
        else:
6997 
          iprot.skip(ftype)
6998 
      elif fid == 1:
6999 
        if ftype == TType.STRUCT:
7000 
          self.ucx = UserCommunicationException()
7001 
          self.ucx.read(iprot)
7002 
        else:
7003 
          iprot.skip(ftype)
7004 
      else:
7005 
        iprot.skip(ftype)
7006 
      iprot.readFieldEnd()
7007 
    iprot.readStructEnd()
7008 
 
7009 
  def write(self, oprot):
7010 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7011 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7012 
      return
7013 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
7014 
    if self.success != None:
7015 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7016 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 7017 
      for iter48 in self.success:
7018 
        iter48.write(oprot)
1590 varun.gupt 7019 
      oprot.writeListEnd()
7020 
      oprot.writeFieldEnd()
7021 
    if self.ucx != None:
7022 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7023 
      self.ucx.write(oprot)
7024 
      oprot.writeFieldEnd()
7025 
    oprot.writeFieldStop()
7026 
    oprot.writeStructEnd()
7027 
 
7028 
  def __repr__(self):
7029 
    L = ['%s=%r' % (key, value)
7030 
      for key, value in self.__dict__.iteritems()]
7031 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7032 
 
7033 
  def __eq__(self, other):
7034 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7035 
 
7036 
  def __ne__(self, other):
7037 
    return not (self == other)
7038 
 
7039 
class getAllUserCommunications_args:
7040 
 
7041 
  thrift_spec = (
7042 
  )
7043 
 
7044 
  def read(self, iprot):
7045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7047 
      return
7048 
    iprot.readStructBegin()
7049 
    while True:
7050 
      (fname, ftype, fid) = iprot.readFieldBegin()
7051 
      if ftype == TType.STOP:
7052 
        break
7053 
      else:
7054 
        iprot.skip(ftype)
7055 
      iprot.readFieldEnd()
7056 
    iprot.readStructEnd()
7057 
 
7058 
  def write(self, oprot):
7059 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7060 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7061 
      return
7062 
    oprot.writeStructBegin('getAllUserCommunications_args')
7063 
    oprot.writeFieldStop()
7064 
    oprot.writeStructEnd()
7065 
 
7066 
  def __repr__(self):
7067 
    L = ['%s=%r' % (key, value)
7068 
      for key, value in self.__dict__.iteritems()]
7069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7070 
 
7071 
  def __eq__(self, other):
7072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7073 
 
7074 
  def __ne__(self, other):
7075 
    return not (self == other)
7076 
 
7077 
class getAllUserCommunications_result:
7078 
  """
7079 
  Attributes:
7080 
   - success
7081 
   - ucx
7082 
  """
7083 
 
7084 
  thrift_spec = (
7085 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
7086 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7087 
  )
7088 
 
7089 
  def __init__(self, success=None, ucx=None,):
7090 
    self.success = success
7091 
    self.ucx = ucx
7092 
 
7093 
  def read(self, iprot):
7094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7096 
      return
7097 
    iprot.readStructBegin()
7098 
    while True:
7099 
      (fname, ftype, fid) = iprot.readFieldBegin()
7100 
      if ftype == TType.STOP:
7101 
        break
7102 
      if fid == 0:
7103 
        if ftype == TType.LIST:
7104 
          self.success = []
1976 varun.gupt 7105 
          (_etype52, _size49) = iprot.readListBegin()
7106 
          for _i53 in xrange(_size49):
7107 
            _elem54 = UserCommunication()
7108 
            _elem54.read(iprot)
7109 
            self.success.append(_elem54)
1590 varun.gupt 7110 
          iprot.readListEnd()
7111 
        else:
7112 
          iprot.skip(ftype)
7113 
      elif fid == 1:
7114 
        if ftype == TType.STRUCT:
7115 
          self.ucx = UserCommunicationException()
7116 
          self.ucx.read(iprot)
7117 
        else:
7118 
          iprot.skip(ftype)
7119 
      else:
7120 
        iprot.skip(ftype)
7121 
      iprot.readFieldEnd()
7122 
    iprot.readStructEnd()
7123 
 
7124 
  def write(self, oprot):
7125 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7126 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7127 
      return
7128 
    oprot.writeStructBegin('getAllUserCommunications_result')
7129 
    if self.success != None:
7130 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7131 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 7132 
      for iter55 in self.success:
7133 
        iter55.write(oprot)
1590 varun.gupt 7134 
      oprot.writeListEnd()
7135 
      oprot.writeFieldEnd()
7136 
    if self.ucx != None:
7137 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7138 
      self.ucx.write(oprot)
7139 
      oprot.writeFieldEnd()
7140 
    oprot.writeFieldStop()
7141 
    oprot.writeStructEnd()
7142 
 
7143 
  def __repr__(self):
7144 
    L = ['%s=%r' % (key, value)
7145 
      for key, value in self.__dict__.iteritems()]
7146 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7147 
 
7148 
  def __eq__(self, other):
7149 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7150 
 
7151 
  def __ne__(self, other):
7152 
    return not (self == other)
7153 
 
1845 vikas 7154 
class createMasterAffiliate_args:
7155 
  """
7156 
  Attributes:
7157 
   - name
1859 vikas 7158 
   - addedOn
1845 vikas 7159 
  """
7160 
 
7161 
  thrift_spec = (
7162 
    None, # 0
7163 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 7164 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 7165 
  )
7166 
 
1859 vikas 7167 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 7168 
    self.name = name
1859 vikas 7169 
    self.addedOn = addedOn
1845 vikas 7170 
 
7171 
  def read(self, iprot):
7172 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7173 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7174 
      return
7175 
    iprot.readStructBegin()
7176 
    while True:
7177 
      (fname, ftype, fid) = iprot.readFieldBegin()
7178 
      if ftype == TType.STOP:
7179 
        break
7180 
      if fid == 1:
7181 
        if ftype == TType.STRING:
7182 
          self.name = iprot.readString();
7183 
        else:
7184 
          iprot.skip(ftype)
1859 vikas 7185 
      elif fid == 2:
7186 
        if ftype == TType.I64:
7187 
          self.addedOn = iprot.readI64();
7188 
        else:
7189 
          iprot.skip(ftype)
1845 vikas 7190 
      else:
7191 
        iprot.skip(ftype)
7192 
      iprot.readFieldEnd()
7193 
    iprot.readStructEnd()
7194 
 
7195 
  def write(self, oprot):
7196 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7197 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7198 
      return
7199 
    oprot.writeStructBegin('createMasterAffiliate_args')
7200 
    if self.name != None:
7201 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7202 
      oprot.writeString(self.name)
7203 
      oprot.writeFieldEnd()
1859 vikas 7204 
    if self.addedOn != None:
7205 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
7206 
      oprot.writeI64(self.addedOn)
7207 
      oprot.writeFieldEnd()
1845 vikas 7208 
    oprot.writeFieldStop()
7209 
    oprot.writeStructEnd()
7210 
 
7211 
  def __repr__(self):
7212 
    L = ['%s=%r' % (key, value)
7213 
      for key, value in self.__dict__.iteritems()]
7214 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7215 
 
7216 
  def __eq__(self, other):
7217 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7218 
 
7219 
  def __ne__(self, other):
7220 
    return not (self == other)
7221 
 
7222 
class createMasterAffiliate_result:
7223 
  """
7224 
  Attributes:
7225 
   - success
7226 
   - utx
7227 
  """
7228 
 
7229 
  thrift_spec = (
7230 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7231 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7232 
  )
7233 
 
7234 
  def __init__(self, success=None, utx=None,):
7235 
    self.success = success
7236 
    self.utx = utx
7237 
 
7238 
  def read(self, iprot):
7239 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7240 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7241 
      return
7242 
    iprot.readStructBegin()
7243 
    while True:
7244 
      (fname, ftype, fid) = iprot.readFieldBegin()
7245 
      if ftype == TType.STOP:
7246 
        break
7247 
      if fid == 0:
7248 
        if ftype == TType.STRUCT:
7249 
          self.success = MasterAffiliate()
7250 
          self.success.read(iprot)
7251 
        else:
7252 
          iprot.skip(ftype)
7253 
      elif fid == 1:
7254 
        if ftype == TType.STRUCT:
1996 vikas 7255 
          self.utx = UserAffiliateException()
1845 vikas 7256 
          self.utx.read(iprot)
7257 
        else:
7258 
          iprot.skip(ftype)
7259 
      else:
7260 
        iprot.skip(ftype)
7261 
      iprot.readFieldEnd()
7262 
    iprot.readStructEnd()
7263 
 
7264 
  def write(self, oprot):
7265 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7266 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7267 
      return
7268 
    oprot.writeStructBegin('createMasterAffiliate_result')
7269 
    if self.success != None:
7270 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7271 
      self.success.write(oprot)
7272 
      oprot.writeFieldEnd()
7273 
    if self.utx != None:
7274 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7275 
      self.utx.write(oprot)
7276 
      oprot.writeFieldEnd()
7277 
    oprot.writeFieldStop()
7278 
    oprot.writeStructEnd()
7279 
 
7280 
  def __repr__(self):
7281 
    L = ['%s=%r' % (key, value)
7282 
      for key, value in self.__dict__.iteritems()]
7283 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7284 
 
7285 
  def __eq__(self, other):
7286 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7287 
 
7288 
  def __ne__(self, other):
7289 
    return not (self == other)
7290 
 
1899 vikas 7291 
class getAllMasterAffiliates_args:
7292 
 
7293 
  thrift_spec = (
7294 
  )
7295 
 
7296 
  def read(self, iprot):
7297 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7298 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7299 
      return
7300 
    iprot.readStructBegin()
7301 
    while True:
7302 
      (fname, ftype, fid) = iprot.readFieldBegin()
7303 
      if ftype == TType.STOP:
7304 
        break
7305 
      else:
7306 
        iprot.skip(ftype)
7307 
      iprot.readFieldEnd()
7308 
    iprot.readStructEnd()
7309 
 
7310 
  def write(self, oprot):
7311 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7312 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7313 
      return
7314 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
7315 
    oprot.writeFieldStop()
7316 
    oprot.writeStructEnd()
7317 
 
7318 
  def __repr__(self):
7319 
    L = ['%s=%r' % (key, value)
7320 
      for key, value in self.__dict__.iteritems()]
7321 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7322 
 
7323 
  def __eq__(self, other):
7324 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7325 
 
7326 
  def __ne__(self, other):
7327 
    return not (self == other)
7328 
 
7329 
class getAllMasterAffiliates_result:
7330 
  """
7331 
  Attributes:
7332 
   - success
7333 
   - utx
7334 
  """
7335 
 
7336 
  thrift_spec = (
7337 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 7338 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 7339 
  )
7340 
 
7341 
  def __init__(self, success=None, utx=None,):
7342 
    self.success = success
7343 
    self.utx = utx
7344 
 
7345 
  def read(self, iprot):
7346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7348 
      return
7349 
    iprot.readStructBegin()
7350 
    while True:
7351 
      (fname, ftype, fid) = iprot.readFieldBegin()
7352 
      if ftype == TType.STOP:
7353 
        break
7354 
      if fid == 0:
7355 
        if ftype == TType.LIST:
7356 
          self.success = []
1976 varun.gupt 7357 
          (_etype59, _size56) = iprot.readListBegin()
7358 
          for _i60 in xrange(_size56):
7359 
            _elem61 = MasterAffiliate()
7360 
            _elem61.read(iprot)
7361 
            self.success.append(_elem61)
1899 vikas 7362 
          iprot.readListEnd()
7363 
        else:
7364 
          iprot.skip(ftype)
7365 
      elif fid == 1:
7366 
        if ftype == TType.STRUCT:
1996 vikas 7367 
          self.utx = UserAffiliateException()
1899 vikas 7368 
          self.utx.read(iprot)
7369 
        else:
7370 
          iprot.skip(ftype)
7371 
      else:
7372 
        iprot.skip(ftype)
7373 
      iprot.readFieldEnd()
7374 
    iprot.readStructEnd()
7375 
 
7376 
  def write(self, oprot):
7377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7379 
      return
7380 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
7381 
    if self.success != None:
7382 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7383 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 7384 
      for iter62 in self.success:
7385 
        iter62.write(oprot)
1899 vikas 7386 
      oprot.writeListEnd()
7387 
      oprot.writeFieldEnd()
7388 
    if self.utx != None:
7389 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7390 
      self.utx.write(oprot)
7391 
      oprot.writeFieldEnd()
7392 
    oprot.writeFieldStop()
7393 
    oprot.writeStructEnd()
7394 
 
7395 
  def __repr__(self):
7396 
    L = ['%s=%r' % (key, value)
7397 
      for key, value in self.__dict__.iteritems()]
7398 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7399 
 
7400 
  def __eq__(self, other):
7401 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7402 
 
7403 
  def __ne__(self, other):
7404 
    return not (self == other)
7405 
 
1845 vikas 7406 
class getMasterAffiliateById_args:
7407 
  """
7408 
  Attributes:
7409 
   - id
7410 
  """
7411 
 
7412 
  thrift_spec = (
7413 
    None, # 0
7414 
    (1, TType.I64, 'id', None, None, ), # 1
7415 
  )
7416 
 
7417 
  def __init__(self, id=None,):
7418 
    self.id = id
7419 
 
7420 
  def read(self, iprot):
7421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7423 
      return
7424 
    iprot.readStructBegin()
7425 
    while True:
7426 
      (fname, ftype, fid) = iprot.readFieldBegin()
7427 
      if ftype == TType.STOP:
7428 
        break
7429 
      if fid == 1:
7430 
        if ftype == TType.I64:
7431 
          self.id = iprot.readI64();
7432 
        else:
7433 
          iprot.skip(ftype)
7434 
      else:
7435 
        iprot.skip(ftype)
7436 
      iprot.readFieldEnd()
7437 
    iprot.readStructEnd()
7438 
 
7439 
  def write(self, oprot):
7440 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7441 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7442 
      return
7443 
    oprot.writeStructBegin('getMasterAffiliateById_args')
7444 
    if self.id != None:
7445 
      oprot.writeFieldBegin('id', TType.I64, 1)
7446 
      oprot.writeI64(self.id)
7447 
      oprot.writeFieldEnd()
7448 
    oprot.writeFieldStop()
7449 
    oprot.writeStructEnd()
7450 
 
7451 
  def __repr__(self):
7452 
    L = ['%s=%r' % (key, value)
7453 
      for key, value in self.__dict__.iteritems()]
7454 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7455 
 
7456 
  def __eq__(self, other):
7457 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7458 
 
7459 
  def __ne__(self, other):
7460 
    return not (self == other)
7461 
 
7462 
class getMasterAffiliateById_result:
7463 
  """
7464 
  Attributes:
7465 
   - success
7466 
   - utx
7467 
  """
7468 
 
7469 
  thrift_spec = (
7470 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7471 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7472 
  )
7473 
 
7474 
  def __init__(self, success=None, utx=None,):
7475 
    self.success = success
7476 
    self.utx = utx
7477 
 
7478 
  def read(self, iprot):
7479 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7480 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7481 
      return
7482 
    iprot.readStructBegin()
7483 
    while True:
7484 
      (fname, ftype, fid) = iprot.readFieldBegin()
7485 
      if ftype == TType.STOP:
7486 
        break
7487 
      if fid == 0:
7488 
        if ftype == TType.STRUCT:
7489 
          self.success = MasterAffiliate()
7490 
          self.success.read(iprot)
7491 
        else:
7492 
          iprot.skip(ftype)
7493 
      elif fid == 1:
7494 
        if ftype == TType.STRUCT:
1996 vikas 7495 
          self.utx = UserAffiliateException()
1845 vikas 7496 
          self.utx.read(iprot)
7497 
        else:
7498 
          iprot.skip(ftype)
7499 
      else:
7500 
        iprot.skip(ftype)
7501 
      iprot.readFieldEnd()
7502 
    iprot.readStructEnd()
7503 
 
7504 
  def write(self, oprot):
7505 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7506 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7507 
      return
7508 
    oprot.writeStructBegin('getMasterAffiliateById_result')
7509 
    if self.success != None:
7510 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7511 
      self.success.write(oprot)
7512 
      oprot.writeFieldEnd()
7513 
    if self.utx != None:
7514 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7515 
      self.utx.write(oprot)
7516 
      oprot.writeFieldEnd()
7517 
    oprot.writeFieldStop()
7518 
    oprot.writeStructEnd()
7519 
 
7520 
  def __repr__(self):
7521 
    L = ['%s=%r' % (key, value)
7522 
      for key, value in self.__dict__.iteritems()]
7523 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7524 
 
7525 
  def __eq__(self, other):
7526 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7527 
 
7528 
  def __ne__(self, other):
7529 
    return not (self == other)
7530 
 
7531 
class getMasterAffiliateByName_args:
7532 
  """
7533 
  Attributes:
7534 
   - name
7535 
  """
7536 
 
7537 
  thrift_spec = (
7538 
    None, # 0
7539 
    (1, TType.STRING, 'name', None, None, ), # 1
7540 
  )
7541 
 
7542 
  def __init__(self, name=None,):
7543 
    self.name = name
7544 
 
7545 
  def read(self, iprot):
7546 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7547 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7548 
      return
7549 
    iprot.readStructBegin()
7550 
    while True:
7551 
      (fname, ftype, fid) = iprot.readFieldBegin()
7552 
      if ftype == TType.STOP:
7553 
        break
7554 
      if fid == 1:
7555 
        if ftype == TType.STRING:
7556 
          self.name = iprot.readString();
7557 
        else:
7558 
          iprot.skip(ftype)
7559 
      else:
7560 
        iprot.skip(ftype)
7561 
      iprot.readFieldEnd()
7562 
    iprot.readStructEnd()
7563 
 
7564 
  def write(self, oprot):
7565 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7566 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7567 
      return
7568 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
7569 
    if self.name != None:
7570 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7571 
      oprot.writeString(self.name)
7572 
      oprot.writeFieldEnd()
7573 
    oprot.writeFieldStop()
7574 
    oprot.writeStructEnd()
7575 
 
7576 
  def __repr__(self):
7577 
    L = ['%s=%r' % (key, value)
7578 
      for key, value in self.__dict__.iteritems()]
7579 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7580 
 
7581 
  def __eq__(self, other):
7582 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7583 
 
7584 
  def __ne__(self, other):
7585 
    return not (self == other)
7586 
 
7587 
class getMasterAffiliateByName_result:
7588 
  """
7589 
  Attributes:
7590 
   - success
7591 
   - utx
7592 
  """
7593 
 
7594 
  thrift_spec = (
7595 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7596 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7597 
  )
7598 
 
7599 
  def __init__(self, success=None, utx=None,):
7600 
    self.success = success
7601 
    self.utx = utx
7602 
 
7603 
  def read(self, iprot):
7604 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7605 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7606 
      return
7607 
    iprot.readStructBegin()
7608 
    while True:
7609 
      (fname, ftype, fid) = iprot.readFieldBegin()
7610 
      if ftype == TType.STOP:
7611 
        break
7612 
      if fid == 0:
7613 
        if ftype == TType.STRUCT:
7614 
          self.success = MasterAffiliate()
7615 
          self.success.read(iprot)
7616 
        else:
7617 
          iprot.skip(ftype)
7618 
      elif fid == 1:
7619 
        if ftype == TType.STRUCT:
1996 vikas 7620 
          self.utx = UserAffiliateException()
1845 vikas 7621 
          self.utx.read(iprot)
7622 
        else:
7623 
          iprot.skip(ftype)
7624 
      else:
7625 
        iprot.skip(ftype)
7626 
      iprot.readFieldEnd()
7627 
    iprot.readStructEnd()
7628 
 
7629 
  def write(self, oprot):
7630 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7631 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7632 
      return
7633 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
7634 
    if self.success != None:
7635 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7636 
      self.success.write(oprot)
7637 
      oprot.writeFieldEnd()
7638 
    if self.utx != None:
7639 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7640 
      self.utx.write(oprot)
7641 
      oprot.writeFieldEnd()
7642 
    oprot.writeFieldStop()
7643 
    oprot.writeStructEnd()
7644 
 
7645 
  def __repr__(self):
7646 
    L = ['%s=%r' % (key, value)
7647 
      for key, value in self.__dict__.iteritems()]
7648 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7649 
 
7650 
  def __eq__(self, other):
7651 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7652 
 
7653 
  def __ne__(self, other):
7654 
    return not (self == other)
7655 
 
7656 
class createAffiliate_args:
7657 
  """
7658 
  Attributes:
7659 
   - name
7660 
   - url
7661 
   - masterAffiliateId
1859 vikas 7662 
   - addedOn
1845 vikas 7663 
  """
7664 
 
7665 
  thrift_spec = (
7666 
    None, # 0
7667 
    (1, TType.STRING, 'name', None, None, ), # 1
7668 
    (2, TType.STRING, 'url', None, None, ), # 2
7669 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 7670 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 7671 
  )
7672 
 
1859 vikas 7673 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 7674 
    self.name = name
7675 
    self.url = url
7676 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 7677 
    self.addedOn = addedOn
1845 vikas 7678 
 
7679 
  def read(self, iprot):
7680 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7681 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7682 
      return
7683 
    iprot.readStructBegin()
7684 
    while True:
7685 
      (fname, ftype, fid) = iprot.readFieldBegin()
7686 
      if ftype == TType.STOP:
7687 
        break
7688 
      if fid == 1:
7689 
        if ftype == TType.STRING:
7690 
          self.name = iprot.readString();
7691 
        else:
7692 
          iprot.skip(ftype)
7693 
      elif fid == 2:
7694 
        if ftype == TType.STRING:
7695 
          self.url = iprot.readString();
7696 
        else:
7697 
          iprot.skip(ftype)
7698 
      elif fid == 3:
7699 
        if ftype == TType.I64:
7700 
          self.masterAffiliateId = iprot.readI64();
7701 
        else:
7702 
          iprot.skip(ftype)
1859 vikas 7703 
      elif fid == 4:
7704 
        if ftype == TType.I64:
7705 
          self.addedOn = iprot.readI64();
7706 
        else:
7707 
          iprot.skip(ftype)
1845 vikas 7708 
      else:
7709 
        iprot.skip(ftype)
7710 
      iprot.readFieldEnd()
7711 
    iprot.readStructEnd()
7712 
 
7713 
  def write(self, oprot):
7714 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7715 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7716 
      return
7717 
    oprot.writeStructBegin('createAffiliate_args')
7718 
    if self.name != None:
7719 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7720 
      oprot.writeString(self.name)
7721 
      oprot.writeFieldEnd()
7722 
    if self.url != None:
7723 
      oprot.writeFieldBegin('url', TType.STRING, 2)
7724 
      oprot.writeString(self.url)
7725 
      oprot.writeFieldEnd()
7726 
    if self.masterAffiliateId != None:
7727 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
7728 
      oprot.writeI64(self.masterAffiliateId)
7729 
      oprot.writeFieldEnd()
1859 vikas 7730 
    if self.addedOn != None:
7731 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
7732 
      oprot.writeI64(self.addedOn)
7733 
      oprot.writeFieldEnd()
1845 vikas 7734 
    oprot.writeFieldStop()
7735 
    oprot.writeStructEnd()
7736 
 
7737 
  def __repr__(self):
7738 
    L = ['%s=%r' % (key, value)
7739 
      for key, value in self.__dict__.iteritems()]
7740 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7741 
 
7742 
  def __eq__(self, other):
7743 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7744 
 
7745 
  def __ne__(self, other):
7746 
    return not (self == other)
7747 
 
7748 
class createAffiliate_result:
7749 
  """
7750 
  Attributes:
7751 
   - success
7752 
   - utx
7753 
  """
7754 
 
7755 
  thrift_spec = (
7756 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 7757 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7758 
  )
7759 
 
7760 
  def __init__(self, success=None, utx=None,):
7761 
    self.success = success
7762 
    self.utx = utx
7763 
 
7764 
  def read(self, iprot):
7765 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7766 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7767 
      return
7768 
    iprot.readStructBegin()
7769 
    while True:
7770 
      (fname, ftype, fid) = iprot.readFieldBegin()
7771 
      if ftype == TType.STOP:
7772 
        break
7773 
      if fid == 0:
7774 
        if ftype == TType.STRUCT:
7775 
          self.success = Affiliate()
7776 
          self.success.read(iprot)
7777 
        else:
7778 
          iprot.skip(ftype)
7779 
      elif fid == 1:
7780 
        if ftype == TType.STRUCT:
1996 vikas 7781 
          self.utx = UserAffiliateException()
1845 vikas 7782 
          self.utx.read(iprot)
7783 
        else:
7784 
          iprot.skip(ftype)
7785 
      else:
7786 
        iprot.skip(ftype)
7787 
      iprot.readFieldEnd()
7788 
    iprot.readStructEnd()
7789 
 
7790 
  def write(self, oprot):
7791 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7792 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7793 
      return
7794 
    oprot.writeStructBegin('createAffiliate_result')
7795 
    if self.success != None:
7796 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7797 
      self.success.write(oprot)
7798 
      oprot.writeFieldEnd()
7799 
    if self.utx != None:
7800 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7801 
      self.utx.write(oprot)
7802 
      oprot.writeFieldEnd()
7803 
    oprot.writeFieldStop()
7804 
    oprot.writeStructEnd()
7805 
 
7806 
  def __repr__(self):
7807 
    L = ['%s=%r' % (key, value)
7808 
      for key, value in self.__dict__.iteritems()]
7809 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7810 
 
7811 
  def __eq__(self, other):
7812 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7813 
 
7814 
  def __ne__(self, other):
7815 
    return not (self == other)
7816 
 
7817 
class getAffiliateById_args:
7818 
  """
7819 
  Attributes:
7820 
   - id
7821 
  """
7822 
 
7823 
  thrift_spec = (
7824 
    None, # 0
7825 
    (1, TType.I64, 'id', None, None, ), # 1
7826 
  )
7827 
 
7828 
  def __init__(self, id=None,):
7829 
    self.id = id
7830 
 
7831 
  def read(self, iprot):
7832 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7833 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7834 
      return
7835 
    iprot.readStructBegin()
7836 
    while True:
7837 
      (fname, ftype, fid) = iprot.readFieldBegin()
7838 
      if ftype == TType.STOP:
7839 
        break
7840 
      if fid == 1:
7841 
        if ftype == TType.I64:
7842 
          self.id = iprot.readI64();
7843 
        else:
7844 
          iprot.skip(ftype)
7845 
      else:
7846 
        iprot.skip(ftype)
7847 
      iprot.readFieldEnd()
7848 
    iprot.readStructEnd()
7849 
 
7850 
  def write(self, oprot):
7851 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7852 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7853 
      return
7854 
    oprot.writeStructBegin('getAffiliateById_args')
7855 
    if self.id != None:
7856 
      oprot.writeFieldBegin('id', TType.I64, 1)
7857 
      oprot.writeI64(self.id)
7858 
      oprot.writeFieldEnd()
7859 
    oprot.writeFieldStop()
7860 
    oprot.writeStructEnd()
7861 
 
7862 
  def __repr__(self):
7863 
    L = ['%s=%r' % (key, value)
7864 
      for key, value in self.__dict__.iteritems()]
7865 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7866 
 
7867 
  def __eq__(self, other):
7868 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7869 
 
7870 
  def __ne__(self, other):
7871 
    return not (self == other)
7872 
 
7873 
class getAffiliateById_result:
7874 
  """
7875 
  Attributes:
7876 
   - success
7877 
   - utx
7878 
  """
7879 
 
7880 
  thrift_spec = (
7881 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 7882 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7883 
  )
7884 
 
7885 
  def __init__(self, success=None, utx=None,):
7886 
    self.success = success
7887 
    self.utx = utx
7888 
 
7889 
  def read(self, iprot):
7890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7892 
      return
7893 
    iprot.readStructBegin()
7894 
    while True:
7895 
      (fname, ftype, fid) = iprot.readFieldBegin()
7896 
      if ftype == TType.STOP:
7897 
        break
7898 
      if fid == 0:
7899 
        if ftype == TType.STRUCT:
7900 
          self.success = Affiliate()
7901 
          self.success.read(iprot)
7902 
        else:
7903 
          iprot.skip(ftype)
7904 
      elif fid == 1:
7905 
        if ftype == TType.STRUCT:
1996 vikas 7906 
          self.utx = UserAffiliateException()
1845 vikas 7907 
          self.utx.read(iprot)
7908 
        else:
7909 
          iprot.skip(ftype)
7910 
      else:
7911 
        iprot.skip(ftype)
7912 
      iprot.readFieldEnd()
7913 
    iprot.readStructEnd()
7914 
 
7915 
  def write(self, oprot):
7916 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7917 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7918 
      return
7919 
    oprot.writeStructBegin('getAffiliateById_result')
7920 
    if self.success != None:
7921 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7922 
      self.success.write(oprot)
7923 
      oprot.writeFieldEnd()
7924 
    if self.utx != None:
7925 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7926 
      self.utx.write(oprot)
7927 
      oprot.writeFieldEnd()
7928 
    oprot.writeFieldStop()
7929 
    oprot.writeStructEnd()
7930 
 
7931 
  def __repr__(self):
7932 
    L = ['%s=%r' % (key, value)
7933 
      for key, value in self.__dict__.iteritems()]
7934 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7935 
 
7936 
  def __eq__(self, other):
7937 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7938 
 
7939 
  def __ne__(self, other):
7940 
    return not (self == other)
7941 
 
7942 
class getAffiliateByName_args:
7943 
  """
7944 
  Attributes:
7945 
   - name
7946 
  """
7947 
 
7948 
  thrift_spec = (
7949 
    None, # 0
7950 
    (1, TType.STRING, 'name', None, None, ), # 1
7951 
  )
7952 
 
7953 
  def __init__(self, name=None,):
7954 
    self.name = name
7955 
 
7956 
  def read(self, iprot):
7957 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7958 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7959 
      return
7960 
    iprot.readStructBegin()
7961 
    while True:
7962 
      (fname, ftype, fid) = iprot.readFieldBegin()
7963 
      if ftype == TType.STOP:
7964 
        break
7965 
      if fid == 1:
7966 
        if ftype == TType.STRING:
7967 
          self.name = iprot.readString();
7968 
        else:
7969 
          iprot.skip(ftype)
7970 
      else:
7971 
        iprot.skip(ftype)
7972 
      iprot.readFieldEnd()
7973 
    iprot.readStructEnd()
7974 
 
7975 
  def write(self, oprot):
7976 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7977 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7978 
      return
7979 
    oprot.writeStructBegin('getAffiliateByName_args')
7980 
    if self.name != None:
7981 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7982 
      oprot.writeString(self.name)
7983 
      oprot.writeFieldEnd()
7984 
    oprot.writeFieldStop()
7985 
    oprot.writeStructEnd()
7986 
 
7987 
  def __repr__(self):
7988 
    L = ['%s=%r' % (key, value)
7989 
      for key, value in self.__dict__.iteritems()]
7990 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7991 
 
7992 
  def __eq__(self, other):
7993 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7994 
 
7995 
  def __ne__(self, other):
7996 
    return not (self == other)
7997 
 
7998 
class getAffiliateByName_result:
7999 
  """
8000 
  Attributes:
8001 
   - success
8002 
   - utx
8003 
  """
8004 
 
8005 
  thrift_spec = (
8006 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8007 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8008 
  )
8009 
 
8010 
  def __init__(self, success=None, utx=None,):
8011 
    self.success = success
8012 
    self.utx = utx
8013 
 
8014 
  def read(self, iprot):
8015 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8016 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8017 
      return
8018 
    iprot.readStructBegin()
8019 
    while True:
8020 
      (fname, ftype, fid) = iprot.readFieldBegin()
8021 
      if ftype == TType.STOP:
8022 
        break
8023 
      if fid == 0:
8024 
        if ftype == TType.STRUCT:
8025 
          self.success = Affiliate()
8026 
          self.success.read(iprot)
8027 
        else:
8028 
          iprot.skip(ftype)
8029 
      elif fid == 1:
8030 
        if ftype == TType.STRUCT:
1996 vikas 8031 
          self.utx = UserAffiliateException()
1845 vikas 8032 
          self.utx.read(iprot)
8033 
        else:
8034 
          iprot.skip(ftype)
8035 
      else:
8036 
        iprot.skip(ftype)
8037 
      iprot.readFieldEnd()
8038 
    iprot.readStructEnd()
8039 
 
8040 
  def write(self, oprot):
8041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8043 
      return
8044 
    oprot.writeStructBegin('getAffiliateByName_result')
8045 
    if self.success != None:
8046 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8047 
      self.success.write(oprot)
8048 
      oprot.writeFieldEnd()
8049 
    if self.utx != None:
8050 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8051 
      self.utx.write(oprot)
8052 
      oprot.writeFieldEnd()
8053 
    oprot.writeFieldStop()
8054 
    oprot.writeStructEnd()
8055 
 
8056 
  def __repr__(self):
8057 
    L = ['%s=%r' % (key, value)
8058 
      for key, value in self.__dict__.iteritems()]
8059 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8060 
 
8061 
  def __eq__(self, other):
8062 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8063 
 
8064 
  def __ne__(self, other):
8065 
    return not (self == other)
8066 
 
1996 vikas 8067 
class getTrackerById_args:
1845 vikas 8068 
  """
8069 
  Attributes:
8070 
   - id
8071 
  """
8072 
 
8073 
  thrift_spec = (
8074 
    None, # 0
8075 
    (1, TType.I64, 'id', None, None, ), # 1
8076 
  )
8077 
 
8078 
  def __init__(self, id=None,):
8079 
    self.id = id
8080 
 
8081 
  def read(self, iprot):
8082 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8083 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8084 
      return
8085 
    iprot.readStructBegin()
8086 
    while True:
8087 
      (fname, ftype, fid) = iprot.readFieldBegin()
8088 
      if ftype == TType.STOP:
8089 
        break
8090 
      if fid == 1:
8091 
        if ftype == TType.I64:
8092 
          self.id = iprot.readI64();
8093 
        else:
8094 
          iprot.skip(ftype)
8095 
      else:
8096 
        iprot.skip(ftype)
8097 
      iprot.readFieldEnd()
8098 
    iprot.readStructEnd()
8099 
 
8100 
  def write(self, oprot):
8101 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8102 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8103 
      return
1996 vikas 8104 
    oprot.writeStructBegin('getTrackerById_args')
1845 vikas 8105 
    if self.id != None:
8106 
      oprot.writeFieldBegin('id', TType.I64, 1)
8107 
      oprot.writeI64(self.id)
8108 
      oprot.writeFieldEnd()
8109 
    oprot.writeFieldStop()
8110 
    oprot.writeStructEnd()
8111 
 
8112 
  def __repr__(self):
8113 
    L = ['%s=%r' % (key, value)
8114 
      for key, value in self.__dict__.iteritems()]
8115 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8116 
 
8117 
  def __eq__(self, other):
8118 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8119 
 
8120 
  def __ne__(self, other):
8121 
    return not (self == other)
8122 
 
8123 
class getTrackerById_result:
8124 
  """
8125 
  Attributes:
8126 
   - success
8127 
   - utx
8128 
  """
8129 
 
8130 
  thrift_spec = (
8131 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 8132 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8133 
  )
8134 
 
8135 
  def __init__(self, success=None, utx=None,):
8136 
    self.success = success
8137 
    self.utx = utx
8138 
 
8139 
  def read(self, iprot):
8140 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8141 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8142 
      return
8143 
    iprot.readStructBegin()
8144 
    while True:
8145 
      (fname, ftype, fid) = iprot.readFieldBegin()
8146 
      if ftype == TType.STOP:
8147 
        break
8148 
      if fid == 0:
8149 
        if ftype == TType.STRUCT:
8150 
          self.success = Tracker()
8151 
          self.success.read(iprot)
8152 
        else:
8153 
          iprot.skip(ftype)
8154 
      elif fid == 1:
8155 
        if ftype == TType.STRUCT:
1996 vikas 8156 
          self.utx = UserAffiliateException()
1845 vikas 8157 
          self.utx.read(iprot)
8158 
        else:
8159 
          iprot.skip(ftype)
8160 
      else:
8161 
        iprot.skip(ftype)
8162 
      iprot.readFieldEnd()
8163 
    iprot.readStructEnd()
8164 
 
8165 
  def write(self, oprot):
8166 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8167 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8168 
      return
8169 
    oprot.writeStructBegin('getTrackerById_result')
8170 
    if self.success != None:
8171 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8172 
      self.success.write(oprot)
8173 
      oprot.writeFieldEnd()
8174 
    if self.utx != None:
8175 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8176 
      self.utx.write(oprot)
8177 
      oprot.writeFieldEnd()
8178 
    oprot.writeFieldStop()
8179 
    oprot.writeStructEnd()
8180 
 
8181 
  def __repr__(self):
8182 
    L = ['%s=%r' % (key, value)
8183 
      for key, value in self.__dict__.iteritems()]
8184 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8185 
 
8186 
  def __eq__(self, other):
8187 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8188 
 
8189 
  def __ne__(self, other):
8190 
    return not (self == other)
8191 
 
1996 vikas 8192 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 8193 
  """
8194 
  Attributes:
1996 vikas 8195 
   - id
1845 vikas 8196 
  """
8197 
 
8198 
  thrift_spec = (
8199 
    None, # 0
1996 vikas 8200 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 8201 
  )
8202 
 
1996 vikas 8203 
  def __init__(self, id=None,):
8204 
    self.id = id
1845 vikas 8205 
 
8206 
  def read(self, iprot):
8207 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8208 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8209 
      return
8210 
    iprot.readStructBegin()
8211 
    while True:
8212 
      (fname, ftype, fid) = iprot.readFieldBegin()
8213 
      if ftype == TType.STOP:
8214 
        break
8215 
      if fid == 1:
8216 
        if ftype == TType.I64:
1996 vikas 8217 
          self.id = iprot.readI64();
1845 vikas 8218 
        else:
8219 
          iprot.skip(ftype)
8220 
      else:
8221 
        iprot.skip(ftype)
8222 
      iprot.readFieldEnd()
8223 
    iprot.readStructEnd()
8224 
 
8225 
  def write(self, oprot):
8226 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8227 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8228 
      return
1996 vikas 8229 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
8230 
    if self.id != None:
8231 
      oprot.writeFieldBegin('id', TType.I64, 1)
8232 
      oprot.writeI64(self.id)
1845 vikas 8233 
      oprot.writeFieldEnd()
8234 
    oprot.writeFieldStop()
8235 
    oprot.writeStructEnd()
8236 
 
8237 
  def __repr__(self):
8238 
    L = ['%s=%r' % (key, value)
8239 
      for key, value in self.__dict__.iteritems()]
8240 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8241 
 
8242 
  def __eq__(self, other):
8243 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8244 
 
8245 
  def __ne__(self, other):
8246 
    return not (self == other)
8247 
 
1996 vikas 8248 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 8249 
  """
8250 
  Attributes:
8251 
   - success
8252 
   - utx
8253 
  """
8254 
 
8255 
  thrift_spec = (
1996 vikas 8256 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
8257 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8258 
  )
8259 
 
8260 
  def __init__(self, success=None, utx=None,):
8261 
    self.success = success
8262 
    self.utx = utx
8263 
 
8264 
  def read(self, iprot):
8265 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8266 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8267 
      return
8268 
    iprot.readStructBegin()
8269 
    while True:
8270 
      (fname, ftype, fid) = iprot.readFieldBegin()
8271 
      if ftype == TType.STOP:
8272 
        break
8273 
      if fid == 0:
8274 
        if ftype == TType.LIST:
8275 
          self.success = []
1996 vikas 8276 
          (_etype66, _size63) = iprot.readListBegin()
8277 
          for _i67 in xrange(_size63):
8278 
            _elem68 = Affiliate()
8279 
            _elem68.read(iprot)
8280 
            self.success.append(_elem68)
1845 vikas 8281 
          iprot.readListEnd()
8282 
        else:
8283 
          iprot.skip(ftype)
8284 
      elif fid == 1:
8285 
        if ftype == TType.STRUCT:
1996 vikas 8286 
          self.utx = UserAffiliateException()
1845 vikas 8287 
          self.utx.read(iprot)
8288 
        else:
8289 
          iprot.skip(ftype)
8290 
      else:
8291 
        iprot.skip(ftype)
8292 
      iprot.readFieldEnd()
8293 
    iprot.readStructEnd()
8294 
 
8295 
  def write(self, oprot):
8296 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8297 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8298 
      return
1996 vikas 8299 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
1845 vikas 8300 
    if self.success != None:
8301 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8302 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 8303 
      for iter69 in self.success:
8304 
        iter69.write(oprot)
1845 vikas 8305 
      oprot.writeListEnd()
8306 
      oprot.writeFieldEnd()
8307 
    if self.utx != None:
8308 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8309 
      self.utx.write(oprot)
8310 
      oprot.writeFieldEnd()
8311 
    oprot.writeFieldStop()
8312 
    oprot.writeStructEnd()
8313 
 
8314 
  def __repr__(self):
8315 
    L = ['%s=%r' % (key, value)
8316 
      for key, value in self.__dict__.iteritems()]
8317 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8318 
 
8319 
  def __eq__(self, other):
8320 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8321 
 
8322 
  def __ne__(self, other):
8323 
    return not (self == other)
8324 
 
8325 
class addTrackLog_args:
8326 
  """
8327 
  Attributes:
1996 vikas 8328 
   - affiliateId
1845 vikas 8329 
   - userId
8330 
   - event
8331 
   - url
8332 
   - data
1859 vikas 8333 
   - addedOn
1845 vikas 8334 
  """
8335 
 
8336 
  thrift_spec = (
8337 
    None, # 0
1996 vikas 8338 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 8339 
    (2, TType.I64, 'userId', None, None, ), # 2
8340 
    (3, TType.STRING, 'event', None, None, ), # 3
8341 
    (4, TType.STRING, 'url', None, None, ), # 4
8342 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 8343 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 8344 
  )
8345 
 
1996 vikas 8346 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
8347 
    self.affiliateId = affiliateId
1845 vikas 8348 
    self.userId = userId
8349 
    self.event = event
8350 
    self.url = url
8351 
    self.data = data
1859 vikas 8352 
    self.addedOn = addedOn
1845 vikas 8353 
 
8354 
  def read(self, iprot):
8355 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8356 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8357 
      return
8358 
    iprot.readStructBegin()
8359 
    while True:
8360 
      (fname, ftype, fid) = iprot.readFieldBegin()
8361 
      if ftype == TType.STOP:
8362 
        break
8363 
      if fid == 1:
8364 
        if ftype == TType.I64:
1996 vikas 8365 
          self.affiliateId = iprot.readI64();
1845 vikas 8366 
        else:
8367 
          iprot.skip(ftype)
8368 
      elif fid == 2:
8369 
        if ftype == TType.I64:
8370 
          self.userId = iprot.readI64();
8371 
        else:
8372 
          iprot.skip(ftype)
8373 
      elif fid == 3:
8374 
        if ftype == TType.STRING:
8375 
          self.event = iprot.readString();
8376 
        else:
8377 
          iprot.skip(ftype)
8378 
      elif fid == 4:
8379 
        if ftype == TType.STRING:
8380 
          self.url = iprot.readString();
8381 
        else:
8382 
          iprot.skip(ftype)
8383 
      elif fid == 5:
8384 
        if ftype == TType.STRING:
8385 
          self.data = iprot.readString();
8386 
        else:
8387 
          iprot.skip(ftype)
1859 vikas 8388 
      elif fid == 6:
8389 
        if ftype == TType.I64:
8390 
          self.addedOn = iprot.readI64();
8391 
        else:
8392 
          iprot.skip(ftype)
1845 vikas 8393 
      else:
8394 
        iprot.skip(ftype)
8395 
      iprot.readFieldEnd()
8396 
    iprot.readStructEnd()
8397 
 
8398 
  def write(self, oprot):
8399 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8400 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8401 
      return
8402 
    oprot.writeStructBegin('addTrackLog_args')
1996 vikas 8403 
    if self.affiliateId != None:
8404 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
8405 
      oprot.writeI64(self.affiliateId)
1845 vikas 8406 
      oprot.writeFieldEnd()
8407 
    if self.userId != None:
8408 
      oprot.writeFieldBegin('userId', TType.I64, 2)
8409 
      oprot.writeI64(self.userId)
8410 
      oprot.writeFieldEnd()
8411 
    if self.event != None:
8412 
      oprot.writeFieldBegin('event', TType.STRING, 3)
8413 
      oprot.writeString(self.event)
8414 
      oprot.writeFieldEnd()
8415 
    if self.url != None:
8416 
      oprot.writeFieldBegin('url', TType.STRING, 4)
8417 
      oprot.writeString(self.url)
8418 
      oprot.writeFieldEnd()
8419 
    if self.data != None:
8420 
      oprot.writeFieldBegin('data', TType.STRING, 5)
8421 
      oprot.writeString(self.data)
8422 
      oprot.writeFieldEnd()
1859 vikas 8423 
    if self.addedOn != None:
8424 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
8425 
      oprot.writeI64(self.addedOn)
8426 
      oprot.writeFieldEnd()
1845 vikas 8427 
    oprot.writeFieldStop()
8428 
    oprot.writeStructEnd()
8429 
 
8430 
  def __repr__(self):
8431 
    L = ['%s=%r' % (key, value)
8432 
      for key, value in self.__dict__.iteritems()]
8433 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8434 
 
8435 
  def __eq__(self, other):
8436 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8437 
 
8438 
  def __ne__(self, other):
8439 
    return not (self == other)
8440 
 
8441 
class addTrackLog_result:
8442 
  """
8443 
  Attributes:
8444 
   - success
8445 
   - utx
8446 
  """
8447 
 
8448 
  thrift_spec = (
8449 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 8450 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8451 
  )
8452 
 
8453 
  def __init__(self, success=None, utx=None,):
8454 
    self.success = success
8455 
    self.utx = utx
8456 
 
8457 
  def read(self, iprot):
8458 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8459 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8460 
      return
8461 
    iprot.readStructBegin()
8462 
    while True:
8463 
      (fname, ftype, fid) = iprot.readFieldBegin()
8464 
      if ftype == TType.STOP:
8465 
        break
8466 
      if fid == 0:
8467 
        if ftype == TType.I64:
8468 
          self.success = iprot.readI64();
8469 
        else:
8470 
          iprot.skip(ftype)
8471 
      elif fid == 1:
8472 
        if ftype == TType.STRUCT:
1996 vikas 8473 
          self.utx = UserAffiliateException()
1845 vikas 8474 
          self.utx.read(iprot)
8475 
        else:
8476 
          iprot.skip(ftype)
8477 
      else:
8478 
        iprot.skip(ftype)
8479 
      iprot.readFieldEnd()
8480 
    iprot.readStructEnd()
8481 
 
8482 
  def write(self, oprot):
8483 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8484 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8485 
      return
8486 
    oprot.writeStructBegin('addTrackLog_result')
8487 
    if self.success != None:
8488 
      oprot.writeFieldBegin('success', TType.I64, 0)
8489 
      oprot.writeI64(self.success)
8490 
      oprot.writeFieldEnd()
8491 
    if self.utx != None:
8492 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8493 
      self.utx.write(oprot)
8494 
      oprot.writeFieldEnd()
8495 
    oprot.writeFieldStop()
8496 
    oprot.writeStructEnd()
8497 
 
8498 
  def __repr__(self):
8499 
    L = ['%s=%r' % (key, value)
8500 
      for key, value in self.__dict__.iteritems()]
8501 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8502 
 
8503 
  def __eq__(self, other):
8504 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8505 
 
8506 
  def __ne__(self, other):
8507 
    return not (self == other)
8508 
 
8509 
class getTrackLogById_args:
8510 
  """
8511 
  Attributes:
8512 
   - id
8513 
  """
8514 
 
8515 
  thrift_spec = (
8516 
    None, # 0
8517 
    (1, TType.I64, 'id', None, None, ), # 1
8518 
  )
8519 
 
8520 
  def __init__(self, id=None,):
8521 
    self.id = id
8522 
 
8523 
  def read(self, iprot):
8524 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8525 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8526 
      return
8527 
    iprot.readStructBegin()
8528 
    while True:
8529 
      (fname, ftype, fid) = iprot.readFieldBegin()
8530 
      if ftype == TType.STOP:
8531 
        break
8532 
      if fid == 1:
8533 
        if ftype == TType.I64:
8534 
          self.id = iprot.readI64();
8535 
        else:
8536 
          iprot.skip(ftype)
8537 
      else:
8538 
        iprot.skip(ftype)
8539 
      iprot.readFieldEnd()
8540 
    iprot.readStructEnd()
8541 
 
8542 
  def write(self, oprot):
8543 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8544 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8545 
      return
8546 
    oprot.writeStructBegin('getTrackLogById_args')
8547 
    if self.id != None:
8548 
      oprot.writeFieldBegin('id', TType.I64, 1)
8549 
      oprot.writeI64(self.id)
8550 
      oprot.writeFieldEnd()
8551 
    oprot.writeFieldStop()
8552 
    oprot.writeStructEnd()
8553 
 
8554 
  def __repr__(self):
8555 
    L = ['%s=%r' % (key, value)
8556 
      for key, value in self.__dict__.iteritems()]
8557 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8558 
 
8559 
  def __eq__(self, other):
8560 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8561 
 
8562 
  def __ne__(self, other):
8563 
    return not (self == other)
8564 
 
8565 
class getTrackLogById_result:
8566 
  """
8567 
  Attributes:
8568 
   - success
8569 
   - utx
8570 
  """
8571 
 
8572 
  thrift_spec = (
8573 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 8574 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8575 
  )
8576 
 
8577 
  def __init__(self, success=None, utx=None,):
8578 
    self.success = success
8579 
    self.utx = utx
8580 
 
8581 
  def read(self, iprot):
8582 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8583 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8584 
      return
8585 
    iprot.readStructBegin()
8586 
    while True:
8587 
      (fname, ftype, fid) = iprot.readFieldBegin()
8588 
      if ftype == TType.STOP:
8589 
        break
8590 
      if fid == 0:
8591 
        if ftype == TType.STRUCT:
8592 
          self.success = TrackLog()
8593 
          self.success.read(iprot)
8594 
        else:
8595 
          iprot.skip(ftype)
8596 
      elif fid == 1:
8597 
        if ftype == TType.STRUCT:
1996 vikas 8598 
          self.utx = UserAffiliateException()
1845 vikas 8599 
          self.utx.read(iprot)
8600 
        else:
8601 
          iprot.skip(ftype)
8602 
      else:
8603 
        iprot.skip(ftype)
8604 
      iprot.readFieldEnd()
8605 
    iprot.readStructEnd()
8606 
 
8607 
  def write(self, oprot):
8608 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8609 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8610 
      return
8611 
    oprot.writeStructBegin('getTrackLogById_result')
8612 
    if self.success != None:
8613 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8614 
      self.success.write(oprot)
8615 
      oprot.writeFieldEnd()
8616 
    if self.utx != None:
8617 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8618 
      self.utx.write(oprot)
8619 
      oprot.writeFieldEnd()
8620 
    oprot.writeFieldStop()
8621 
    oprot.writeStructEnd()
8622 
 
8623 
  def __repr__(self):
8624 
    L = ['%s=%r' % (key, value)
8625 
      for key, value in self.__dict__.iteritems()]
8626 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8627 
 
8628 
  def __eq__(self, other):
8629 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8630 
 
8631 
  def __ne__(self, other):
8632 
    return not (self == other)
8633 
 
1996 vikas 8634 
class getTrackLogsByAffiliate_args:
1845 vikas 8635 
  """
8636 
  Attributes:
1996 vikas 8637 
   - affiliateId
1845 vikas 8638 
  """
8639 
 
8640 
  thrift_spec = (
8641 
    None, # 0
1996 vikas 8642 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 8643 
  )
8644 
 
1996 vikas 8645 
  def __init__(self, affiliateId=None,):
8646 
    self.affiliateId = affiliateId
1845 vikas 8647 
 
8648 
  def read(self, iprot):
8649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8651 
      return
8652 
    iprot.readStructBegin()
8653 
    while True:
8654 
      (fname, ftype, fid) = iprot.readFieldBegin()
8655 
      if ftype == TType.STOP:
8656 
        break
8657 
      if fid == 1:
8658 
        if ftype == TType.I64:
1996 vikas 8659 
          self.affiliateId = iprot.readI64();
1845 vikas 8660 
        else:
8661 
          iprot.skip(ftype)
8662 
      else:
8663 
        iprot.skip(ftype)
8664 
      iprot.readFieldEnd()
8665 
    iprot.readStructEnd()
8666 
 
8667 
  def write(self, oprot):
8668 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8669 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8670 
      return
1996 vikas 8671 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
8672 
    if self.affiliateId != None:
8673 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
8674 
      oprot.writeI64(self.affiliateId)
1845 vikas 8675 
      oprot.writeFieldEnd()
8676 
    oprot.writeFieldStop()
8677 
    oprot.writeStructEnd()
8678 
 
8679 
  def __repr__(self):
8680 
    L = ['%s=%r' % (key, value)
8681 
      for key, value in self.__dict__.iteritems()]
8682 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8683 
 
8684 
  def __eq__(self, other):
8685 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8686 
 
8687 
  def __ne__(self, other):
8688 
    return not (self == other)
8689 
 
1996 vikas 8690 
class getTrackLogsByAffiliate_result:
1845 vikas 8691 
  """
8692 
  Attributes:
8693 
   - success
8694 
   - utx
8695 
  """
8696 
 
8697 
  thrift_spec = (
8698 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 8699 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8700 
  )
8701 
 
8702 
  def __init__(self, success=None, utx=None,):
8703 
    self.success = success
8704 
    self.utx = utx
8705 
 
8706 
  def read(self, iprot):
8707 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8708 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8709 
      return
8710 
    iprot.readStructBegin()
8711 
    while True:
8712 
      (fname, ftype, fid) = iprot.readFieldBegin()
8713 
      if ftype == TType.STOP:
8714 
        break
8715 
      if fid == 0:
8716 
        if ftype == TType.LIST:
8717 
          self.success = []
1996 vikas 8718 
          (_etype73, _size70) = iprot.readListBegin()
8719 
          for _i74 in xrange(_size70):
8720 
            _elem75 = TrackLog()
8721 
            _elem75.read(iprot)
8722 
            self.success.append(_elem75)
1845 vikas 8723 
          iprot.readListEnd()
8724 
        else:
8725 
          iprot.skip(ftype)
8726 
      elif fid == 1:
8727 
        if ftype == TType.STRUCT:
1996 vikas 8728 
          self.utx = UserAffiliateException()
1845 vikas 8729 
          self.utx.read(iprot)
8730 
        else:
8731 
          iprot.skip(ftype)
8732 
      else:
8733 
        iprot.skip(ftype)
8734 
      iprot.readFieldEnd()
8735 
    iprot.readStructEnd()
8736 
 
8737 
  def write(self, oprot):
8738 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8739 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8740 
      return
1996 vikas 8741 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
1845 vikas 8742 
    if self.success != None:
8743 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8744 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 8745 
      for iter76 in self.success:
8746 
        iter76.write(oprot)
1845 vikas 8747 
      oprot.writeListEnd()
8748 
      oprot.writeFieldEnd()
8749 
    if self.utx != None:
8750 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8751 
      self.utx.write(oprot)
8752 
      oprot.writeFieldEnd()
8753 
    oprot.writeFieldStop()
8754 
    oprot.writeStructEnd()
8755 
 
8756 
  def __repr__(self):
8757 
    L = ['%s=%r' % (key, value)
8758 
      for key, value in self.__dict__.iteritems()]
8759 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8760 
 
8761 
  def __eq__(self, other):
8762 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8763 
 
8764 
  def __ne__(self, other):
8765 
    return not (self == other)
8766 
 
8767 
class getTrackLogsByUser_args:
8768 
  """
8769 
  Attributes:
8770 
   - userId
8771 
  """
8772 
 
8773 
  thrift_spec = (
8774 
    None, # 0
8775 
    (1, TType.I64, 'userId', None, None, ), # 1
8776 
  )
8777 
 
8778 
  def __init__(self, userId=None,):
8779 
    self.userId = userId
8780 
 
8781 
  def read(self, iprot):
8782 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8783 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8784 
      return
8785 
    iprot.readStructBegin()
8786 
    while True:
8787 
      (fname, ftype, fid) = iprot.readFieldBegin()
8788 
      if ftype == TType.STOP:
8789 
        break
8790 
      if fid == 1:
8791 
        if ftype == TType.I64:
8792 
          self.userId = iprot.readI64();
8793 
        else:
8794 
          iprot.skip(ftype)
8795 
      else:
8796 
        iprot.skip(ftype)
8797 
      iprot.readFieldEnd()
8798 
    iprot.readStructEnd()
8799 
 
8800 
  def write(self, oprot):
8801 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8802 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8803 
      return
8804 
    oprot.writeStructBegin('getTrackLogsByUser_args')
8805 
    if self.userId != None:
8806 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8807 
      oprot.writeI64(self.userId)
8808 
      oprot.writeFieldEnd()
8809 
    oprot.writeFieldStop()
8810 
    oprot.writeStructEnd()
8811 
 
8812 
  def __repr__(self):
8813 
    L = ['%s=%r' % (key, value)
8814 
      for key, value in self.__dict__.iteritems()]
8815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8816 
 
8817 
  def __eq__(self, other):
8818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8819 
 
8820 
  def __ne__(self, other):
8821 
    return not (self == other)
8822 
 
8823 
class getTrackLogsByUser_result:
8824 
  """
8825 
  Attributes:
8826 
   - success
8827 
   - utx
8828 
  """
8829 
 
8830 
  thrift_spec = (
8831 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 8832 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8833 
  )
8834 
 
8835 
  def __init__(self, success=None, utx=None,):
8836 
    self.success = success
8837 
    self.utx = utx
8838 
 
8839 
  def read(self, iprot):
8840 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8841 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8842 
      return
8843 
    iprot.readStructBegin()
8844 
    while True:
8845 
      (fname, ftype, fid) = iprot.readFieldBegin()
8846 
      if ftype == TType.STOP:
8847 
        break
8848 
      if fid == 0:
8849 
        if ftype == TType.LIST:
8850 
          self.success = []
1996 vikas 8851 
          (_etype80, _size77) = iprot.readListBegin()
8852 
          for _i81 in xrange(_size77):
8853 
            _elem82 = TrackLog()
8854 
            _elem82.read(iprot)
8855 
            self.success.append(_elem82)
1845 vikas 8856 
          iprot.readListEnd()
8857 
        else:
8858 
          iprot.skip(ftype)
8859 
      elif fid == 1:
8860 
        if ftype == TType.STRUCT:
1996 vikas 8861 
          self.utx = UserAffiliateException()
1845 vikas 8862 
          self.utx.read(iprot)
8863 
        else:
8864 
          iprot.skip(ftype)
8865 
      else:
8866 
        iprot.skip(ftype)
8867 
      iprot.readFieldEnd()
8868 
    iprot.readStructEnd()
8869 
 
8870 
  def write(self, oprot):
8871 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8872 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8873 
      return
8874 
    oprot.writeStructBegin('getTrackLogsByUser_result')
8875 
    if self.success != None:
8876 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8877 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 8878 
      for iter83 in self.success:
8879 
        iter83.write(oprot)
1845 vikas 8880 
      oprot.writeListEnd()
8881 
      oprot.writeFieldEnd()
8882 
    if self.utx != None:
8883 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8884 
      self.utx.write(oprot)
8885 
      oprot.writeFieldEnd()
8886 
    oprot.writeFieldStop()
8887 
    oprot.writeStructEnd()
8888 
 
8889 
  def __repr__(self):
8890 
    L = ['%s=%r' % (key, value)
8891 
      for key, value in self.__dict__.iteritems()]
8892 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8893 
 
8894 
  def __eq__(self, other):
8895 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8896 
 
8897 
  def __ne__(self, other):
8898 
    return not (self == other)
8899 
 
8900 
class getTrackLogs_args:
8901 
  """
8902 
  Attributes:
8903 
   - userId
8904 
   - event
8905 
   - url
8906 
  """
8907 
 
8908 
  thrift_spec = (
8909 
    None, # 0
1996 vikas 8910 
    (1, TType.I64, 'userId', None, None, ), # 1
8911 
    (2, TType.STRING, 'event', None, None, ), # 2
8912 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 8913 
  )
8914 
 
1996 vikas 8915 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 8916 
    self.userId = userId
8917 
    self.event = event
8918 
    self.url = url
8919 
 
8920 
  def read(self, iprot):
8921 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8922 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8923 
      return
8924 
    iprot.readStructBegin()
8925 
    while True:
8926 
      (fname, ftype, fid) = iprot.readFieldBegin()
8927 
      if ftype == TType.STOP:
8928 
        break
8929 
      if fid == 1:
8930 
        if ftype == TType.I64:
1996 vikas 8931 
          self.userId = iprot.readI64();
1845 vikas 8932 
        else:
8933 
          iprot.skip(ftype)
8934 
      elif fid == 2:
8935 
        if ftype == TType.STRING:
8936 
          self.event = iprot.readString();
8937 
        else:
8938 
          iprot.skip(ftype)
1996 vikas 8939 
      elif fid == 3:
1845 vikas 8940 
        if ftype == TType.STRING:
8941 
          self.url = iprot.readString();
8942 
        else:
8943 
          iprot.skip(ftype)
8944 
      else:
8945 
        iprot.skip(ftype)
8946 
      iprot.readFieldEnd()
8947 
    iprot.readStructEnd()
8948 
 
8949 
  def write(self, oprot):
8950 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8951 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8952 
      return
8953 
    oprot.writeStructBegin('getTrackLogs_args')
8954 
    if self.userId != None:
1996 vikas 8955 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 8956 
      oprot.writeI64(self.userId)
8957 
      oprot.writeFieldEnd()
8958 
    if self.event != None:
1996 vikas 8959 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 8960 
      oprot.writeString(self.event)
8961 
      oprot.writeFieldEnd()
8962 
    if self.url != None:
1996 vikas 8963 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 8964 
      oprot.writeString(self.url)
8965 
      oprot.writeFieldEnd()
8966 
    oprot.writeFieldStop()
8967 
    oprot.writeStructEnd()
8968 
 
8969 
  def __repr__(self):
8970 
    L = ['%s=%r' % (key, value)
8971 
      for key, value in self.__dict__.iteritems()]
8972 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8973 
 
8974 
  def __eq__(self, other):
8975 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8976 
 
8977 
  def __ne__(self, other):
8978 
    return not (self == other)
8979 
 
8980 
class getTrackLogs_result:
8981 
  """
8982 
  Attributes:
8983 
   - success
8984 
   - utx
8985 
  """
8986 
 
8987 
  thrift_spec = (
8988 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 8989 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8990 
  )
8991 
 
8992 
  def __init__(self, success=None, utx=None,):
8993 
    self.success = success
8994 
    self.utx = utx
8995 
 
8996 
  def read(self, iprot):
8997 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8998 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8999 
      return
9000 
    iprot.readStructBegin()
9001 
    while True:
9002 
      (fname, ftype, fid) = iprot.readFieldBegin()
9003 
      if ftype == TType.STOP:
9004 
        break
9005 
      if fid == 0:
9006 
        if ftype == TType.LIST:
9007 
          self.success = []
1996 vikas 9008 
          (_etype87, _size84) = iprot.readListBegin()
9009 
          for _i88 in xrange(_size84):
9010 
            _elem89 = TrackLog()
9011 
            _elem89.read(iprot)
9012 
            self.success.append(_elem89)
1845 vikas 9013 
          iprot.readListEnd()
9014 
        else:
9015 
          iprot.skip(ftype)
9016 
      elif fid == 1:
9017 
        if ftype == TType.STRUCT:
1996 vikas 9018 
          self.utx = UserAffiliateException()
1845 vikas 9019 
          self.utx.read(iprot)
9020 
        else:
9021 
          iprot.skip(ftype)
9022 
      else:
9023 
        iprot.skip(ftype)
9024 
      iprot.readFieldEnd()
9025 
    iprot.readStructEnd()
9026 
 
9027 
  def write(self, oprot):
9028 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9029 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9030 
      return
9031 
    oprot.writeStructBegin('getTrackLogs_result')
9032 
    if self.success != None:
9033 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9034 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 9035 
      for iter90 in self.success:
9036 
        iter90.write(oprot)
1845 vikas 9037 
      oprot.writeListEnd()
9038 
      oprot.writeFieldEnd()
9039 
    if self.utx != None:
9040 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9041 
      self.utx.write(oprot)
9042 
      oprot.writeFieldEnd()
9043 
    oprot.writeFieldStop()
9044 
    oprot.writeStructEnd()
9045 
 
9046 
  def __repr__(self):
9047 
    L = ['%s=%r' % (key, value)
9048 
      for key, value in self.__dict__.iteritems()]
9049 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9050 
 
9051 
  def __eq__(self, other):
9052 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9053 
 
9054 
  def __ne__(self, other):
9055 
    return not (self == other)
9056 
 
559 chandransh 9057 
class createCart_args:
94 ashish 9058 
  """
9059 
  Attributes:
559 chandransh 9060 
   - userId
94 ashish 9061 
  """
9062 
 
9063 
  thrift_spec = (
9064 
    None, # 0
559 chandransh 9065 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 9066 
  )
9067 
 
559 chandransh 9068 
  def __init__(self, userId=None,):
9069 
    self.userId = userId
94 ashish 9070 
 
9071 
  def read(self, iprot):
9072 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9073 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9074 
      return
9075 
    iprot.readStructBegin()
9076 
    while True:
9077 
      (fname, ftype, fid) = iprot.readFieldBegin()
9078 
      if ftype == TType.STOP:
9079 
        break
9080 
      if fid == 1:
9081 
        if ftype == TType.I64:
559 chandransh 9082 
          self.userId = iprot.readI64();
94 ashish 9083 
        else:
9084 
          iprot.skip(ftype)
559 chandransh 9085 
      else:
9086 
        iprot.skip(ftype)
9087 
      iprot.readFieldEnd()
9088 
    iprot.readStructEnd()
9089 
 
9090 
  def write(self, oprot):
9091 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9092 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9093 
      return
9094 
    oprot.writeStructBegin('createCart_args')
9095 
    if self.userId != None:
9096 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9097 
      oprot.writeI64(self.userId)
9098 
      oprot.writeFieldEnd()
9099 
    oprot.writeFieldStop()
9100 
    oprot.writeStructEnd()
9101 
 
9102 
  def __repr__(self):
9103 
    L = ['%s=%r' % (key, value)
9104 
      for key, value in self.__dict__.iteritems()]
9105 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9106 
 
9107 
  def __eq__(self, other):
9108 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9109 
 
9110 
  def __ne__(self, other):
9111 
    return not (self == other)
9112 
 
9113 
class createCart_result:
9114 
  """
9115 
  Attributes:
9116 
   - success
9117 
   - scx
9118 
  """
9119 
 
9120 
  thrift_spec = (
9121 
    (0, TType.I64, 'success', None, None, ), # 0
9122 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9123 
  )
9124 
 
9125 
  def __init__(self, success=None, scx=None,):
9126 
    self.success = success
9127 
    self.scx = scx
9128 
 
9129 
  def read(self, iprot):
9130 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9131 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9132 
      return
9133 
    iprot.readStructBegin()
9134 
    while True:
9135 
      (fname, ftype, fid) = iprot.readFieldBegin()
9136 
      if ftype == TType.STOP:
9137 
        break
9138 
      if fid == 0:
94 ashish 9139 
        if ftype == TType.I64:
559 chandransh 9140 
          self.success = iprot.readI64();
94 ashish 9141 
        else:
9142 
          iprot.skip(ftype)
559 chandransh 9143 
      elif fid == 1:
9144 
        if ftype == TType.STRUCT:
9145 
          self.scx = ShoppingCartException()
9146 
          self.scx.read(iprot)
9147 
        else:
9148 
          iprot.skip(ftype)
94 ashish 9149 
      else:
9150 
        iprot.skip(ftype)
9151 
      iprot.readFieldEnd()
9152 
    iprot.readStructEnd()
9153 
 
9154 
  def write(self, oprot):
9155 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9156 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9157 
      return
559 chandransh 9158 
    oprot.writeStructBegin('createCart_result')
9159 
    if self.success != None:
9160 
      oprot.writeFieldBegin('success', TType.I64, 0)
9161 
      oprot.writeI64(self.success)
94 ashish 9162 
      oprot.writeFieldEnd()
559 chandransh 9163 
    if self.scx != None:
9164 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9165 
      self.scx.write(oprot)
94 ashish 9166 
      oprot.writeFieldEnd()
9167 
    oprot.writeFieldStop()
9168 
    oprot.writeStructEnd()
9169 
 
9170 
  def __repr__(self):
9171 
    L = ['%s=%r' % (key, value)
9172 
      for key, value in self.__dict__.iteritems()]
9173 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9174 
 
9175 
  def __eq__(self, other):
9176 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9177 
 
9178 
  def __ne__(self, other):
9179 
    return not (self == other)
9180 
 
559 chandransh 9181 
class getCurrentCart_args:
94 ashish 9182 
  """
9183 
  Attributes:
559 chandransh 9184 
   - userId
9185 
  """
9186 
 
9187 
  thrift_spec = (
9188 
    None, # 0
9189 
    (1, TType.I64, 'userId', None, None, ), # 1
9190 
  )
9191 
 
9192 
  def __init__(self, userId=None,):
9193 
    self.userId = userId
9194 
 
9195 
  def read(self, iprot):
9196 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9197 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9198 
      return
9199 
    iprot.readStructBegin()
9200 
    while True:
9201 
      (fname, ftype, fid) = iprot.readFieldBegin()
9202 
      if ftype == TType.STOP:
9203 
        break
9204 
      if fid == 1:
9205 
        if ftype == TType.I64:
9206 
          self.userId = iprot.readI64();
9207 
        else:
9208 
          iprot.skip(ftype)
9209 
      else:
9210 
        iprot.skip(ftype)
9211 
      iprot.readFieldEnd()
9212 
    iprot.readStructEnd()
9213 
 
9214 
  def write(self, oprot):
9215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9217 
      return
9218 
    oprot.writeStructBegin('getCurrentCart_args')
9219 
    if self.userId != None:
9220 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9221 
      oprot.writeI64(self.userId)
9222 
      oprot.writeFieldEnd()
9223 
    oprot.writeFieldStop()
9224 
    oprot.writeStructEnd()
9225 
 
9226 
  def __repr__(self):
9227 
    L = ['%s=%r' % (key, value)
9228 
      for key, value in self.__dict__.iteritems()]
9229 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9230 
 
9231 
  def __eq__(self, other):
9232 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9233 
 
9234 
  def __ne__(self, other):
9235 
    return not (self == other)
9236 
 
9237 
class getCurrentCart_result:
9238 
  """
9239 
  Attributes:
94 ashish 9240 
   - success
559 chandransh 9241 
   - scx
94 ashish 9242 
  """
9243 
 
9244 
  thrift_spec = (
559 chandransh 9245 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9246 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9247 
  )
9248 
 
559 chandransh 9249 
  def __init__(self, success=None, scx=None,):
94 ashish 9250 
    self.success = success
559 chandransh 9251 
    self.scx = scx
94 ashish 9252 
 
9253 
  def read(self, iprot):
9254 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9255 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9256 
      return
9257 
    iprot.readStructBegin()
9258 
    while True:
9259 
      (fname, ftype, fid) = iprot.readFieldBegin()
9260 
      if ftype == TType.STOP:
9261 
        break
9262 
      if fid == 0:
559 chandransh 9263 
        if ftype == TType.STRUCT:
9264 
          self.success = Cart()
9265 
          self.success.read(iprot)
94 ashish 9266 
        else:
9267 
          iprot.skip(ftype)
9268 
      elif fid == 1:
9269 
        if ftype == TType.STRUCT:
559 chandransh 9270 
          self.scx = ShoppingCartException()
9271 
          self.scx.read(iprot)
94 ashish 9272 
        else:
9273 
          iprot.skip(ftype)
9274 
      else:
9275 
        iprot.skip(ftype)
9276 
      iprot.readFieldEnd()
9277 
    iprot.readStructEnd()
9278 
 
9279 
  def write(self, oprot):
9280 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9281 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9282 
      return
559 chandransh 9283 
    oprot.writeStructBegin('getCurrentCart_result')
94 ashish 9284 
    if self.success != None:
559 chandransh 9285 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9286 
      self.success.write(oprot)
94 ashish 9287 
      oprot.writeFieldEnd()
559 chandransh 9288 
    if self.scx != None:
9289 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9290 
      self.scx.write(oprot)
94 ashish 9291 
      oprot.writeFieldEnd()
9292 
    oprot.writeFieldStop()
9293 
    oprot.writeStructEnd()
9294 
 
9295 
  def __repr__(self):
9296 
    L = ['%s=%r' % (key, value)
9297 
      for key, value in self.__dict__.iteritems()]
9298 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9299 
 
9300 
  def __eq__(self, other):
9301 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9302 
 
9303 
  def __ne__(self, other):
9304 
    return not (self == other)
9305 
 
559 chandransh 9306 
class getCart_args:
504 rajveer 9307 
  """
9308 
  Attributes:
559 chandransh 9309 
   - cartId
504 rajveer 9310 
  """
9311 
 
9312 
  thrift_spec = (
9313 
    None, # 0
559 chandransh 9314 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 9315 
  )
9316 
 
559 chandransh 9317 
  def __init__(self, cartId=None,):
9318 
    self.cartId = cartId
504 rajveer 9319 
 
9320 
  def read(self, iprot):
9321 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9322 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9323 
      return
9324 
    iprot.readStructBegin()
9325 
    while True:
9326 
      (fname, ftype, fid) = iprot.readFieldBegin()
9327 
      if ftype == TType.STOP:
9328 
        break
9329 
      if fid == 1:
9330 
        if ftype == TType.I64:
559 chandransh 9331 
          self.cartId = iprot.readI64();
504 rajveer 9332 
        else:
9333 
          iprot.skip(ftype)
9334 
      else:
9335 
        iprot.skip(ftype)
9336 
      iprot.readFieldEnd()
9337 
    iprot.readStructEnd()
9338 
 
9339 
  def write(self, oprot):
9340 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9341 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9342 
      return
559 chandransh 9343 
    oprot.writeStructBegin('getCart_args')
9344 
    if self.cartId != None:
9345 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9346 
      oprot.writeI64(self.cartId)
504 rajveer 9347 
      oprot.writeFieldEnd()
9348 
    oprot.writeFieldStop()
9349 
    oprot.writeStructEnd()
9350 
 
9351 
  def __repr__(self):
9352 
    L = ['%s=%r' % (key, value)
9353 
      for key, value in self.__dict__.iteritems()]
9354 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9355 
 
9356 
  def __eq__(self, other):
9357 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9358 
 
9359 
  def __ne__(self, other):
9360 
    return not (self == other)
9361 
 
559 chandransh 9362 
class getCart_result:
504 rajveer 9363 
  """
9364 
  Attributes:
9365 
   - success
559 chandransh 9366 
   - scx
504 rajveer 9367 
  """
9368 
 
9369 
  thrift_spec = (
559 chandransh 9370 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9371 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 9372 
  )
9373 
 
559 chandransh 9374 
  def __init__(self, success=None, scx=None,):
504 rajveer 9375 
    self.success = success
559 chandransh 9376 
    self.scx = scx
504 rajveer 9377 
 
9378 
  def read(self, iprot):
9379 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9380 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9381 
      return
9382 
    iprot.readStructBegin()
9383 
    while True:
9384 
      (fname, ftype, fid) = iprot.readFieldBegin()
9385 
      if ftype == TType.STOP:
9386 
        break
9387 
      if fid == 0:
559 chandransh 9388 
        if ftype == TType.STRUCT:
9389 
          self.success = Cart()
9390 
          self.success.read(iprot)
504 rajveer 9391 
        else:
9392 
          iprot.skip(ftype)
9393 
      elif fid == 1:
9394 
        if ftype == TType.STRUCT:
559 chandransh 9395 
          self.scx = ShoppingCartException()
9396 
          self.scx.read(iprot)
504 rajveer 9397 
        else:
9398 
          iprot.skip(ftype)
9399 
      else:
9400 
        iprot.skip(ftype)
9401 
      iprot.readFieldEnd()
9402 
    iprot.readStructEnd()
9403 
 
9404 
  def write(self, oprot):
9405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9407 
      return
559 chandransh 9408 
    oprot.writeStructBegin('getCart_result')
504 rajveer 9409 
    if self.success != None:
559 chandransh 9410 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9411 
      self.success.write(oprot)
504 rajveer 9412 
      oprot.writeFieldEnd()
559 chandransh 9413 
    if self.scx != None:
9414 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9415 
      self.scx.write(oprot)
504 rajveer 9416 
      oprot.writeFieldEnd()
9417 
    oprot.writeFieldStop()
9418 
    oprot.writeStructEnd()
9419 
 
9420 
  def __repr__(self):
9421 
    L = ['%s=%r' % (key, value)
9422 
      for key, value in self.__dict__.iteritems()]
9423 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9424 
 
9425 
  def __eq__(self, other):
9426 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9427 
 
9428 
  def __ne__(self, other):
9429 
    return not (self == other)
9430 
 
559 chandransh 9431 
class getCartsForUser_args:
94 ashish 9432 
  """
9433 
  Attributes:
559 chandransh 9434 
   - userId
9435 
   - status
94 ashish 9436 
  """
9437 
 
9438 
  thrift_spec = (
9439 
    None, # 0
559 chandransh 9440 
    (1, TType.I64, 'userId', None, None, ), # 1
9441 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 9442 
  )
9443 
 
559 chandransh 9444 
  def __init__(self, userId=None, status=None,):
9445 
    self.userId = userId
9446 
    self.status = status
94 ashish 9447 
 
9448 
  def read(self, iprot):
9449 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9450 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9451 
      return
9452 
    iprot.readStructBegin()
9453 
    while True:
9454 
      (fname, ftype, fid) = iprot.readFieldBegin()
9455 
      if ftype == TType.STOP:
9456 
        break
9457 
      if fid == 1:
9458 
        if ftype == TType.I64:
559 chandransh 9459 
          self.userId = iprot.readI64();
94 ashish 9460 
        else:
9461 
          iprot.skip(ftype)
9462 
      elif fid == 2:
559 chandransh 9463 
        if ftype == TType.I32:
9464 
          self.status = iprot.readI32();
94 ashish 9465 
        else:
9466 
          iprot.skip(ftype)
9467 
      else:
9468 
        iprot.skip(ftype)
9469 
      iprot.readFieldEnd()
9470 
    iprot.readStructEnd()
9471 
 
9472 
  def write(self, oprot):
9473 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9474 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9475 
      return
559 chandransh 9476 
    oprot.writeStructBegin('getCartsForUser_args')
9477 
    if self.userId != None:
9478 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9479 
      oprot.writeI64(self.userId)
94 ashish 9480 
      oprot.writeFieldEnd()
559 chandransh 9481 
    if self.status != None:
9482 
      oprot.writeFieldBegin('status', TType.I32, 2)
9483 
      oprot.writeI32(self.status)
94 ashish 9484 
      oprot.writeFieldEnd()
9485 
    oprot.writeFieldStop()
9486 
    oprot.writeStructEnd()
9487 
 
9488 
  def __repr__(self):
9489 
    L = ['%s=%r' % (key, value)
9490 
      for key, value in self.__dict__.iteritems()]
9491 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9492 
 
9493 
  def __eq__(self, other):
9494 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9495 
 
9496 
  def __ne__(self, other):
9497 
    return not (self == other)
9498 
 
559 chandransh 9499 
class getCartsForUser_result:
94 ashish 9500 
  """
9501 
  Attributes:
9502 
   - success
559 chandransh 9503 
   - scx
94 ashish 9504 
  """
9505 
 
9506 
  thrift_spec = (
559 chandransh 9507 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9508 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9509 
  )
9510 
 
559 chandransh 9511 
  def __init__(self, success=None, scx=None,):
94 ashish 9512 
    self.success = success
559 chandransh 9513 
    self.scx = scx
94 ashish 9514 
 
9515 
  def read(self, iprot):
9516 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9517 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9518 
      return
9519 
    iprot.readStructBegin()
9520 
    while True:
9521 
      (fname, ftype, fid) = iprot.readFieldBegin()
9522 
      if ftype == TType.STOP:
9523 
        break
9524 
      if fid == 0:
559 chandransh 9525 
        if ftype == TType.LIST:
9526 
          self.success = []
1996 vikas 9527 
          (_etype94, _size91) = iprot.readListBegin()
9528 
          for _i95 in xrange(_size91):
9529 
            _elem96 = Cart()
9530 
            _elem96.read(iprot)
9531 
            self.success.append(_elem96)
559 chandransh 9532 
          iprot.readListEnd()
94 ashish 9533 
        else:
9534 
          iprot.skip(ftype)
9535 
      elif fid == 1:
9536 
        if ftype == TType.STRUCT:
559 chandransh 9537 
          self.scx = ShoppingCartException()
9538 
          self.scx.read(iprot)
94 ashish 9539 
        else:
9540 
          iprot.skip(ftype)
9541 
      else:
9542 
        iprot.skip(ftype)
9543 
      iprot.readFieldEnd()
9544 
    iprot.readStructEnd()
9545 
 
9546 
  def write(self, oprot):
9547 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9548 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9549 
      return
559 chandransh 9550 
    oprot.writeStructBegin('getCartsForUser_result')
94 ashish 9551 
    if self.success != None:
559 chandransh 9552 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9553 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 9554 
      for iter97 in self.success:
9555 
        iter97.write(oprot)
559 chandransh 9556 
      oprot.writeListEnd()
94 ashish 9557 
      oprot.writeFieldEnd()
559 chandransh 9558 
    if self.scx != None:
9559 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9560 
      self.scx.write(oprot)
94 ashish 9561 
      oprot.writeFieldEnd()
9562 
    oprot.writeFieldStop()
9563 
    oprot.writeStructEnd()
9564 
 
9565 
  def __repr__(self):
9566 
    L = ['%s=%r' % (key, value)
9567 
      for key, value in self.__dict__.iteritems()]
9568 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9569 
 
9570 
  def __eq__(self, other):
9571 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9572 
 
9573 
  def __ne__(self, other):
9574 
    return not (self == other)
9575 
 
559 chandransh 9576 
class getCartsByStatus_args:
94 ashish 9577 
  """
9578 
  Attributes:
559 chandransh 9579 
   - status
94 ashish 9580 
  """
9581 
 
9582 
  thrift_spec = (
9583 
    None, # 0
559 chandransh 9584 
    (1, TType.I32, 'status', None, None, ), # 1
94 ashish 9585 
  )
9586 
 
559 chandransh 9587 
  def __init__(self, status=None,):
9588 
    self.status = status
94 ashish 9589 
 
9590 
  def read(self, iprot):
9591 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9592 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9593 
      return
9594 
    iprot.readStructBegin()
9595 
    while True:
9596 
      (fname, ftype, fid) = iprot.readFieldBegin()
9597 
      if ftype == TType.STOP:
9598 
        break
9599 
      if fid == 1:
559 chandransh 9600 
        if ftype == TType.I32:
9601 
          self.status = iprot.readI32();
9602 
        else:
9603 
          iprot.skip(ftype)
9604 
      else:
9605 
        iprot.skip(ftype)
9606 
      iprot.readFieldEnd()
9607 
    iprot.readStructEnd()
9608 
 
9609 
  def write(self, oprot):
9610 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9611 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9612 
      return
9613 
    oprot.writeStructBegin('getCartsByStatus_args')
9614 
    if self.status != None:
9615 
      oprot.writeFieldBegin('status', TType.I32, 1)
9616 
      oprot.writeI32(self.status)
9617 
      oprot.writeFieldEnd()
9618 
    oprot.writeFieldStop()
9619 
    oprot.writeStructEnd()
9620 
 
9621 
  def __repr__(self):
9622 
    L = ['%s=%r' % (key, value)
9623 
      for key, value in self.__dict__.iteritems()]
9624 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9625 
 
9626 
  def __eq__(self, other):
9627 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9628 
 
9629 
  def __ne__(self, other):
9630 
    return not (self == other)
9631 
 
9632 
class getCartsByStatus_result:
9633 
  """
9634 
  Attributes:
9635 
   - success
9636 
   - scx
9637 
  """
9638 
 
9639 
  thrift_spec = (
9640 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9641 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9642 
  )
9643 
 
9644 
  def __init__(self, success=None, scx=None,):
9645 
    self.success = success
9646 
    self.scx = scx
9647 
 
9648 
  def read(self, iprot):
9649 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9650 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9651 
      return
9652 
    iprot.readStructBegin()
9653 
    while True:
9654 
      (fname, ftype, fid) = iprot.readFieldBegin()
9655 
      if ftype == TType.STOP:
9656 
        break
9657 
      if fid == 0:
9658 
        if ftype == TType.LIST:
9659 
          self.success = []
1996 vikas 9660 
          (_etype101, _size98) = iprot.readListBegin()
9661 
          for _i102 in xrange(_size98):
9662 
            _elem103 = Cart()
9663 
            _elem103.read(iprot)
9664 
            self.success.append(_elem103)
559 chandransh 9665 
          iprot.readListEnd()
9666 
        else:
9667 
          iprot.skip(ftype)
9668 
      elif fid == 1:
9669 
        if ftype == TType.STRUCT:
9670 
          self.scx = ShoppingCartException()
9671 
          self.scx.read(iprot)
9672 
        else:
9673 
          iprot.skip(ftype)
9674 
      else:
9675 
        iprot.skip(ftype)
9676 
      iprot.readFieldEnd()
9677 
    iprot.readStructEnd()
9678 
 
9679 
  def write(self, oprot):
9680 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9681 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9682 
      return
9683 
    oprot.writeStructBegin('getCartsByStatus_result')
9684 
    if self.success != None:
9685 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9686 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 9687 
      for iter104 in self.success:
9688 
        iter104.write(oprot)
559 chandransh 9689 
      oprot.writeListEnd()
9690 
      oprot.writeFieldEnd()
9691 
    if self.scx != None:
9692 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9693 
      self.scx.write(oprot)
9694 
      oprot.writeFieldEnd()
9695 
    oprot.writeFieldStop()
9696 
    oprot.writeStructEnd()
9697 
 
9698 
  def __repr__(self):
9699 
    L = ['%s=%r' % (key, value)
9700 
      for key, value in self.__dict__.iteritems()]
9701 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9702 
 
9703 
  def __eq__(self, other):
9704 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9705 
 
9706 
  def __ne__(self, other):
9707 
    return not (self == other)
9708 
 
9709 
class getCartsByTime_args:
9710 
  """
9711 
  Attributes:
9712 
   - from_time
9713 
   - to_time
9714 
   - status
9715 
  """
9716 
 
9717 
  thrift_spec = (
9718 
    None, # 0
9719 
    (1, TType.I64, 'from_time', None, None, ), # 1
9720 
    (2, TType.I64, 'to_time', None, None, ), # 2
9721 
    (3, TType.I32, 'status', None, None, ), # 3
9722 
  )
9723 
 
9724 
  def __init__(self, from_time=None, to_time=None, status=None,):
9725 
    self.from_time = from_time
9726 
    self.to_time = to_time
9727 
    self.status = status
9728 
 
9729 
  def read(self, iprot):
9730 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9731 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9732 
      return
9733 
    iprot.readStructBegin()
9734 
    while True:
9735 
      (fname, ftype, fid) = iprot.readFieldBegin()
9736 
      if ftype == TType.STOP:
9737 
        break
9738 
      if fid == 1:
94 ashish 9739 
        if ftype == TType.I64:
559 chandransh 9740 
          self.from_time = iprot.readI64();
94 ashish 9741 
        else:
9742 
          iprot.skip(ftype)
122 ashish 9743 
      elif fid == 2:
559 chandransh 9744 
        if ftype == TType.I64:
9745 
          self.to_time = iprot.readI64();
122 ashish 9746 
        else:
9747 
          iprot.skip(ftype)
559 chandransh 9748 
      elif fid == 3:
9749 
        if ftype == TType.I32:
9750 
          self.status = iprot.readI32();
9751 
        else:
9752 
          iprot.skip(ftype)
94 ashish 9753 
      else:
9754 
        iprot.skip(ftype)
9755 
      iprot.readFieldEnd()
9756 
    iprot.readStructEnd()
9757 
 
9758 
  def write(self, oprot):
9759 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9760 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9761 
      return
559 chandransh 9762 
    oprot.writeStructBegin('getCartsByTime_args')
9763 
    if self.from_time != None:
9764 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
9765 
      oprot.writeI64(self.from_time)
94 ashish 9766 
      oprot.writeFieldEnd()
559 chandransh 9767 
    if self.to_time != None:
9768 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
9769 
      oprot.writeI64(self.to_time)
122 ashish 9770 
      oprot.writeFieldEnd()
559 chandransh 9771 
    if self.status != None:
9772 
      oprot.writeFieldBegin('status', TType.I32, 3)
9773 
      oprot.writeI32(self.status)
9774 
      oprot.writeFieldEnd()
94 ashish 9775 
    oprot.writeFieldStop()
9776 
    oprot.writeStructEnd()
9777 
 
9778 
  def __repr__(self):
9779 
    L = ['%s=%r' % (key, value)
9780 
      for key, value in self.__dict__.iteritems()]
9781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9782 
 
9783 
  def __eq__(self, other):
9784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9785 
 
9786 
  def __ne__(self, other):
9787 
    return not (self == other)
9788 
 
559 chandransh 9789 
class getCartsByTime_result:
94 ashish 9790 
  """
9791 
  Attributes:
9792 
   - success
559 chandransh 9793 
   - scx
94 ashish 9794 
  """
9795 
 
9796 
  thrift_spec = (
559 chandransh 9797 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9798 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9799 
  )
9800 
 
559 chandransh 9801 
  def __init__(self, success=None, scx=None,):
94 ashish 9802 
    self.success = success
559 chandransh 9803 
    self.scx = scx
94 ashish 9804 
 
9805 
  def read(self, iprot):
9806 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9807 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9808 
      return
9809 
    iprot.readStructBegin()
9810 
    while True:
9811 
      (fname, ftype, fid) = iprot.readFieldBegin()
9812 
      if ftype == TType.STOP:
9813 
        break
9814 
      if fid == 0:
559 chandransh 9815 
        if ftype == TType.LIST:
9816 
          self.success = []
1996 vikas 9817 
          (_etype108, _size105) = iprot.readListBegin()
9818 
          for _i109 in xrange(_size105):
9819 
            _elem110 = Cart()
9820 
            _elem110.read(iprot)
9821 
            self.success.append(_elem110)
559 chandransh 9822 
          iprot.readListEnd()
94 ashish 9823 
        else:
9824 
          iprot.skip(ftype)
9825 
      elif fid == 1:
9826 
        if ftype == TType.STRUCT:
559 chandransh 9827 
          self.scx = ShoppingCartException()
9828 
          self.scx.read(iprot)
94 ashish 9829 
        else:
9830 
          iprot.skip(ftype)
9831 
      else:
9832 
        iprot.skip(ftype)
9833 
      iprot.readFieldEnd()
9834 
    iprot.readStructEnd()
9835 
 
9836 
  def write(self, oprot):
9837 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9838 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9839 
      return
559 chandransh 9840 
    oprot.writeStructBegin('getCartsByTime_result')
94 ashish 9841 
    if self.success != None:
559 chandransh 9842 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9843 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 9844 
      for iter111 in self.success:
9845 
        iter111.write(oprot)
559 chandransh 9846 
      oprot.writeListEnd()
94 ashish 9847 
      oprot.writeFieldEnd()
559 chandransh 9848 
    if self.scx != None:
9849 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9850 
      self.scx.write(oprot)
94 ashish 9851 
      oprot.writeFieldEnd()
9852 
    oprot.writeFieldStop()
9853 
    oprot.writeStructEnd()
9854 
 
9855 
  def __repr__(self):
9856 
    L = ['%s=%r' % (key, value)
9857 
      for key, value in self.__dict__.iteritems()]
9858 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9859 
 
9860 
  def __eq__(self, other):
9861 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9862 
 
9863 
  def __ne__(self, other):
9864 
    return not (self == other)
9865 
 
559 chandransh 9866 
class changeCartStatus_args:
94 ashish 9867 
  """
9868 
  Attributes:
559 chandransh 9869 
   - cartId
9870 
   - status
94 ashish 9871 
  """
9872 
 
9873 
  thrift_spec = (
9874 
    None, # 0
559 chandransh 9875 
    (1, TType.I64, 'cartId', None, None, ), # 1
9876 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 9877 
  )
9878 
 
559 chandransh 9879 
  def __init__(self, cartId=None, status=None,):
9880 
    self.cartId = cartId
9881 
    self.status = status
94 ashish 9882 
 
9883 
  def read(self, iprot):
9884 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9885 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9886 
      return
9887 
    iprot.readStructBegin()
9888 
    while True:
9889 
      (fname, ftype, fid) = iprot.readFieldBegin()
9890 
      if ftype == TType.STOP:
9891 
        break
9892 
      if fid == 1:
9893 
        if ftype == TType.I64:
559 chandransh 9894 
          self.cartId = iprot.readI64();
94 ashish 9895 
        else:
9896 
          iprot.skip(ftype)
559 chandransh 9897 
      elif fid == 2:
9898 
        if ftype == TType.I32:
9899 
          self.status = iprot.readI32();
9900 
        else:
9901 
          iprot.skip(ftype)
94 ashish 9902 
      else:
9903 
        iprot.skip(ftype)
9904 
      iprot.readFieldEnd()
9905 
    iprot.readStructEnd()
9906 
 
9907 
  def write(self, oprot):
9908 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9909 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9910 
      return
559 chandransh 9911 
    oprot.writeStructBegin('changeCartStatus_args')
9912 
    if self.cartId != None:
9913 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9914 
      oprot.writeI64(self.cartId)
94 ashish 9915 
      oprot.writeFieldEnd()
559 chandransh 9916 
    if self.status != None:
9917 
      oprot.writeFieldBegin('status', TType.I32, 2)
9918 
      oprot.writeI32(self.status)
9919 
      oprot.writeFieldEnd()
94 ashish 9920 
    oprot.writeFieldStop()
9921 
    oprot.writeStructEnd()
9922 
 
9923 
  def __repr__(self):
9924 
    L = ['%s=%r' % (key, value)
9925 
      for key, value in self.__dict__.iteritems()]
9926 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9927 
 
9928 
  def __eq__(self, other):
9929 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9930 
 
9931 
  def __ne__(self, other):
9932 
    return not (self == other)
9933 
 
559 chandransh 9934 
class changeCartStatus_result:
94 ashish 9935 
  """
9936 
  Attributes:
559 chandransh 9937 
   - scx
9938 
  """
9939 
 
9940 
  thrift_spec = (
9941 
    None, # 0
9942 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9943 
  )
9944 
 
9945 
  def __init__(self, scx=None,):
9946 
    self.scx = scx
9947 
 
9948 
  def read(self, iprot):
9949 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9950 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9951 
      return
9952 
    iprot.readStructBegin()
9953 
    while True:
9954 
      (fname, ftype, fid) = iprot.readFieldBegin()
9955 
      if ftype == TType.STOP:
9956 
        break
9957 
      if fid == 1:
9958 
        if ftype == TType.STRUCT:
9959 
          self.scx = ShoppingCartException()
9960 
          self.scx.read(iprot)
9961 
        else:
9962 
          iprot.skip(ftype)
9963 
      else:
9964 
        iprot.skip(ftype)
9965 
      iprot.readFieldEnd()
9966 
    iprot.readStructEnd()
9967 
 
9968 
  def write(self, oprot):
9969 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9970 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9971 
      return
9972 
    oprot.writeStructBegin('changeCartStatus_result')
9973 
    if self.scx != None:
9974 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9975 
      self.scx.write(oprot)
9976 
      oprot.writeFieldEnd()
9977 
    oprot.writeFieldStop()
9978 
    oprot.writeStructEnd()
9979 
 
9980 
  def __repr__(self):
9981 
    L = ['%s=%r' % (key, value)
9982 
      for key, value in self.__dict__.iteritems()]
9983 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9984 
 
9985 
  def __eq__(self, other):
9986 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9987 
 
9988 
  def __ne__(self, other):
9989 
    return not (self == other)
9990 
 
9991 
class addItemToCart_args:
9992 
  """
9993 
  Attributes:
9994 
   - cartId
9995 
   - itemId
9996 
   - quantity
9997 
  """
9998 
 
9999 
  thrift_spec = (
10000 
    None, # 0
10001 
    (1, TType.I64, 'cartId', None, None, ), # 1
10002 
    (2, TType.I64, 'itemId', None, None, ), # 2
10003 
    (3, TType.I64, 'quantity', None, None, ), # 3
10004 
  )
10005 
 
10006 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
10007 
    self.cartId = cartId
10008 
    self.itemId = itemId
10009 
    self.quantity = quantity
10010 
 
10011 
  def read(self, iprot):
10012 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10013 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10014 
      return
10015 
    iprot.readStructBegin()
10016 
    while True:
10017 
      (fname, ftype, fid) = iprot.readFieldBegin()
10018 
      if ftype == TType.STOP:
10019 
        break
10020 
      if fid == 1:
10021 
        if ftype == TType.I64:
10022 
          self.cartId = iprot.readI64();
10023 
        else:
10024 
          iprot.skip(ftype)
10025 
      elif fid == 2:
10026 
        if ftype == TType.I64:
10027 
          self.itemId = iprot.readI64();
10028 
        else:
10029 
          iprot.skip(ftype)
10030 
      elif fid == 3:
10031 
        if ftype == TType.I64:
10032 
          self.quantity = iprot.readI64();
10033 
        else:
10034 
          iprot.skip(ftype)
10035 
      else:
10036 
        iprot.skip(ftype)
10037 
      iprot.readFieldEnd()
10038 
    iprot.readStructEnd()
10039 
 
10040 
  def write(self, oprot):
10041 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10042 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10043 
      return
10044 
    oprot.writeStructBegin('addItemToCart_args')
10045 
    if self.cartId != None:
10046 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10047 
      oprot.writeI64(self.cartId)
10048 
      oprot.writeFieldEnd()
10049 
    if self.itemId != None:
10050 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10051 
      oprot.writeI64(self.itemId)
10052 
      oprot.writeFieldEnd()
10053 
    if self.quantity != None:
10054 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10055 
      oprot.writeI64(self.quantity)
10056 
      oprot.writeFieldEnd()
10057 
    oprot.writeFieldStop()
10058 
    oprot.writeStructEnd()
10059 
 
10060 
  def __repr__(self):
10061 
    L = ['%s=%r' % (key, value)
10062 
      for key, value in self.__dict__.iteritems()]
10063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10064 
 
10065 
  def __eq__(self, other):
10066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10067 
 
10068 
  def __ne__(self, other):
10069 
    return not (self == other)
10070 
 
10071 
class addItemToCart_result:
10072 
  """
10073 
  Attributes:
2035 rajveer 10074 
   - success
559 chandransh 10075 
   - scx
10076 
  """
10077 
 
10078 
  thrift_spec = (
2035 rajveer 10079 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 10080 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10081 
  )
10082 
 
2035 rajveer 10083 
  def __init__(self, success=None, scx=None,):
10084 
    self.success = success
559 chandransh 10085 
    self.scx = scx
10086 
 
10087 
  def read(self, iprot):
10088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10090 
      return
10091 
    iprot.readStructBegin()
10092 
    while True:
10093 
      (fname, ftype, fid) = iprot.readFieldBegin()
10094 
      if ftype == TType.STOP:
10095 
        break
2035 rajveer 10096 
      if fid == 0:
10097 
        if ftype == TType.STRING:
10098 
          self.success = iprot.readString();
10099 
        else:
10100 
          iprot.skip(ftype)
10101 
      elif fid == 1:
559 chandransh 10102 
        if ftype == TType.STRUCT:
10103 
          self.scx = ShoppingCartException()
10104 
          self.scx.read(iprot)
10105 
        else:
10106 
          iprot.skip(ftype)
10107 
      else:
10108 
        iprot.skip(ftype)
10109 
      iprot.readFieldEnd()
10110 
    iprot.readStructEnd()
10111 
 
10112 
  def write(self, oprot):
10113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10115 
      return
10116 
    oprot.writeStructBegin('addItemToCart_result')
2035 rajveer 10117 
    if self.success != None:
10118 
      oprot.writeFieldBegin('success', TType.STRING, 0)
10119 
      oprot.writeString(self.success)
10120 
      oprot.writeFieldEnd()
559 chandransh 10121 
    if self.scx != None:
10122 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10123 
      self.scx.write(oprot)
10124 
      oprot.writeFieldEnd()
10125 
    oprot.writeFieldStop()
10126 
    oprot.writeStructEnd()
10127 
 
10128 
  def __repr__(self):
10129 
    L = ['%s=%r' % (key, value)
10130 
      for key, value in self.__dict__.iteritems()]
10131 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10132 
 
10133 
  def __eq__(self, other):
10134 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10135 
 
10136 
  def __ne__(self, other):
10137 
    return not (self == other)
10138 
 
10139 
class deleteItemFromCart_args:
10140 
  """
10141 
  Attributes:
10142 
   - cartId
10143 
   - itemId
10144 
  """
10145 
 
10146 
  thrift_spec = (
10147 
    None, # 0
10148 
    (1, TType.I64, 'cartId', None, None, ), # 1
10149 
    (2, TType.I64, 'itemId', None, None, ), # 2
10150 
  )
10151 
 
10152 
  def __init__(self, cartId=None, itemId=None,):
10153 
    self.cartId = cartId
10154 
    self.itemId = itemId
10155 
 
10156 
  def read(self, iprot):
10157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10159 
      return
10160 
    iprot.readStructBegin()
10161 
    while True:
10162 
      (fname, ftype, fid) = iprot.readFieldBegin()
10163 
      if ftype == TType.STOP:
10164 
        break
10165 
      if fid == 1:
10166 
        if ftype == TType.I64:
10167 
          self.cartId = iprot.readI64();
10168 
        else:
10169 
          iprot.skip(ftype)
10170 
      elif fid == 2:
10171 
        if ftype == TType.I64:
10172 
          self.itemId = iprot.readI64();
10173 
        else:
10174 
          iprot.skip(ftype)
10175 
      else:
10176 
        iprot.skip(ftype)
10177 
      iprot.readFieldEnd()
10178 
    iprot.readStructEnd()
10179 
 
10180 
  def write(self, oprot):
10181 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10182 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10183 
      return
10184 
    oprot.writeStructBegin('deleteItemFromCart_args')
10185 
    if self.cartId != None:
10186 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10187 
      oprot.writeI64(self.cartId)
10188 
      oprot.writeFieldEnd()
10189 
    if self.itemId != None:
10190 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10191 
      oprot.writeI64(self.itemId)
10192 
      oprot.writeFieldEnd()
10193 
    oprot.writeFieldStop()
10194 
    oprot.writeStructEnd()
10195 
 
10196 
  def __repr__(self):
10197 
    L = ['%s=%r' % (key, value)
10198 
      for key, value in self.__dict__.iteritems()]
10199 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10200 
 
10201 
  def __eq__(self, other):
10202 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10203 
 
10204 
  def __ne__(self, other):
10205 
    return not (self == other)
10206 
 
10207 
class deleteItemFromCart_result:
10208 
  """
10209 
  Attributes:
10210 
   - scx
10211 
  """
10212 
 
10213 
  thrift_spec = (
10214 
    None, # 0
10215 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10216 
  )
10217 
 
10218 
  def __init__(self, scx=None,):
10219 
    self.scx = scx
10220 
 
10221 
  def read(self, iprot):
10222 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10223 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10224 
      return
10225 
    iprot.readStructBegin()
10226 
    while True:
10227 
      (fname, ftype, fid) = iprot.readFieldBegin()
10228 
      if ftype == TType.STOP:
10229 
        break
10230 
      if fid == 1:
10231 
        if ftype == TType.STRUCT:
10232 
          self.scx = ShoppingCartException()
10233 
          self.scx.read(iprot)
10234 
        else:
10235 
          iprot.skip(ftype)
10236 
      else:
10237 
        iprot.skip(ftype)
10238 
      iprot.readFieldEnd()
10239 
    iprot.readStructEnd()
10240 
 
10241 
  def write(self, oprot):
10242 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10243 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10244 
      return
10245 
    oprot.writeStructBegin('deleteItemFromCart_result')
10246 
    if self.scx != None:
10247 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10248 
      self.scx.write(oprot)
10249 
      oprot.writeFieldEnd()
10250 
    oprot.writeFieldStop()
10251 
    oprot.writeStructEnd()
10252 
 
10253 
  def __repr__(self):
10254 
    L = ['%s=%r' % (key, value)
10255 
      for key, value in self.__dict__.iteritems()]
10256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10257 
 
10258 
  def __eq__(self, other):
10259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10260 
 
10261 
  def __ne__(self, other):
10262 
    return not (self == other)
10263 
 
10264 
class changeQuantity_args:
10265 
  """
10266 
  Attributes:
10267 
   - cartId
10268 
   - itemId
10269 
   - quantity
10270 
  """
10271 
 
10272 
  thrift_spec = (
10273 
    None, # 0
10274 
    (1, TType.I64, 'cartId', None, None, ), # 1
10275 
    (2, TType.I64, 'itemId', None, None, ), # 2
10276 
    (3, TType.I64, 'quantity', None, None, ), # 3
10277 
  )
10278 
 
10279 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
10280 
    self.cartId = cartId
10281 
    self.itemId = itemId
10282 
    self.quantity = quantity
10283 
 
10284 
  def read(self, iprot):
10285 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10286 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10287 
      return
10288 
    iprot.readStructBegin()
10289 
    while True:
10290 
      (fname, ftype, fid) = iprot.readFieldBegin()
10291 
      if ftype == TType.STOP:
10292 
        break
10293 
      if fid == 1:
10294 
        if ftype == TType.I64:
10295 
          self.cartId = iprot.readI64();
10296 
        else:
10297 
          iprot.skip(ftype)
10298 
      elif fid == 2:
10299 
        if ftype == TType.I64:
10300 
          self.itemId = iprot.readI64();
10301 
        else:
10302 
          iprot.skip(ftype)
10303 
      elif fid == 3:
10304 
        if ftype == TType.I64:
10305 
          self.quantity = iprot.readI64();
10306 
        else:
10307 
          iprot.skip(ftype)
10308 
      else:
10309 
        iprot.skip(ftype)
10310 
      iprot.readFieldEnd()
10311 
    iprot.readStructEnd()
10312 
 
10313 
  def write(self, oprot):
10314 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10315 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10316 
      return
10317 
    oprot.writeStructBegin('changeQuantity_args')
10318 
    if self.cartId != None:
10319 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10320 
      oprot.writeI64(self.cartId)
10321 
      oprot.writeFieldEnd()
10322 
    if self.itemId != None:
10323 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10324 
      oprot.writeI64(self.itemId)
10325 
      oprot.writeFieldEnd()
10326 
    if self.quantity != None:
10327 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10328 
      oprot.writeI64(self.quantity)
10329 
      oprot.writeFieldEnd()
10330 
    oprot.writeFieldStop()
10331 
    oprot.writeStructEnd()
10332 
 
10333 
  def __repr__(self):
10334 
    L = ['%s=%r' % (key, value)
10335 
      for key, value in self.__dict__.iteritems()]
10336 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10337 
 
10338 
  def __eq__(self, other):
10339 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10340 
 
10341 
  def __ne__(self, other):
10342 
    return not (self == other)
10343 
 
10344 
class changeQuantity_result:
10345 
  """
10346 
  Attributes:
10347 
   - scx
10348 
  """
10349 
 
10350 
  thrift_spec = (
10351 
    None, # 0
10352 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10353 
  )
10354 
 
10355 
  def __init__(self, scx=None,):
10356 
    self.scx = scx
10357 
 
10358 
  def read(self, iprot):
10359 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10360 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10361 
      return
10362 
    iprot.readStructBegin()
10363 
    while True:
10364 
      (fname, ftype, fid) = iprot.readFieldBegin()
10365 
      if ftype == TType.STOP:
10366 
        break
10367 
      if fid == 1:
10368 
        if ftype == TType.STRUCT:
10369 
          self.scx = ShoppingCartException()
10370 
          self.scx.read(iprot)
10371 
        else:
10372 
          iprot.skip(ftype)
10373 
      else:
10374 
        iprot.skip(ftype)
10375 
      iprot.readFieldEnd()
10376 
    iprot.readStructEnd()
10377 
 
10378 
  def write(self, oprot):
10379 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10380 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10381 
      return
10382 
    oprot.writeStructBegin('changeQuantity_result')
10383 
    if self.scx != None:
10384 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10385 
      self.scx.write(oprot)
10386 
      oprot.writeFieldEnd()
10387 
    oprot.writeFieldStop()
10388 
    oprot.writeStructEnd()
10389 
 
10390 
  def __repr__(self):
10391 
    L = ['%s=%r' % (key, value)
10392 
      for key, value in self.__dict__.iteritems()]
10393 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10394 
 
10395 
  def __eq__(self, other):
10396 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10397 
 
10398 
  def __ne__(self, other):
10399 
    return not (self == other)
10400 
 
10401 
class changeItemStatus_args:
10402 
  """
10403 
  Attributes:
10404 
   - cartId
10405 
   - itemId
10406 
   - status
10407 
  """
10408 
 
10409 
  thrift_spec = (
10410 
    None, # 0
10411 
    (1, TType.I64, 'cartId', None, None, ), # 1
10412 
    (2, TType.I64, 'itemId', None, None, ), # 2
10413 
    (3, TType.I32, 'status', None, None, ), # 3
10414 
  )
10415 
 
10416 
  def __init__(self, cartId=None, itemId=None, status=None,):
10417 
    self.cartId = cartId
10418 
    self.itemId = itemId
10419 
    self.status = status
10420 
 
10421 
  def read(self, iprot):
10422 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10423 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10424 
      return
10425 
    iprot.readStructBegin()
10426 
    while True:
10427 
      (fname, ftype, fid) = iprot.readFieldBegin()
10428 
      if ftype == TType.STOP:
10429 
        break
10430 
      if fid == 1:
10431 
        if ftype == TType.I64:
10432 
          self.cartId = iprot.readI64();
10433 
        else:
10434 
          iprot.skip(ftype)
10435 
      elif fid == 2:
10436 
        if ftype == TType.I64:
10437 
          self.itemId = iprot.readI64();
10438 
        else:
10439 
          iprot.skip(ftype)
10440 
      elif fid == 3:
10441 
        if ftype == TType.I32:
10442 
          self.status = iprot.readI32();
10443 
        else:
10444 
          iprot.skip(ftype)
10445 
      else:
10446 
        iprot.skip(ftype)
10447 
      iprot.readFieldEnd()
10448 
    iprot.readStructEnd()
10449 
 
10450 
  def write(self, oprot):
10451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10453 
      return
10454 
    oprot.writeStructBegin('changeItemStatus_args')
10455 
    if self.cartId != None:
10456 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10457 
      oprot.writeI64(self.cartId)
10458 
      oprot.writeFieldEnd()
10459 
    if self.itemId != None:
10460 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10461 
      oprot.writeI64(self.itemId)
10462 
      oprot.writeFieldEnd()
10463 
    if self.status != None:
10464 
      oprot.writeFieldBegin('status', TType.I32, 3)
10465 
      oprot.writeI32(self.status)
10466 
      oprot.writeFieldEnd()
10467 
    oprot.writeFieldStop()
10468 
    oprot.writeStructEnd()
10469 
 
10470 
  def __repr__(self):
10471 
    L = ['%s=%r' % (key, value)
10472 
      for key, value in self.__dict__.iteritems()]
10473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10474 
 
10475 
  def __eq__(self, other):
10476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10477 
 
10478 
  def __ne__(self, other):
10479 
    return not (self == other)
10480 
 
10481 
class changeItemStatus_result:
10482 
  """
10483 
  Attributes:
10484 
   - scx
10485 
  """
10486 
 
10487 
  thrift_spec = (
10488 
    None, # 0
10489 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10490 
  )
10491 
 
10492 
  def __init__(self, scx=None,):
10493 
    self.scx = scx
10494 
 
10495 
  def read(self, iprot):
10496 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10497 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10498 
      return
10499 
    iprot.readStructBegin()
10500 
    while True:
10501 
      (fname, ftype, fid) = iprot.readFieldBegin()
10502 
      if ftype == TType.STOP:
10503 
        break
10504 
      if fid == 1:
10505 
        if ftype == TType.STRUCT:
10506 
          self.scx = ShoppingCartException()
10507 
          self.scx.read(iprot)
10508 
        else:
10509 
          iprot.skip(ftype)
10510 
      else:
10511 
        iprot.skip(ftype)
10512 
      iprot.readFieldEnd()
10513 
    iprot.readStructEnd()
10514 
 
10515 
  def write(self, oprot):
10516 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10517 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10518 
      return
10519 
    oprot.writeStructBegin('changeItemStatus_result')
10520 
    if self.scx != None:
10521 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10522 
      self.scx.write(oprot)
10523 
      oprot.writeFieldEnd()
10524 
    oprot.writeFieldStop()
10525 
    oprot.writeStructEnd()
10526 
 
10527 
  def __repr__(self):
10528 
    L = ['%s=%r' % (key, value)
10529 
      for key, value in self.__dict__.iteritems()]
10530 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10531 
 
10532 
  def __eq__(self, other):
10533 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10534 
 
10535 
  def __ne__(self, other):
10536 
    return not (self == other)
10537 
 
10538 
class addAddressToCart_args:
10539 
  """
10540 
  Attributes:
10541 
   - cartId
10542 
   - addressId
10543 
  """
10544 
 
10545 
  thrift_spec = (
10546 
    None, # 0
10547 
    (1, TType.I64, 'cartId', None, None, ), # 1
10548 
    (2, TType.I64, 'addressId', None, None, ), # 2
10549 
  )
10550 
 
10551 
  def __init__(self, cartId=None, addressId=None,):
10552 
    self.cartId = cartId
10553 
    self.addressId = addressId
10554 
 
10555 
  def read(self, iprot):
10556 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10557 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10558 
      return
10559 
    iprot.readStructBegin()
10560 
    while True:
10561 
      (fname, ftype, fid) = iprot.readFieldBegin()
10562 
      if ftype == TType.STOP:
10563 
        break
10564 
      if fid == 1:
10565 
        if ftype == TType.I64:
10566 
          self.cartId = iprot.readI64();
10567 
        else:
10568 
          iprot.skip(ftype)
10569 
      elif fid == 2:
10570 
        if ftype == TType.I64:
10571 
          self.addressId = iprot.readI64();
10572 
        else:
10573 
          iprot.skip(ftype)
10574 
      else:
10575 
        iprot.skip(ftype)
10576 
      iprot.readFieldEnd()
10577 
    iprot.readStructEnd()
10578 
 
10579 
  def write(self, oprot):
10580 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10581 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10582 
      return
10583 
    oprot.writeStructBegin('addAddressToCart_args')
10584 
    if self.cartId != None:
10585 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10586 
      oprot.writeI64(self.cartId)
10587 
      oprot.writeFieldEnd()
10588 
    if self.addressId != None:
10589 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
10590 
      oprot.writeI64(self.addressId)
10591 
      oprot.writeFieldEnd()
10592 
    oprot.writeFieldStop()
10593 
    oprot.writeStructEnd()
10594 
 
10595 
  def __repr__(self):
10596 
    L = ['%s=%r' % (key, value)
10597 
      for key, value in self.__dict__.iteritems()]
10598 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10599 
 
10600 
  def __eq__(self, other):
10601 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10602 
 
10603 
  def __ne__(self, other):
10604 
    return not (self == other)
10605 
 
10606 
class addAddressToCart_result:
575 chandransh 10607 
  """
10608 
  Attributes:
10609 
   - scx
10610 
  """
559 chandransh 10611 
 
10612 
  thrift_spec = (
575 chandransh 10613 
    None, # 0
10614 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 10615 
  )
10616 
 
575 chandransh 10617 
  def __init__(self, scx=None,):
10618 
    self.scx = scx
10619 
 
559 chandransh 10620 
  def read(self, iprot):
10621 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10622 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10623 
      return
10624 
    iprot.readStructBegin()
10625 
    while True:
10626 
      (fname, ftype, fid) = iprot.readFieldBegin()
10627 
      if ftype == TType.STOP:
10628 
        break
575 chandransh 10629 
      if fid == 1:
10630 
        if ftype == TType.STRUCT:
10631 
          self.scx = ShoppingCartException()
10632 
          self.scx.read(iprot)
10633 
        else:
10634 
          iprot.skip(ftype)
559 chandransh 10635 
      else:
10636 
        iprot.skip(ftype)
10637 
      iprot.readFieldEnd()
10638 
    iprot.readStructEnd()
10639 
 
10640 
  def write(self, oprot):
10641 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10642 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10643 
      return
10644 
    oprot.writeStructBegin('addAddressToCart_result')
575 chandransh 10645 
    if self.scx != None:
10646 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10647 
      self.scx.write(oprot)
10648 
      oprot.writeFieldEnd()
559 chandransh 10649 
    oprot.writeFieldStop()
10650 
    oprot.writeStructEnd()
10651 
 
10652 
  def __repr__(self):
10653 
    L = ['%s=%r' % (key, value)
10654 
      for key, value in self.__dict__.iteritems()]
10655 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10656 
 
10657 
  def __eq__(self, other):
10658 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10659 
 
10660 
  def __ne__(self, other):
10661 
    return not (self == other)
10662 
 
1976 varun.gupt 10663 
class applyCouponToCart_args:
10664 
  """
10665 
  Attributes:
10666 
   - cartId
10667 
   - couponCode
10668 
   - totalPrice
10669 
   - discountedPrice
10670 
  """
10671 
 
10672 
  thrift_spec = (
10673 
    None, # 0
10674 
    (1, TType.I64, 'cartId', None, None, ), # 1
10675 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
10676 
    (3, TType.DOUBLE, 'totalPrice', None, None, ), # 3
10677 
    (4, TType.DOUBLE, 'discountedPrice', None, None, ), # 4
10678 
  )
10679 
 
10680 
  def __init__(self, cartId=None, couponCode=None, totalPrice=None, discountedPrice=None,):
10681 
    self.cartId = cartId
10682 
    self.couponCode = couponCode
10683 
    self.totalPrice = totalPrice
10684 
    self.discountedPrice = discountedPrice
10685 
 
10686 
  def read(self, iprot):
10687 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10688 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10689 
      return
10690 
    iprot.readStructBegin()
10691 
    while True:
10692 
      (fname, ftype, fid) = iprot.readFieldBegin()
10693 
      if ftype == TType.STOP:
10694 
        break
10695 
      if fid == 1:
10696 
        if ftype == TType.I64:
10697 
          self.cartId = iprot.readI64();
10698 
        else:
10699 
          iprot.skip(ftype)
10700 
      elif fid == 2:
10701 
        if ftype == TType.STRING:
10702 
          self.couponCode = iprot.readString();
10703 
        else:
10704 
          iprot.skip(ftype)
10705 
      elif fid == 3:
10706 
        if ftype == TType.DOUBLE:
10707 
          self.totalPrice = iprot.readDouble();
10708 
        else:
10709 
          iprot.skip(ftype)
10710 
      elif fid == 4:
10711 
        if ftype == TType.DOUBLE:
10712 
          self.discountedPrice = iprot.readDouble();
10713 
        else:
10714 
          iprot.skip(ftype)
10715 
      else:
10716 
        iprot.skip(ftype)
10717 
      iprot.readFieldEnd()
10718 
    iprot.readStructEnd()
10719 
 
10720 
  def write(self, oprot):
10721 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10722 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10723 
      return
10724 
    oprot.writeStructBegin('applyCouponToCart_args')
10725 
    if self.cartId != None:
10726 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10727 
      oprot.writeI64(self.cartId)
10728 
      oprot.writeFieldEnd()
10729 
    if self.couponCode != None:
10730 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
10731 
      oprot.writeString(self.couponCode)
10732 
      oprot.writeFieldEnd()
10733 
    if self.totalPrice != None:
10734 
      oprot.writeFieldBegin('totalPrice', TType.DOUBLE, 3)
10735 
      oprot.writeDouble(self.totalPrice)
10736 
      oprot.writeFieldEnd()
10737 
    if self.discountedPrice != None:
10738 
      oprot.writeFieldBegin('discountedPrice', TType.DOUBLE, 4)
10739 
      oprot.writeDouble(self.discountedPrice)
10740 
      oprot.writeFieldEnd()
10741 
    oprot.writeFieldStop()
10742 
    oprot.writeStructEnd()
10743 
 
10744 
  def __repr__(self):
10745 
    L = ['%s=%r' % (key, value)
10746 
      for key, value in self.__dict__.iteritems()]
10747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10748 
 
10749 
  def __eq__(self, other):
10750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10751 
 
10752 
  def __ne__(self, other):
10753 
    return not (self == other)
10754 
 
10755 
class applyCouponToCart_result:
10756 
  """
10757 
  Attributes:
10758 
   - scx
10759 
  """
10760 
 
10761 
  thrift_spec = (
10762 
    None, # 0
10763 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10764 
  )
10765 
 
10766 
  def __init__(self, scx=None,):
10767 
    self.scx = scx
10768 
 
10769 
  def read(self, iprot):
10770 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10771 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10772 
      return
10773 
    iprot.readStructBegin()
10774 
    while True:
10775 
      (fname, ftype, fid) = iprot.readFieldBegin()
10776 
      if ftype == TType.STOP:
10777 
        break
10778 
      if fid == 1:
10779 
        if ftype == TType.STRUCT:
10780 
          self.scx = ShoppingCartException()
10781 
          self.scx.read(iprot)
10782 
        else:
10783 
          iprot.skip(ftype)
10784 
      else:
10785 
        iprot.skip(ftype)
10786 
      iprot.readFieldEnd()
10787 
    iprot.readStructEnd()
10788 
 
10789 
  def write(self, oprot):
10790 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10791 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10792 
      return
10793 
    oprot.writeStructBegin('applyCouponToCart_result')
10794 
    if self.scx != None:
10795 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10796 
      self.scx.write(oprot)
10797 
      oprot.writeFieldEnd()
10798 
    oprot.writeFieldStop()
10799 
    oprot.writeStructEnd()
10800 
 
10801 
  def __repr__(self):
10802 
    L = ['%s=%r' % (key, value)
10803 
      for key, value in self.__dict__.iteritems()]
10804 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10805 
 
10806 
  def __eq__(self, other):
10807 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10808 
 
10809 
  def __ne__(self, other):
10810 
    return not (self == other)
10811 
 
10812 
class removeCoupon_args:
10813 
  """
10814 
  Attributes:
10815 
   - cartId
10816 
  """
10817 
 
10818 
  thrift_spec = (
10819 
    None, # 0
10820 
    (1, TType.I64, 'cartId', None, None, ), # 1
10821 
  )
10822 
 
10823 
  def __init__(self, cartId=None,):
10824 
    self.cartId = cartId
10825 
 
10826 
  def read(self, iprot):
10827 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10828 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10829 
      return
10830 
    iprot.readStructBegin()
10831 
    while True:
10832 
      (fname, ftype, fid) = iprot.readFieldBegin()
10833 
      if ftype == TType.STOP:
10834 
        break
10835 
      if fid == 1:
10836 
        if ftype == TType.I64:
10837 
          self.cartId = iprot.readI64();
10838 
        else:
10839 
          iprot.skip(ftype)
10840 
      else:
10841 
        iprot.skip(ftype)
10842 
      iprot.readFieldEnd()
10843 
    iprot.readStructEnd()
10844 
 
10845 
  def write(self, oprot):
10846 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10847 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10848 
      return
10849 
    oprot.writeStructBegin('removeCoupon_args')
10850 
    if self.cartId != None:
10851 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10852 
      oprot.writeI64(self.cartId)
10853 
      oprot.writeFieldEnd()
10854 
    oprot.writeFieldStop()
10855 
    oprot.writeStructEnd()
10856 
 
10857 
  def __repr__(self):
10858 
    L = ['%s=%r' % (key, value)
10859 
      for key, value in self.__dict__.iteritems()]
10860 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10861 
 
10862 
  def __eq__(self, other):
10863 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10864 
 
10865 
  def __ne__(self, other):
10866 
    return not (self == other)
10867 
 
10868 
class removeCoupon_result:
10869 
  """
10870 
  Attributes:
10871 
   - scx
10872 
  """
10873 
 
10874 
  thrift_spec = (
10875 
    None, # 0
10876 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10877 
  )
10878 
 
10879 
  def __init__(self, scx=None,):
10880 
    self.scx = scx
10881 
 
10882 
  def read(self, iprot):
10883 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10884 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10885 
      return
10886 
    iprot.readStructBegin()
10887 
    while True:
10888 
      (fname, ftype, fid) = iprot.readFieldBegin()
10889 
      if ftype == TType.STOP:
10890 
        break
10891 
      if fid == 1:
10892 
        if ftype == TType.STRUCT:
10893 
          self.scx = ShoppingCartException()
10894 
          self.scx.read(iprot)
10895 
        else:
10896 
          iprot.skip(ftype)
10897 
      else:
10898 
        iprot.skip(ftype)
10899 
      iprot.readFieldEnd()
10900 
    iprot.readStructEnd()
10901 
 
10902 
  def write(self, oprot):
10903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10905 
      return
10906 
    oprot.writeStructBegin('removeCoupon_result')
10907 
    if self.scx != None:
10908 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10909 
      self.scx.write(oprot)
10910 
      oprot.writeFieldEnd()
10911 
    oprot.writeFieldStop()
10912 
    oprot.writeStructEnd()
10913 
 
10914 
  def __repr__(self):
10915 
    L = ['%s=%r' % (key, value)
10916 
      for key, value in self.__dict__.iteritems()]
10917 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10918 
 
10919 
  def __eq__(self, other):
10920 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10921 
 
10922 
  def __ne__(self, other):
10923 
    return not (self == other)
10924 
 
690 chandransh 10925 
class createOrders_args:
559 chandransh 10926 
  """
10927 
  Attributes:
10928 
   - cartId
10929 
  """
10930 
 
10931 
  thrift_spec = (
10932 
    None, # 0
10933 
    (1, TType.I64, 'cartId', None, None, ), # 1
10934 
  )
10935 
 
10936 
  def __init__(self, cartId=None,):
10937 
    self.cartId = cartId
10938 
 
10939 
  def read(self, iprot):
10940 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10941 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10942 
      return
10943 
    iprot.readStructBegin()
10944 
    while True:
10945 
      (fname, ftype, fid) = iprot.readFieldBegin()
10946 
      if ftype == TType.STOP:
10947 
        break
10948 
      if fid == 1:
10949 
        if ftype == TType.I64:
10950 
          self.cartId = iprot.readI64();
10951 
        else:
10952 
          iprot.skip(ftype)
10953 
      else:
10954 
        iprot.skip(ftype)
10955 
      iprot.readFieldEnd()
10956 
    iprot.readStructEnd()
10957 
 
10958 
  def write(self, oprot):
10959 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10960 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10961 
      return
690 chandransh 10962 
    oprot.writeStructBegin('createOrders_args')
559 chandransh 10963 
    if self.cartId != None:
10964 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10965 
      oprot.writeI64(self.cartId)
10966 
      oprot.writeFieldEnd()
10967 
    oprot.writeFieldStop()
10968 
    oprot.writeStructEnd()
10969 
 
10970 
  def __repr__(self):
10971 
    L = ['%s=%r' % (key, value)
10972 
      for key, value in self.__dict__.iteritems()]
10973 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10974 
 
10975 
  def __eq__(self, other):
10976 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10977 
 
10978 
  def __ne__(self, other):
10979 
    return not (self == other)
10980 
 
690 chandransh 10981 
class createOrders_result:
559 chandransh 10982 
  """
10983 
  Attributes:
94 ashish 10984 
   - success
559 chandransh 10985 
   - scx
94 ashish 10986 
  """
10987 
 
10988 
  thrift_spec = (
575 chandransh 10989 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 10990 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 10991 
  )
10992 
 
559 chandransh 10993 
  def __init__(self, success=None, scx=None,):
94 ashish 10994 
    self.success = success
559 chandransh 10995 
    self.scx = scx
94 ashish 10996 
 
10997 
  def read(self, iprot):
10998 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10999 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11000 
      return
11001 
    iprot.readStructBegin()
11002 
    while True:
11003 
      (fname, ftype, fid) = iprot.readFieldBegin()
11004 
      if ftype == TType.STOP:
11005 
        break
11006 
      if fid == 0:
575 chandransh 11007 
        if ftype == TType.I64:
11008 
          self.success = iprot.readI64();
94 ashish 11009 
        else:
11010 
          iprot.skip(ftype)
11011 
      elif fid == 1:
11012 
        if ftype == TType.STRUCT:
559 chandransh 11013 
          self.scx = ShoppingCartException()
11014 
          self.scx.read(iprot)
94 ashish 11015 
        else:
11016 
          iprot.skip(ftype)
11017 
      else:
11018 
        iprot.skip(ftype)
11019 
      iprot.readFieldEnd()
11020 
    iprot.readStructEnd()
11021 
 
11022 
  def write(self, oprot):
11023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11025 
      return
690 chandransh 11026 
    oprot.writeStructBegin('createOrders_result')
94 ashish 11027 
    if self.success != None:
575 chandransh 11028 
      oprot.writeFieldBegin('success', TType.I64, 0)
11029 
      oprot.writeI64(self.success)
94 ashish 11030 
      oprot.writeFieldEnd()
559 chandransh 11031 
    if self.scx != None:
11032 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11033 
      self.scx.write(oprot)
94 ashish 11034 
      oprot.writeFieldEnd()
11035 
    oprot.writeFieldStop()
11036 
    oprot.writeStructEnd()
11037 
 
11038 
  def __repr__(self):
11039 
    L = ['%s=%r' % (key, value)
11040 
      for key, value in self.__dict__.iteritems()]
11041 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11042 
 
11043 
  def __eq__(self, other):
11044 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11045 
 
11046 
  def __ne__(self, other):
11047 
    return not (self == other)
11048 
 
559 chandransh 11049 
class validateCart_args:
94 ashish 11050 
  """
11051 
  Attributes:
559 chandransh 11052 
   - cartId
94 ashish 11053 
  """
11054 
 
11055 
  thrift_spec = (
11056 
    None, # 0
559 chandransh 11057 
    (1, TType.I64, 'cartId', None, None, ), # 1
94 ashish 11058 
  )
11059 
 
559 chandransh 11060 
  def __init__(self, cartId=None,):
11061 
    self.cartId = cartId
94 ashish 11062 
 
11063 
  def read(self, iprot):
11064 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11065 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11066 
      return
11067 
    iprot.readStructBegin()
11068 
    while True:
11069 
      (fname, ftype, fid) = iprot.readFieldBegin()
11070 
      if ftype == TType.STOP:
11071 
        break
11072 
      if fid == 1:
11073 
        if ftype == TType.I64:
559 chandransh 11074 
          self.cartId = iprot.readI64();
94 ashish 11075 
        else:
11076 
          iprot.skip(ftype)
11077 
      else:
11078 
        iprot.skip(ftype)
11079 
      iprot.readFieldEnd()
11080 
    iprot.readStructEnd()
11081 
 
11082 
  def write(self, oprot):
11083 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11084 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11085 
      return
559 chandransh 11086 
    oprot.writeStructBegin('validateCart_args')
11087 
    if self.cartId != None:
11088 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11089 
      oprot.writeI64(self.cartId)
94 ashish 11090 
      oprot.writeFieldEnd()
11091 
    oprot.writeFieldStop()
11092 
    oprot.writeStructEnd()
11093 
 
11094 
  def __repr__(self):
11095 
    L = ['%s=%r' % (key, value)
11096 
      for key, value in self.__dict__.iteritems()]
11097 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11098 
 
11099 
  def __eq__(self, other):
11100 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11101 
 
11102 
  def __ne__(self, other):
11103 
    return not (self == other)
11104 
 
559 chandransh 11105 
class validateCart_result:
94 ashish 11106 
  """
11107 
  Attributes:
11108 
   - success
575 chandransh 11109 
   - scex
94 ashish 11110 
  """
11111 
 
11112 
  thrift_spec = (
1466 ankur.sing 11113 
    (0, TType.STRING, 'success', None, None, ), # 0
575 chandransh 11114 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11115 
  )
11116 
 
575 chandransh 11117 
  def __init__(self, success=None, scex=None,):
94 ashish 11118 
    self.success = success
575 chandransh 11119 
    self.scex = scex
94 ashish 11120 
 
11121 
  def read(self, iprot):
11122 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11123 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11124 
      return
11125 
    iprot.readStructBegin()
11126 
    while True:
11127 
      (fname, ftype, fid) = iprot.readFieldBegin()
11128 
      if ftype == TType.STOP:
11129 
        break
11130 
      if fid == 0:
1466 ankur.sing 11131 
        if ftype == TType.STRING:
11132 
          self.success = iprot.readString();
94 ashish 11133 
        else:
11134 
          iprot.skip(ftype)
575 chandransh 11135 
      elif fid == 1:
11136 
        if ftype == TType.STRUCT:
11137 
          self.scex = ShoppingCartException()
11138 
          self.scex.read(iprot)
11139 
        else:
11140 
          iprot.skip(ftype)
94 ashish 11141 
      else:
11142 
        iprot.skip(ftype)
11143 
      iprot.readFieldEnd()
11144 
    iprot.readStructEnd()
11145 
 
11146 
  def write(self, oprot):
11147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11149 
      return
559 chandransh 11150 
    oprot.writeStructBegin('validateCart_result')
94 ashish 11151 
    if self.success != None:
1466 ankur.sing 11152 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11153 
      oprot.writeString(self.success)
94 ashish 11154 
      oprot.writeFieldEnd()
575 chandransh 11155 
    if self.scex != None:
11156 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11157 
      self.scex.write(oprot)
11158 
      oprot.writeFieldEnd()
559 chandransh 11159 
    oprot.writeFieldStop()
11160 
    oprot.writeStructEnd()
11161 
 
11162 
  def __repr__(self):
11163 
    L = ['%s=%r' % (key, value)
11164 
      for key, value in self.__dict__.iteritems()]
11165 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11166 
 
11167 
  def __eq__(self, other):
11168 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11169 
 
11170 
  def __ne__(self, other):
11171 
    return not (self == other)
11172 
 
690 chandransh 11173 
class mergeCart_args:
575 chandransh 11174 
  """
11175 
  Attributes:
690 chandransh 11176 
   - fromCartId
11177 
   - toCartId
11178 
  """
11179 
 
11180 
  thrift_spec = (
11181 
    None, # 0
11182 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
11183 
    (2, TType.I64, 'toCartId', None, None, ), # 2
11184 
  )
11185 
 
11186 
  def __init__(self, fromCartId=None, toCartId=None,):
11187 
    self.fromCartId = fromCartId
11188 
    self.toCartId = toCartId
11189 
 
11190 
  def read(self, iprot):
11191 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11192 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11193 
      return
11194 
    iprot.readStructBegin()
11195 
    while True:
11196 
      (fname, ftype, fid) = iprot.readFieldBegin()
11197 
      if ftype == TType.STOP:
11198 
        break
11199 
      if fid == 1:
11200 
        if ftype == TType.I64:
11201 
          self.fromCartId = iprot.readI64();
11202 
        else:
11203 
          iprot.skip(ftype)
11204 
      elif fid == 2:
11205 
        if ftype == TType.I64:
11206 
          self.toCartId = iprot.readI64();
11207 
        else:
11208 
          iprot.skip(ftype)
11209 
      else:
11210 
        iprot.skip(ftype)
11211 
      iprot.readFieldEnd()
11212 
    iprot.readStructEnd()
11213 
 
11214 
  def write(self, oprot):
11215 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11216 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11217 
      return
11218 
    oprot.writeStructBegin('mergeCart_args')
11219 
    if self.fromCartId != None:
11220 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
11221 
      oprot.writeI64(self.fromCartId)
11222 
      oprot.writeFieldEnd()
11223 
    if self.toCartId != None:
11224 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
11225 
      oprot.writeI64(self.toCartId)
11226 
      oprot.writeFieldEnd()
11227 
    oprot.writeFieldStop()
11228 
    oprot.writeStructEnd()
11229 
 
11230 
  def __repr__(self):
11231 
    L = ['%s=%r' % (key, value)
11232 
      for key, value in self.__dict__.iteritems()]
11233 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11234 
 
11235 
  def __eq__(self, other):
11236 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11237 
 
11238 
  def __ne__(self, other):
11239 
    return not (self == other)
11240 
 
11241 
class mergeCart_result:
11242 
 
11243 
  thrift_spec = (
11244 
  )
11245 
 
11246 
  def read(self, iprot):
11247 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11248 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11249 
      return
11250 
    iprot.readStructBegin()
11251 
    while True:
11252 
      (fname, ftype, fid) = iprot.readFieldBegin()
11253 
      if ftype == TType.STOP:
11254 
        break
11255 
      else:
11256 
        iprot.skip(ftype)
11257 
      iprot.readFieldEnd()
11258 
    iprot.readStructEnd()
11259 
 
11260 
  def write(self, oprot):
11261 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11262 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11263 
      return
11264 
    oprot.writeStructBegin('mergeCart_result')
11265 
    oprot.writeFieldStop()
11266 
    oprot.writeStructEnd()
11267 
 
11268 
  def __repr__(self):
11269 
    L = ['%s=%r' % (key, value)
11270 
      for key, value in self.__dict__.iteritems()]
11271 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11272 
 
11273 
  def __eq__(self, other):
11274 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11275 
 
11276 
  def __ne__(self, other):
11277 
    return not (self == other)
11278 
 
11279 
class checkOut_args:
11280 
  """
11281 
  Attributes:
575 chandransh 11282 
   - cartId
11283 
  """
11284 
 
11285 
  thrift_spec = (
11286 
    None, # 0
11287 
    (1, TType.I64, 'cartId', None, None, ), # 1
11288 
  )
11289 
 
11290 
  def __init__(self, cartId=None,):
11291 
    self.cartId = cartId
11292 
 
11293 
  def read(self, iprot):
11294 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11295 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11296 
      return
11297 
    iprot.readStructBegin()
11298 
    while True:
11299 
      (fname, ftype, fid) = iprot.readFieldBegin()
11300 
      if ftype == TType.STOP:
11301 
        break
11302 
      if fid == 1:
11303 
        if ftype == TType.I64:
11304 
          self.cartId = iprot.readI64();
11305 
        else:
11306 
          iprot.skip(ftype)
11307 
      else:
11308 
        iprot.skip(ftype)
11309 
      iprot.readFieldEnd()
11310 
    iprot.readStructEnd()
11311 
 
11312 
  def write(self, oprot):
11313 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11314 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11315 
      return
690 chandransh 11316 
    oprot.writeStructBegin('checkOut_args')
575 chandransh 11317 
    if self.cartId != None:
11318 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11319 
      oprot.writeI64(self.cartId)
11320 
      oprot.writeFieldEnd()
11321 
    oprot.writeFieldStop()
11322 
    oprot.writeStructEnd()
11323 
 
11324 
  def __repr__(self):
11325 
    L = ['%s=%r' % (key, value)
11326 
      for key, value in self.__dict__.iteritems()]
11327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11328 
 
11329 
  def __eq__(self, other):
11330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11331 
 
11332 
  def __ne__(self, other):
11333 
    return not (self == other)
11334 
 
690 chandransh 11335 
class checkOut_result:
575 chandransh 11336 
  """
11337 
  Attributes:
11338 
   - success
11339 
   - scex
11340 
  """
11341 
 
11342 
  thrift_spec = (
11343 
    (0, TType.BOOL, 'success', None, None, ), # 0
11344 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11345 
  )
11346 
 
11347 
  def __init__(self, success=None, scex=None,):
11348 
    self.success = success
11349 
    self.scex = scex
11350 
 
11351 
  def read(self, iprot):
11352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11354 
      return
11355 
    iprot.readStructBegin()
11356 
    while True:
11357 
      (fname, ftype, fid) = iprot.readFieldBegin()
11358 
      if ftype == TType.STOP:
11359 
        break
11360 
      if fid == 0:
11361 
        if ftype == TType.BOOL:
11362 
          self.success = iprot.readBool();
11363 
        else:
11364 
          iprot.skip(ftype)
11365 
      elif fid == 1:
11366 
        if ftype == TType.STRUCT:
11367 
          self.scex = ShoppingCartException()
11368 
          self.scex.read(iprot)
11369 
        else:
11370 
          iprot.skip(ftype)
11371 
      else:
11372 
        iprot.skip(ftype)
11373 
      iprot.readFieldEnd()
11374 
    iprot.readStructEnd()
11375 
 
11376 
  def write(self, oprot):
11377 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11378 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11379 
      return
690 chandransh 11380 
    oprot.writeStructBegin('checkOut_result')
575 chandransh 11381 
    if self.success != None:
11382 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11383 
      oprot.writeBool(self.success)
11384 
      oprot.writeFieldEnd()
11385 
    if self.scex != None:
11386 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11387 
      self.scex.write(oprot)
11388 
      oprot.writeFieldEnd()
11389 
    oprot.writeFieldStop()
11390 
    oprot.writeStructEnd()
11391 
 
11392 
  def __repr__(self):
11393 
    L = ['%s=%r' % (key, value)
11394 
      for key, value in self.__dict__.iteritems()]
11395 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11396 
 
11397 
  def __eq__(self, other):
11398 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11399 
 
11400 
  def __ne__(self, other):
11401 
    return not (self == other)
11402 
 
690 chandransh 11403 
class resetCart_args:
559 chandransh 11404 
  """
11405 
  Attributes:
690 chandransh 11406 
   - cartId
11407 
   - items
559 chandransh 11408 
  """
11409 
 
11410 
  thrift_spec = (
11411 
    None, # 0
690 chandransh 11412 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 11413 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 11414 
  )
11415 
 
690 chandransh 11416 
  def __init__(self, cartId=None, items=None,):
11417 
    self.cartId = cartId
11418 
    self.items = items
559 chandransh 11419 
 
11420 
  def read(self, iprot):
11421 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11422 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11423 
      return
11424 
    iprot.readStructBegin()
11425 
    while True:
11426 
      (fname, ftype, fid) = iprot.readFieldBegin()
11427 
      if ftype == TType.STOP:
11428 
        break
11429 
      if fid == 1:
11430 
        if ftype == TType.I64:
690 chandransh 11431 
          self.cartId = iprot.readI64();
559 chandransh 11432 
        else:
11433 
          iprot.skip(ftype)
11434 
      elif fid == 2:
690 chandransh 11435 
        if ftype == TType.MAP:
11436 
          self.items = {}
1996 vikas 11437 
          (_ktype113, _vtype114, _size112 ) = iprot.readMapBegin()
11438 
          for _i116 in xrange(_size112):
11439 
            _key117 = iprot.readI64();
11440 
            _val118 = iprot.readDouble();
11441 
            self.items[_key117] = _val118
690 chandransh 11442 
          iprot.readMapEnd()
559 chandransh 11443 
        else:
11444 
          iprot.skip(ftype)
11445 
      else:
11446 
        iprot.skip(ftype)
11447 
      iprot.readFieldEnd()
11448 
    iprot.readStructEnd()
11449 
 
11450 
  def write(self, oprot):
11451 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11452 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11453 
      return
690 chandransh 11454 
    oprot.writeStructBegin('resetCart_args')
11455 
    if self.cartId != None:
11456 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11457 
      oprot.writeI64(self.cartId)
94 ashish 11458 
      oprot.writeFieldEnd()
690 chandransh 11459 
    if self.items != None:
11460 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 11461 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
1996 vikas 11462 
      for kiter119,viter120 in self.items.items():
11463 
        oprot.writeI64(kiter119)
11464 
        oprot.writeDouble(viter120)
690 chandransh 11465 
      oprot.writeMapEnd()
559 chandransh 11466 
      oprot.writeFieldEnd()
94 ashish 11467 
    oprot.writeFieldStop()
11468 
    oprot.writeStructEnd()
11469 
 
11470 
  def __repr__(self):
11471 
    L = ['%s=%r' % (key, value)
11472 
      for key, value in self.__dict__.iteritems()]
11473 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11474 
 
11475 
  def __eq__(self, other):
11476 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11477 
 
11478 
  def __ne__(self, other):
11479 
    return not (self == other)
11480 
 
690 chandransh 11481 
class resetCart_result:
11482 
  """
11483 
  Attributes:
11484 
   - success
11485 
   - scex
11486 
  """
559 chandransh 11487 
 
11488 
  thrift_spec = (
690 chandransh 11489 
    (0, TType.BOOL, 'success', None, None, ), # 0
11490 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11491 
  )
11492 
 
690 chandransh 11493 
  def __init__(self, success=None, scex=None,):
11494 
    self.success = success
11495 
    self.scex = scex
11496 
 
559 chandransh 11497 
  def read(self, iprot):
11498 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11499 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11500 
      return
11501 
    iprot.readStructBegin()
11502 
    while True:
11503 
      (fname, ftype, fid) = iprot.readFieldBegin()
11504 
      if ftype == TType.STOP:
11505 
        break
690 chandransh 11506 
      if fid == 0:
11507 
        if ftype == TType.BOOL:
11508 
          self.success = iprot.readBool();
11509 
        else:
11510 
          iprot.skip(ftype)
11511 
      elif fid == 1:
11512 
        if ftype == TType.STRUCT:
11513 
          self.scex = ShoppingCartException()
11514 
          self.scex.read(iprot)
11515 
        else:
11516 
          iprot.skip(ftype)
559 chandransh 11517 
      else:
11518 
        iprot.skip(ftype)
11519 
      iprot.readFieldEnd()
11520 
    iprot.readStructEnd()
11521 
 
11522 
  def write(self, oprot):
11523 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11524 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11525 
      return
690 chandransh 11526 
    oprot.writeStructBegin('resetCart_result')
11527 
    if self.success != None:
11528 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11529 
      oprot.writeBool(self.success)
11530 
      oprot.writeFieldEnd()
11531 
    if self.scex != None:
11532 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11533 
      self.scex.write(oprot)
11534 
      oprot.writeFieldEnd()
559 chandransh 11535 
    oprot.writeFieldStop()
11536 
    oprot.writeStructEnd()
11537 
 
11538 
  def __repr__(self):
11539 
    L = ['%s=%r' % (key, value)
11540 
      for key, value in self.__dict__.iteritems()]
11541 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11542 
 
11543 
  def __eq__(self, other):
11544 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11545 
 
11546 
  def __ne__(self, other):
11547 
    return not (self == other)
11548 
 
772 rajveer 11549 
class getMyResearch_args:
94 ashish 11550 
  """
11551 
  Attributes:
559 chandransh 11552 
   - userId
11553 
  """
11554 
 
11555 
  thrift_spec = (
11556 
    None, # 0
772 rajveer 11557 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 11558 
  )
11559 
 
772 rajveer 11560 
  def __init__(self, userId=None,):
559 chandransh 11561 
    self.userId = userId
11562 
 
11563 
  def read(self, iprot):
11564 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11565 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11566 
      return
11567 
    iprot.readStructBegin()
11568 
    while True:
11569 
      (fname, ftype, fid) = iprot.readFieldBegin()
11570 
      if ftype == TType.STOP:
11571 
        break
11572 
      if fid == 1:
11573 
        if ftype == TType.I64:
11574 
          self.userId = iprot.readI64();
11575 
        else:
11576 
          iprot.skip(ftype)
11577 
      else:
11578 
        iprot.skip(ftype)
11579 
      iprot.readFieldEnd()
11580 
    iprot.readStructEnd()
11581 
 
11582 
  def write(self, oprot):
11583 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11584 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11585 
      return
772 rajveer 11586 
    oprot.writeStructBegin('getMyResearch_args')
559 chandransh 11587 
    if self.userId != None:
772 rajveer 11588 
      oprot.writeFieldBegin('userId', TType.I64, 1)
559 chandransh 11589 
      oprot.writeI64(self.userId)
11590 
      oprot.writeFieldEnd()
11591 
    oprot.writeFieldStop()
11592 
    oprot.writeStructEnd()
11593 
 
11594 
  def __repr__(self):
11595 
    L = ['%s=%r' % (key, value)
11596 
      for key, value in self.__dict__.iteritems()]
11597 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11598 
 
11599 
  def __eq__(self, other):
11600 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11601 
 
11602 
  def __ne__(self, other):
11603 
    return not (self == other)
11604 
 
11605 
class getMyResearch_result:
94 ashish 11606 
  """
11607 
  Attributes:
11608 
   - success
559 chandransh 11609 
   - scx
94 ashish 11610 
  """
11611 
 
11612 
  thrift_spec = (
559 chandransh 11613 
    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
11614 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
94 ashish 11615 
  )
11616 
 
559 chandransh 11617 
  def __init__(self, success=None, scx=None,):
94 ashish 11618 
    self.success = success
559 chandransh 11619 
    self.scx = scx
94 ashish 11620 
 
11621 
  def read(self, iprot):
11622 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11623 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11624 
      return
11625 
    iprot.readStructBegin()
11626 
    while True:
11627 
      (fname, ftype, fid) = iprot.readFieldBegin()
11628 
      if ftype == TType.STOP:
11629 
        break
11630 
      if fid == 0:
559 chandransh 11631 
        if ftype == TType.STRUCT:
11632 
          self.success = Widget()
11633 
          self.success.read(iprot)
94 ashish 11634 
        else:
11635 
          iprot.skip(ftype)
11636 
      elif fid == 1:
11637 
        if ftype == TType.STRUCT:
559 chandransh 11638 
          self.scx = WidgetException()
11639 
          self.scx.read(iprot)
94 ashish 11640 
        else:
11641 
          iprot.skip(ftype)
11642 
      else:
11643 
        iprot.skip(ftype)
11644 
      iprot.readFieldEnd()
11645 
    iprot.readStructEnd()
11646 
 
11647 
  def write(self, oprot):
11648 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11649 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11650 
      return
559 chandransh 11651 
    oprot.writeStructBegin('getMyResearch_result')
94 ashish 11652 
    if self.success != None:
559 chandransh 11653 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11654 
      self.success.write(oprot)
94 ashish 11655 
      oprot.writeFieldEnd()
559 chandransh 11656 
    if self.scx != None:
11657 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11658 
      self.scx.write(oprot)
94 ashish 11659 
      oprot.writeFieldEnd()
11660 
    oprot.writeFieldStop()
11661 
    oprot.writeStructEnd()
11662 
 
11663 
  def __repr__(self):
11664 
    L = ['%s=%r' % (key, value)
11665 
      for key, value in self.__dict__.iteritems()]
11666 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11667 
 
11668 
  def __eq__(self, other):
11669 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11670 
 
11671 
  def __ne__(self, other):
11672 
    return not (self == other)
11673 
 
559 chandransh 11674 
class updateMyResearch_args:
94 ashish 11675 
  """
11676 
  Attributes:
772 rajveer 11677 
   - userId
11678 
   - itemId
94 ashish 11679 
  """
11680 
 
11681 
  thrift_spec = (
11682 
    None, # 0
772 rajveer 11683 
    (1, TType.I64, 'userId', None, None, ), # 1
11684 
    (2, TType.I64, 'itemId', None, None, ), # 2
94 ashish 11685 
  )
11686 
 
772 rajveer 11687 
  def __init__(self, userId=None, itemId=None,):
11688 
    self.userId = userId
11689 
    self.itemId = itemId
94 ashish 11690 
 
11691 
  def read(self, iprot):
11692 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11693 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11694 
      return
11695 
    iprot.readStructBegin()
11696 
    while True:
11697 
      (fname, ftype, fid) = iprot.readFieldBegin()
11698 
      if ftype == TType.STOP:
11699 
        break
11700 
      if fid == 1:
11701 
        if ftype == TType.I64:
772 rajveer 11702 
          self.userId = iprot.readI64();
94 ashish 11703 
        else:
11704 
          iprot.skip(ftype)
11705 
      elif fid == 2:
559 chandransh 11706 
        if ftype == TType.I64:
772 rajveer 11707 
          self.itemId = iprot.readI64();
94 ashish 11708 
        else:
11709 
          iprot.skip(ftype)
11710 
      else:
11711 
        iprot.skip(ftype)
11712 
      iprot.readFieldEnd()
11713 
    iprot.readStructEnd()
11714 
 
11715 
  def write(self, oprot):
11716 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11717 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11718 
      return
559 chandransh 11719 
    oprot.writeStructBegin('updateMyResearch_args')
772 rajveer 11720 
    if self.userId != None:
11721 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11722 
      oprot.writeI64(self.userId)
94 ashish 11723 
      oprot.writeFieldEnd()
772 rajveer 11724 
    if self.itemId != None:
11725 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11726 
      oprot.writeI64(self.itemId)
94 ashish 11727 
      oprot.writeFieldEnd()
11728 
    oprot.writeFieldStop()
11729 
    oprot.writeStructEnd()
11730 
 
11731 
  def __repr__(self):
11732 
    L = ['%s=%r' % (key, value)
11733 
      for key, value in self.__dict__.iteritems()]
11734 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11735 
 
11736 
  def __eq__(self, other):
11737 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11738 
 
11739 
  def __ne__(self, other):
11740 
    return not (self == other)
11741 
 
559 chandransh 11742 
class updateMyResearch_result:
94 ashish 11743 
  """
11744 
  Attributes:
11745 
   - success
559 chandransh 11746 
   - scx
94 ashish 11747 
  """
11748 
 
11749 
  thrift_spec = (
11750 
    (0, TType.BOOL, 'success', None, None, ), # 0
559 chandransh 11751 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
94 ashish 11752 
  )
11753 
 
559 chandransh 11754 
  def __init__(self, success=None, scx=None,):
94 ashish 11755 
    self.success = success
559 chandransh 11756 
    self.scx = scx
94 ashish 11757 
 
11758 
  def read(self, iprot):
11759 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11760 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11761 
      return
11762 
    iprot.readStructBegin()
11763 
    while True:
11764 
      (fname, ftype, fid) = iprot.readFieldBegin()
11765 
      if ftype == TType.STOP:
11766 
        break
11767 
      if fid == 0:
11768 
        if ftype == TType.BOOL:
11769 
          self.success = iprot.readBool();
11770 
        else:
11771 
          iprot.skip(ftype)
11772 
      elif fid == 1:
11773 
        if ftype == TType.STRUCT:
559 chandransh 11774 
          self.scx = WidgetException()
11775 
          self.scx.read(iprot)
94 ashish 11776 
        else:
11777 
          iprot.skip(ftype)
11778 
      else:
11779 
        iprot.skip(ftype)
11780 
      iprot.readFieldEnd()
11781 
    iprot.readStructEnd()
11782 
 
11783 
  def write(self, oprot):
11784 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11785 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11786 
      return
559 chandransh 11787 
    oprot.writeStructBegin('updateMyResearch_result')
94 ashish 11788 
    if self.success != None:
11789 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11790 
      oprot.writeBool(self.success)
11791 
      oprot.writeFieldEnd()
559 chandransh 11792 
    if self.scx != None:
11793 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11794 
      self.scx.write(oprot)
94 ashish 11795 
      oprot.writeFieldEnd()
11796 
    oprot.writeFieldStop()
11797 
    oprot.writeStructEnd()
11798 
 
11799 
  def __repr__(self):
11800 
    L = ['%s=%r' % (key, value)
11801 
      for key, value in self.__dict__.iteritems()]
11802 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11803 
 
11804 
  def __eq__(self, other):
11805 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11806 
 
11807 
  def __ne__(self, other):
11808 
    return not (self == other)
11809 
 
559 chandransh 11810 
class deleteItemFromMyResearch_args:
130 ashish 11811 
  """
11812 
  Attributes:
772 rajveer 11813 
   - userId
11814 
   - itemId
130 ashish 11815 
  """
94 ashish 11816 
 
130 ashish 11817 
  thrift_spec = (
11818 
    None, # 0
772 rajveer 11819 
    (1, TType.I64, 'userId', None, None, ), # 1
11820 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 11821 
  )
11822 
 
772 rajveer 11823 
  def __init__(self, userId=None, itemId=None,):
11824 
    self.userId = userId
11825 
    self.itemId = itemId
130 ashish 11826 
 
11827 
  def read(self, iprot):
11828 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11829 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11830 
      return
11831 
    iprot.readStructBegin()
11832 
    while True:
11833 
      (fname, ftype, fid) = iprot.readFieldBegin()
11834 
      if ftype == TType.STOP:
11835 
        break
11836 
      if fid == 1:
11837 
        if ftype == TType.I64:
772 rajveer 11838 
          self.userId = iprot.readI64();
130 ashish 11839 
        else:
11840 
          iprot.skip(ftype)
559 chandransh 11841 
      elif fid == 2:
11842 
        if ftype == TType.I64:
772 rajveer 11843 
          self.itemId = iprot.readI64();
559 chandransh 11844 
        else:
11845 
          iprot.skip(ftype)
130 ashish 11846 
      else:
11847 
        iprot.skip(ftype)
11848 
      iprot.readFieldEnd()
11849 
    iprot.readStructEnd()
11850 
 
11851 
  def write(self, oprot):
11852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11854 
      return
559 chandransh 11855 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
772 rajveer 11856 
    if self.userId != None:
11857 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11858 
      oprot.writeI64(self.userId)
130 ashish 11859 
      oprot.writeFieldEnd()
772 rajveer 11860 
    if self.itemId != None:
11861 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11862 
      oprot.writeI64(self.itemId)
559 chandransh 11863 
      oprot.writeFieldEnd()
130 ashish 11864 
    oprot.writeFieldStop()
11865 
    oprot.writeStructEnd()
11866 
 
11867 
  def __repr__(self):
11868 
    L = ['%s=%r' % (key, value)
11869 
      for key, value in self.__dict__.iteritems()]
11870 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11871 
 
11872 
  def __eq__(self, other):
11873 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11874 
 
11875 
  def __ne__(self, other):
11876 
    return not (self == other)
11877 
 
559 chandransh 11878 
class deleteItemFromMyResearch_result:
130 ashish 11879 
  """
11880 
  Attributes:
559 chandransh 11881 
   - scx
11882 
  """
11883 
 
11884 
  thrift_spec = (
11885 
    None, # 0
11886 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
11887 
  )
11888 
 
11889 
  def __init__(self, scx=None,):
11890 
    self.scx = scx
11891 
 
11892 
  def read(self, iprot):
11893 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11894 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11895 
      return
11896 
    iprot.readStructBegin()
11897 
    while True:
11898 
      (fname, ftype, fid) = iprot.readFieldBegin()
11899 
      if ftype == TType.STOP:
11900 
        break
11901 
      if fid == 1:
11902 
        if ftype == TType.STRUCT:
11903 
          self.scx = WidgetException()
11904 
          self.scx.read(iprot)
11905 
        else:
11906 
          iprot.skip(ftype)
11907 
      else:
11908 
        iprot.skip(ftype)
11909 
      iprot.readFieldEnd()
11910 
    iprot.readStructEnd()
11911 
 
11912 
  def write(self, oprot):
11913 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11914 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11915 
      return
11916 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
11917 
    if self.scx != None:
11918 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11919 
      self.scx.write(oprot)
11920 
      oprot.writeFieldEnd()
11921 
    oprot.writeFieldStop()
11922 
    oprot.writeStructEnd()
11923 
 
11924 
  def __repr__(self):
11925 
    L = ['%s=%r' % (key, value)
11926 
      for key, value in self.__dict__.iteritems()]
11927 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11928 
 
11929 
  def __eq__(self, other):
11930 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11931 
 
11932 
  def __ne__(self, other):
11933 
    return not (self == other)
11934 
 
772 rajveer 11935 
class updateBrowseHistory_args:
559 chandransh 11936 
  """
11937 
  Attributes:
772 rajveer 11938 
   - userId
11939 
   - itemId
559 chandransh 11940 
  """
11941 
 
11942 
  thrift_spec = (
11943 
    None, # 0
772 rajveer 11944 
    (1, TType.I64, 'userId', None, None, ), # 1
11945 
    (2, TType.I64, 'itemId', None, None, ), # 2
559 chandransh 11946 
  )
11947 
 
772 rajveer 11948 
  def __init__(self, userId=None, itemId=None,):
11949 
    self.userId = userId
11950 
    self.itemId = itemId
559 chandransh 11951 
 
11952 
  def read(self, iprot):
11953 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11954 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11955 
      return
11956 
    iprot.readStructBegin()
11957 
    while True:
11958 
      (fname, ftype, fid) = iprot.readFieldBegin()
11959 
      if ftype == TType.STOP:
11960 
        break
11961 
      if fid == 1:
11962 
        if ftype == TType.I64:
772 rajveer 11963 
          self.userId = iprot.readI64();
559 chandransh 11964 
        else:
11965 
          iprot.skip(ftype)
11966 
      elif fid == 2:
11967 
        if ftype == TType.I64:
772 rajveer 11968 
          self.itemId = iprot.readI64();
559 chandransh 11969 
        else:
11970 
          iprot.skip(ftype)
11971 
      else:
11972 
        iprot.skip(ftype)
11973 
      iprot.readFieldEnd()
11974 
    iprot.readStructEnd()
11975 
 
11976 
  def write(self, oprot):
11977 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11978 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11979 
      return
772 rajveer 11980 
    oprot.writeStructBegin('updateBrowseHistory_args')
11981 
    if self.userId != None:
11982 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11983 
      oprot.writeI64(self.userId)
559 chandransh 11984 
      oprot.writeFieldEnd()
772 rajveer 11985 
    if self.itemId != None:
11986 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11987 
      oprot.writeI64(self.itemId)
559 chandransh 11988 
      oprot.writeFieldEnd()
11989 
    oprot.writeFieldStop()
11990 
    oprot.writeStructEnd()
11991 
 
11992 
  def __repr__(self):
11993 
    L = ['%s=%r' % (key, value)
11994 
      for key, value in self.__dict__.iteritems()]
11995 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11996 
 
11997 
  def __eq__(self, other):
11998 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11999 
 
12000 
  def __ne__(self, other):
12001 
    return not (self == other)
12002 
 
772 rajveer 12003 
class updateBrowseHistory_result:
559 chandransh 12004 
 
12005 
  thrift_spec = (
12006 
  )
12007 
 
12008 
  def read(self, iprot):
12009 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12010 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12011 
      return
12012 
    iprot.readStructBegin()
12013 
    while True:
12014 
      (fname, ftype, fid) = iprot.readFieldBegin()
12015 
      if ftype == TType.STOP:
12016 
        break
12017 
      else:
12018 
        iprot.skip(ftype)
12019 
      iprot.readFieldEnd()
12020 
    iprot.readStructEnd()
12021 
 
12022 
  def write(self, oprot):
12023 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12024 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12025 
      return
772 rajveer 12026 
    oprot.writeStructBegin('updateBrowseHistory_result')
559 chandransh 12027 
    oprot.writeFieldStop()
12028 
    oprot.writeStructEnd()
12029 
 
12030 
  def __repr__(self):
12031 
    L = ['%s=%r' % (key, value)
12032 
      for key, value in self.__dict__.iteritems()]
12033 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12034 
 
12035 
  def __eq__(self, other):
12036 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12037 
 
12038 
  def __ne__(self, other):
12039 
    return not (self == other)
12040 
 
772 rajveer 12041 
class getBrowseHistory_args:
559 chandransh 12042 
  """
12043 
  Attributes:
772 rajveer 12044 
   - userId
559 chandransh 12045 
  """
12046 
 
12047 
  thrift_spec = (
12048 
    None, # 0
772 rajveer 12049 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 12050 
  )
12051 
 
772 rajveer 12052 
  def __init__(self, userId=None,):
12053 
    self.userId = userId
559 chandransh 12054 
 
12055 
  def read(self, iprot):
12056 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12057 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12058 
      return
12059 
    iprot.readStructBegin()
12060 
    while True:
12061 
      (fname, ftype, fid) = iprot.readFieldBegin()
12062 
      if ftype == TType.STOP:
12063 
        break
12064 
      if fid == 1:
12065 
        if ftype == TType.I64:
772 rajveer 12066 
          self.userId = iprot.readI64();
559 chandransh 12067 
        else:
12068 
          iprot.skip(ftype)
12069 
      else:
12070 
        iprot.skip(ftype)
12071 
      iprot.readFieldEnd()
12072 
    iprot.readStructEnd()
12073 
 
12074 
  def write(self, oprot):
12075 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12076 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12077 
      return
772 rajveer 12078 
    oprot.writeStructBegin('getBrowseHistory_args')
12079 
    if self.userId != None:
12080 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12081 
      oprot.writeI64(self.userId)
559 chandransh 12082 
      oprot.writeFieldEnd()
12083 
    oprot.writeFieldStop()
12084 
    oprot.writeStructEnd()
12085 
 
12086 
  def __repr__(self):
12087 
    L = ['%s=%r' % (key, value)
12088 
      for key, value in self.__dict__.iteritems()]
12089 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12090 
 
12091 
  def __eq__(self, other):
12092 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12093 
 
12094 
  def __ne__(self, other):
12095 
    return not (self == other)
12096 
 
772 rajveer 12097 
class getBrowseHistory_result:
559 chandransh 12098 
  """
12099 
  Attributes:
130 ashish 12100 
   - success
559 chandransh 12101 
   - scx
130 ashish 12102 
  """
12103 
 
12104 
  thrift_spec = (
772 rajveer 12105 
    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
559 chandransh 12106 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 12107 
  )
12108 
 
559 chandransh 12109 
  def __init__(self, success=None, scx=None,):
130 ashish 12110 
    self.success = success
559 chandransh 12111 
    self.scx = scx
130 ashish 12112 
 
12113 
  def read(self, iprot):
12114 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12115 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12116 
      return
12117 
    iprot.readStructBegin()
12118 
    while True:
12119 
      (fname, ftype, fid) = iprot.readFieldBegin()
12120 
      if ftype == TType.STOP:
12121 
        break
12122 
      if fid == 0:
559 chandransh 12123 
        if ftype == TType.STRUCT:
772 rajveer 12124 
          self.success = Widget()
559 chandransh 12125 
          self.success.read(iprot)
130 ashish 12126 
        else:
12127 
          iprot.skip(ftype)
12128 
      elif fid == 1:
12129 
        if ftype == TType.STRUCT:
559 chandransh 12130 
          self.scx = WidgetException()
12131 
          self.scx.read(iprot)
130 ashish 12132 
        else:
12133 
          iprot.skip(ftype)
12134 
      else:
12135 
        iprot.skip(ftype)
12136 
      iprot.readFieldEnd()
12137 
    iprot.readStructEnd()
12138 
 
12139 
  def write(self, oprot):
12140 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12141 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12142 
      return
772 rajveer 12143 
    oprot.writeStructBegin('getBrowseHistory_result')
130 ashish 12144 
    if self.success != None:
559 chandransh 12145 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12146 
      self.success.write(oprot)
130 ashish 12147 
      oprot.writeFieldEnd()
559 chandransh 12148 
    if self.scx != None:
12149 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12150 
      self.scx.write(oprot)
130 ashish 12151 
      oprot.writeFieldEnd()
12152 
    oprot.writeFieldStop()
12153 
    oprot.writeStructEnd()
12154 
 
12155 
  def __repr__(self):
12156 
    L = ['%s=%r' % (key, value)
12157 
      for key, value in self.__dict__.iteritems()]
12158 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12159 
 
12160 
  def __eq__(self, other):
12161 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12162 
 
12163 
  def __ne__(self, other):
12164 
    return not (self == other)
12165 
 
772 rajveer 12166 
class mergeBrowseHistory_args:
130 ashish 12167 
  """
12168 
  Attributes:
772 rajveer 12169 
   - fromUserId
12170 
   - toUserId
130 ashish 12171 
  """
12172 
 
12173 
  thrift_spec = (
12174 
    None, # 0
772 rajveer 12175 
    (1, TType.I64, 'fromUserId', None, None, ), # 1
12176 
    (2, TType.I64, 'toUserId', None, None, ), # 2
130 ashish 12177 
  )
12178 
 
772 rajveer 12179 
  def __init__(self, fromUserId=None, toUserId=None,):
12180 
    self.fromUserId = fromUserId
12181 
    self.toUserId = toUserId
130 ashish 12182 
 
12183 
  def read(self, iprot):
12184 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12185 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12186 
      return
12187 
    iprot.readStructBegin()
12188 
    while True:
12189 
      (fname, ftype, fid) = iprot.readFieldBegin()
12190 
      if ftype == TType.STOP:
12191 
        break
12192 
      if fid == 1:
559 chandransh 12193 
        if ftype == TType.I64:
772 rajveer 12194 
          self.fromUserId = iprot.readI64();
130 ashish 12195 
        else:
12196 
          iprot.skip(ftype)
12197 
      elif fid == 2:
559 chandransh 12198 
        if ftype == TType.I64:
772 rajveer 12199 
          self.toUserId = iprot.readI64();
559 chandransh 12200 
        else:
12201 
          iprot.skip(ftype)
130 ashish 12202 
      else:
12203 
        iprot.skip(ftype)
12204 
      iprot.readFieldEnd()
12205 
    iprot.readStructEnd()
12206 
 
12207 
  def write(self, oprot):
12208 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12209 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12210 
      return
772 rajveer 12211 
    oprot.writeStructBegin('mergeBrowseHistory_args')
12212 
    if self.fromUserId != None:
12213 
      oprot.writeFieldBegin('fromUserId', TType.I64, 1)
12214 
      oprot.writeI64(self.fromUserId)
130 ashish 12215 
      oprot.writeFieldEnd()
772 rajveer 12216 
    if self.toUserId != None:
12217 
      oprot.writeFieldBegin('toUserId', TType.I64, 2)
12218 
      oprot.writeI64(self.toUserId)
130 ashish 12219 
      oprot.writeFieldEnd()
12220 
    oprot.writeFieldStop()
12221 
    oprot.writeStructEnd()
12222 
 
12223 
  def __repr__(self):
12224 
    L = ['%s=%r' % (key, value)
12225 
      for key, value in self.__dict__.iteritems()]
12226 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12227 
 
12228 
  def __eq__(self, other):
12229 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12230 
 
12231 
  def __ne__(self, other):
12232 
    return not (self == other)
12233 
 
772 rajveer 12234 
class mergeBrowseHistory_result:
559 chandransh 12235 
 
12236 
  thrift_spec = (
12237 
  )
12238 
 
12239 
  def read(self, iprot):
12240 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12241 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12242 
      return
12243 
    iprot.readStructBegin()
12244 
    while True:
12245 
      (fname, ftype, fid) = iprot.readFieldBegin()
12246 
      if ftype == TType.STOP:
12247 
        break
12248 
      else:
12249 
        iprot.skip(ftype)
12250 
      iprot.readFieldEnd()
12251 
    iprot.readStructEnd()
12252 
 
12253 
  def write(self, oprot):
12254 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12255 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12256 
      return
772 rajveer 12257 
    oprot.writeStructBegin('mergeBrowseHistory_result')
559 chandransh 12258 
    oprot.writeFieldStop()
12259 
    oprot.writeStructEnd()
12260 
 
12261 
  def __repr__(self):
12262 
    L = ['%s=%r' % (key, value)
12263 
      for key, value in self.__dict__.iteritems()]
12264 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12265 
 
12266 
  def __eq__(self, other):
12267 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12268 
 
12269 
  def __ne__(self, other):
12270 
    return not (self == other)
12271 
 
1596 ankur.sing 12272 
class getUserCount_args:
12273 
  """
12274 
  Attributes:
12275 
   - userType
12276 
  """
559 chandransh 12277 
 
1596 ankur.sing 12278 
  thrift_spec = (
12279 
    None, # 0
12280 
    (1, TType.I32, 'userType', None, None, ), # 1
12281 
  )
12282 
 
12283 
  def __init__(self, userType=None,):
12284 
    self.userType = userType
12285 
 
12286 
  def read(self, iprot):
12287 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12288 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12289 
      return
12290 
    iprot.readStructBegin()
12291 
    while True:
12292 
      (fname, ftype, fid) = iprot.readFieldBegin()
12293 
      if ftype == TType.STOP:
12294 
        break
12295 
      if fid == 1:
12296 
        if ftype == TType.I32:
12297 
          self.userType = iprot.readI32();
12298 
        else:
12299 
          iprot.skip(ftype)
12300 
      else:
12301 
        iprot.skip(ftype)
12302 
      iprot.readFieldEnd()
12303 
    iprot.readStructEnd()
12304 
 
12305 
  def write(self, oprot):
12306 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12307 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12308 
      return
12309 
    oprot.writeStructBegin('getUserCount_args')
12310 
    if self.userType != None:
12311 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12312 
      oprot.writeI32(self.userType)
12313 
      oprot.writeFieldEnd()
12314 
    oprot.writeFieldStop()
12315 
    oprot.writeStructEnd()
12316 
 
12317 
  def __repr__(self):
12318 
    L = ['%s=%r' % (key, value)
12319 
      for key, value in self.__dict__.iteritems()]
12320 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12321 
 
12322 
  def __eq__(self, other):
12323 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12324 
 
12325 
  def __ne__(self, other):
12326 
    return not (self == other)
12327 
 
12328 
class getUserCount_result:
12329 
  """
12330 
  Attributes:
12331 
   - success
12332 
  """
12333 
 
12334 
  thrift_spec = (
12335 
    (0, TType.I64, 'success', None, None, ), # 0
12336 
  )
12337 
 
12338 
  def __init__(self, success=None,):
12339 
    self.success = success
12340 
 
12341 
  def read(self, iprot):
12342 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12343 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12344 
      return
12345 
    iprot.readStructBegin()
12346 
    while True:
12347 
      (fname, ftype, fid) = iprot.readFieldBegin()
12348 
      if ftype == TType.STOP:
12349 
        break
12350 
      if fid == 0:
12351 
        if ftype == TType.I64:
12352 
          self.success = iprot.readI64();
12353 
        else:
12354 
          iprot.skip(ftype)
12355 
      else:
12356 
        iprot.skip(ftype)
12357 
      iprot.readFieldEnd()
12358 
    iprot.readStructEnd()
12359 
 
12360 
  def write(self, oprot):
12361 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12362 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12363 
      return
12364 
    oprot.writeStructBegin('getUserCount_result')
12365 
    if self.success != None:
12366 
      oprot.writeFieldBegin('success', TType.I64, 0)
12367 
      oprot.writeI64(self.success)
12368 
      oprot.writeFieldEnd()
12369 
    oprot.writeFieldStop()
12370 
    oprot.writeStructEnd()
12371 
 
12372 
  def __repr__(self):
12373 
    L = ['%s=%r' % (key, value)
12374 
      for key, value in self.__dict__.iteritems()]
12375 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12376 
 
12377 
  def __eq__(self, other):
12378 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12379 
 
12380 
  def __ne__(self, other):
12381 
    return not (self == other)
12382 
 
1673 ankur.sing 12383 
class getAllUsers_args:
12384 
  """
12385 
  Attributes:
12386 
   - userType
1891 ankur.sing 12387 
   - startDate
12388 
   - endDate
1673 ankur.sing 12389 
  """
1596 ankur.sing 12390 
 
1673 ankur.sing 12391 
  thrift_spec = (
12392 
    None, # 0
12393 
    (1, TType.I32, 'userType', None, None, ), # 1
1891 ankur.sing 12394 
    (2, TType.I64, 'startDate', None, None, ), # 2
12395 
    (3, TType.I64, 'endDate', None, None, ), # 3
1673 ankur.sing 12396 
  )
12397 
 
1891 ankur.sing 12398 
  def __init__(self, userType=None, startDate=None, endDate=None,):
1673 ankur.sing 12399 
    self.userType = userType
1891 ankur.sing 12400 
    self.startDate = startDate
12401 
    self.endDate = endDate
1673 ankur.sing 12402 
 
12403 
  def read(self, iprot):
12404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12406 
      return
12407 
    iprot.readStructBegin()
12408 
    while True:
12409 
      (fname, ftype, fid) = iprot.readFieldBegin()
12410 
      if ftype == TType.STOP:
12411 
        break
12412 
      if fid == 1:
12413 
        if ftype == TType.I32:
12414 
          self.userType = iprot.readI32();
12415 
        else:
12416 
          iprot.skip(ftype)
1891 ankur.sing 12417 
      elif fid == 2:
12418 
        if ftype == TType.I64:
12419 
          self.startDate = iprot.readI64();
12420 
        else:
12421 
          iprot.skip(ftype)
12422 
      elif fid == 3:
12423 
        if ftype == TType.I64:
12424 
          self.endDate = iprot.readI64();
12425 
        else:
12426 
          iprot.skip(ftype)
1673 ankur.sing 12427 
      else:
12428 
        iprot.skip(ftype)
12429 
      iprot.readFieldEnd()
12430 
    iprot.readStructEnd()
12431 
 
12432 
  def write(self, oprot):
12433 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12434 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12435 
      return
12436 
    oprot.writeStructBegin('getAllUsers_args')
12437 
    if self.userType != None:
12438 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12439 
      oprot.writeI32(self.userType)
12440 
      oprot.writeFieldEnd()
1891 ankur.sing 12441 
    if self.startDate != None:
12442 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
12443 
      oprot.writeI64(self.startDate)
12444 
      oprot.writeFieldEnd()
12445 
    if self.endDate != None:
12446 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
12447 
      oprot.writeI64(self.endDate)
12448 
      oprot.writeFieldEnd()
1673 ankur.sing 12449 
    oprot.writeFieldStop()
12450 
    oprot.writeStructEnd()
12451 
 
12452 
  def __repr__(self):
12453 
    L = ['%s=%r' % (key, value)
12454 
      for key, value in self.__dict__.iteritems()]
12455 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12456 
 
12457 
  def __eq__(self, other):
12458 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12459 
 
12460 
  def __ne__(self, other):
12461 
    return not (self == other)
12462 
 
12463 
class getAllUsers_result:
12464 
  """
12465 
  Attributes:
12466 
   - success
12467 
  """
12468 
 
12469 
  thrift_spec = (
12470 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
12471 
  )
12472 
 
12473 
  def __init__(self, success=None,):
12474 
    self.success = success
12475 
 
12476 
  def read(self, iprot):
12477 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12478 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12479 
      return
12480 
    iprot.readStructBegin()
12481 
    while True:
12482 
      (fname, ftype, fid) = iprot.readFieldBegin()
12483 
      if ftype == TType.STOP:
12484 
        break
12485 
      if fid == 0:
12486 
        if ftype == TType.LIST:
12487 
          self.success = []
1996 vikas 12488 
          (_etype124, _size121) = iprot.readListBegin()
12489 
          for _i125 in xrange(_size121):
12490 
            _elem126 = User()
12491 
            _elem126.read(iprot)
12492 
            self.success.append(_elem126)
1673 ankur.sing 12493 
          iprot.readListEnd()
12494 
        else:
12495 
          iprot.skip(ftype)
12496 
      else:
12497 
        iprot.skip(ftype)
12498 
      iprot.readFieldEnd()
12499 
    iprot.readStructEnd()
12500 
 
12501 
  def write(self, oprot):
12502 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12503 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12504 
      return
12505 
    oprot.writeStructBegin('getAllUsers_result')
12506 
    if self.success != None:
12507 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12508 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 12509 
      for iter127 in self.success:
12510 
        iter127.write(oprot)
1673 ankur.sing 12511 
      oprot.writeListEnd()
12512 
      oprot.writeFieldEnd()
12513 
    oprot.writeFieldStop()
12514 
    oprot.writeStructEnd()
12515 
 
12516 
  def __repr__(self):
12517 
    L = ['%s=%r' % (key, value)
12518 
      for key, value in self.__dict__.iteritems()]
12519 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12520 
 
12521 
  def __eq__(self, other):
12522 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12523 
 
12524 
  def __ne__(self, other):
12525 
    return not (self == other)
12526 
 
2642 varun.gupt 12527 
class putUserNote_args:
12528 
  """
12529 
  Attributes:
12530 
   - user_id
12531 
   - entity_id
2717 varun.gupt 12532 
   - slide
2642 varun.gupt 12533 
   - note
12534 
  """
1673 ankur.sing 12535 
 
2642 varun.gupt 12536 
  thrift_spec = (
12537 
    None, # 0
12538 
    (1, TType.I64, 'user_id', None, None, ), # 1
12539 
    (2, TType.I64, 'entity_id', None, None, ), # 2
2717 varun.gupt 12540 
    (3, TType.STRING, 'slide', None, None, ), # 3
2642 varun.gupt 12541 
    (4, TType.STRING, 'note', None, None, ), # 4
12542 
  )
12543 
 
2717 varun.gupt 12544 
  def __init__(self, user_id=None, entity_id=None, slide=None, note=None,):
2642 varun.gupt 12545 
    self.user_id = user_id
12546 
    self.entity_id = entity_id
2717 varun.gupt 12547 
    self.slide = slide
2642 varun.gupt 12548 
    self.note = note
12549 
 
12550 
  def read(self, iprot):
12551 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12552 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12553 
      return
12554 
    iprot.readStructBegin()
12555 
    while True:
12556 
      (fname, ftype, fid) = iprot.readFieldBegin()
12557 
      if ftype == TType.STOP:
12558 
        break
12559 
      if fid == 1:
12560 
        if ftype == TType.I64:
12561 
          self.user_id = iprot.readI64();
12562 
        else:
12563 
          iprot.skip(ftype)
12564 
      elif fid == 2:
12565 
        if ftype == TType.I64:
12566 
          self.entity_id = iprot.readI64();
12567 
        else:
12568 
          iprot.skip(ftype)
12569 
      elif fid == 3:
2717 varun.gupt 12570 
        if ftype == TType.STRING:
12571 
          self.slide = iprot.readString();
2642 varun.gupt 12572 
        else:
12573 
          iprot.skip(ftype)
12574 
      elif fid == 4:
12575 
        if ftype == TType.STRING:
12576 
          self.note = iprot.readString();
12577 
        else:
12578 
          iprot.skip(ftype)
12579 
      else:
12580 
        iprot.skip(ftype)
12581 
      iprot.readFieldEnd()
12582 
    iprot.readStructEnd()
12583 
 
12584 
  def write(self, oprot):
12585 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12586 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12587 
      return
12588 
    oprot.writeStructBegin('putUserNote_args')
12589 
    if self.user_id != None:
12590 
      oprot.writeFieldBegin('user_id', TType.I64, 1)
12591 
      oprot.writeI64(self.user_id)
12592 
      oprot.writeFieldEnd()
12593 
    if self.entity_id != None:
12594 
      oprot.writeFieldBegin('entity_id', TType.I64, 2)
12595 
      oprot.writeI64(self.entity_id)
12596 
      oprot.writeFieldEnd()
2717 varun.gupt 12597 
    if self.slide != None:
12598 
      oprot.writeFieldBegin('slide', TType.STRING, 3)
12599 
      oprot.writeString(self.slide)
2642 varun.gupt 12600 
      oprot.writeFieldEnd()
12601 
    if self.note != None:
12602 
      oprot.writeFieldBegin('note', TType.STRING, 4)
12603 
      oprot.writeString(self.note)
12604 
      oprot.writeFieldEnd()
12605 
    oprot.writeFieldStop()
12606 
    oprot.writeStructEnd()
12607 
 
12608 
  def __repr__(self):
12609 
    L = ['%s=%r' % (key, value)
12610 
      for key, value in self.__dict__.iteritems()]
12611 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12612 
 
12613 
  def __eq__(self, other):
12614 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12615 
 
12616 
  def __ne__(self, other):
12617 
    return not (self == other)
12618 
 
12619 
class putUserNote_result:
12620 
 
12621 
  thrift_spec = (
12622 
  )
12623 
 
12624 
  def read(self, iprot):
12625 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12626 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12627 
      return
12628 
    iprot.readStructBegin()
12629 
    while True:
12630 
      (fname, ftype, fid) = iprot.readFieldBegin()
12631 
      if ftype == TType.STOP:
12632 
        break
12633 
      else:
12634 
        iprot.skip(ftype)
12635 
      iprot.readFieldEnd()
12636 
    iprot.readStructEnd()
12637 
 
12638 
  def write(self, oprot):
12639 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12640 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12641 
      return
12642 
    oprot.writeStructBegin('putUserNote_result')
12643 
    oprot.writeFieldStop()
12644 
    oprot.writeStructEnd()
12645 
 
12646 
  def __repr__(self):
12647 
    L = ['%s=%r' % (key, value)
12648 
      for key, value in self.__dict__.iteritems()]
12649 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12650 
 
12651 
  def __eq__(self, other):
12652 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12653 
 
12654 
  def __ne__(self, other):
12655 
    return not (self == other)
12656 
 
12657 
class getUserNotes_args:
12658 
  """
12659 
  Attributes:
12660 
   - user_id
12661 
   - entity_id
12662 
  """
12663 
 
12664 
  thrift_spec = (
12665 
    None, # 0
12666 
    (1, TType.I64, 'user_id', None, None, ), # 1
12667 
    (2, TType.I64, 'entity_id', None, None, ), # 2
12668 
  )
12669 
 
12670 
  def __init__(self, user_id=None, entity_id=None,):
12671 
    self.user_id = user_id
12672 
    self.entity_id = entity_id
12673 
 
12674 
  def read(self, iprot):
12675 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12676 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12677 
      return
12678 
    iprot.readStructBegin()
12679 
    while True:
12680 
      (fname, ftype, fid) = iprot.readFieldBegin()
12681 
      if ftype == TType.STOP:
12682 
        break
12683 
      if fid == 1:
12684 
        if ftype == TType.I64:
12685 
          self.user_id = iprot.readI64();
12686 
        else:
12687 
          iprot.skip(ftype)
12688 
      elif fid == 2:
12689 
        if ftype == TType.I64:
12690 
          self.entity_id = iprot.readI64();
12691 
        else:
12692 
          iprot.skip(ftype)
12693 
      else:
12694 
        iprot.skip(ftype)
12695 
      iprot.readFieldEnd()
12696 
    iprot.readStructEnd()
12697 
 
12698 
  def write(self, oprot):
12699 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12700 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12701 
      return
12702 
    oprot.writeStructBegin('getUserNotes_args')
12703 
    if self.user_id != None:
12704 
      oprot.writeFieldBegin('user_id', TType.I64, 1)
12705 
      oprot.writeI64(self.user_id)
12706 
      oprot.writeFieldEnd()
12707 
    if self.entity_id != None:
12708 
      oprot.writeFieldBegin('entity_id', TType.I64, 2)
12709 
      oprot.writeI64(self.entity_id)
12710 
      oprot.writeFieldEnd()
12711 
    oprot.writeFieldStop()
12712 
    oprot.writeStructEnd()
12713 
 
12714 
  def __repr__(self):
12715 
    L = ['%s=%r' % (key, value)
12716 
      for key, value in self.__dict__.iteritems()]
12717 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12718 
 
12719 
  def __eq__(self, other):
12720 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12721 
 
12722 
  def __ne__(self, other):
12723 
    return not (self == other)
12724 
 
12725 
class getUserNotes_result:
12726 
  """
12727 
  Attributes:
12728 
   - success
12729 
  """
12730 
 
12731 
  thrift_spec = (
12732 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserNote, UserNote.thrift_spec)), None, ), # 0
12733 
  )
12734 
 
12735 
  def __init__(self, success=None,):
12736 
    self.success = success
12737 
 
12738 
  def read(self, iprot):
12739 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12740 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12741 
      return
12742 
    iprot.readStructBegin()
12743 
    while True:
12744 
      (fname, ftype, fid) = iprot.readFieldBegin()
12745 
      if ftype == TType.STOP:
12746 
        break
12747 
      if fid == 0:
12748 
        if ftype == TType.LIST:
12749 
          self.success = []
12750 
          (_etype131, _size128) = iprot.readListBegin()
12751 
          for _i132 in xrange(_size128):
12752 
            _elem133 = UserNote()
12753 
            _elem133.read(iprot)
12754 
            self.success.append(_elem133)
12755 
          iprot.readListEnd()
12756 
        else:
12757 
          iprot.skip(ftype)
12758 
      else:
12759 
        iprot.skip(ftype)
12760 
      iprot.readFieldEnd()
12761 
    iprot.readStructEnd()
12762 
 
12763 
  def write(self, oprot):
12764 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12765 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12766 
      return
12767 
    oprot.writeStructBegin('getUserNotes_result')
12768 
    if self.success != None:
12769 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12770 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
12771 
      for iter134 in self.success:
12772 
        iter134.write(oprot)
12773 
      oprot.writeListEnd()
12774 
      oprot.writeFieldEnd()
12775 
    oprot.writeFieldStop()
12776 
    oprot.writeStructEnd()
12777 
 
12778 
  def __repr__(self):
12779 
    L = ['%s=%r' % (key, value)
12780 
      for key, value in self.__dict__.iteritems()]
12781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12782 
 
12783 
  def __eq__(self, other):
12784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12785 
 
12786 
  def __ne__(self, other):
12787 
    return not (self == other)
12788 
 
12789