Subversion Repositories SmartDukaan

Rev

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

Rev Author Line No. Line
94 ashish 1 
#
2 
# Autogenerated by Thrift
3 
#
4 
# DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
5 
#
6 
 
7 
from thrift.Thrift import *
8 
from ttypes import *
9 
from thrift.Thrift import TProcessor
10 
from thrift.transport import TTransport
11 
from thrift.protocol import TBinaryProtocol
12 
try:
13 
  from thrift.protocol import fastbinary
14 
except:
15 
  fastbinary = None
16 
 
17 
 
18 
class Iface:
19 
  """
20 
  service
21 
  """
765 rajveer 22 
  def closeSession(self, ):
23 
    """
24 
    For closing the open session in sqlalchemy
25 
    """
26 
    pass
27 
 
559 chandransh 28 
  def createAnonymousUser(self, jsessionId):
94 ashish 29 
    """
30 
    Parameters:
559 chandransh 31 
     - jsessionId
94 ashish 32 
    """
33 
    pass
34 
 
559 chandransh 35 
  def getUserById(self, userId):
94 ashish 36 
    """
37 
    Parameters:
38 
     - userId
39 
    """
40 
    pass
41 
 
1491 vikas 42 
  def getUserByEmail(self, email):
43 
    """
44 
    Parameters:
45 
     - email
46 
    """
47 
    pass
48 
 
559 chandransh 49 
  def createUser(self, user):
94 ashish 50 
    """
51 
    Parameters:
559 chandransh 52 
     - user
94 ashish 53 
    """
54 
    pass
55 
 
559 chandransh 56 
  def updateUser(self, user):
94 ashish 57 
    """
58 
    Parameters:
559 chandransh 59 
     - user
94 ashish 60 
    """
61 
    pass
62 
 
559 chandransh 63 
  def deleteUser(self, userId):
94 ashish 64 
    """
65 
    Parameters:
66 
     - userId
67 
    """
68 
    pass
69 
 
559 chandransh 70 
  def getUserState(self, userId):
94 ashish 71 
    """
72 
    Parameters:
73 
     - userId
74 
    """
75 
    pass
76 
 
559 chandransh 77 
  def authenticateUser(self, email, password):
94 ashish 78 
    """
79 
    Parameters:
80 
     - email
81 
     - password
82 
    """
83 
    pass
84 
 
85 
  def userExists(self, email):
86 
    """
87 
    Parameters:
88 
     - email
89 
    """
90 
    pass
91 
 
567 rajveer 92 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 93 
    """
94 
    Parameters:
95 
     - userId
96 
     - address
513 rajveer 97 
     - setDefault
94 ashish 98 
    """
99 
    pass
100 
 
101 
  def removeAddressForUser(self, userid, addressId):
102 
    """
103 
    Parameters:
104 
     - userid
105 
     - addressId
106 
    """
107 
    pass
108 
 
109 
  def setUserAsLoggedIn(self, userId, timestamp):
110 
    """
111 
    Parameters:
112 
     - userId
113 
     - timestamp
114 
    """
115 
    pass
116 
 
117 
  def setUserAsLoggedOut(self, userid, timestamp):
118 
    """
119 
    Parameters:
120 
     - userid
121 
     - timestamp
122 
    """
123 
    pass
124 
 
504 rajveer 125 
  def setDefaultAddress(self, userid, addressId):
126 
    """
127 
    Parameters:
128 
     - userid
129 
     - addressId
130 
    """
131 
    pass
132 
 
594 rajveer 133 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 134 
    """
135 
    Parameters:
136 
     - userid
594 rajveer 137 
     - oldPassword
138 
     - newPassword
94 ashish 139 
    """
140 
    pass
141 
 
884 rajveer 142 
  def forgotPassword(self, email, newPassword):
581 rajveer 143 
    """
144 
    Parameters:
145 
     - email
884 rajveer 146 
     - newPassword
581 rajveer 147 
    """
148 
    pass
149 
 
594 rajveer 150 
  def getAllAddressesForUser(self, userId):
151 
    """
152 
    Parameters:
153 
     - userId
154 
    """
155 
    pass
156 
 
1894 vikas 157 
  def getAddressById(self, addressId):
158 
    """
159 
    Parameters:
160 
     - addressId
161 
    """
162 
    pass
163 
 
594 rajveer 164 
  def getDefaultAddressId(self, userId):
165 
    """
166 
    Parameters:
167 
     - userId
168 
    """
169 
    pass
170 
 
785 rajveer 171 
  def getDefaultPincode(self, userId):
172 
    """
173 
    Parameters:
174 
     - userId
175 
    """
176 
    pass
177 
 
1274 varun.gupt 178 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
179 
    """
180 
    Parameters:
181 
     - userId
182 
     - replyTo
183 
     - communicationType
184 
     - orderId
185 
     - airwaybillNo
186 
     - productName
187 
     - subject
188 
     - message
189 
    """
190 
    pass
191 
 
1590 varun.gupt 192 
  def getUserCommunicationById(self, id):
193 
    """
194 
    Parameters:
195 
     - id
196 
    """
197 
    pass
198 
 
199 
  def getUserCommunicationByUser(self, userId):
200 
    """
201 
    Parameters:
202 
     - userId
203 
    """
204 
    pass
205 
 
206 
  def getAllUserCommunications(self, ):
207 
    pass
208 
 
1859 vikas 209 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 210 
    """
211 
    Parameters:
212 
     - name
1859 vikas 213 
     - addedOn
1845 vikas 214 
    """
215 
    pass
216 
 
1899 vikas 217 
  def getAllMasterAffiliates(self, ):
218 
    pass
219 
 
1845 vikas 220 
  def getMasterAffiliateById(self, id):
221 
    """
222 
    Parameters:
223 
     - id
224 
    """
225 
    pass
226 
 
227 
  def getMasterAffiliateByName(self, name):
228 
    """
229 
    Parameters:
230 
     - name
231 
    """
232 
    pass
233 
 
1859 vikas 234 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 235 
    """
236 
    Parameters:
237 
     - name
238 
     - url
239 
     - masterAffiliateId
1859 vikas 240 
     - addedOn
1845 vikas 241 
    """
242 
    pass
243 
 
244 
  def getAffiliateById(self, id):
245 
    """
246 
    Parameters:
247 
     - id
248 
    """
249 
    pass
250 
 
251 
  def getAffiliateByName(self, name):
252 
    """
253 
    Parameters:
254 
     - name
255 
    """
256 
    pass
257 
 
1996 vikas 258 
  def getTrackerById(self, id):
1845 vikas 259 
    """
260 
    Parameters:
261 
     - id
262 
    """
263 
    pass
264 
 
1996 vikas 265 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 266 
    """
267 
    Parameters:
1996 vikas 268 
     - id
1845 vikas 269 
    """
270 
    pass
271 
 
1996 vikas 272 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 273 
    """
274 
    Parameters:
275 
     - affiliateId
276 
     - userId
277 
     - event
278 
     - url
279 
     - data
1859 vikas 280 
     - addedOn
1845 vikas 281 
    """
282 
    pass
283 
 
284 
  def getTrackLogById(self, id):
285 
    """
286 
    Parameters:
287 
     - id
288 
    """
289 
    pass
290 
 
1996 vikas 291 
  def getTrackLogsByAffiliate(self, affiliateId):
1845 vikas 292 
    """
293 
    Parameters:
1996 vikas 294 
     - affiliateId
1845 vikas 295 
    """
296 
    pass
297 
 
298 
  def getTrackLogsByUser(self, userId):
299 
    """
300 
    Parameters:
301 
     - userId
302 
    """
303 
    pass
304 
 
1996 vikas 305 
  def getTrackLogs(self, userId, event, url):
1845 vikas 306 
    """
307 
    Parameters:
308 
     - userId
309 
     - event
310 
     - url
311 
    """
312 
    pass
313 
 
559 chandransh 314 
  def createCart(self, userId):
94 ashish 315 
    """
316 
    Parameters:
559 chandransh 317 
     - userId
94 ashish 318 
    """
319 
    pass
320 
 
559 chandransh 321 
  def getCurrentCart(self, userId):
94 ashish 322 
    """
323 
    Parameters:
559 chandransh 324 
     - userId
94 ashish 325 
    """
326 
    pass
327 
 
559 chandransh 328 
  def getCart(self, cartId):
94 ashish 329 
    """
330 
    Parameters:
559 chandransh 331 
     - cartId
94 ashish 332 
    """
333 
    pass
334 
 
559 chandransh 335 
  def getCartsForUser(self, userId, status):
94 ashish 336 
    """
337 
    Parameters:
559 chandransh 338 
     - userId
339 
     - status
94 ashish 340 
    """
341 
    pass
342 
 
559 chandransh 343 
  def getCartsByStatus(self, status):
94 ashish 344 
    """
345 
    Parameters:
559 chandransh 346 
     - status
94 ashish 347 
    """
348 
    pass
349 
 
559 chandransh 350 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 351 
    """
352 
    Parameters:
559 chandransh 353 
     - from_time
354 
     - to_time
355 
     - status
94 ashish 356 
    """
357 
    pass
358 
 
559 chandransh 359 
  def changeCartStatus(self, cartId, status):
130 ashish 360 
    """
361 
    Parameters:
559 chandransh 362 
     - cartId
363 
     - status
130 ashish 364 
    """
365 
    pass
94 ashish 366 
 
559 chandransh 367 
  def addItemToCart(self, cartId, itemId, quantity):
130 ashish 368 
    """
369 
    Parameters:
559 chandransh 370 
     - cartId
371 
     - itemId
372 
     - quantity
130 ashish 373 
    """
374 
    pass
375 
 
559 chandransh 376 
  def deleteItemFromCart(self, cartId, itemId):
377 
    """
378 
    Parameters:
379 
     - cartId
380 
     - itemId
381 
    """
382 
    pass
130 ashish 383 
 
559 chandransh 384 
  def changeQuantity(self, cartId, itemId, quantity):
385 
    """
386 
    Parameters:
387 
     - cartId
388 
     - itemId
389 
     - quantity
390 
    """
391 
    pass
392 
 
393 
  def changeItemStatus(self, cartId, itemId, status):
394 
    """
395 
    Parameters:
396 
     - cartId
397 
     - itemId
398 
     - status
399 
    """
400 
    pass
401 
 
402 
  def addAddressToCart(self, cartId, addressId):
403 
    """
404 
    Parameters:
405 
     - cartId
406 
     - addressId
407 
    """
408 
    pass
409 
 
1976 varun.gupt 410 
  def applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
411 
    """
412 
    Parameters:
413 
     - cartId
414 
     - couponCode
415 
     - totalPrice
416 
     - discountedPrice
417 
    """
418 
    pass
419 
 
420 
  def removeCoupon(self, cartId):
421 
    """
422 
    Parameters:
423 
     - cartId
424 
    """
425 
    pass
426 
 
2815 vikas 427 
  def createOrders(self, cartId, sessionSource, sessionStartTime):
559 chandransh 428 
    """
690 chandransh 429 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
430 
 
559 chandransh 431 
    Parameters:
432 
     - cartId
2815 vikas 433 
     - sessionSource
434 
     - sessionStartTime
559 chandransh 435 
    """
436 
    pass
437 
 
438 
  def validateCart(self, cartId):
439 
    """
690 chandransh 440 
    Validates that:
441 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 442 
    2. All of the lines in the cart are active items.
690 chandransh 443 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 444 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 445 
 
559 chandransh 446 
    Parameters:
447 
     - cartId
448 
    """
449 
    pass
450 
 
690 chandransh 451 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 452 
    """
690 chandransh 453 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
454 
 
575 chandransh 455 
    Parameters:
690 chandransh 456 
     - fromCartId
457 
     - toCartId
458 
    """
459 
    pass
460 
 
461 
  def checkOut(self, cartId):
462 
    """
463 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
464 
 
465 
    Parameters:
575 chandransh 466 
     - cartId
467 
    """
468 
    pass
469 
 
690 chandransh 470 
  def resetCart(self, cartId, items):
559 chandransh 471 
    """
690 chandransh 472 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
473 
    This methods removes the specified quantiry of the specified item from the cart.
474 
 
559 chandransh 475 
    Parameters:
690 chandransh 476 
     - cartId
477 
     - items
559 chandransh 478 
    """
479 
    pass
480 
 
772 rajveer 481 
  def getMyResearch(self, userId):
559 chandransh 482 
    """
772 rajveer 483 
    Widgets
484 
 
559 chandransh 485 
    Parameters:
772 rajveer 486 
     - userId
559 chandransh 487 
    """
488 
    pass
489 
 
772 rajveer 490 
  def updateMyResearch(self, userId, itemId):
559 chandransh 491 
    """
492 
    Parameters:
772 rajveer 493 
     - userId
494 
     - itemId
559 chandransh 495 
    """
496 
    pass
497 
 
772 rajveer 498 
  def deleteItemFromMyResearch(self, userId, itemId):
559 chandransh 499 
    """
500 
    Parameters:
772 rajveer 501 
     - userId
502 
     - itemId
559 chandransh 503 
    """
504 
    pass
505 
 
772 rajveer 506 
  def updateBrowseHistory(self, userId, itemId):
559 chandransh 507 
    """
508 
    Parameters:
772 rajveer 509 
     - userId
510 
     - itemId
559 chandransh 511 
    """
512 
    pass
513 
 
772 rajveer 514 
  def getBrowseHistory(self, userId):
559 chandransh 515 
    """
516 
    Parameters:
517 
     - userId
518 
    """
519 
    pass
520 
 
772 rajveer 521 
  def mergeBrowseHistory(self, fromUserId, toUserId):
559 chandransh 522 
    """
523 
    Parameters:
772 rajveer 524 
     - fromUserId
525 
     - toUserId
559 chandransh 526 
    """
527 
    pass
528 
 
1596 ankur.sing 529 
  def getUserCount(self, userType):
530 
    """
531 
    Returns number of registered users.
532 
    If userType = null, then it returns count of all users, including anonymous
533 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
534 
    If userType = UserType.USER, then it returns count of non-anonymous users only
535 
 
536 
    Parameters:
537 
     - userType
538 
    """
539 
    pass
559 chandransh 540 
 
1891 ankur.sing 541 
  def getAllUsers(self, userType, startDate, endDate):
1673 ankur.sing 542 
    """
1891 ankur.sing 543 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
544 
    If any of startDate or endDate is -1, then that filter is ignored.
545 
    If userType is null, then returns all the users, irrespective of anonymous flag
1673 ankur.sing 546 
 
1891 ankur.sing 547 
 
1673 ankur.sing 548 
    Parameters:
549 
     - userType
1891 ankur.sing 550 
     - startDate
551 
     - endDate
1673 ankur.sing 552 
    """
553 
    pass
1596 ankur.sing 554 
 
2717 varun.gupt 555 
  def putUserNote(self, user_id, entity_id, slide, note):
2642 varun.gupt 556 
    """
557 
    Masking right now. May be used later.
558 
    void addWidget(1:Widget widget) throws (1:WidgetException scx),
559 
    void addItemToWidget(1:i64 widget_id, 2:list<i64> items) throws (1:WidgetException scx),
560 
    void deleteItemFromWidget(1:i64 widget_id, 2:i64 item_id) throws (1:WidgetException scx),
561 
    void updateWidget(1:i64 widgetId, 2:bool enable) throws (1:WidgetException scx),
562 
    void updateWidgetItem(1:i64 widgetId, 2:bool enable) throws (1:WidgetException scx),
563 
    Widget getWidget(1:WidgetType type, 2:i64 userId, 3:bool onlyEnabled) throws (1:WidgetException scx),
564 
 
565 
    Parameters:
566 
     - user_id
567 
     - entity_id
2717 varun.gupt 568 
     - slide
2642 varun.gupt 569 
     - note
570 
    """
571 
    pass
1673 ankur.sing 572 
 
2642 varun.gupt 573 
  def getUserNotes(self, user_id, entity_id):
574 
    """
575 
    Parameters:
576 
     - user_id
577 
     - entity_id
578 
    """
579 
    pass
580 
 
581 
 
94 ashish 582 
class Client(Iface):
583 
  """
584 
  service
585 
  """
586 
  def __init__(self, iprot, oprot=None):
587 
    self._iprot = self._oprot = iprot
588 
    if oprot != None:
589 
      self._oprot = oprot
590 
    self._seqid = 0
591 
 
765 rajveer 592 
  def closeSession(self, ):
593 
    """
594 
    For closing the open session in sqlalchemy
595 
    """
596 
    self.send_closeSession()
597 
    self.recv_closeSession()
598 
 
599 
  def send_closeSession(self, ):
600 
    self._oprot.writeMessageBegin('closeSession', TMessageType.CALL, self._seqid)
601 
    args = closeSession_args()
602 
    args.write(self._oprot)
603 
    self._oprot.writeMessageEnd()
604 
    self._oprot.trans.flush()
605 
 
606 
  def recv_closeSession(self, ):
607 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
608 
    if mtype == TMessageType.EXCEPTION:
609 
      x = TApplicationException()
610 
      x.read(self._iprot)
611 
      self._iprot.readMessageEnd()
612 
      raise x
613 
    result = closeSession_result()
614 
    result.read(self._iprot)
615 
    self._iprot.readMessageEnd()
616 
    return
617 
 
559 chandransh 618 
  def createAnonymousUser(self, jsessionId):
94 ashish 619 
    """
620 
    Parameters:
559 chandransh 621 
     - jsessionId
94 ashish 622 
    """
559 chandransh 623 
    self.send_createAnonymousUser(jsessionId)
624 
    return self.recv_createAnonymousUser()
94 ashish 625 
 
559 chandransh 626 
  def send_createAnonymousUser(self, jsessionId):
627 
    self._oprot.writeMessageBegin('createAnonymousUser', TMessageType.CALL, self._seqid)
628 
    args = createAnonymousUser_args()
629 
    args.jsessionId = jsessionId
94 ashish 630 
    args.write(self._oprot)
631 
    self._oprot.writeMessageEnd()
632 
    self._oprot.trans.flush()
633 
 
559 chandransh 634 
  def recv_createAnonymousUser(self, ):
94 ashish 635 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
636 
    if mtype == TMessageType.EXCEPTION:
637 
      x = TApplicationException()
638 
      x.read(self._iprot)
639 
      self._iprot.readMessageEnd()
640 
      raise x
559 chandransh 641 
    result = createAnonymousUser_result()
94 ashish 642 
    result.read(self._iprot)
643 
    self._iprot.readMessageEnd()
644 
    if result.success != None:
645 
      return result.success
559 chandransh 646 
    if result.ucex != None:
647 
      raise result.ucex
648 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAnonymousUser failed: unknown result");
94 ashish 649 
 
559 chandransh 650 
  def getUserById(self, userId):
94 ashish 651 
    """
652 
    Parameters:
653 
     - userId
654 
    """
559 chandransh 655 
    self.send_getUserById(userId)
656 
    return self.recv_getUserById()
94 ashish 657 
 
559 chandransh 658 
  def send_getUserById(self, userId):
659 
    self._oprot.writeMessageBegin('getUserById', TMessageType.CALL, self._seqid)
660 
    args = getUserById_args()
94 ashish 661 
    args.userId = userId
662 
    args.write(self._oprot)
663 
    self._oprot.writeMessageEnd()
664 
    self._oprot.trans.flush()
665 
 
559 chandransh 666 
  def recv_getUserById(self, ):
94 ashish 667 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
668 
    if mtype == TMessageType.EXCEPTION:
669 
      x = TApplicationException()
670 
      x.read(self._iprot)
671 
      self._iprot.readMessageEnd()
672 
      raise x
559 chandransh 673 
    result = getUserById_result()
94 ashish 674 
    result.read(self._iprot)
675 
    self._iprot.readMessageEnd()
676 
    if result.success != None:
677 
      return result.success
559 chandransh 678 
    if result.ucex != None:
679 
      raise result.ucex
680 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserById failed: unknown result");
94 ashish 681 
 
1491 vikas 682 
  def getUserByEmail(self, email):
683 
    """
684 
    Parameters:
685 
     - email
686 
    """
687 
    self.send_getUserByEmail(email)
688 
    return self.recv_getUserByEmail()
689 
 
690 
  def send_getUserByEmail(self, email):
691 
    self._oprot.writeMessageBegin('getUserByEmail', TMessageType.CALL, self._seqid)
692 
    args = getUserByEmail_args()
693 
    args.email = email
694 
    args.write(self._oprot)
695 
    self._oprot.writeMessageEnd()
696 
    self._oprot.trans.flush()
697 
 
698 
  def recv_getUserByEmail(self, ):
699 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
700 
    if mtype == TMessageType.EXCEPTION:
701 
      x = TApplicationException()
702 
      x.read(self._iprot)
703 
      self._iprot.readMessageEnd()
704 
      raise x
705 
    result = getUserByEmail_result()
706 
    result.read(self._iprot)
707 
    self._iprot.readMessageEnd()
708 
    if result.success != None:
709 
      return result.success
710 
    if result.ucex != None:
711 
      raise result.ucex
712 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserByEmail failed: unknown result");
713 
 
559 chandransh 714 
  def createUser(self, user):
94 ashish 715 
    """
716 
    Parameters:
559 chandransh 717 
     - user
94 ashish 718 
    """
559 chandransh 719 
    self.send_createUser(user)
720 
    return self.recv_createUser()
94 ashish 721 
 
559 chandransh 722 
  def send_createUser(self, user):
723 
    self._oprot.writeMessageBegin('createUser', TMessageType.CALL, self._seqid)
724 
    args = createUser_args()
725 
    args.user = user
94 ashish 726 
    args.write(self._oprot)
727 
    self._oprot.writeMessageEnd()
728 
    self._oprot.trans.flush()
729 
 
559 chandransh 730 
  def recv_createUser(self, ):
94 ashish 731 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
732 
    if mtype == TMessageType.EXCEPTION:
733 
      x = TApplicationException()
734 
      x.read(self._iprot)
735 
      self._iprot.readMessageEnd()
736 
      raise x
559 chandransh 737 
    result = createUser_result()
94 ashish 738 
    result.read(self._iprot)
739 
    self._iprot.readMessageEnd()
740 
    if result.success != None:
741 
      return result.success
559 chandransh 742 
    if result.ucex != None:
743 
      raise result.ucex
744 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createUser failed: unknown result");
94 ashish 745 
 
559 chandransh 746 
  def updateUser(self, user):
94 ashish 747 
    """
748 
    Parameters:
559 chandransh 749 
     - user
94 ashish 750 
    """
559 chandransh 751 
    self.send_updateUser(user)
752 
    return self.recv_updateUser()
94 ashish 753 
 
559 chandransh 754 
  def send_updateUser(self, user):
755 
    self._oprot.writeMessageBegin('updateUser', TMessageType.CALL, self._seqid)
756 
    args = updateUser_args()
757 
    args.user = user
94 ashish 758 
    args.write(self._oprot)
759 
    self._oprot.writeMessageEnd()
760 
    self._oprot.trans.flush()
761 
 
559 chandransh 762 
  def recv_updateUser(self, ):
94 ashish 763 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
764 
    if mtype == TMessageType.EXCEPTION:
765 
      x = TApplicationException()
766 
      x.read(self._iprot)
767 
      self._iprot.readMessageEnd()
768 
      raise x
559 chandransh 769 
    result = updateUser_result()
94 ashish 770 
    result.read(self._iprot)
771 
    self._iprot.readMessageEnd()
772 
    if result.success != None:
773 
      return result.success
559 chandransh 774 
    if result.ucex != None:
775 
      raise result.ucex
776 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateUser failed: unknown result");
94 ashish 777 
 
559 chandransh 778 
  def deleteUser(self, userId):
94 ashish 779 
    """
780 
    Parameters:
781 
     - userId
782 
    """
559 chandransh 783 
    self.send_deleteUser(userId)
784 
    return self.recv_deleteUser()
94 ashish 785 
 
559 chandransh 786 
  def send_deleteUser(self, userId):
787 
    self._oprot.writeMessageBegin('deleteUser', TMessageType.CALL, self._seqid)
788 
    args = deleteUser_args()
94 ashish 789 
    args.userId = userId
790 
    args.write(self._oprot)
791 
    self._oprot.writeMessageEnd()
792 
    self._oprot.trans.flush()
793 
 
559 chandransh 794 
  def recv_deleteUser(self, ):
94 ashish 795 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
796 
    if mtype == TMessageType.EXCEPTION:
797 
      x = TApplicationException()
798 
      x.read(self._iprot)
799 
      self._iprot.readMessageEnd()
800 
      raise x
559 chandransh 801 
    result = deleteUser_result()
94 ashish 802 
    result.read(self._iprot)
803 
    self._iprot.readMessageEnd()
804 
    if result.success != None:
805 
      return result.success
559 chandransh 806 
    if result.ucex != None:
807 
      raise result.ucex
808 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "deleteUser failed: unknown result");
94 ashish 809 
 
559 chandransh 810 
  def getUserState(self, userId):
94 ashish 811 
    """
812 
    Parameters:
813 
     - userId
814 
    """
559 chandransh 815 
    self.send_getUserState(userId)
816 
    return self.recv_getUserState()
94 ashish 817 
 
559 chandransh 818 
  def send_getUserState(self, userId):
819 
    self._oprot.writeMessageBegin('getUserState', TMessageType.CALL, self._seqid)
820 
    args = getUserState_args()
94 ashish 821 
    args.userId = userId
822 
    args.write(self._oprot)
823 
    self._oprot.writeMessageEnd()
824 
    self._oprot.trans.flush()
825 
 
559 chandransh 826 
  def recv_getUserState(self, ):
94 ashish 827 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
828 
    if mtype == TMessageType.EXCEPTION:
829 
      x = TApplicationException()
830 
      x.read(self._iprot)
831 
      self._iprot.readMessageEnd()
832 
      raise x
559 chandransh 833 
    result = getUserState_result()
94 ashish 834 
    result.read(self._iprot)
835 
    self._iprot.readMessageEnd()
836 
    if result.success != None:
837 
      return result.success
559 chandransh 838 
    if result.ucex != None:
839 
      raise result.ucex
840 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserState failed: unknown result");
94 ashish 841 
 
559 chandransh 842 
  def authenticateUser(self, email, password):
94 ashish 843 
    """
844 
    Parameters:
845 
     - email
846 
     - password
847 
    """
559 chandransh 848 
    self.send_authenticateUser(email, password)
122 ashish 849 
    return self.recv_authenticateUser()
850 
 
559 chandransh 851 
  def send_authenticateUser(self, email, password):
122 ashish 852 
    self._oprot.writeMessageBegin('authenticateUser', TMessageType.CALL, self._seqid)
853 
    args = authenticateUser_args()
559 chandransh 854 
    args.email = email
122 ashish 855 
    args.password = password
856 
    args.write(self._oprot)
857 
    self._oprot.writeMessageEnd()
858 
    self._oprot.trans.flush()
859 
 
860 
  def recv_authenticateUser(self, ):
861 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
862 
    if mtype == TMessageType.EXCEPTION:
863 
      x = TApplicationException()
864 
      x.read(self._iprot)
865 
      self._iprot.readMessageEnd()
866 
      raise x
867 
    result = authenticateUser_result()
868 
    result.read(self._iprot)
869 
    self._iprot.readMessageEnd()
870 
    if result.success != None:
871 
      return result.success
559 chandransh 872 
    if result.auex != None:
873 
      raise result.auex
122 ashish 874 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "authenticateUser failed: unknown result");
875 
 
94 ashish 876 
  def userExists(self, email):
877 
    """
878 
    Parameters:
879 
     - email
880 
    """
881 
    self.send_userExists(email)
882 
    return self.recv_userExists()
883 
 
884 
  def send_userExists(self, email):
885 
    self._oprot.writeMessageBegin('userExists', TMessageType.CALL, self._seqid)
886 
    args = userExists_args()
887 
    args.email = email
888 
    args.write(self._oprot)
889 
    self._oprot.writeMessageEnd()
890 
    self._oprot.trans.flush()
891 
 
892 
  def recv_userExists(self, ):
893 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
894 
    if mtype == TMessageType.EXCEPTION:
895 
      x = TApplicationException()
896 
      x.read(self._iprot)
897 
      self._iprot.readMessageEnd()
898 
      raise x
899 
    result = userExists_result()
900 
    result.read(self._iprot)
901 
    self._iprot.readMessageEnd()
902 
    if result.success != None:
903 
      return result.success
904 
    if result.ucx != None:
905 
      raise result.ucx
906 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "userExists failed: unknown result");
907 
 
567 rajveer 908 
  def addAddressForUser(self, userId, address, setDefault):
94 ashish 909 
    """
910 
    Parameters:
911 
     - userId
912 
     - address
513 rajveer 913 
     - setDefault
94 ashish 914 
    """
567 rajveer 915 
    self.send_addAddressForUser(userId, address, setDefault)
94 ashish 916 
    return self.recv_addAddressForUser()
917 
 
567 rajveer 918 
  def send_addAddressForUser(self, userId, address, setDefault):
94 ashish 919 
    self._oprot.writeMessageBegin('addAddressForUser', TMessageType.CALL, self._seqid)
920 
    args = addAddressForUser_args()
559 chandransh 921 
    args.userId = userId
94 ashish 922 
    args.address = address
513 rajveer 923 
    args.setDefault = setDefault
94 ashish 924 
    args.write(self._oprot)
925 
    self._oprot.writeMessageEnd()
926 
    self._oprot.trans.flush()
927 
 
928 
  def recv_addAddressForUser(self, ):
929 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
930 
    if mtype == TMessageType.EXCEPTION:
931 
      x = TApplicationException()
932 
      x.read(self._iprot)
933 
      self._iprot.readMessageEnd()
934 
      raise x
935 
    result = addAddressForUser_result()
936 
    result.read(self._iprot)
937 
    self._iprot.readMessageEnd()
938 
    if result.success != None:
939 
      return result.success
940 
    if result.ucx != None:
941 
      raise result.ucx
942 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addAddressForUser failed: unknown result");
943 
 
944 
  def removeAddressForUser(self, userid, addressId):
945 
    """
946 
    Parameters:
947 
     - userid
948 
     - addressId
949 
    """
950 
    self.send_removeAddressForUser(userid, addressId)
951 
    return self.recv_removeAddressForUser()
952 
 
953 
  def send_removeAddressForUser(self, userid, addressId):
954 
    self._oprot.writeMessageBegin('removeAddressForUser', TMessageType.CALL, self._seqid)
955 
    args = removeAddressForUser_args()
956 
    args.userid = userid
957 
    args.addressId = addressId
958 
    args.write(self._oprot)
959 
    self._oprot.writeMessageEnd()
960 
    self._oprot.trans.flush()
961 
 
962 
  def recv_removeAddressForUser(self, ):
963 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
964 
    if mtype == TMessageType.EXCEPTION:
965 
      x = TApplicationException()
966 
      x.read(self._iprot)
967 
      self._iprot.readMessageEnd()
968 
      raise x
969 
    result = removeAddressForUser_result()
970 
    result.read(self._iprot)
971 
    self._iprot.readMessageEnd()
972 
    if result.success != None:
973 
      return result.success
974 
    if result.ucx != None:
975 
      raise result.ucx
976 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "removeAddressForUser failed: unknown result");
977 
 
978 
  def setUserAsLoggedIn(self, userId, timestamp):
979 
    """
980 
    Parameters:
981 
     - userId
982 
     - timestamp
983 
    """
984 
    self.send_setUserAsLoggedIn(userId, timestamp)
985 
    return self.recv_setUserAsLoggedIn()
986 
 
987 
  def send_setUserAsLoggedIn(self, userId, timestamp):
988 
    self._oprot.writeMessageBegin('setUserAsLoggedIn', TMessageType.CALL, self._seqid)
989 
    args = setUserAsLoggedIn_args()
990 
    args.userId = userId
991 
    args.timestamp = timestamp
992 
    args.write(self._oprot)
993 
    self._oprot.writeMessageEnd()
994 
    self._oprot.trans.flush()
995 
 
996 
  def recv_setUserAsLoggedIn(self, ):
997 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
998 
    if mtype == TMessageType.EXCEPTION:
999 
      x = TApplicationException()
1000 
      x.read(self._iprot)
1001 
      self._iprot.readMessageEnd()
1002 
      raise x
1003 
    result = setUserAsLoggedIn_result()
1004 
    result.read(self._iprot)
1005 
    self._iprot.readMessageEnd()
1006 
    if result.success != None:
1007 
      return result.success
1008 
    if result.ucx != None:
1009 
      raise result.ucx
1010 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedIn failed: unknown result");
1011 
 
1012 
  def setUserAsLoggedOut(self, userid, timestamp):
1013 
    """
1014 
    Parameters:
1015 
     - userid
1016 
     - timestamp
1017 
    """
1018 
    self.send_setUserAsLoggedOut(userid, timestamp)
1019 
    return self.recv_setUserAsLoggedOut()
1020 
 
1021 
  def send_setUserAsLoggedOut(self, userid, timestamp):
1022 
    self._oprot.writeMessageBegin('setUserAsLoggedOut', TMessageType.CALL, self._seqid)
1023 
    args = setUserAsLoggedOut_args()
1024 
    args.userid = userid
1025 
    args.timestamp = timestamp
1026 
    args.write(self._oprot)
1027 
    self._oprot.writeMessageEnd()
1028 
    self._oprot.trans.flush()
1029 
 
1030 
  def recv_setUserAsLoggedOut(self, ):
1031 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1032 
    if mtype == TMessageType.EXCEPTION:
1033 
      x = TApplicationException()
1034 
      x.read(self._iprot)
1035 
      self._iprot.readMessageEnd()
1036 
      raise x
1037 
    result = setUserAsLoggedOut_result()
1038 
    result.read(self._iprot)
1039 
    self._iprot.readMessageEnd()
1040 
    if result.success != None:
1041 
      return result.success
1042 
    if result.ucx != None:
1043 
      raise result.ucx
1044 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setUserAsLoggedOut failed: unknown result");
1045 
 
504 rajveer 1046 
  def setDefaultAddress(self, userid, addressId):
1047 
    """
1048 
    Parameters:
1049 
     - userid
1050 
     - addressId
1051 
    """
1052 
    self.send_setDefaultAddress(userid, addressId)
1053 
    return self.recv_setDefaultAddress()
1054 
 
1055 
  def send_setDefaultAddress(self, userid, addressId):
1056 
    self._oprot.writeMessageBegin('setDefaultAddress', TMessageType.CALL, self._seqid)
1057 
    args = setDefaultAddress_args()
1058 
    args.userid = userid
1059 
    args.addressId = addressId
1060 
    args.write(self._oprot)
1061 
    self._oprot.writeMessageEnd()
1062 
    self._oprot.trans.flush()
1063 
 
1064 
  def recv_setDefaultAddress(self, ):
1065 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1066 
    if mtype == TMessageType.EXCEPTION:
1067 
      x = TApplicationException()
1068 
      x.read(self._iprot)
1069 
      self._iprot.readMessageEnd()
1070 
      raise x
1071 
    result = setDefaultAddress_result()
1072 
    result.read(self._iprot)
1073 
    self._iprot.readMessageEnd()
1074 
    if result.success != None:
1075 
      return result.success
1076 
    if result.ucx != None:
1077 
      raise result.ucx
1078 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "setDefaultAddress failed: unknown result");
1079 
 
594 rajveer 1080 
  def updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1081 
    """
1082 
    Parameters:
1083 
     - userid
594 rajveer 1084 
     - oldPassword
1085 
     - newPassword
94 ashish 1086 
    """
594 rajveer 1087 
    self.send_updatePassword(userid, oldPassword, newPassword)
94 ashish 1088 
    return self.recv_updatePassword()
1089 
 
594 rajveer 1090 
  def send_updatePassword(self, userid, oldPassword, newPassword):
94 ashish 1091 
    self._oprot.writeMessageBegin('updatePassword', TMessageType.CALL, self._seqid)
1092 
    args = updatePassword_args()
1093 
    args.userid = userid
594 rajveer 1094 
    args.oldPassword = oldPassword
1095 
    args.newPassword = newPassword
94 ashish 1096 
    args.write(self._oprot)
1097 
    self._oprot.writeMessageEnd()
1098 
    self._oprot.trans.flush()
1099 
 
1100 
  def recv_updatePassword(self, ):
1101 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1102 
    if mtype == TMessageType.EXCEPTION:
1103 
      x = TApplicationException()
1104 
      x.read(self._iprot)
1105 
      self._iprot.readMessageEnd()
1106 
      raise x
1107 
    result = updatePassword_result()
1108 
    result.read(self._iprot)
1109 
    self._iprot.readMessageEnd()
1110 
    if result.success != None:
1111 
      return result.success
1112 
    if result.ucx != None:
1113 
      raise result.ucx
1114 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updatePassword failed: unknown result");
1115 
 
884 rajveer 1116 
  def forgotPassword(self, email, newPassword):
581 rajveer 1117 
    """
1118 
    Parameters:
1119 
     - email
884 rajveer 1120 
     - newPassword
581 rajveer 1121 
    """
884 rajveer 1122 
    self.send_forgotPassword(email, newPassword)
581 rajveer 1123 
    return self.recv_forgotPassword()
1124 
 
884 rajveer 1125 
  def send_forgotPassword(self, email, newPassword):
581 rajveer 1126 
    self._oprot.writeMessageBegin('forgotPassword', TMessageType.CALL, self._seqid)
1127 
    args = forgotPassword_args()
1128 
    args.email = email
884 rajveer 1129 
    args.newPassword = newPassword
581 rajveer 1130 
    args.write(self._oprot)
1131 
    self._oprot.writeMessageEnd()
1132 
    self._oprot.trans.flush()
1133 
 
1134 
  def recv_forgotPassword(self, ):
1135 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1136 
    if mtype == TMessageType.EXCEPTION:
1137 
      x = TApplicationException()
1138 
      x.read(self._iprot)
1139 
      self._iprot.readMessageEnd()
1140 
      raise x
1141 
    result = forgotPassword_result()
1142 
    result.read(self._iprot)
1143 
    self._iprot.readMessageEnd()
1144 
    if result.success != None:
1145 
      return result.success
1146 
    if result.ucx != None:
1147 
      raise result.ucx
1148 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "forgotPassword failed: unknown result");
1149 
 
594 rajveer 1150 
  def getAllAddressesForUser(self, userId):
1151 
    """
1152 
    Parameters:
1153 
     - userId
1154 
    """
1155 
    self.send_getAllAddressesForUser(userId)
1156 
    return self.recv_getAllAddressesForUser()
1157 
 
1158 
  def send_getAllAddressesForUser(self, userId):
1159 
    self._oprot.writeMessageBegin('getAllAddressesForUser', TMessageType.CALL, self._seqid)
1160 
    args = getAllAddressesForUser_args()
1161 
    args.userId = userId
1162 
    args.write(self._oprot)
1163 
    self._oprot.writeMessageEnd()
1164 
    self._oprot.trans.flush()
1165 
 
1166 
  def recv_getAllAddressesForUser(self, ):
1167 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1168 
    if mtype == TMessageType.EXCEPTION:
1169 
      x = TApplicationException()
1170 
      x.read(self._iprot)
1171 
      self._iprot.readMessageEnd()
1172 
      raise x
1173 
    result = getAllAddressesForUser_result()
1174 
    result.read(self._iprot)
1175 
    self._iprot.readMessageEnd()
1176 
    if result.success != None:
1177 
      return result.success
1178 
    if result.ucx != None:
1179 
      raise result.ucx
1180 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllAddressesForUser failed: unknown result");
1181 
 
1894 vikas 1182 
  def getAddressById(self, addressId):
1183 
    """
1184 
    Parameters:
1185 
     - addressId
1186 
    """
1187 
    self.send_getAddressById(addressId)
1188 
    return self.recv_getAddressById()
1189 
 
1190 
  def send_getAddressById(self, addressId):
1191 
    self._oprot.writeMessageBegin('getAddressById', TMessageType.CALL, self._seqid)
1192 
    args = getAddressById_args()
1193 
    args.addressId = addressId
1194 
    args.write(self._oprot)
1195 
    self._oprot.writeMessageEnd()
1196 
    self._oprot.trans.flush()
1197 
 
1198 
  def recv_getAddressById(self, ):
1199 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1200 
    if mtype == TMessageType.EXCEPTION:
1201 
      x = TApplicationException()
1202 
      x.read(self._iprot)
1203 
      self._iprot.readMessageEnd()
1204 
      raise x
1205 
    result = getAddressById_result()
1206 
    result.read(self._iprot)
1207 
    self._iprot.readMessageEnd()
1208 
    if result.success != None:
1209 
      return result.success
1210 
    if result.ucx != None:
1211 
      raise result.ucx
1212 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAddressById failed: unknown result");
1213 
 
594 rajveer 1214 
  def getDefaultAddressId(self, userId):
1215 
    """
1216 
    Parameters:
1217 
     - userId
1218 
    """
1219 
    self.send_getDefaultAddressId(userId)
1220 
    return self.recv_getDefaultAddressId()
1221 
 
1222 
  def send_getDefaultAddressId(self, userId):
1223 
    self._oprot.writeMessageBegin('getDefaultAddressId', TMessageType.CALL, self._seqid)
1224 
    args = getDefaultAddressId_args()
1225 
    args.userId = userId
1226 
    args.write(self._oprot)
1227 
    self._oprot.writeMessageEnd()
1228 
    self._oprot.trans.flush()
1229 
 
1230 
  def recv_getDefaultAddressId(self, ):
1231 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1232 
    if mtype == TMessageType.EXCEPTION:
1233 
      x = TApplicationException()
1234 
      x.read(self._iprot)
1235 
      self._iprot.readMessageEnd()
1236 
      raise x
1237 
    result = getDefaultAddressId_result()
1238 
    result.read(self._iprot)
1239 
    self._iprot.readMessageEnd()
1240 
    if result.success != None:
1241 
      return result.success
1242 
    if result.ucx != None:
1243 
      raise result.ucx
1244 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultAddressId failed: unknown result");
1245 
 
785 rajveer 1246 
  def getDefaultPincode(self, userId):
1247 
    """
1248 
    Parameters:
1249 
     - userId
1250 
    """
1251 
    self.send_getDefaultPincode(userId)
1252 
    return self.recv_getDefaultPincode()
1253 
 
1254 
  def send_getDefaultPincode(self, userId):
1255 
    self._oprot.writeMessageBegin('getDefaultPincode', TMessageType.CALL, self._seqid)
1256 
    args = getDefaultPincode_args()
1257 
    args.userId = userId
1258 
    args.write(self._oprot)
1259 
    self._oprot.writeMessageEnd()
1260 
    self._oprot.trans.flush()
1261 
 
1262 
  def recv_getDefaultPincode(self, ):
1263 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1264 
    if mtype == TMessageType.EXCEPTION:
1265 
      x = TApplicationException()
1266 
      x.read(self._iprot)
1267 
      self._iprot.readMessageEnd()
1268 
      raise x
1269 
    result = getDefaultPincode_result()
1270 
    result.read(self._iprot)
1271 
    self._iprot.readMessageEnd()
1272 
    if result.success != None:
1273 
      return result.success
1274 
    if result.ucx != None:
1275 
      raise result.ucx
1276 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getDefaultPincode failed: unknown result");
1277 
 
1274 varun.gupt 1278 
  def saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1279 
    """
1280 
    Parameters:
1281 
     - userId
1282 
     - replyTo
1283 
     - communicationType
1284 
     - orderId
1285 
     - airwaybillNo
1286 
     - productName
1287 
     - subject
1288 
     - message
1289 
    """
1290 
    self.send_saveUserCommunication(userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message)
1291 
    return self.recv_saveUserCommunication()
1292 
 
1293 
  def send_saveUserCommunication(self, userId, replyTo, communicationType, orderId, airwaybillNo, productName, subject, message):
1294 
    self._oprot.writeMessageBegin('saveUserCommunication', TMessageType.CALL, self._seqid)
1295 
    args = saveUserCommunication_args()
1296 
    args.userId = userId
1297 
    args.replyTo = replyTo
1298 
    args.communicationType = communicationType
1299 
    args.orderId = orderId
1300 
    args.airwaybillNo = airwaybillNo
1301 
    args.productName = productName
1302 
    args.subject = subject
1303 
    args.message = message
1304 
    args.write(self._oprot)
1305 
    self._oprot.writeMessageEnd()
1306 
    self._oprot.trans.flush()
1307 
 
1308 
  def recv_saveUserCommunication(self, ):
1309 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1310 
    if mtype == TMessageType.EXCEPTION:
1311 
      x = TApplicationException()
1312 
      x.read(self._iprot)
1313 
      self._iprot.readMessageEnd()
1314 
      raise x
1315 
    result = saveUserCommunication_result()
1316 
    result.read(self._iprot)
1317 
    self._iprot.readMessageEnd()
1318 
    if result.success != None:
1319 
      return result.success
1320 
    if result.ucx != None:
1321 
      raise result.ucx
1322 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "saveUserCommunication failed: unknown result");
1323 
 
1590 varun.gupt 1324 
  def getUserCommunicationById(self, id):
1325 
    """
1326 
    Parameters:
1327 
     - id
1328 
    """
1329 
    self.send_getUserCommunicationById(id)
1330 
    return self.recv_getUserCommunicationById()
1331 
 
1332 
  def send_getUserCommunicationById(self, id):
1333 
    self._oprot.writeMessageBegin('getUserCommunicationById', TMessageType.CALL, self._seqid)
1334 
    args = getUserCommunicationById_args()
1335 
    args.id = id
1336 
    args.write(self._oprot)
1337 
    self._oprot.writeMessageEnd()
1338 
    self._oprot.trans.flush()
1339 
 
1340 
  def recv_getUserCommunicationById(self, ):
1341 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1342 
    if mtype == TMessageType.EXCEPTION:
1343 
      x = TApplicationException()
1344 
      x.read(self._iprot)
1345 
      self._iprot.readMessageEnd()
1346 
      raise x
1347 
    result = getUserCommunicationById_result()
1348 
    result.read(self._iprot)
1349 
    self._iprot.readMessageEnd()
1350 
    if result.success != None:
1351 
      return result.success
1352 
    if result.ucx != None:
1353 
      raise result.ucx
1354 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationById failed: unknown result");
1355 
 
1356 
  def getUserCommunicationByUser(self, userId):
1357 
    """
1358 
    Parameters:
1359 
     - userId
1360 
    """
1361 
    self.send_getUserCommunicationByUser(userId)
1362 
    return self.recv_getUserCommunicationByUser()
1363 
 
1364 
  def send_getUserCommunicationByUser(self, userId):
1365 
    self._oprot.writeMessageBegin('getUserCommunicationByUser', TMessageType.CALL, self._seqid)
1366 
    args = getUserCommunicationByUser_args()
1367 
    args.userId = userId
1368 
    args.write(self._oprot)
1369 
    self._oprot.writeMessageEnd()
1370 
    self._oprot.trans.flush()
1371 
 
1372 
  def recv_getUserCommunicationByUser(self, ):
1373 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1374 
    if mtype == TMessageType.EXCEPTION:
1375 
      x = TApplicationException()
1376 
      x.read(self._iprot)
1377 
      self._iprot.readMessageEnd()
1378 
      raise x
1379 
    result = getUserCommunicationByUser_result()
1380 
    result.read(self._iprot)
1381 
    self._iprot.readMessageEnd()
1382 
    if result.success != None:
1383 
      return result.success
1384 
    if result.ucx != None:
1385 
      raise result.ucx
1386 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCommunicationByUser failed: unknown result");
1387 
 
1388 
  def getAllUserCommunications(self, ):
1389 
    self.send_getAllUserCommunications()
1390 
    return self.recv_getAllUserCommunications()
1391 
 
1392 
  def send_getAllUserCommunications(self, ):
1393 
    self._oprot.writeMessageBegin('getAllUserCommunications', TMessageType.CALL, self._seqid)
1394 
    args = getAllUserCommunications_args()
1395 
    args.write(self._oprot)
1396 
    self._oprot.writeMessageEnd()
1397 
    self._oprot.trans.flush()
1398 
 
1399 
  def recv_getAllUserCommunications(self, ):
1400 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1401 
    if mtype == TMessageType.EXCEPTION:
1402 
      x = TApplicationException()
1403 
      x.read(self._iprot)
1404 
      self._iprot.readMessageEnd()
1405 
      raise x
1406 
    result = getAllUserCommunications_result()
1407 
    result.read(self._iprot)
1408 
    self._iprot.readMessageEnd()
1409 
    if result.success != None:
1410 
      return result.success
1411 
    if result.ucx != None:
1412 
      raise result.ucx
1413 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUserCommunications failed: unknown result");
1414 
 
1859 vikas 1415 
  def createMasterAffiliate(self, name, addedOn):
1845 vikas 1416 
    """
1417 
    Parameters:
1418 
     - name
1859 vikas 1419 
     - addedOn
1845 vikas 1420 
    """
1859 vikas 1421 
    self.send_createMasterAffiliate(name, addedOn)
1845 vikas 1422 
    return self.recv_createMasterAffiliate()
1423 
 
1859 vikas 1424 
  def send_createMasterAffiliate(self, name, addedOn):
1845 vikas 1425 
    self._oprot.writeMessageBegin('createMasterAffiliate', TMessageType.CALL, self._seqid)
1426 
    args = createMasterAffiliate_args()
1427 
    args.name = name
1859 vikas 1428 
    args.addedOn = addedOn
1845 vikas 1429 
    args.write(self._oprot)
1430 
    self._oprot.writeMessageEnd()
1431 
    self._oprot.trans.flush()
1432 
 
1433 
  def recv_createMasterAffiliate(self, ):
1434 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1435 
    if mtype == TMessageType.EXCEPTION:
1436 
      x = TApplicationException()
1437 
      x.read(self._iprot)
1438 
      self._iprot.readMessageEnd()
1439 
      raise x
1440 
    result = createMasterAffiliate_result()
1441 
    result.read(self._iprot)
1442 
    self._iprot.readMessageEnd()
1443 
    if result.success != None:
1444 
      return result.success
1445 
    if result.utx != None:
1446 
      raise result.utx
1447 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createMasterAffiliate failed: unknown result");
1448 
 
1899 vikas 1449 
  def getAllMasterAffiliates(self, ):
1450 
    self.send_getAllMasterAffiliates()
1451 
    return self.recv_getAllMasterAffiliates()
1452 
 
1453 
  def send_getAllMasterAffiliates(self, ):
1454 
    self._oprot.writeMessageBegin('getAllMasterAffiliates', TMessageType.CALL, self._seqid)
1455 
    args = getAllMasterAffiliates_args()
1456 
    args.write(self._oprot)
1457 
    self._oprot.writeMessageEnd()
1458 
    self._oprot.trans.flush()
1459 
 
1460 
  def recv_getAllMasterAffiliates(self, ):
1461 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1462 
    if mtype == TMessageType.EXCEPTION:
1463 
      x = TApplicationException()
1464 
      x.read(self._iprot)
1465 
      self._iprot.readMessageEnd()
1466 
      raise x
1467 
    result = getAllMasterAffiliates_result()
1468 
    result.read(self._iprot)
1469 
    self._iprot.readMessageEnd()
1470 
    if result.success != None:
1471 
      return result.success
1472 
    if result.utx != None:
1473 
      raise result.utx
1474 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllMasterAffiliates failed: unknown result");
1475 
 
1845 vikas 1476 
  def getMasterAffiliateById(self, id):
1477 
    """
1478 
    Parameters:
1479 
     - id
1480 
    """
1481 
    self.send_getMasterAffiliateById(id)
1482 
    return self.recv_getMasterAffiliateById()
1483 
 
1484 
  def send_getMasterAffiliateById(self, id):
1485 
    self._oprot.writeMessageBegin('getMasterAffiliateById', TMessageType.CALL, self._seqid)
1486 
    args = getMasterAffiliateById_args()
1487 
    args.id = id
1488 
    args.write(self._oprot)
1489 
    self._oprot.writeMessageEnd()
1490 
    self._oprot.trans.flush()
1491 
 
1492 
  def recv_getMasterAffiliateById(self, ):
1493 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1494 
    if mtype == TMessageType.EXCEPTION:
1495 
      x = TApplicationException()
1496 
      x.read(self._iprot)
1497 
      self._iprot.readMessageEnd()
1498 
      raise x
1499 
    result = getMasterAffiliateById_result()
1500 
    result.read(self._iprot)
1501 
    self._iprot.readMessageEnd()
1502 
    if result.success != None:
1503 
      return result.success
1504 
    if result.utx != None:
1505 
      raise result.utx
1506 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateById failed: unknown result");
1507 
 
1508 
  def getMasterAffiliateByName(self, name):
1509 
    """
1510 
    Parameters:
1511 
     - name
1512 
    """
1513 
    self.send_getMasterAffiliateByName(name)
1514 
    return self.recv_getMasterAffiliateByName()
1515 
 
1516 
  def send_getMasterAffiliateByName(self, name):
1517 
    self._oprot.writeMessageBegin('getMasterAffiliateByName', TMessageType.CALL, self._seqid)
1518 
    args = getMasterAffiliateByName_args()
1519 
    args.name = name
1520 
    args.write(self._oprot)
1521 
    self._oprot.writeMessageEnd()
1522 
    self._oprot.trans.flush()
1523 
 
1524 
  def recv_getMasterAffiliateByName(self, ):
1525 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1526 
    if mtype == TMessageType.EXCEPTION:
1527 
      x = TApplicationException()
1528 
      x.read(self._iprot)
1529 
      self._iprot.readMessageEnd()
1530 
      raise x
1531 
    result = getMasterAffiliateByName_result()
1532 
    result.read(self._iprot)
1533 
    self._iprot.readMessageEnd()
1534 
    if result.success != None:
1535 
      return result.success
1536 
    if result.utx != None:
1537 
      raise result.utx
1538 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMasterAffiliateByName failed: unknown result");
1539 
 
1859 vikas 1540 
  def createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1541 
    """
1542 
    Parameters:
1543 
     - name
1544 
     - url
1545 
     - masterAffiliateId
1859 vikas 1546 
     - addedOn
1845 vikas 1547 
    """
1859 vikas 1548 
    self.send_createAffiliate(name, url, masterAffiliateId, addedOn)
1845 vikas 1549 
    return self.recv_createAffiliate()
1550 
 
1859 vikas 1551 
  def send_createAffiliate(self, name, url, masterAffiliateId, addedOn):
1845 vikas 1552 
    self._oprot.writeMessageBegin('createAffiliate', TMessageType.CALL, self._seqid)
1553 
    args = createAffiliate_args()
1554 
    args.name = name
1555 
    args.url = url
1556 
    args.masterAffiliateId = masterAffiliateId
1859 vikas 1557 
    args.addedOn = addedOn
1845 vikas 1558 
    args.write(self._oprot)
1559 
    self._oprot.writeMessageEnd()
1560 
    self._oprot.trans.flush()
1561 
 
1562 
  def recv_createAffiliate(self, ):
1563 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1564 
    if mtype == TMessageType.EXCEPTION:
1565 
      x = TApplicationException()
1566 
      x.read(self._iprot)
1567 
      self._iprot.readMessageEnd()
1568 
      raise x
1569 
    result = createAffiliate_result()
1570 
    result.read(self._iprot)
1571 
    self._iprot.readMessageEnd()
1572 
    if result.success != None:
1573 
      return result.success
1574 
    if result.utx != None:
1575 
      raise result.utx
1576 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createAffiliate failed: unknown result");
1577 
 
1578 
  def getAffiliateById(self, id):
1579 
    """
1580 
    Parameters:
1581 
     - id
1582 
    """
1583 
    self.send_getAffiliateById(id)
1584 
    return self.recv_getAffiliateById()
1585 
 
1586 
  def send_getAffiliateById(self, id):
1587 
    self._oprot.writeMessageBegin('getAffiliateById', TMessageType.CALL, self._seqid)
1588 
    args = getAffiliateById_args()
1589 
    args.id = id
1590 
    args.write(self._oprot)
1591 
    self._oprot.writeMessageEnd()
1592 
    self._oprot.trans.flush()
1593 
 
1594 
  def recv_getAffiliateById(self, ):
1595 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1596 
    if mtype == TMessageType.EXCEPTION:
1597 
      x = TApplicationException()
1598 
      x.read(self._iprot)
1599 
      self._iprot.readMessageEnd()
1600 
      raise x
1601 
    result = getAffiliateById_result()
1602 
    result.read(self._iprot)
1603 
    self._iprot.readMessageEnd()
1604 
    if result.success != None:
1605 
      return result.success
1606 
    if result.utx != None:
1607 
      raise result.utx
1608 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateById failed: unknown result");
1609 
 
1610 
  def getAffiliateByName(self, name):
1611 
    """
1612 
    Parameters:
1613 
     - name
1614 
    """
1615 
    self.send_getAffiliateByName(name)
1616 
    return self.recv_getAffiliateByName()
1617 
 
1618 
  def send_getAffiliateByName(self, name):
1619 
    self._oprot.writeMessageBegin('getAffiliateByName', TMessageType.CALL, self._seqid)
1620 
    args = getAffiliateByName_args()
1621 
    args.name = name
1622 
    args.write(self._oprot)
1623 
    self._oprot.writeMessageEnd()
1624 
    self._oprot.trans.flush()
1625 
 
1626 
  def recv_getAffiliateByName(self, ):
1627 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1628 
    if mtype == TMessageType.EXCEPTION:
1629 
      x = TApplicationException()
1630 
      x.read(self._iprot)
1631 
      self._iprot.readMessageEnd()
1632 
      raise x
1633 
    result = getAffiliateByName_result()
1634 
    result.read(self._iprot)
1635 
    self._iprot.readMessageEnd()
1636 
    if result.success != None:
1637 
      return result.success
1638 
    if result.utx != None:
1639 
      raise result.utx
1640 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliateByName failed: unknown result");
1641 
 
1996 vikas 1642 
  def getTrackerById(self, id):
1845 vikas 1643 
    """
1644 
    Parameters:
1645 
     - id
1646 
    """
1996 vikas 1647 
    self.send_getTrackerById(id)
1845 vikas 1648 
    return self.recv_getTrackerById()
1649 
 
1996 vikas 1650 
  def send_getTrackerById(self, id):
1845 vikas 1651 
    self._oprot.writeMessageBegin('getTrackerById', TMessageType.CALL, self._seqid)
1652 
    args = getTrackerById_args()
1996 vikas 1653 
    args.id = id
1845 vikas 1654 
    args.write(self._oprot)
1655 
    self._oprot.writeMessageEnd()
1656 
    self._oprot.trans.flush()
1657 
 
1658 
  def recv_getTrackerById(self, ):
1659 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1660 
    if mtype == TMessageType.EXCEPTION:
1661 
      x = TApplicationException()
1662 
      x.read(self._iprot)
1663 
      self._iprot.readMessageEnd()
1664 
      raise x
1665 
    result = getTrackerById_result()
1666 
    result.read(self._iprot)
1667 
    self._iprot.readMessageEnd()
1668 
    if result.success != None:
1669 
      return result.success
1670 
    if result.utx != None:
1671 
      raise result.utx
1672 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackerById failed: unknown result");
1673 
 
1996 vikas 1674 
  def getAffiliatesByMasterAffiliate(self, id):
1845 vikas 1675 
    """
1676 
    Parameters:
1996 vikas 1677 
     - id
1845 vikas 1678 
    """
1996 vikas 1679 
    self.send_getAffiliatesByMasterAffiliate(id)
1680 
    return self.recv_getAffiliatesByMasterAffiliate()
1845 vikas 1681 
 
1996 vikas 1682 
  def send_getAffiliatesByMasterAffiliate(self, id):
1683 
    self._oprot.writeMessageBegin('getAffiliatesByMasterAffiliate', TMessageType.CALL, self._seqid)
1684 
    args = getAffiliatesByMasterAffiliate_args()
1685 
    args.id = id
1845 vikas 1686 
    args.write(self._oprot)
1687 
    self._oprot.writeMessageEnd()
1688 
    self._oprot.trans.flush()
1689 
 
1996 vikas 1690 
  def recv_getAffiliatesByMasterAffiliate(self, ):
1845 vikas 1691 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1692 
    if mtype == TMessageType.EXCEPTION:
1693 
      x = TApplicationException()
1694 
      x.read(self._iprot)
1695 
      self._iprot.readMessageEnd()
1696 
      raise x
1996 vikas 1697 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 1698 
    result.read(self._iprot)
1699 
    self._iprot.readMessageEnd()
1700 
    if result.success != None:
1701 
      return result.success
1702 
    if result.utx != None:
1703 
      raise result.utx
1996 vikas 1704 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAffiliatesByMasterAffiliate failed: unknown result");
1845 vikas 1705 
 
1996 vikas 1706 
  def addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1707 
    """
1708 
    Parameters:
1996 vikas 1709 
     - affiliateId
1845 vikas 1710 
     - userId
1711 
     - event
1712 
     - url
1713 
     - data
1859 vikas 1714 
     - addedOn
1845 vikas 1715 
    """
1996 vikas 1716 
    self.send_addTrackLog(affiliateId, userId, event, url, data, addedOn)
1845 vikas 1717 
    return self.recv_addTrackLog()
1718 
 
1996 vikas 1719 
  def send_addTrackLog(self, affiliateId, userId, event, url, data, addedOn):
1845 vikas 1720 
    self._oprot.writeMessageBegin('addTrackLog', TMessageType.CALL, self._seqid)
1721 
    args = addTrackLog_args()
1996 vikas 1722 
    args.affiliateId = affiliateId
1845 vikas 1723 
    args.userId = userId
1724 
    args.event = event
1725 
    args.url = url
1726 
    args.data = data
1859 vikas 1727 
    args.addedOn = addedOn
1845 vikas 1728 
    args.write(self._oprot)
1729 
    self._oprot.writeMessageEnd()
1730 
    self._oprot.trans.flush()
1731 
 
1732 
  def recv_addTrackLog(self, ):
1733 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1734 
    if mtype == TMessageType.EXCEPTION:
1735 
      x = TApplicationException()
1736 
      x.read(self._iprot)
1737 
      self._iprot.readMessageEnd()
1738 
      raise x
1739 
    result = addTrackLog_result()
1740 
    result.read(self._iprot)
1741 
    self._iprot.readMessageEnd()
1742 
    if result.success != None:
1743 
      return result.success
1744 
    if result.utx != None:
1745 
      raise result.utx
1746 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addTrackLog failed: unknown result");
1747 
 
1748 
  def getTrackLogById(self, id):
1749 
    """
1750 
    Parameters:
1751 
     - id
1752 
    """
1753 
    self.send_getTrackLogById(id)
1754 
    return self.recv_getTrackLogById()
1755 
 
1756 
  def send_getTrackLogById(self, id):
1757 
    self._oprot.writeMessageBegin('getTrackLogById', TMessageType.CALL, self._seqid)
1758 
    args = getTrackLogById_args()
1759 
    args.id = id
1760 
    args.write(self._oprot)
1761 
    self._oprot.writeMessageEnd()
1762 
    self._oprot.trans.flush()
1763 
 
1764 
  def recv_getTrackLogById(self, ):
1765 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1766 
    if mtype == TMessageType.EXCEPTION:
1767 
      x = TApplicationException()
1768 
      x.read(self._iprot)
1769 
      self._iprot.readMessageEnd()
1770 
      raise x
1771 
    result = getTrackLogById_result()
1772 
    result.read(self._iprot)
1773 
    self._iprot.readMessageEnd()
1774 
    if result.success != None:
1775 
      return result.success
1776 
    if result.utx != None:
1777 
      raise result.utx
1778 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogById failed: unknown result");
1779 
 
1996 vikas 1780 
  def getTrackLogsByAffiliate(self, affiliateId):
1845 vikas 1781 
    """
1782 
    Parameters:
1996 vikas 1783 
     - affiliateId
1845 vikas 1784 
    """
1996 vikas 1785 
    self.send_getTrackLogsByAffiliate(affiliateId)
1786 
    return self.recv_getTrackLogsByAffiliate()
1845 vikas 1787 
 
1996 vikas 1788 
  def send_getTrackLogsByAffiliate(self, affiliateId):
1789 
    self._oprot.writeMessageBegin('getTrackLogsByAffiliate', TMessageType.CALL, self._seqid)
1790 
    args = getTrackLogsByAffiliate_args()
1791 
    args.affiliateId = affiliateId
1845 vikas 1792 
    args.write(self._oprot)
1793 
    self._oprot.writeMessageEnd()
1794 
    self._oprot.trans.flush()
1795 
 
1996 vikas 1796 
  def recv_getTrackLogsByAffiliate(self, ):
1845 vikas 1797 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1798 
    if mtype == TMessageType.EXCEPTION:
1799 
      x = TApplicationException()
1800 
      x.read(self._iprot)
1801 
      self._iprot.readMessageEnd()
1802 
      raise x
1996 vikas 1803 
    result = getTrackLogsByAffiliate_result()
1845 vikas 1804 
    result.read(self._iprot)
1805 
    self._iprot.readMessageEnd()
1806 
    if result.success != None:
1807 
      return result.success
1808 
    if result.utx != None:
1809 
      raise result.utx
1996 vikas 1810 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByAffiliate failed: unknown result");
1845 vikas 1811 
 
1812 
  def getTrackLogsByUser(self, userId):
1813 
    """
1814 
    Parameters:
1815 
     - userId
1816 
    """
1817 
    self.send_getTrackLogsByUser(userId)
1818 
    return self.recv_getTrackLogsByUser()
1819 
 
1820 
  def send_getTrackLogsByUser(self, userId):
1821 
    self._oprot.writeMessageBegin('getTrackLogsByUser', TMessageType.CALL, self._seqid)
1822 
    args = getTrackLogsByUser_args()
1823 
    args.userId = userId
1824 
    args.write(self._oprot)
1825 
    self._oprot.writeMessageEnd()
1826 
    self._oprot.trans.flush()
1827 
 
1828 
  def recv_getTrackLogsByUser(self, ):
1829 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1830 
    if mtype == TMessageType.EXCEPTION:
1831 
      x = TApplicationException()
1832 
      x.read(self._iprot)
1833 
      self._iprot.readMessageEnd()
1834 
      raise x
1835 
    result = getTrackLogsByUser_result()
1836 
    result.read(self._iprot)
1837 
    self._iprot.readMessageEnd()
1838 
    if result.success != None:
1839 
      return result.success
1840 
    if result.utx != None:
1841 
      raise result.utx
1842 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogsByUser failed: unknown result");
1843 
 
1996 vikas 1844 
  def getTrackLogs(self, userId, event, url):
1845 vikas 1845 
    """
1846 
    Parameters:
1847 
     - userId
1848 
     - event
1849 
     - url
1850 
    """
1996 vikas 1851 
    self.send_getTrackLogs(userId, event, url)
1845 vikas 1852 
    return self.recv_getTrackLogs()
1853 
 
1996 vikas 1854 
  def send_getTrackLogs(self, userId, event, url):
1845 vikas 1855 
    self._oprot.writeMessageBegin('getTrackLogs', TMessageType.CALL, self._seqid)
1856 
    args = getTrackLogs_args()
1857 
    args.userId = userId
1858 
    args.event = event
1859 
    args.url = url
1860 
    args.write(self._oprot)
1861 
    self._oprot.writeMessageEnd()
1862 
    self._oprot.trans.flush()
1863 
 
1864 
  def recv_getTrackLogs(self, ):
1865 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1866 
    if mtype == TMessageType.EXCEPTION:
1867 
      x = TApplicationException()
1868 
      x.read(self._iprot)
1869 
      self._iprot.readMessageEnd()
1870 
      raise x
1871 
    result = getTrackLogs_result()
1872 
    result.read(self._iprot)
1873 
    self._iprot.readMessageEnd()
1874 
    if result.success != None:
1875 
      return result.success
1876 
    if result.utx != None:
1877 
      raise result.utx
1878 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getTrackLogs failed: unknown result");
1879 
 
559 chandransh 1880 
  def createCart(self, userId):
94 ashish 1881 
    """
1882 
    Parameters:
559 chandransh 1883 
     - userId
94 ashish 1884 
    """
559 chandransh 1885 
    self.send_createCart(userId)
1886 
    return self.recv_createCart()
94 ashish 1887 
 
559 chandransh 1888 
  def send_createCart(self, userId):
1889 
    self._oprot.writeMessageBegin('createCart', TMessageType.CALL, self._seqid)
1890 
    args = createCart_args()
1891 
    args.userId = userId
94 ashish 1892 
    args.write(self._oprot)
1893 
    self._oprot.writeMessageEnd()
1894 
    self._oprot.trans.flush()
1895 
 
559 chandransh 1896 
  def recv_createCart(self, ):
94 ashish 1897 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1898 
    if mtype == TMessageType.EXCEPTION:
1899 
      x = TApplicationException()
1900 
      x.read(self._iprot)
1901 
      self._iprot.readMessageEnd()
1902 
      raise x
559 chandransh 1903 
    result = createCart_result()
94 ashish 1904 
    result.read(self._iprot)
1905 
    self._iprot.readMessageEnd()
1906 
    if result.success != None:
1907 
      return result.success
559 chandransh 1908 
    if result.scx != None:
1909 
      raise result.scx
1910 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createCart failed: unknown result");
94 ashish 1911 
 
559 chandransh 1912 
  def getCurrentCart(self, userId):
94 ashish 1913 
    """
1914 
    Parameters:
559 chandransh 1915 
     - userId
94 ashish 1916 
    """
559 chandransh 1917 
    self.send_getCurrentCart(userId)
1918 
    return self.recv_getCurrentCart()
94 ashish 1919 
 
559 chandransh 1920 
  def send_getCurrentCart(self, userId):
1921 
    self._oprot.writeMessageBegin('getCurrentCart', TMessageType.CALL, self._seqid)
1922 
    args = getCurrentCart_args()
1923 
    args.userId = userId
94 ashish 1924 
    args.write(self._oprot)
1925 
    self._oprot.writeMessageEnd()
1926 
    self._oprot.trans.flush()
1927 
 
559 chandransh 1928 
  def recv_getCurrentCart(self, ):
94 ashish 1929 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1930 
    if mtype == TMessageType.EXCEPTION:
1931 
      x = TApplicationException()
1932 
      x.read(self._iprot)
1933 
      self._iprot.readMessageEnd()
1934 
      raise x
559 chandransh 1935 
    result = getCurrentCart_result()
94 ashish 1936 
    result.read(self._iprot)
1937 
    self._iprot.readMessageEnd()
1938 
    if result.success != None:
1939 
      return result.success
559 chandransh 1940 
    if result.scx != None:
1941 
      raise result.scx
1942 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCurrentCart failed: unknown result");
94 ashish 1943 
 
559 chandransh 1944 
  def getCart(self, cartId):
94 ashish 1945 
    """
1946 
    Parameters:
559 chandransh 1947 
     - cartId
94 ashish 1948 
    """
559 chandransh 1949 
    self.send_getCart(cartId)
1950 
    return self.recv_getCart()
94 ashish 1951 
 
559 chandransh 1952 
  def send_getCart(self, cartId):
1953 
    self._oprot.writeMessageBegin('getCart', TMessageType.CALL, self._seqid)
1954 
    args = getCart_args()
1955 
    args.cartId = cartId
94 ashish 1956 
    args.write(self._oprot)
1957 
    self._oprot.writeMessageEnd()
1958 
    self._oprot.trans.flush()
1959 
 
559 chandransh 1960 
  def recv_getCart(self, ):
94 ashish 1961 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1962 
    if mtype == TMessageType.EXCEPTION:
1963 
      x = TApplicationException()
1964 
      x.read(self._iprot)
1965 
      self._iprot.readMessageEnd()
1966 
      raise x
559 chandransh 1967 
    result = getCart_result()
94 ashish 1968 
    result.read(self._iprot)
1969 
    self._iprot.readMessageEnd()
1970 
    if result.success != None:
1971 
      return result.success
559 chandransh 1972 
    if result.scx != None:
1973 
      raise result.scx
1974 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCart failed: unknown result");
94 ashish 1975 
 
559 chandransh 1976 
  def getCartsForUser(self, userId, status):
94 ashish 1977 
    """
1978 
    Parameters:
559 chandransh 1979 
     - userId
1980 
     - status
94 ashish 1981 
    """
559 chandransh 1982 
    self.send_getCartsForUser(userId, status)
1983 
    return self.recv_getCartsForUser()
94 ashish 1984 
 
559 chandransh 1985 
  def send_getCartsForUser(self, userId, status):
1986 
    self._oprot.writeMessageBegin('getCartsForUser', TMessageType.CALL, self._seqid)
1987 
    args = getCartsForUser_args()
1988 
    args.userId = userId
1989 
    args.status = status
94 ashish 1990 
    args.write(self._oprot)
1991 
    self._oprot.writeMessageEnd()
1992 
    self._oprot.trans.flush()
1993 
 
559 chandransh 1994 
  def recv_getCartsForUser(self, ):
94 ashish 1995 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
1996 
    if mtype == TMessageType.EXCEPTION:
1997 
      x = TApplicationException()
1998 
      x.read(self._iprot)
1999 
      self._iprot.readMessageEnd()
2000 
      raise x
559 chandransh 2001 
    result = getCartsForUser_result()
94 ashish 2002 
    result.read(self._iprot)
2003 
    self._iprot.readMessageEnd()
2004 
    if result.success != None:
2005 
      return result.success
559 chandransh 2006 
    if result.scx != None:
2007 
      raise result.scx
2008 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsForUser failed: unknown result");
94 ashish 2009 
 
559 chandransh 2010 
  def getCartsByStatus(self, status):
94 ashish 2011 
    """
2012 
    Parameters:
559 chandransh 2013 
     - status
94 ashish 2014 
    """
559 chandransh 2015 
    self.send_getCartsByStatus(status)
2016 
    return self.recv_getCartsByStatus()
94 ashish 2017 
 
559 chandransh 2018 
  def send_getCartsByStatus(self, status):
2019 
    self._oprot.writeMessageBegin('getCartsByStatus', TMessageType.CALL, self._seqid)
2020 
    args = getCartsByStatus_args()
2021 
    args.status = status
94 ashish 2022 
    args.write(self._oprot)
2023 
    self._oprot.writeMessageEnd()
2024 
    self._oprot.trans.flush()
2025 
 
559 chandransh 2026 
  def recv_getCartsByStatus(self, ):
94 ashish 2027 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2028 
    if mtype == TMessageType.EXCEPTION:
2029 
      x = TApplicationException()
2030 
      x.read(self._iprot)
2031 
      self._iprot.readMessageEnd()
2032 
      raise x
559 chandransh 2033 
    result = getCartsByStatus_result()
94 ashish 2034 
    result.read(self._iprot)
2035 
    self._iprot.readMessageEnd()
2036 
    if result.success != None:
2037 
      return result.success
559 chandransh 2038 
    if result.scx != None:
2039 
      raise result.scx
2040 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByStatus failed: unknown result");
94 ashish 2041 
 
559 chandransh 2042 
  def getCartsByTime(self, from_time, to_time, status):
94 ashish 2043 
    """
2044 
    Parameters:
559 chandransh 2045 
     - from_time
2046 
     - to_time
2047 
     - status
94 ashish 2048 
    """
559 chandransh 2049 
    self.send_getCartsByTime(from_time, to_time, status)
2050 
    return self.recv_getCartsByTime()
94 ashish 2051 
 
559 chandransh 2052 
  def send_getCartsByTime(self, from_time, to_time, status):
2053 
    self._oprot.writeMessageBegin('getCartsByTime', TMessageType.CALL, self._seqid)
2054 
    args = getCartsByTime_args()
2055 
    args.from_time = from_time
2056 
    args.to_time = to_time
2057 
    args.status = status
94 ashish 2058 
    args.write(self._oprot)
2059 
    self._oprot.writeMessageEnd()
2060 
    self._oprot.trans.flush()
2061 
 
559 chandransh 2062 
  def recv_getCartsByTime(self, ):
94 ashish 2063 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2064 
    if mtype == TMessageType.EXCEPTION:
2065 
      x = TApplicationException()
2066 
      x.read(self._iprot)
2067 
      self._iprot.readMessageEnd()
2068 
      raise x
559 chandransh 2069 
    result = getCartsByTime_result()
94 ashish 2070 
    result.read(self._iprot)
2071 
    self._iprot.readMessageEnd()
2072 
    if result.success != None:
2073 
      return result.success
559 chandransh 2074 
    if result.scx != None:
2075 
      raise result.scx
2076 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getCartsByTime failed: unknown result");
94 ashish 2077 
 
559 chandransh 2078 
  def changeCartStatus(self, cartId, status):
130 ashish 2079 
    """
2080 
    Parameters:
559 chandransh 2081 
     - cartId
2082 
     - status
130 ashish 2083 
    """
559 chandransh 2084 
    self.send_changeCartStatus(cartId, status)
2085 
    self.recv_changeCartStatus()
94 ashish 2086 
 
559 chandransh 2087 
  def send_changeCartStatus(self, cartId, status):
2088 
    self._oprot.writeMessageBegin('changeCartStatus', TMessageType.CALL, self._seqid)
2089 
    args = changeCartStatus_args()
2090 
    args.cartId = cartId
2091 
    args.status = status
130 ashish 2092 
    args.write(self._oprot)
2093 
    self._oprot.writeMessageEnd()
2094 
    self._oprot.trans.flush()
2095 
 
559 chandransh 2096 
  def recv_changeCartStatus(self, ):
130 ashish 2097 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2098 
    if mtype == TMessageType.EXCEPTION:
2099 
      x = TApplicationException()
2100 
      x.read(self._iprot)
2101 
      self._iprot.readMessageEnd()
2102 
      raise x
559 chandransh 2103 
    result = changeCartStatus_result()
130 ashish 2104 
    result.read(self._iprot)
2105 
    self._iprot.readMessageEnd()
559 chandransh 2106 
    if result.scx != None:
2107 
      raise result.scx
2108 
    return
2109 
 
2110 
  def addItemToCart(self, cartId, itemId, quantity):
2111 
    """
2112 
    Parameters:
2113 
     - cartId
2114 
     - itemId
2115 
     - quantity
2116 
    """
2117 
    self.send_addItemToCart(cartId, itemId, quantity)
2035 rajveer 2118 
    return self.recv_addItemToCart()
559 chandransh 2119 
 
2120 
  def send_addItemToCart(self, cartId, itemId, quantity):
2121 
    self._oprot.writeMessageBegin('addItemToCart', TMessageType.CALL, self._seqid)
2122 
    args = addItemToCart_args()
2123 
    args.cartId = cartId
2124 
    args.itemId = itemId
2125 
    args.quantity = quantity
2126 
    args.write(self._oprot)
2127 
    self._oprot.writeMessageEnd()
2128 
    self._oprot.trans.flush()
2129 
 
2130 
  def recv_addItemToCart(self, ):
2131 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2132 
    if mtype == TMessageType.EXCEPTION:
2133 
      x = TApplicationException()
2134 
      x.read(self._iprot)
2135 
      self._iprot.readMessageEnd()
2136 
      raise x
2137 
    result = addItemToCart_result()
2138 
    result.read(self._iprot)
2139 
    self._iprot.readMessageEnd()
2035 rajveer 2140 
    if result.success != None:
2141 
      return result.success
559 chandransh 2142 
    if result.scx != None:
2143 
      raise result.scx
2035 rajveer 2144 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "addItemToCart failed: unknown result");
559 chandransh 2145 
 
2146 
  def deleteItemFromCart(self, cartId, itemId):
2147 
    """
2148 
    Parameters:
2149 
     - cartId
2150 
     - itemId
2151 
    """
2152 
    self.send_deleteItemFromCart(cartId, itemId)
2153 
    self.recv_deleteItemFromCart()
2154 
 
2155 
  def send_deleteItemFromCart(self, cartId, itemId):
2156 
    self._oprot.writeMessageBegin('deleteItemFromCart', TMessageType.CALL, self._seqid)
2157 
    args = deleteItemFromCart_args()
2158 
    args.cartId = cartId
2159 
    args.itemId = itemId
2160 
    args.write(self._oprot)
2161 
    self._oprot.writeMessageEnd()
2162 
    self._oprot.trans.flush()
2163 
 
2164 
  def recv_deleteItemFromCart(self, ):
2165 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2166 
    if mtype == TMessageType.EXCEPTION:
2167 
      x = TApplicationException()
2168 
      x.read(self._iprot)
2169 
      self._iprot.readMessageEnd()
2170 
      raise x
2171 
    result = deleteItemFromCart_result()
2172 
    result.read(self._iprot)
2173 
    self._iprot.readMessageEnd()
2174 
    if result.scx != None:
2175 
      raise result.scx
2176 
    return
2177 
 
2178 
  def changeQuantity(self, cartId, itemId, quantity):
2179 
    """
2180 
    Parameters:
2181 
     - cartId
2182 
     - itemId
2183 
     - quantity
2184 
    """
2185 
    self.send_changeQuantity(cartId, itemId, quantity)
2186 
    self.recv_changeQuantity()
2187 
 
2188 
  def send_changeQuantity(self, cartId, itemId, quantity):
2189 
    self._oprot.writeMessageBegin('changeQuantity', TMessageType.CALL, self._seqid)
2190 
    args = changeQuantity_args()
2191 
    args.cartId = cartId
2192 
    args.itemId = itemId
2193 
    args.quantity = quantity
2194 
    args.write(self._oprot)
2195 
    self._oprot.writeMessageEnd()
2196 
    self._oprot.trans.flush()
2197 
 
2198 
  def recv_changeQuantity(self, ):
2199 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2200 
    if mtype == TMessageType.EXCEPTION:
2201 
      x = TApplicationException()
2202 
      x.read(self._iprot)
2203 
      self._iprot.readMessageEnd()
2204 
      raise x
2205 
    result = changeQuantity_result()
2206 
    result.read(self._iprot)
2207 
    self._iprot.readMessageEnd()
2208 
    if result.scx != None:
2209 
      raise result.scx
2210 
    return
2211 
 
2212 
  def changeItemStatus(self, cartId, itemId, status):
2213 
    """
2214 
    Parameters:
2215 
     - cartId
2216 
     - itemId
2217 
     - status
2218 
    """
2219 
    self.send_changeItemStatus(cartId, itemId, status)
2220 
    self.recv_changeItemStatus()
2221 
 
2222 
  def send_changeItemStatus(self, cartId, itemId, status):
2223 
    self._oprot.writeMessageBegin('changeItemStatus', TMessageType.CALL, self._seqid)
2224 
    args = changeItemStatus_args()
2225 
    args.cartId = cartId
2226 
    args.itemId = itemId
2227 
    args.status = status
2228 
    args.write(self._oprot)
2229 
    self._oprot.writeMessageEnd()
2230 
    self._oprot.trans.flush()
2231 
 
2232 
  def recv_changeItemStatus(self, ):
2233 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2234 
    if mtype == TMessageType.EXCEPTION:
2235 
      x = TApplicationException()
2236 
      x.read(self._iprot)
2237 
      self._iprot.readMessageEnd()
2238 
      raise x
2239 
    result = changeItemStatus_result()
2240 
    result.read(self._iprot)
2241 
    self._iprot.readMessageEnd()
2242 
    if result.scx != None:
2243 
      raise result.scx
2244 
    return
2245 
 
2246 
  def addAddressToCart(self, cartId, addressId):
2247 
    """
2248 
    Parameters:
2249 
     - cartId
2250 
     - addressId
2251 
    """
2252 
    self.send_addAddressToCart(cartId, addressId)
2253 
    self.recv_addAddressToCart()
2254 
 
2255 
  def send_addAddressToCart(self, cartId, addressId):
2256 
    self._oprot.writeMessageBegin('addAddressToCart', TMessageType.CALL, self._seqid)
2257 
    args = addAddressToCart_args()
2258 
    args.cartId = cartId
2259 
    args.addressId = addressId
2260 
    args.write(self._oprot)
2261 
    self._oprot.writeMessageEnd()
2262 
    self._oprot.trans.flush()
2263 
 
2264 
  def recv_addAddressToCart(self, ):
2265 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2266 
    if mtype == TMessageType.EXCEPTION:
2267 
      x = TApplicationException()
2268 
      x.read(self._iprot)
2269 
      self._iprot.readMessageEnd()
2270 
      raise x
2271 
    result = addAddressToCart_result()
2272 
    result.read(self._iprot)
2273 
    self._iprot.readMessageEnd()
575 chandransh 2274 
    if result.scx != None:
2275 
      raise result.scx
559 chandransh 2276 
    return
2277 
 
1976 varun.gupt 2278 
  def applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
2279 
    """
2280 
    Parameters:
2281 
     - cartId
2282 
     - couponCode
2283 
     - totalPrice
2284 
     - discountedPrice
2285 
    """
2286 
    self.send_applyCouponToCart(cartId, couponCode, totalPrice, discountedPrice)
2287 
    self.recv_applyCouponToCart()
2288 
 
2289 
  def send_applyCouponToCart(self, cartId, couponCode, totalPrice, discountedPrice):
2290 
    self._oprot.writeMessageBegin('applyCouponToCart', TMessageType.CALL, self._seqid)
2291 
    args = applyCouponToCart_args()
2292 
    args.cartId = cartId
2293 
    args.couponCode = couponCode
2294 
    args.totalPrice = totalPrice
2295 
    args.discountedPrice = discountedPrice
2296 
    args.write(self._oprot)
2297 
    self._oprot.writeMessageEnd()
2298 
    self._oprot.trans.flush()
2299 
 
2300 
  def recv_applyCouponToCart(self, ):
2301 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2302 
    if mtype == TMessageType.EXCEPTION:
2303 
      x = TApplicationException()
2304 
      x.read(self._iprot)
2305 
      self._iprot.readMessageEnd()
2306 
      raise x
2307 
    result = applyCouponToCart_result()
2308 
    result.read(self._iprot)
2309 
    self._iprot.readMessageEnd()
2310 
    if result.scx != None:
2311 
      raise result.scx
2312 
    return
2313 
 
2314 
  def removeCoupon(self, cartId):
2315 
    """
2316 
    Parameters:
2317 
     - cartId
2318 
    """
2319 
    self.send_removeCoupon(cartId)
2320 
    self.recv_removeCoupon()
2321 
 
2322 
  def send_removeCoupon(self, cartId):
2323 
    self._oprot.writeMessageBegin('removeCoupon', TMessageType.CALL, self._seqid)
2324 
    args = removeCoupon_args()
2325 
    args.cartId = cartId
2326 
    args.write(self._oprot)
2327 
    self._oprot.writeMessageEnd()
2328 
    self._oprot.trans.flush()
2329 
 
2330 
  def recv_removeCoupon(self, ):
2331 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2332 
    if mtype == TMessageType.EXCEPTION:
2333 
      x = TApplicationException()
2334 
      x.read(self._iprot)
2335 
      self._iprot.readMessageEnd()
2336 
      raise x
2337 
    result = removeCoupon_result()
2338 
    result.read(self._iprot)
2339 
    self._iprot.readMessageEnd()
2340 
    if result.scx != None:
2341 
      raise result.scx
2342 
    return
2343 
 
2815 vikas 2344 
  def createOrders(self, cartId, sessionSource, sessionStartTime):
559 chandransh 2345 
    """
690 chandransh 2346 
    Creates a transaction and multiple orders for the given cart. Returns the transaction ID created.
2347 
 
559 chandransh 2348 
    Parameters:
2349 
     - cartId
2815 vikas 2350 
     - sessionSource
2351 
     - sessionStartTime
559 chandransh 2352 
    """
2815 vikas 2353 
    self.send_createOrders(cartId, sessionSource, sessionStartTime)
690 chandransh 2354 
    return self.recv_createOrders()
559 chandransh 2355 
 
2815 vikas 2356 
  def send_createOrders(self, cartId, sessionSource, sessionStartTime):
690 chandransh 2357 
    self._oprot.writeMessageBegin('createOrders', TMessageType.CALL, self._seqid)
2358 
    args = createOrders_args()
559 chandransh 2359 
    args.cartId = cartId
2815 vikas 2360 
    args.sessionSource = sessionSource
2361 
    args.sessionStartTime = sessionStartTime
559 chandransh 2362 
    args.write(self._oprot)
2363 
    self._oprot.writeMessageEnd()
2364 
    self._oprot.trans.flush()
2365 
 
690 chandransh 2366 
  def recv_createOrders(self, ):
559 chandransh 2367 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2368 
    if mtype == TMessageType.EXCEPTION:
2369 
      x = TApplicationException()
2370 
      x.read(self._iprot)
2371 
      self._iprot.readMessageEnd()
2372 
      raise x
690 chandransh 2373 
    result = createOrders_result()
559 chandransh 2374 
    result.read(self._iprot)
2375 
    self._iprot.readMessageEnd()
130 ashish 2376 
    if result.success != None:
2377 
      return result.success
559 chandransh 2378 
    if result.scx != None:
2379 
      raise result.scx
690 chandransh 2380 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "createOrders failed: unknown result");
130 ashish 2381 
 
559 chandransh 2382 
  def validateCart(self, cartId):
130 ashish 2383 
    """
690 chandransh 2384 
    Validates that:
2385 
    1. The checkout timestamp is greater than the updatedOn timestamp.
1466 ankur.sing 2386 
    2. All of the lines in the cart are active items.
690 chandransh 2387 
    3. The estimate for any of the lines in cart doesn't change.
1466 ankur.sing 2388 
    If all three are true, returns empty string; else returns appropriate message.
690 chandransh 2389 
 
130 ashish 2390 
    Parameters:
559 chandransh 2391 
     - cartId
130 ashish 2392 
    """
559 chandransh 2393 
    self.send_validateCart(cartId)
2394 
    return self.recv_validateCart()
130 ashish 2395 
 
559 chandransh 2396 
  def send_validateCart(self, cartId):
2397 
    self._oprot.writeMessageBegin('validateCart', TMessageType.CALL, self._seqid)
2398 
    args = validateCart_args()
2399 
    args.cartId = cartId
130 ashish 2400 
    args.write(self._oprot)
2401 
    self._oprot.writeMessageEnd()
2402 
    self._oprot.trans.flush()
2403 
 
559 chandransh 2404 
  def recv_validateCart(self, ):
130 ashish 2405 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2406 
    if mtype == TMessageType.EXCEPTION:
2407 
      x = TApplicationException()
2408 
      x.read(self._iprot)
2409 
      self._iprot.readMessageEnd()
2410 
      raise x
559 chandransh 2411 
    result = validateCart_result()
130 ashish 2412 
    result.read(self._iprot)
2413 
    self._iprot.readMessageEnd()
2414 
    if result.success != None:
2415 
      return result.success
575 chandransh 2416 
    if result.scex != None:
2417 
      raise result.scex
559 chandransh 2418 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "validateCart failed: unknown result");
130 ashish 2419 
 
690 chandransh 2420 
  def mergeCart(self, fromCartId, toCartId):
575 chandransh 2421 
    """
690 chandransh 2422 
    Merges the lines from the first cart into the second cart. Lines with duplicate items are removed.
2423 
 
575 chandransh 2424 
    Parameters:
690 chandransh 2425 
     - fromCartId
2426 
     - toCartId
2427 
    """
2428 
    self.send_mergeCart(fromCartId, toCartId)
2429 
    self.recv_mergeCart()
2430 
 
2431 
  def send_mergeCart(self, fromCartId, toCartId):
2432 
    self._oprot.writeMessageBegin('mergeCart', TMessageType.CALL, self._seqid)
2433 
    args = mergeCart_args()
2434 
    args.fromCartId = fromCartId
2435 
    args.toCartId = toCartId
2436 
    args.write(self._oprot)
2437 
    self._oprot.writeMessageEnd()
2438 
    self._oprot.trans.flush()
2439 
 
2440 
  def recv_mergeCart(self, ):
2441 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2442 
    if mtype == TMessageType.EXCEPTION:
2443 
      x = TApplicationException()
2444 
      x.read(self._iprot)
2445 
      self._iprot.readMessageEnd()
2446 
      raise x
2447 
    result = mergeCart_result()
2448 
    result.read(self._iprot)
2449 
    self._iprot.readMessageEnd()
2450 
    return
2451 
 
2452 
  def checkOut(self, cartId):
2453 
    """
2454 
    Sets the checkedOutOn timestamp of the cart. Raises an exception if the specified cart can't be found.
2455 
 
2456 
    Parameters:
575 chandransh 2457 
     - cartId
2458 
    """
690 chandransh 2459 
    self.send_checkOut(cartId)
2460 
    return self.recv_checkOut()
575 chandransh 2461 
 
690 chandransh 2462 
  def send_checkOut(self, cartId):
2463 
    self._oprot.writeMessageBegin('checkOut', TMessageType.CALL, self._seqid)
2464 
    args = checkOut_args()
575 chandransh 2465 
    args.cartId = cartId
2466 
    args.write(self._oprot)
2467 
    self._oprot.writeMessageEnd()
2468 
    self._oprot.trans.flush()
2469 
 
690 chandransh 2470 
  def recv_checkOut(self, ):
575 chandransh 2471 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2472 
    if mtype == TMessageType.EXCEPTION:
2473 
      x = TApplicationException()
2474 
      x.read(self._iprot)
2475 
      self._iprot.readMessageEnd()
2476 
      raise x
690 chandransh 2477 
    result = checkOut_result()
575 chandransh 2478 
    result.read(self._iprot)
2479 
    self._iprot.readMessageEnd()
2480 
    if result.success != None:
2481 
      return result.success
2482 
    if result.scex != None:
2483 
      raise result.scex
690 chandransh 2484 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "checkOut failed: unknown result");
575 chandransh 2485 
 
690 chandransh 2486 
  def resetCart(self, cartId, items):
559 chandransh 2487 
    """
690 chandransh 2488 
    The second parameter is a map of item ids and their quantities which have been successfully processed.
2489 
    This methods removes the specified quantiry of the specified item from the cart.
2490 
 
559 chandransh 2491 
    Parameters:
690 chandransh 2492 
     - cartId
2493 
     - items
559 chandransh 2494 
    """
690 chandransh 2495 
    self.send_resetCart(cartId, items)
2496 
    return self.recv_resetCart()
130 ashish 2497 
 
690 chandransh 2498 
  def send_resetCart(self, cartId, items):
2499 
    self._oprot.writeMessageBegin('resetCart', TMessageType.CALL, self._seqid)
2500 
    args = resetCart_args()
2501 
    args.cartId = cartId
2502 
    args.items = items
559 chandransh 2503 
    args.write(self._oprot)
2504 
    self._oprot.writeMessageEnd()
2505 
    self._oprot.trans.flush()
2506 
 
690 chandransh 2507 
  def recv_resetCart(self, ):
559 chandransh 2508 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2509 
    if mtype == TMessageType.EXCEPTION:
2510 
      x = TApplicationException()
2511 
      x.read(self._iprot)
2512 
      self._iprot.readMessageEnd()
2513 
      raise x
690 chandransh 2514 
    result = resetCart_result()
559 chandransh 2515 
    result.read(self._iprot)
2516 
    self._iprot.readMessageEnd()
690 chandransh 2517 
    if result.success != None:
2518 
      return result.success
2519 
    if result.scex != None:
2520 
      raise result.scex
2521 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "resetCart failed: unknown result");
559 chandransh 2522 
 
772 rajveer 2523 
  def getMyResearch(self, userId):
559 chandransh 2524 
    """
772 rajveer 2525 
    Widgets
2526 
 
559 chandransh 2527 
    Parameters:
2528 
     - userId
2529 
    """
772 rajveer 2530 
    self.send_getMyResearch(userId)
559 chandransh 2531 
    return self.recv_getMyResearch()
2532 
 
772 rajveer 2533 
  def send_getMyResearch(self, userId):
559 chandransh 2534 
    self._oprot.writeMessageBegin('getMyResearch', TMessageType.CALL, self._seqid)
2535 
    args = getMyResearch_args()
772 rajveer 2536 
    args.userId = userId
559 chandransh 2537 
    args.write(self._oprot)
2538 
    self._oprot.writeMessageEnd()
2539 
    self._oprot.trans.flush()
2540 
 
2541 
  def recv_getMyResearch(self, ):
2542 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2543 
    if mtype == TMessageType.EXCEPTION:
2544 
      x = TApplicationException()
2545 
      x.read(self._iprot)
2546 
      self._iprot.readMessageEnd()
2547 
      raise x
2548 
    result = getMyResearch_result()
2549 
    result.read(self._iprot)
2550 
    self._iprot.readMessageEnd()
2551 
    if result.success != None:
2552 
      return result.success
2553 
    if result.scx != None:
2554 
      raise result.scx
2555 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getMyResearch failed: unknown result");
2556 
 
772 rajveer 2557 
  def updateMyResearch(self, userId, itemId):
559 chandransh 2558 
    """
2559 
    Parameters:
772 rajveer 2560 
     - userId
2561 
     - itemId
559 chandransh 2562 
    """
772 rajveer 2563 
    self.send_updateMyResearch(userId, itemId)
559 chandransh 2564 
    return self.recv_updateMyResearch()
2565 
 
772 rajveer 2566 
  def send_updateMyResearch(self, userId, itemId):
559 chandransh 2567 
    self._oprot.writeMessageBegin('updateMyResearch', TMessageType.CALL, self._seqid)
2568 
    args = updateMyResearch_args()
772 rajveer 2569 
    args.userId = userId
2570 
    args.itemId = itemId
559 chandransh 2571 
    args.write(self._oprot)
2572 
    self._oprot.writeMessageEnd()
2573 
    self._oprot.trans.flush()
2574 
 
2575 
  def recv_updateMyResearch(self, ):
2576 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2577 
    if mtype == TMessageType.EXCEPTION:
2578 
      x = TApplicationException()
2579 
      x.read(self._iprot)
2580 
      self._iprot.readMessageEnd()
2581 
      raise x
2582 
    result = updateMyResearch_result()
2583 
    result.read(self._iprot)
2584 
    self._iprot.readMessageEnd()
2585 
    if result.success != None:
2586 
      return result.success
2587 
    if result.scx != None:
2588 
      raise result.scx
2589 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "updateMyResearch failed: unknown result");
2590 
 
772 rajveer 2591 
  def deleteItemFromMyResearch(self, userId, itemId):
559 chandransh 2592 
    """
2593 
    Parameters:
772 rajveer 2594 
     - userId
2595 
     - itemId
559 chandransh 2596 
    """
772 rajveer 2597 
    self.send_deleteItemFromMyResearch(userId, itemId)
559 chandransh 2598 
    self.recv_deleteItemFromMyResearch()
2599 
 
772 rajveer 2600 
  def send_deleteItemFromMyResearch(self, userId, itemId):
559 chandransh 2601 
    self._oprot.writeMessageBegin('deleteItemFromMyResearch', TMessageType.CALL, self._seqid)
2602 
    args = deleteItemFromMyResearch_args()
772 rajveer 2603 
    args.userId = userId
2604 
    args.itemId = itemId
559 chandransh 2605 
    args.write(self._oprot)
2606 
    self._oprot.writeMessageEnd()
2607 
    self._oprot.trans.flush()
2608 
 
2609 
  def recv_deleteItemFromMyResearch(self, ):
2610 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2611 
    if mtype == TMessageType.EXCEPTION:
2612 
      x = TApplicationException()
2613 
      x.read(self._iprot)
2614 
      self._iprot.readMessageEnd()
2615 
      raise x
2616 
    result = deleteItemFromMyResearch_result()
2617 
    result.read(self._iprot)
2618 
    self._iprot.readMessageEnd()
2619 
    if result.scx != None:
2620 
      raise result.scx
2621 
    return
2622 
 
772 rajveer 2623 
  def updateBrowseHistory(self, userId, itemId):
559 chandransh 2624 
    """
2625 
    Parameters:
772 rajveer 2626 
     - userId
2627 
     - itemId
559 chandransh 2628 
    """
772 rajveer 2629 
    self.send_updateBrowseHistory(userId, itemId)
2630 
    self.recv_updateBrowseHistory()
559 chandransh 2631 
 
772 rajveer 2632 
  def send_updateBrowseHistory(self, userId, itemId):
2633 
    self._oprot.writeMessageBegin('updateBrowseHistory', TMessageType.CALL, self._seqid)
2634 
    args = updateBrowseHistory_args()
2635 
    args.userId = userId
2636 
    args.itemId = itemId
559 chandransh 2637 
    args.write(self._oprot)
2638 
    self._oprot.writeMessageEnd()
2639 
    self._oprot.trans.flush()
2640 
 
772 rajveer 2641 
  def recv_updateBrowseHistory(self, ):
559 chandransh 2642 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2643 
    if mtype == TMessageType.EXCEPTION:
2644 
      x = TApplicationException()
2645 
      x.read(self._iprot)
2646 
      self._iprot.readMessageEnd()
2647 
      raise x
772 rajveer 2648 
    result = updateBrowseHistory_result()
559 chandransh 2649 
    result.read(self._iprot)
2650 
    self._iprot.readMessageEnd()
2651 
    return
2652 
 
772 rajveer 2653 
  def getBrowseHistory(self, userId):
559 chandransh 2654 
    """
2655 
    Parameters:
772 rajveer 2656 
     - userId
559 chandransh 2657 
    """
772 rajveer 2658 
    self.send_getBrowseHistory(userId)
2659 
    return self.recv_getBrowseHistory()
559 chandransh 2660 
 
772 rajveer 2661 
  def send_getBrowseHistory(self, userId):
2662 
    self._oprot.writeMessageBegin('getBrowseHistory', TMessageType.CALL, self._seqid)
2663 
    args = getBrowseHistory_args()
2664 
    args.userId = userId
559 chandransh 2665 
    args.write(self._oprot)
2666 
    self._oprot.writeMessageEnd()
2667 
    self._oprot.trans.flush()
2668 
 
772 rajveer 2669 
  def recv_getBrowseHistory(self, ):
559 chandransh 2670 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2671 
    if mtype == TMessageType.EXCEPTION:
2672 
      x = TApplicationException()
2673 
      x.read(self._iprot)
2674 
      self._iprot.readMessageEnd()
2675 
      raise x
772 rajveer 2676 
    result = getBrowseHistory_result()
559 chandransh 2677 
    result.read(self._iprot)
2678 
    self._iprot.readMessageEnd()
2679 
    if result.success != None:
2680 
      return result.success
2681 
    if result.scx != None:
2682 
      raise result.scx
772 rajveer 2683 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getBrowseHistory failed: unknown result");
559 chandransh 2684 
 
772 rajveer 2685 
  def mergeBrowseHistory(self, fromUserId, toUserId):
559 chandransh 2686 
    """
2687 
    Parameters:
772 rajveer 2688 
     - fromUserId
2689 
     - toUserId
559 chandransh 2690 
    """
772 rajveer 2691 
    self.send_mergeBrowseHistory(fromUserId, toUserId)
2692 
    self.recv_mergeBrowseHistory()
559 chandransh 2693 
 
772 rajveer 2694 
  def send_mergeBrowseHistory(self, fromUserId, toUserId):
2695 
    self._oprot.writeMessageBegin('mergeBrowseHistory', TMessageType.CALL, self._seqid)
2696 
    args = mergeBrowseHistory_args()
2697 
    args.fromUserId = fromUserId
2698 
    args.toUserId = toUserId
559 chandransh 2699 
    args.write(self._oprot)
2700 
    self._oprot.writeMessageEnd()
2701 
    self._oprot.trans.flush()
2702 
 
772 rajveer 2703 
  def recv_mergeBrowseHistory(self, ):
559 chandransh 2704 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2705 
    if mtype == TMessageType.EXCEPTION:
2706 
      x = TApplicationException()
2707 
      x.read(self._iprot)
2708 
      self._iprot.readMessageEnd()
2709 
      raise x
772 rajveer 2710 
    result = mergeBrowseHistory_result()
559 chandransh 2711 
    result.read(self._iprot)
2712 
    self._iprot.readMessageEnd()
2713 
    return
2714 
 
1596 ankur.sing 2715 
  def getUserCount(self, userType):
2716 
    """
2717 
    Returns number of registered users.
2718 
    If userType = null, then it returns count of all users, including anonymous
2719 
    If userType = UserType.ANONYMOUS, then it returns count of anonymous users only
2720 
    If userType = UserType.USER, then it returns count of non-anonymous users only
2721 
 
2722 
    Parameters:
2723 
     - userType
2724 
    """
2725 
    self.send_getUserCount(userType)
2726 
    return self.recv_getUserCount()
559 chandransh 2727 
 
1596 ankur.sing 2728 
  def send_getUserCount(self, userType):
2729 
    self._oprot.writeMessageBegin('getUserCount', TMessageType.CALL, self._seqid)
2730 
    args = getUserCount_args()
2731 
    args.userType = userType
2732 
    args.write(self._oprot)
2733 
    self._oprot.writeMessageEnd()
2734 
    self._oprot.trans.flush()
2735 
 
2736 
  def recv_getUserCount(self, ):
2737 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2738 
    if mtype == TMessageType.EXCEPTION:
2739 
      x = TApplicationException()
2740 
      x.read(self._iprot)
2741 
      self._iprot.readMessageEnd()
2742 
      raise x
2743 
    result = getUserCount_result()
2744 
    result.read(self._iprot)
2745 
    self._iprot.readMessageEnd()
2746 
    if result.success != None:
2747 
      return result.success
2748 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserCount failed: unknown result");
2749 
 
1891 ankur.sing 2750 
  def getAllUsers(self, userType, startDate, endDate):
1673 ankur.sing 2751 
    """
1891 ankur.sing 2752 
    Returns list of users of type userType who registered between startDate and endDate (both inclusive).
2753 
    If any of startDate or endDate is -1, then that filter is ignored.
2754 
    If userType is null, then returns all the users, irrespective of anonymous flag
1673 ankur.sing 2755 
 
1891 ankur.sing 2756 
 
1673 ankur.sing 2757 
    Parameters:
2758 
     - userType
1891 ankur.sing 2759 
     - startDate
2760 
     - endDate
1673 ankur.sing 2761 
    """
1891 ankur.sing 2762 
    self.send_getAllUsers(userType, startDate, endDate)
1673 ankur.sing 2763 
    return self.recv_getAllUsers()
1596 ankur.sing 2764 
 
1891 ankur.sing 2765 
  def send_getAllUsers(self, userType, startDate, endDate):
1673 ankur.sing 2766 
    self._oprot.writeMessageBegin('getAllUsers', TMessageType.CALL, self._seqid)
2767 
    args = getAllUsers_args()
2768 
    args.userType = userType
1891 ankur.sing 2769 
    args.startDate = startDate
2770 
    args.endDate = endDate
1673 ankur.sing 2771 
    args.write(self._oprot)
2772 
    self._oprot.writeMessageEnd()
2773 
    self._oprot.trans.flush()
2774 
 
2775 
  def recv_getAllUsers(self, ):
2776 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2777 
    if mtype == TMessageType.EXCEPTION:
2778 
      x = TApplicationException()
2779 
      x.read(self._iprot)
2780 
      self._iprot.readMessageEnd()
2781 
      raise x
2782 
    result = getAllUsers_result()
2783 
    result.read(self._iprot)
2784 
    self._iprot.readMessageEnd()
2785 
    if result.success != None:
2786 
      return result.success
2787 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getAllUsers failed: unknown result");
2788 
 
2717 varun.gupt 2789 
  def putUserNote(self, user_id, entity_id, slide, note):
2642 varun.gupt 2790 
    """
2791 
    Masking right now. May be used later.
2792 
    void addWidget(1:Widget widget) throws (1:WidgetException scx),
2793 
    void addItemToWidget(1:i64 widget_id, 2:list<i64> items) throws (1:WidgetException scx),
2794 
    void deleteItemFromWidget(1:i64 widget_id, 2:i64 item_id) throws (1:WidgetException scx),
2795 
    void updateWidget(1:i64 widgetId, 2:bool enable) throws (1:WidgetException scx),
2796 
    void updateWidgetItem(1:i64 widgetId, 2:bool enable) throws (1:WidgetException scx),
2797 
    Widget getWidget(1:WidgetType type, 2:i64 userId, 3:bool onlyEnabled) throws (1:WidgetException scx),
2798 
 
2799 
    Parameters:
2800 
     - user_id
2801 
     - entity_id
2717 varun.gupt 2802 
     - slide
2642 varun.gupt 2803 
     - note
2804 
    """
2717 varun.gupt 2805 
    self.send_putUserNote(user_id, entity_id, slide, note)
2642 varun.gupt 2806 
    self.recv_putUserNote()
1673 ankur.sing 2807 
 
2717 varun.gupt 2808 
  def send_putUserNote(self, user_id, entity_id, slide, note):
2642 varun.gupt 2809 
    self._oprot.writeMessageBegin('putUserNote', TMessageType.CALL, self._seqid)
2810 
    args = putUserNote_args()
2811 
    args.user_id = user_id
2812 
    args.entity_id = entity_id
2717 varun.gupt 2813 
    args.slide = slide
2642 varun.gupt 2814 
    args.note = note
2815 
    args.write(self._oprot)
2816 
    self._oprot.writeMessageEnd()
2817 
    self._oprot.trans.flush()
2818 
 
2819 
  def recv_putUserNote(self, ):
2820 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2821 
    if mtype == TMessageType.EXCEPTION:
2822 
      x = TApplicationException()
2823 
      x.read(self._iprot)
2824 
      self._iprot.readMessageEnd()
2825 
      raise x
2826 
    result = putUserNote_result()
2827 
    result.read(self._iprot)
2828 
    self._iprot.readMessageEnd()
2829 
    return
2830 
 
2831 
  def getUserNotes(self, user_id, entity_id):
2832 
    """
2833 
    Parameters:
2834 
     - user_id
2835 
     - entity_id
2836 
    """
2837 
    self.send_getUserNotes(user_id, entity_id)
2838 
    return self.recv_getUserNotes()
2839 
 
2840 
  def send_getUserNotes(self, user_id, entity_id):
2841 
    self._oprot.writeMessageBegin('getUserNotes', TMessageType.CALL, self._seqid)
2842 
    args = getUserNotes_args()
2843 
    args.user_id = user_id
2844 
    args.entity_id = entity_id
2845 
    args.write(self._oprot)
2846 
    self._oprot.writeMessageEnd()
2847 
    self._oprot.trans.flush()
2848 
 
2849 
  def recv_getUserNotes(self, ):
2850 
    (fname, mtype, rseqid) = self._iprot.readMessageBegin()
2851 
    if mtype == TMessageType.EXCEPTION:
2852 
      x = TApplicationException()
2853 
      x.read(self._iprot)
2854 
      self._iprot.readMessageEnd()
2855 
      raise x
2856 
    result = getUserNotes_result()
2857 
    result.read(self._iprot)
2858 
    self._iprot.readMessageEnd()
2859 
    if result.success != None:
2860 
      return result.success
2861 
    raise TApplicationException(TApplicationException.MISSING_RESULT, "getUserNotes failed: unknown result");
2862 
 
2863 
 
94 ashish 2864 
class Processor(Iface, TProcessor):
2865 
  def __init__(self, handler):
2866 
    self._handler = handler
2867 
    self._processMap = {}
765 rajveer 2868 
    self._processMap["closeSession"] = Processor.process_closeSession
559 chandransh 2869 
    self._processMap["createAnonymousUser"] = Processor.process_createAnonymousUser
2870 
    self._processMap["getUserById"] = Processor.process_getUserById
1491 vikas 2871 
    self._processMap["getUserByEmail"] = Processor.process_getUserByEmail
559 chandransh 2872 
    self._processMap["createUser"] = Processor.process_createUser
2873 
    self._processMap["updateUser"] = Processor.process_updateUser
2874 
    self._processMap["deleteUser"] = Processor.process_deleteUser
2875 
    self._processMap["getUserState"] = Processor.process_getUserState
122 ashish 2876 
    self._processMap["authenticateUser"] = Processor.process_authenticateUser
94 ashish 2877 
    self._processMap["userExists"] = Processor.process_userExists
2878 
    self._processMap["addAddressForUser"] = Processor.process_addAddressForUser
2879 
    self._processMap["removeAddressForUser"] = Processor.process_removeAddressForUser
2880 
    self._processMap["setUserAsLoggedIn"] = Processor.process_setUserAsLoggedIn
2881 
    self._processMap["setUserAsLoggedOut"] = Processor.process_setUserAsLoggedOut
504 rajveer 2882 
    self._processMap["setDefaultAddress"] = Processor.process_setDefaultAddress
94 ashish 2883 
    self._processMap["updatePassword"] = Processor.process_updatePassword
581 rajveer 2884 
    self._processMap["forgotPassword"] = Processor.process_forgotPassword
594 rajveer 2885 
    self._processMap["getAllAddressesForUser"] = Processor.process_getAllAddressesForUser
1894 vikas 2886 
    self._processMap["getAddressById"] = Processor.process_getAddressById
594 rajveer 2887 
    self._processMap["getDefaultAddressId"] = Processor.process_getDefaultAddressId
785 rajveer 2888 
    self._processMap["getDefaultPincode"] = Processor.process_getDefaultPincode
1274 varun.gupt 2889 
    self._processMap["saveUserCommunication"] = Processor.process_saveUserCommunication
1590 varun.gupt 2890 
    self._processMap["getUserCommunicationById"] = Processor.process_getUserCommunicationById
2891 
    self._processMap["getUserCommunicationByUser"] = Processor.process_getUserCommunicationByUser
2892 
    self._processMap["getAllUserCommunications"] = Processor.process_getAllUserCommunications
1845 vikas 2893 
    self._processMap["createMasterAffiliate"] = Processor.process_createMasterAffiliate
1899 vikas 2894 
    self._processMap["getAllMasterAffiliates"] = Processor.process_getAllMasterAffiliates
1845 vikas 2895 
    self._processMap["getMasterAffiliateById"] = Processor.process_getMasterAffiliateById
2896 
    self._processMap["getMasterAffiliateByName"] = Processor.process_getMasterAffiliateByName
2897 
    self._processMap["createAffiliate"] = Processor.process_createAffiliate
2898 
    self._processMap["getAffiliateById"] = Processor.process_getAffiliateById
2899 
    self._processMap["getAffiliateByName"] = Processor.process_getAffiliateByName
1996 vikas 2900 
    self._processMap["getTrackerById"] = Processor.process_getTrackerById
1845 vikas 2901 
    self._processMap["getAffiliatesByMasterAffiliate"] = Processor.process_getAffiliatesByMasterAffiliate
2902 
    self._processMap["addTrackLog"] = Processor.process_addTrackLog
2903 
    self._processMap["getTrackLogById"] = Processor.process_getTrackLogById
1996 vikas 2904 
    self._processMap["getTrackLogsByAffiliate"] = Processor.process_getTrackLogsByAffiliate
1845 vikas 2905 
    self._processMap["getTrackLogsByUser"] = Processor.process_getTrackLogsByUser
2906 
    self._processMap["getTrackLogs"] = Processor.process_getTrackLogs
559 chandransh 2907 
    self._processMap["createCart"] = Processor.process_createCart
2908 
    self._processMap["getCurrentCart"] = Processor.process_getCurrentCart
2909 
    self._processMap["getCart"] = Processor.process_getCart
2910 
    self._processMap["getCartsForUser"] = Processor.process_getCartsForUser
2911 
    self._processMap["getCartsByStatus"] = Processor.process_getCartsByStatus
2912 
    self._processMap["getCartsByTime"] = Processor.process_getCartsByTime
2913 
    self._processMap["changeCartStatus"] = Processor.process_changeCartStatus
2914 
    self._processMap["addItemToCart"] = Processor.process_addItemToCart
2915 
    self._processMap["deleteItemFromCart"] = Processor.process_deleteItemFromCart
2916 
    self._processMap["changeQuantity"] = Processor.process_changeQuantity
2917 
    self._processMap["changeItemStatus"] = Processor.process_changeItemStatus
2918 
    self._processMap["addAddressToCart"] = Processor.process_addAddressToCart
1976 varun.gupt 2919 
    self._processMap["applyCouponToCart"] = Processor.process_applyCouponToCart
2920 
    self._processMap["removeCoupon"] = Processor.process_removeCoupon
690 chandransh 2921 
    self._processMap["createOrders"] = Processor.process_createOrders
559 chandransh 2922 
    self._processMap["validateCart"] = Processor.process_validateCart
2923 
    self._processMap["mergeCart"] = Processor.process_mergeCart
690 chandransh 2924 
    self._processMap["checkOut"] = Processor.process_checkOut
2925 
    self._processMap["resetCart"] = Processor.process_resetCart
559 chandransh 2926 
    self._processMap["getMyResearch"] = Processor.process_getMyResearch
2927 
    self._processMap["updateMyResearch"] = Processor.process_updateMyResearch
2928 
    self._processMap["deleteItemFromMyResearch"] = Processor.process_deleteItemFromMyResearch
2929 
    self._processMap["updateBrowseHistory"] = Processor.process_updateBrowseHistory
2930 
    self._processMap["getBrowseHistory"] = Processor.process_getBrowseHistory
772 rajveer 2931 
    self._processMap["mergeBrowseHistory"] = Processor.process_mergeBrowseHistory
1596 ankur.sing 2932 
    self._processMap["getUserCount"] = Processor.process_getUserCount
1673 ankur.sing 2933 
    self._processMap["getAllUsers"] = Processor.process_getAllUsers
2642 varun.gupt 2934 
    self._processMap["putUserNote"] = Processor.process_putUserNote
2935 
    self._processMap["getUserNotes"] = Processor.process_getUserNotes
94 ashish 2936 
 
2937 
  def process(self, iprot, oprot):
2938 
    (name, type, seqid) = iprot.readMessageBegin()
2939 
    if name not in self._processMap:
2940 
      iprot.skip(TType.STRUCT)
2941 
      iprot.readMessageEnd()
2942 
      x = TApplicationException(TApplicationException.UNKNOWN_METHOD, 'Unknown function %s' % (name))
2943 
      oprot.writeMessageBegin(name, TMessageType.EXCEPTION, seqid)
2944 
      x.write(oprot)
2945 
      oprot.writeMessageEnd()
2946 
      oprot.trans.flush()
2947 
      return
2948 
    else:
2949 
      self._processMap[name](self, seqid, iprot, oprot)
2950 
    return True
2951 
 
765 rajveer 2952 
  def process_closeSession(self, seqid, iprot, oprot):
2953 
    args = closeSession_args()
2954 
    args.read(iprot)
2955 
    iprot.readMessageEnd()
2956 
    result = closeSession_result()
2957 
    self._handler.closeSession()
2958 
    oprot.writeMessageBegin("closeSession", TMessageType.REPLY, seqid)
2959 
    result.write(oprot)
2960 
    oprot.writeMessageEnd()
2961 
    oprot.trans.flush()
2962 
 
559 chandransh 2963 
  def process_createAnonymousUser(self, seqid, iprot, oprot):
2964 
    args = createAnonymousUser_args()
94 ashish 2965 
    args.read(iprot)
2966 
    iprot.readMessageEnd()
559 chandransh 2967 
    result = createAnonymousUser_result()
94 ashish 2968 
    try:
559 chandransh 2969 
      result.success = self._handler.createAnonymousUser(args.jsessionId)
2970 
    except UserContextException, ucex:
2971 
      result.ucex = ucex
2972 
    oprot.writeMessageBegin("createAnonymousUser", TMessageType.REPLY, seqid)
94 ashish 2973 
    result.write(oprot)
2974 
    oprot.writeMessageEnd()
2975 
    oprot.trans.flush()
2976 
 
559 chandransh 2977 
  def process_getUserById(self, seqid, iprot, oprot):
2978 
    args = getUserById_args()
94 ashish 2979 
    args.read(iprot)
2980 
    iprot.readMessageEnd()
559 chandransh 2981 
    result = getUserById_result()
94 ashish 2982 
    try:
559 chandransh 2983 
      result.success = self._handler.getUserById(args.userId)
2984 
    except UserContextException, ucex:
2985 
      result.ucex = ucex
2986 
    oprot.writeMessageBegin("getUserById", TMessageType.REPLY, seqid)
94 ashish 2987 
    result.write(oprot)
2988 
    oprot.writeMessageEnd()
2989 
    oprot.trans.flush()
2990 
 
1491 vikas 2991 
  def process_getUserByEmail(self, seqid, iprot, oprot):
2992 
    args = getUserByEmail_args()
2993 
    args.read(iprot)
2994 
    iprot.readMessageEnd()
2995 
    result = getUserByEmail_result()
2996 
    try:
2997 
      result.success = self._handler.getUserByEmail(args.email)
2998 
    except UserContextException, ucex:
2999 
      result.ucex = ucex
3000 
    oprot.writeMessageBegin("getUserByEmail", TMessageType.REPLY, seqid)
3001 
    result.write(oprot)
3002 
    oprot.writeMessageEnd()
3003 
    oprot.trans.flush()
3004 
 
559 chandransh 3005 
  def process_createUser(self, seqid, iprot, oprot):
3006 
    args = createUser_args()
94 ashish 3007 
    args.read(iprot)
3008 
    iprot.readMessageEnd()
559 chandransh 3009 
    result = createUser_result()
94 ashish 3010 
    try:
559 chandransh 3011 
      result.success = self._handler.createUser(args.user)
3012 
    except UserContextException, ucex:
3013 
      result.ucex = ucex
3014 
    oprot.writeMessageBegin("createUser", TMessageType.REPLY, seqid)
94 ashish 3015 
    result.write(oprot)
3016 
    oprot.writeMessageEnd()
3017 
    oprot.trans.flush()
3018 
 
559 chandransh 3019 
  def process_updateUser(self, seqid, iprot, oprot):
3020 
    args = updateUser_args()
94 ashish 3021 
    args.read(iprot)
3022 
    iprot.readMessageEnd()
559 chandransh 3023 
    result = updateUser_result()
94 ashish 3024 
    try:
559 chandransh 3025 
      result.success = self._handler.updateUser(args.user)
3026 
    except UserContextException, ucex:
3027 
      result.ucex = ucex
3028 
    oprot.writeMessageBegin("updateUser", TMessageType.REPLY, seqid)
94 ashish 3029 
    result.write(oprot)
3030 
    oprot.writeMessageEnd()
3031 
    oprot.trans.flush()
3032 
 
559 chandransh 3033 
  def process_deleteUser(self, seqid, iprot, oprot):
3034 
    args = deleteUser_args()
94 ashish 3035 
    args.read(iprot)
3036 
    iprot.readMessageEnd()
559 chandransh 3037 
    result = deleteUser_result()
94 ashish 3038 
    try:
559 chandransh 3039 
      result.success = self._handler.deleteUser(args.userId)
3040 
    except UserContextException, ucex:
3041 
      result.ucex = ucex
3042 
    oprot.writeMessageBegin("deleteUser", TMessageType.REPLY, seqid)
94 ashish 3043 
    result.write(oprot)
3044 
    oprot.writeMessageEnd()
3045 
    oprot.trans.flush()
3046 
 
559 chandransh 3047 
  def process_getUserState(self, seqid, iprot, oprot):
3048 
    args = getUserState_args()
94 ashish 3049 
    args.read(iprot)
3050 
    iprot.readMessageEnd()
559 chandransh 3051 
    result = getUserState_result()
94 ashish 3052 
    try:
559 chandransh 3053 
      result.success = self._handler.getUserState(args.userId)
3054 
    except UserContextException, ucex:
3055 
      result.ucex = ucex
3056 
    oprot.writeMessageBegin("getUserState", TMessageType.REPLY, seqid)
94 ashish 3057 
    result.write(oprot)
3058 
    oprot.writeMessageEnd()
3059 
    oprot.trans.flush()
3060 
 
122 ashish 3061 
  def process_authenticateUser(self, seqid, iprot, oprot):
3062 
    args = authenticateUser_args()
3063 
    args.read(iprot)
3064 
    iprot.readMessageEnd()
3065 
    result = authenticateUser_result()
3066 
    try:
559 chandransh 3067 
      result.success = self._handler.authenticateUser(args.email, args.password)
3068 
    except AuthenticationException, auex:
3069 
      result.auex = auex
122 ashish 3070 
    oprot.writeMessageBegin("authenticateUser", TMessageType.REPLY, seqid)
3071 
    result.write(oprot)
3072 
    oprot.writeMessageEnd()
3073 
    oprot.trans.flush()
3074 
 
94 ashish 3075 
  def process_userExists(self, seqid, iprot, oprot):
3076 
    args = userExists_args()
3077 
    args.read(iprot)
3078 
    iprot.readMessageEnd()
3079 
    result = userExists_result()
3080 
    try:
3081 
      result.success = self._handler.userExists(args.email)
3082 
    except UserContextException, ucx:
3083 
      result.ucx = ucx
3084 
    oprot.writeMessageBegin("userExists", TMessageType.REPLY, seqid)
3085 
    result.write(oprot)
3086 
    oprot.writeMessageEnd()
3087 
    oprot.trans.flush()
3088 
 
3089 
  def process_addAddressForUser(self, seqid, iprot, oprot):
3090 
    args = addAddressForUser_args()
3091 
    args.read(iprot)
3092 
    iprot.readMessageEnd()
3093 
    result = addAddressForUser_result()
3094 
    try:
567 rajveer 3095 
      result.success = self._handler.addAddressForUser(args.userId, args.address, args.setDefault)
94 ashish 3096 
    except UserContextException, ucx:
3097 
      result.ucx = ucx
3098 
    oprot.writeMessageBegin("addAddressForUser", TMessageType.REPLY, seqid)
3099 
    result.write(oprot)
3100 
    oprot.writeMessageEnd()
3101 
    oprot.trans.flush()
3102 
 
3103 
  def process_removeAddressForUser(self, seqid, iprot, oprot):
3104 
    args = removeAddressForUser_args()
3105 
    args.read(iprot)
3106 
    iprot.readMessageEnd()
3107 
    result = removeAddressForUser_result()
3108 
    try:
3109 
      result.success = self._handler.removeAddressForUser(args.userid, args.addressId)
3110 
    except UserContextException, ucx:
3111 
      result.ucx = ucx
3112 
    oprot.writeMessageBegin("removeAddressForUser", TMessageType.REPLY, seqid)
3113 
    result.write(oprot)
3114 
    oprot.writeMessageEnd()
3115 
    oprot.trans.flush()
3116 
 
3117 
  def process_setUserAsLoggedIn(self, seqid, iprot, oprot):
3118 
    args = setUserAsLoggedIn_args()
3119 
    args.read(iprot)
3120 
    iprot.readMessageEnd()
3121 
    result = setUserAsLoggedIn_result()
3122 
    try:
3123 
      result.success = self._handler.setUserAsLoggedIn(args.userId, args.timestamp)
3124 
    except UserContextException, ucx:
3125 
      result.ucx = ucx
3126 
    oprot.writeMessageBegin("setUserAsLoggedIn", TMessageType.REPLY, seqid)
3127 
    result.write(oprot)
3128 
    oprot.writeMessageEnd()
3129 
    oprot.trans.flush()
3130 
 
3131 
  def process_setUserAsLoggedOut(self, seqid, iprot, oprot):
3132 
    args = setUserAsLoggedOut_args()
3133 
    args.read(iprot)
3134 
    iprot.readMessageEnd()
3135 
    result = setUserAsLoggedOut_result()
3136 
    try:
3137 
      result.success = self._handler.setUserAsLoggedOut(args.userid, args.timestamp)
3138 
    except UserContextException, ucx:
3139 
      result.ucx = ucx
3140 
    oprot.writeMessageBegin("setUserAsLoggedOut", TMessageType.REPLY, seqid)
3141 
    result.write(oprot)
3142 
    oprot.writeMessageEnd()
3143 
    oprot.trans.flush()
3144 
 
504 rajveer 3145 
  def process_setDefaultAddress(self, seqid, iprot, oprot):
3146 
    args = setDefaultAddress_args()
3147 
    args.read(iprot)
3148 
    iprot.readMessageEnd()
3149 
    result = setDefaultAddress_result()
3150 
    try:
3151 
      result.success = self._handler.setDefaultAddress(args.userid, args.addressId)
3152 
    except UserContextException, ucx:
3153 
      result.ucx = ucx
3154 
    oprot.writeMessageBegin("setDefaultAddress", TMessageType.REPLY, seqid)
3155 
    result.write(oprot)
3156 
    oprot.writeMessageEnd()
3157 
    oprot.trans.flush()
3158 
 
94 ashish 3159 
  def process_updatePassword(self, seqid, iprot, oprot):
3160 
    args = updatePassword_args()
3161 
    args.read(iprot)
3162 
    iprot.readMessageEnd()
3163 
    result = updatePassword_result()
3164 
    try:
594 rajveer 3165 
      result.success = self._handler.updatePassword(args.userid, args.oldPassword, args.newPassword)
94 ashish 3166 
    except UserContextException, ucx:
3167 
      result.ucx = ucx
3168 
    oprot.writeMessageBegin("updatePassword", TMessageType.REPLY, seqid)
3169 
    result.write(oprot)
3170 
    oprot.writeMessageEnd()
3171 
    oprot.trans.flush()
3172 
 
581 rajveer 3173 
  def process_forgotPassword(self, seqid, iprot, oprot):
3174 
    args = forgotPassword_args()
3175 
    args.read(iprot)
3176 
    iprot.readMessageEnd()
3177 
    result = forgotPassword_result()
3178 
    try:
884 rajveer 3179 
      result.success = self._handler.forgotPassword(args.email, args.newPassword)
581 rajveer 3180 
    except UserContextException, ucx:
3181 
      result.ucx = ucx
3182 
    oprot.writeMessageBegin("forgotPassword", TMessageType.REPLY, seqid)
3183 
    result.write(oprot)
3184 
    oprot.writeMessageEnd()
3185 
    oprot.trans.flush()
3186 
 
594 rajveer 3187 
  def process_getAllAddressesForUser(self, seqid, iprot, oprot):
3188 
    args = getAllAddressesForUser_args()
3189 
    args.read(iprot)
3190 
    iprot.readMessageEnd()
3191 
    result = getAllAddressesForUser_result()
3192 
    try:
3193 
      result.success = self._handler.getAllAddressesForUser(args.userId)
3194 
    except UserContextException, ucx:
3195 
      result.ucx = ucx
3196 
    oprot.writeMessageBegin("getAllAddressesForUser", TMessageType.REPLY, seqid)
3197 
    result.write(oprot)
3198 
    oprot.writeMessageEnd()
3199 
    oprot.trans.flush()
3200 
 
1894 vikas 3201 
  def process_getAddressById(self, seqid, iprot, oprot):
3202 
    args = getAddressById_args()
3203 
    args.read(iprot)
3204 
    iprot.readMessageEnd()
3205 
    result = getAddressById_result()
3206 
    try:
3207 
      result.success = self._handler.getAddressById(args.addressId)
3208 
    except UserContextException, ucx:
3209 
      result.ucx = ucx
3210 
    oprot.writeMessageBegin("getAddressById", TMessageType.REPLY, seqid)
3211 
    result.write(oprot)
3212 
    oprot.writeMessageEnd()
3213 
    oprot.trans.flush()
3214 
 
594 rajveer 3215 
  def process_getDefaultAddressId(self, seqid, iprot, oprot):
3216 
    args = getDefaultAddressId_args()
3217 
    args.read(iprot)
3218 
    iprot.readMessageEnd()
3219 
    result = getDefaultAddressId_result()
3220 
    try:
3221 
      result.success = self._handler.getDefaultAddressId(args.userId)
3222 
    except UserContextException, ucx:
3223 
      result.ucx = ucx
3224 
    oprot.writeMessageBegin("getDefaultAddressId", TMessageType.REPLY, seqid)
3225 
    result.write(oprot)
3226 
    oprot.writeMessageEnd()
3227 
    oprot.trans.flush()
3228 
 
785 rajveer 3229 
  def process_getDefaultPincode(self, seqid, iprot, oprot):
3230 
    args = getDefaultPincode_args()
3231 
    args.read(iprot)
3232 
    iprot.readMessageEnd()
3233 
    result = getDefaultPincode_result()
3234 
    try:
3235 
      result.success = self._handler.getDefaultPincode(args.userId)
3236 
    except UserContextException, ucx:
3237 
      result.ucx = ucx
3238 
    oprot.writeMessageBegin("getDefaultPincode", TMessageType.REPLY, seqid)
3239 
    result.write(oprot)
3240 
    oprot.writeMessageEnd()
3241 
    oprot.trans.flush()
3242 
 
1274 varun.gupt 3243 
  def process_saveUserCommunication(self, seqid, iprot, oprot):
3244 
    args = saveUserCommunication_args()
3245 
    args.read(iprot)
3246 
    iprot.readMessageEnd()
3247 
    result = saveUserCommunication_result()
3248 
    try:
3249 
      result.success = self._handler.saveUserCommunication(args.userId, args.replyTo, args.communicationType, args.orderId, args.airwaybillNo, args.productName, args.subject, args.message)
3250 
    except UserCommunicationException, ucx:
3251 
      result.ucx = ucx
3252 
    oprot.writeMessageBegin("saveUserCommunication", TMessageType.REPLY, seqid)
3253 
    result.write(oprot)
3254 
    oprot.writeMessageEnd()
3255 
    oprot.trans.flush()
3256 
 
1590 varun.gupt 3257 
  def process_getUserCommunicationById(self, seqid, iprot, oprot):
3258 
    args = getUserCommunicationById_args()
3259 
    args.read(iprot)
3260 
    iprot.readMessageEnd()
3261 
    result = getUserCommunicationById_result()
3262 
    try:
3263 
      result.success = self._handler.getUserCommunicationById(args.id)
3264 
    except UserCommunicationException, ucx:
3265 
      result.ucx = ucx
3266 
    oprot.writeMessageBegin("getUserCommunicationById", TMessageType.REPLY, seqid)
3267 
    result.write(oprot)
3268 
    oprot.writeMessageEnd()
3269 
    oprot.trans.flush()
3270 
 
3271 
  def process_getUserCommunicationByUser(self, seqid, iprot, oprot):
3272 
    args = getUserCommunicationByUser_args()
3273 
    args.read(iprot)
3274 
    iprot.readMessageEnd()
3275 
    result = getUserCommunicationByUser_result()
3276 
    try:
3277 
      result.success = self._handler.getUserCommunicationByUser(args.userId)
3278 
    except UserCommunicationException, ucx:
3279 
      result.ucx = ucx
3280 
    oprot.writeMessageBegin("getUserCommunicationByUser", TMessageType.REPLY, seqid)
3281 
    result.write(oprot)
3282 
    oprot.writeMessageEnd()
3283 
    oprot.trans.flush()
3284 
 
3285 
  def process_getAllUserCommunications(self, seqid, iprot, oprot):
3286 
    args = getAllUserCommunications_args()
3287 
    args.read(iprot)
3288 
    iprot.readMessageEnd()
3289 
    result = getAllUserCommunications_result()
3290 
    try:
3291 
      result.success = self._handler.getAllUserCommunications()
3292 
    except UserCommunicationException, ucx:
3293 
      result.ucx = ucx
3294 
    oprot.writeMessageBegin("getAllUserCommunications", TMessageType.REPLY, seqid)
3295 
    result.write(oprot)
3296 
    oprot.writeMessageEnd()
3297 
    oprot.trans.flush()
3298 
 
1845 vikas 3299 
  def process_createMasterAffiliate(self, seqid, iprot, oprot):
3300 
    args = createMasterAffiliate_args()
3301 
    args.read(iprot)
3302 
    iprot.readMessageEnd()
3303 
    result = createMasterAffiliate_result()
3304 
    try:
1859 vikas 3305 
      result.success = self._handler.createMasterAffiliate(args.name, args.addedOn)
1996 vikas 3306 
    except UserAffiliateException, utx:
1845 vikas 3307 
      result.utx = utx
3308 
    oprot.writeMessageBegin("createMasterAffiliate", TMessageType.REPLY, seqid)
3309 
    result.write(oprot)
3310 
    oprot.writeMessageEnd()
3311 
    oprot.trans.flush()
3312 
 
1899 vikas 3313 
  def process_getAllMasterAffiliates(self, seqid, iprot, oprot):
3314 
    args = getAllMasterAffiliates_args()
3315 
    args.read(iprot)
3316 
    iprot.readMessageEnd()
3317 
    result = getAllMasterAffiliates_result()
3318 
    try:
3319 
      result.success = self._handler.getAllMasterAffiliates()
1996 vikas 3320 
    except UserAffiliateException, utx:
1899 vikas 3321 
      result.utx = utx
3322 
    oprot.writeMessageBegin("getAllMasterAffiliates", TMessageType.REPLY, seqid)
3323 
    result.write(oprot)
3324 
    oprot.writeMessageEnd()
3325 
    oprot.trans.flush()
3326 
 
1845 vikas 3327 
  def process_getMasterAffiliateById(self, seqid, iprot, oprot):
3328 
    args = getMasterAffiliateById_args()
3329 
    args.read(iprot)
3330 
    iprot.readMessageEnd()
3331 
    result = getMasterAffiliateById_result()
3332 
    try:
3333 
      result.success = self._handler.getMasterAffiliateById(args.id)
1996 vikas 3334 
    except UserAffiliateException, utx:
1845 vikas 3335 
      result.utx = utx
3336 
    oprot.writeMessageBegin("getMasterAffiliateById", TMessageType.REPLY, seqid)
3337 
    result.write(oprot)
3338 
    oprot.writeMessageEnd()
3339 
    oprot.trans.flush()
3340 
 
3341 
  def process_getMasterAffiliateByName(self, seqid, iprot, oprot):
3342 
    args = getMasterAffiliateByName_args()
3343 
    args.read(iprot)
3344 
    iprot.readMessageEnd()
3345 
    result = getMasterAffiliateByName_result()
3346 
    try:
3347 
      result.success = self._handler.getMasterAffiliateByName(args.name)
1996 vikas 3348 
    except UserAffiliateException, utx:
1845 vikas 3349 
      result.utx = utx
3350 
    oprot.writeMessageBegin("getMasterAffiliateByName", TMessageType.REPLY, seqid)
3351 
    result.write(oprot)
3352 
    oprot.writeMessageEnd()
3353 
    oprot.trans.flush()
3354 
 
3355 
  def process_createAffiliate(self, seqid, iprot, oprot):
3356 
    args = createAffiliate_args()
3357 
    args.read(iprot)
3358 
    iprot.readMessageEnd()
3359 
    result = createAffiliate_result()
3360 
    try:
1859 vikas 3361 
      result.success = self._handler.createAffiliate(args.name, args.url, args.masterAffiliateId, args.addedOn)
1996 vikas 3362 
    except UserAffiliateException, utx:
1845 vikas 3363 
      result.utx = utx
3364 
    oprot.writeMessageBegin("createAffiliate", TMessageType.REPLY, seqid)
3365 
    result.write(oprot)
3366 
    oprot.writeMessageEnd()
3367 
    oprot.trans.flush()
3368 
 
3369 
  def process_getAffiliateById(self, seqid, iprot, oprot):
3370 
    args = getAffiliateById_args()
3371 
    args.read(iprot)
3372 
    iprot.readMessageEnd()
3373 
    result = getAffiliateById_result()
3374 
    try:
3375 
      result.success = self._handler.getAffiliateById(args.id)
1996 vikas 3376 
    except UserAffiliateException, utx:
1845 vikas 3377 
      result.utx = utx
3378 
    oprot.writeMessageBegin("getAffiliateById", TMessageType.REPLY, seqid)
3379 
    result.write(oprot)
3380 
    oprot.writeMessageEnd()
3381 
    oprot.trans.flush()
3382 
 
3383 
  def process_getAffiliateByName(self, seqid, iprot, oprot):
3384 
    args = getAffiliateByName_args()
3385 
    args.read(iprot)
3386 
    iprot.readMessageEnd()
3387 
    result = getAffiliateByName_result()
3388 
    try:
3389 
      result.success = self._handler.getAffiliateByName(args.name)
1996 vikas 3390 
    except UserAffiliateException, utx:
1845 vikas 3391 
      result.utx = utx
3392 
    oprot.writeMessageBegin("getAffiliateByName", TMessageType.REPLY, seqid)
3393 
    result.write(oprot)
3394 
    oprot.writeMessageEnd()
3395 
    oprot.trans.flush()
3396 
 
3397 
  def process_getTrackerById(self, seqid, iprot, oprot):
3398 
    args = getTrackerById_args()
3399 
    args.read(iprot)
3400 
    iprot.readMessageEnd()
3401 
    result = getTrackerById_result()
3402 
    try:
1996 vikas 3403 
      result.success = self._handler.getTrackerById(args.id)
3404 
    except UserAffiliateException, utx:
1845 vikas 3405 
      result.utx = utx
3406 
    oprot.writeMessageBegin("getTrackerById", TMessageType.REPLY, seqid)
3407 
    result.write(oprot)
3408 
    oprot.writeMessageEnd()
3409 
    oprot.trans.flush()
3410 
 
1996 vikas 3411 
  def process_getAffiliatesByMasterAffiliate(self, seqid, iprot, oprot):
3412 
    args = getAffiliatesByMasterAffiliate_args()
1845 vikas 3413 
    args.read(iprot)
3414 
    iprot.readMessageEnd()
1996 vikas 3415 
    result = getAffiliatesByMasterAffiliate_result()
1845 vikas 3416 
    try:
1996 vikas 3417 
      result.success = self._handler.getAffiliatesByMasterAffiliate(args.id)
3418 
    except UserAffiliateException, utx:
1845 vikas 3419 
      result.utx = utx
1996 vikas 3420 
    oprot.writeMessageBegin("getAffiliatesByMasterAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3421 
    result.write(oprot)
3422 
    oprot.writeMessageEnd()
3423 
    oprot.trans.flush()
3424 
 
3425 
  def process_addTrackLog(self, seqid, iprot, oprot):
3426 
    args = addTrackLog_args()
3427 
    args.read(iprot)
3428 
    iprot.readMessageEnd()
3429 
    result = addTrackLog_result()
3430 
    try:
1996 vikas 3431 
      result.success = self._handler.addTrackLog(args.affiliateId, args.userId, args.event, args.url, args.data, args.addedOn)
3432 
    except UserAffiliateException, utx:
1845 vikas 3433 
      result.utx = utx
3434 
    oprot.writeMessageBegin("addTrackLog", TMessageType.REPLY, seqid)
3435 
    result.write(oprot)
3436 
    oprot.writeMessageEnd()
3437 
    oprot.trans.flush()
3438 
 
3439 
  def process_getTrackLogById(self, seqid, iprot, oprot):
3440 
    args = getTrackLogById_args()
3441 
    args.read(iprot)
3442 
    iprot.readMessageEnd()
3443 
    result = getTrackLogById_result()
3444 
    try:
3445 
      result.success = self._handler.getTrackLogById(args.id)
1996 vikas 3446 
    except UserAffiliateException, utx:
1845 vikas 3447 
      result.utx = utx
3448 
    oprot.writeMessageBegin("getTrackLogById", TMessageType.REPLY, seqid)
3449 
    result.write(oprot)
3450 
    oprot.writeMessageEnd()
3451 
    oprot.trans.flush()
3452 
 
1996 vikas 3453 
  def process_getTrackLogsByAffiliate(self, seqid, iprot, oprot):
3454 
    args = getTrackLogsByAffiliate_args()
1845 vikas 3455 
    args.read(iprot)
3456 
    iprot.readMessageEnd()
1996 vikas 3457 
    result = getTrackLogsByAffiliate_result()
1845 vikas 3458 
    try:
1996 vikas 3459 
      result.success = self._handler.getTrackLogsByAffiliate(args.affiliateId)
3460 
    except UserAffiliateException, utx:
1845 vikas 3461 
      result.utx = utx
1996 vikas 3462 
    oprot.writeMessageBegin("getTrackLogsByAffiliate", TMessageType.REPLY, seqid)
1845 vikas 3463 
    result.write(oprot)
3464 
    oprot.writeMessageEnd()
3465 
    oprot.trans.flush()
3466 
 
3467 
  def process_getTrackLogsByUser(self, seqid, iprot, oprot):
3468 
    args = getTrackLogsByUser_args()
3469 
    args.read(iprot)
3470 
    iprot.readMessageEnd()
3471 
    result = getTrackLogsByUser_result()
3472 
    try:
3473 
      result.success = self._handler.getTrackLogsByUser(args.userId)
1996 vikas 3474 
    except UserAffiliateException, utx:
1845 vikas 3475 
      result.utx = utx
3476 
    oprot.writeMessageBegin("getTrackLogsByUser", TMessageType.REPLY, seqid)
3477 
    result.write(oprot)
3478 
    oprot.writeMessageEnd()
3479 
    oprot.trans.flush()
3480 
 
3481 
  def process_getTrackLogs(self, seqid, iprot, oprot):
3482 
    args = getTrackLogs_args()
3483 
    args.read(iprot)
3484 
    iprot.readMessageEnd()
3485 
    result = getTrackLogs_result()
3486 
    try:
1996 vikas 3487 
      result.success = self._handler.getTrackLogs(args.userId, args.event, args.url)
3488 
    except UserAffiliateException, utx:
1845 vikas 3489 
      result.utx = utx
3490 
    oprot.writeMessageBegin("getTrackLogs", TMessageType.REPLY, seqid)
3491 
    result.write(oprot)
3492 
    oprot.writeMessageEnd()
3493 
    oprot.trans.flush()
3494 
 
559 chandransh 3495 
  def process_createCart(self, seqid, iprot, oprot):
3496 
    args = createCart_args()
94 ashish 3497 
    args.read(iprot)
3498 
    iprot.readMessageEnd()
559 chandransh 3499 
    result = createCart_result()
94 ashish 3500 
    try:
559 chandransh 3501 
      result.success = self._handler.createCart(args.userId)
3502 
    except ShoppingCartException, scx:
3503 
      result.scx = scx
3504 
    oprot.writeMessageBegin("createCart", TMessageType.REPLY, seqid)
94 ashish 3505 
    result.write(oprot)
3506 
    oprot.writeMessageEnd()
3507 
    oprot.trans.flush()
3508 
 
559 chandransh 3509 
  def process_getCurrentCart(self, seqid, iprot, oprot):
3510 
    args = getCurrentCart_args()
94 ashish 3511 
    args.read(iprot)
3512 
    iprot.readMessageEnd()
559 chandransh 3513 
    result = getCurrentCart_result()
94 ashish 3514 
    try:
559 chandransh 3515 
      result.success = self._handler.getCurrentCart(args.userId)
3516 
    except ShoppingCartException, scx:
3517 
      result.scx = scx
3518 
    oprot.writeMessageBegin("getCurrentCart", TMessageType.REPLY, seqid)
94 ashish 3519 
    result.write(oprot)
3520 
    oprot.writeMessageEnd()
3521 
    oprot.trans.flush()
3522 
 
559 chandransh 3523 
  def process_getCart(self, seqid, iprot, oprot):
3524 
    args = getCart_args()
94 ashish 3525 
    args.read(iprot)
3526 
    iprot.readMessageEnd()
559 chandransh 3527 
    result = getCart_result()
94 ashish 3528 
    try:
559 chandransh 3529 
      result.success = self._handler.getCart(args.cartId)
3530 
    except ShoppingCartException, scx:
3531 
      result.scx = scx
3532 
    oprot.writeMessageBegin("getCart", TMessageType.REPLY, seqid)
94 ashish 3533 
    result.write(oprot)
3534 
    oprot.writeMessageEnd()
3535 
    oprot.trans.flush()
3536 
 
559 chandransh 3537 
  def process_getCartsForUser(self, seqid, iprot, oprot):
3538 
    args = getCartsForUser_args()
94 ashish 3539 
    args.read(iprot)
3540 
    iprot.readMessageEnd()
559 chandransh 3541 
    result = getCartsForUser_result()
94 ashish 3542 
    try:
559 chandransh 3543 
      result.success = self._handler.getCartsForUser(args.userId, args.status)
3544 
    except ShoppingCartException, scx:
3545 
      result.scx = scx
3546 
    oprot.writeMessageBegin("getCartsForUser", TMessageType.REPLY, seqid)
94 ashish 3547 
    result.write(oprot)
3548 
    oprot.writeMessageEnd()
3549 
    oprot.trans.flush()
3550 
 
559 chandransh 3551 
  def process_getCartsByStatus(self, seqid, iprot, oprot):
3552 
    args = getCartsByStatus_args()
94 ashish 3553 
    args.read(iprot)
3554 
    iprot.readMessageEnd()
559 chandransh 3555 
    result = getCartsByStatus_result()
94 ashish 3556 
    try:
559 chandransh 3557 
      result.success = self._handler.getCartsByStatus(args.status)
3558 
    except ShoppingCartException, scx:
3559 
      result.scx = scx
3560 
    oprot.writeMessageBegin("getCartsByStatus", TMessageType.REPLY, seqid)
94 ashish 3561 
    result.write(oprot)
3562 
    oprot.writeMessageEnd()
3563 
    oprot.trans.flush()
3564 
 
559 chandransh 3565 
  def process_getCartsByTime(self, seqid, iprot, oprot):
3566 
    args = getCartsByTime_args()
94 ashish 3567 
    args.read(iprot)
3568 
    iprot.readMessageEnd()
559 chandransh 3569 
    result = getCartsByTime_result()
94 ashish 3570 
    try:
559 chandransh 3571 
      result.success = self._handler.getCartsByTime(args.from_time, args.to_time, args.status)
3572 
    except ShoppingCartException, scx:
3573 
      result.scx = scx
3574 
    oprot.writeMessageBegin("getCartsByTime", TMessageType.REPLY, seqid)
94 ashish 3575 
    result.write(oprot)
3576 
    oprot.writeMessageEnd()
3577 
    oprot.trans.flush()
3578 
 
559 chandransh 3579 
  def process_changeCartStatus(self, seqid, iprot, oprot):
3580 
    args = changeCartStatus_args()
130 ashish 3581 
    args.read(iprot)
3582 
    iprot.readMessageEnd()
559 chandransh 3583 
    result = changeCartStatus_result()
130 ashish 3584 
    try:
559 chandransh 3585 
      self._handler.changeCartStatus(args.cartId, args.status)
3586 
    except ShoppingCartException, scx:
3587 
      result.scx = scx
3588 
    oprot.writeMessageBegin("changeCartStatus", TMessageType.REPLY, seqid)
130 ashish 3589 
    result.write(oprot)
3590 
    oprot.writeMessageEnd()
3591 
    oprot.trans.flush()
94 ashish 3592 
 
559 chandransh 3593 
  def process_addItemToCart(self, seqid, iprot, oprot):
3594 
    args = addItemToCart_args()
130 ashish 3595 
    args.read(iprot)
3596 
    iprot.readMessageEnd()
559 chandransh 3597 
    result = addItemToCart_result()
130 ashish 3598 
    try:
2035 rajveer 3599 
      result.success = self._handler.addItemToCart(args.cartId, args.itemId, args.quantity)
559 chandransh 3600 
    except ShoppingCartException, scx:
3601 
      result.scx = scx
3602 
    oprot.writeMessageBegin("addItemToCart", TMessageType.REPLY, seqid)
130 ashish 3603 
    result.write(oprot)
3604 
    oprot.writeMessageEnd()
3605 
    oprot.trans.flush()
3606 
 
559 chandransh 3607 
  def process_deleteItemFromCart(self, seqid, iprot, oprot):
3608 
    args = deleteItemFromCart_args()
3609 
    args.read(iprot)
3610 
    iprot.readMessageEnd()
3611 
    result = deleteItemFromCart_result()
3612 
    try:
3613 
      self._handler.deleteItemFromCart(args.cartId, args.itemId)
3614 
    except ShoppingCartException, scx:
3615 
      result.scx = scx
3616 
    oprot.writeMessageBegin("deleteItemFromCart", TMessageType.REPLY, seqid)
3617 
    result.write(oprot)
3618 
    oprot.writeMessageEnd()
3619 
    oprot.trans.flush()
130 ashish 3620 
 
559 chandransh 3621 
  def process_changeQuantity(self, seqid, iprot, oprot):
3622 
    args = changeQuantity_args()
3623 
    args.read(iprot)
3624 
    iprot.readMessageEnd()
3625 
    result = changeQuantity_result()
3626 
    try:
3627 
      self._handler.changeQuantity(args.cartId, args.itemId, args.quantity)
3628 
    except ShoppingCartException, scx:
3629 
      result.scx = scx
3630 
    oprot.writeMessageBegin("changeQuantity", TMessageType.REPLY, seqid)
3631 
    result.write(oprot)
3632 
    oprot.writeMessageEnd()
3633 
    oprot.trans.flush()
3634 
 
3635 
  def process_changeItemStatus(self, seqid, iprot, oprot):
3636 
    args = changeItemStatus_args()
3637 
    args.read(iprot)
3638 
    iprot.readMessageEnd()
3639 
    result = changeItemStatus_result()
3640 
    try:
3641 
      self._handler.changeItemStatus(args.cartId, args.itemId, args.status)
3642 
    except ShoppingCartException, scx:
3643 
      result.scx = scx
3644 
    oprot.writeMessageBegin("changeItemStatus", TMessageType.REPLY, seqid)
3645 
    result.write(oprot)
3646 
    oprot.writeMessageEnd()
3647 
    oprot.trans.flush()
3648 
 
3649 
  def process_addAddressToCart(self, seqid, iprot, oprot):
3650 
    args = addAddressToCart_args()
3651 
    args.read(iprot)
3652 
    iprot.readMessageEnd()
3653 
    result = addAddressToCart_result()
575 chandransh 3654 
    try:
3655 
      self._handler.addAddressToCart(args.cartId, args.addressId)
3656 
    except ShoppingCartException, scx:
3657 
      result.scx = scx
559 chandransh 3658 
    oprot.writeMessageBegin("addAddressToCart", TMessageType.REPLY, seqid)
3659 
    result.write(oprot)
3660 
    oprot.writeMessageEnd()
3661 
    oprot.trans.flush()
3662 
 
1976 varun.gupt 3663 
  def process_applyCouponToCart(self, seqid, iprot, oprot):
3664 
    args = applyCouponToCart_args()
3665 
    args.read(iprot)
3666 
    iprot.readMessageEnd()
3667 
    result = applyCouponToCart_result()
3668 
    try:
3669 
      self._handler.applyCouponToCart(args.cartId, args.couponCode, args.totalPrice, args.discountedPrice)
3670 
    except ShoppingCartException, scx:
3671 
      result.scx = scx
3672 
    oprot.writeMessageBegin("applyCouponToCart", TMessageType.REPLY, seqid)
3673 
    result.write(oprot)
3674 
    oprot.writeMessageEnd()
3675 
    oprot.trans.flush()
3676 
 
3677 
  def process_removeCoupon(self, seqid, iprot, oprot):
3678 
    args = removeCoupon_args()
3679 
    args.read(iprot)
3680 
    iprot.readMessageEnd()
3681 
    result = removeCoupon_result()
3682 
    try:
3683 
      self._handler.removeCoupon(args.cartId)
3684 
    except ShoppingCartException, scx:
3685 
      result.scx = scx
3686 
    oprot.writeMessageBegin("removeCoupon", TMessageType.REPLY, seqid)
3687 
    result.write(oprot)
3688 
    oprot.writeMessageEnd()
3689 
    oprot.trans.flush()
3690 
 
690 chandransh 3691 
  def process_createOrders(self, seqid, iprot, oprot):
3692 
    args = createOrders_args()
559 chandransh 3693 
    args.read(iprot)
3694 
    iprot.readMessageEnd()
690 chandransh 3695 
    result = createOrders_result()
559 chandransh 3696 
    try:
2815 vikas 3697 
      result.success = self._handler.createOrders(args.cartId, args.sessionSource, args.sessionStartTime)
559 chandransh 3698 
    except ShoppingCartException, scx:
3699 
      result.scx = scx
690 chandransh 3700 
    oprot.writeMessageBegin("createOrders", TMessageType.REPLY, seqid)
559 chandransh 3701 
    result.write(oprot)
3702 
    oprot.writeMessageEnd()
3703 
    oprot.trans.flush()
3704 
 
3705 
  def process_validateCart(self, seqid, iprot, oprot):
3706 
    args = validateCart_args()
3707 
    args.read(iprot)
3708 
    iprot.readMessageEnd()
3709 
    result = validateCart_result()
575 chandransh 3710 
    try:
3711 
      result.success = self._handler.validateCart(args.cartId)
3712 
    except ShoppingCartException, scex:
3713 
      result.scex = scex
559 chandransh 3714 
    oprot.writeMessageBegin("validateCart", TMessageType.REPLY, seqid)
3715 
    result.write(oprot)
3716 
    oprot.writeMessageEnd()
3717 
    oprot.trans.flush()
3718 
 
690 chandransh 3719 
  def process_mergeCart(self, seqid, iprot, oprot):
3720 
    args = mergeCart_args()
575 chandransh 3721 
    args.read(iprot)
3722 
    iprot.readMessageEnd()
690 chandransh 3723 
    result = mergeCart_result()
3724 
    self._handler.mergeCart(args.fromCartId, args.toCartId)
3725 
    oprot.writeMessageBegin("mergeCart", TMessageType.REPLY, seqid)
3726 
    result.write(oprot)
3727 
    oprot.writeMessageEnd()
3728 
    oprot.trans.flush()
3729 
 
3730 
  def process_checkOut(self, seqid, iprot, oprot):
3731 
    args = checkOut_args()
3732 
    args.read(iprot)
3733 
    iprot.readMessageEnd()
3734 
    result = checkOut_result()
575 chandransh 3735 
    try:
690 chandransh 3736 
      result.success = self._handler.checkOut(args.cartId)
575 chandransh 3737 
    except ShoppingCartException, scex:
3738 
      result.scex = scex
690 chandransh 3739 
    oprot.writeMessageBegin("checkOut", TMessageType.REPLY, seqid)
575 chandransh 3740 
    result.write(oprot)
3741 
    oprot.writeMessageEnd()
3742 
    oprot.trans.flush()
3743 
 
690 chandransh 3744 
  def process_resetCart(self, seqid, iprot, oprot):
3745 
    args = resetCart_args()
559 chandransh 3746 
    args.read(iprot)
3747 
    iprot.readMessageEnd()
690 chandransh 3748 
    result = resetCart_result()
3749 
    try:
3750 
      result.success = self._handler.resetCart(args.cartId, args.items)
3751 
    except ShoppingCartException, scex:
3752 
      result.scex = scex
3753 
    oprot.writeMessageBegin("resetCart", TMessageType.REPLY, seqid)
559 chandransh 3754 
    result.write(oprot)
3755 
    oprot.writeMessageEnd()
3756 
    oprot.trans.flush()
3757 
 
3758 
  def process_getMyResearch(self, seqid, iprot, oprot):
3759 
    args = getMyResearch_args()
3760 
    args.read(iprot)
3761 
    iprot.readMessageEnd()
3762 
    result = getMyResearch_result()
3763 
    try:
772 rajveer 3764 
      result.success = self._handler.getMyResearch(args.userId)
559 chandransh 3765 
    except WidgetException, scx:
3766 
      result.scx = scx
3767 
    oprot.writeMessageBegin("getMyResearch", TMessageType.REPLY, seqid)
3768 
    result.write(oprot)
3769 
    oprot.writeMessageEnd()
3770 
    oprot.trans.flush()
3771 
 
3772 
  def process_updateMyResearch(self, seqid, iprot, oprot):
3773 
    args = updateMyResearch_args()
3774 
    args.read(iprot)
3775 
    iprot.readMessageEnd()
3776 
    result = updateMyResearch_result()
3777 
    try:
772 rajveer 3778 
      result.success = self._handler.updateMyResearch(args.userId, args.itemId)
559 chandransh 3779 
    except WidgetException, scx:
3780 
      result.scx = scx
3781 
    oprot.writeMessageBegin("updateMyResearch", TMessageType.REPLY, seqid)
3782 
    result.write(oprot)
3783 
    oprot.writeMessageEnd()
3784 
    oprot.trans.flush()
3785 
 
3786 
  def process_deleteItemFromMyResearch(self, seqid, iprot, oprot):
3787 
    args = deleteItemFromMyResearch_args()
3788 
    args.read(iprot)
3789 
    iprot.readMessageEnd()
3790 
    result = deleteItemFromMyResearch_result()
3791 
    try:
772 rajveer 3792 
      self._handler.deleteItemFromMyResearch(args.userId, args.itemId)
559 chandransh 3793 
    except WidgetException, scx:
3794 
      result.scx = scx
3795 
    oprot.writeMessageBegin("deleteItemFromMyResearch", TMessageType.REPLY, seqid)
3796 
    result.write(oprot)
3797 
    oprot.writeMessageEnd()
3798 
    oprot.trans.flush()
3799 
 
3800 
  def process_updateBrowseHistory(self, seqid, iprot, oprot):
3801 
    args = updateBrowseHistory_args()
3802 
    args.read(iprot)
3803 
    iprot.readMessageEnd()
3804 
    result = updateBrowseHistory_result()
772 rajveer 3805 
    self._handler.updateBrowseHistory(args.userId, args.itemId)
559 chandransh 3806 
    oprot.writeMessageBegin("updateBrowseHistory", TMessageType.REPLY, seqid)
3807 
    result.write(oprot)
3808 
    oprot.writeMessageEnd()
3809 
    oprot.trans.flush()
3810 
 
3811 
  def process_getBrowseHistory(self, seqid, iprot, oprot):
3812 
    args = getBrowseHistory_args()
3813 
    args.read(iprot)
3814 
    iprot.readMessageEnd()
3815 
    result = getBrowseHistory_result()
3816 
    try:
772 rajveer 3817 
      result.success = self._handler.getBrowseHistory(args.userId)
559 chandransh 3818 
    except WidgetException, scx:
3819 
      result.scx = scx
3820 
    oprot.writeMessageBegin("getBrowseHistory", TMessageType.REPLY, seqid)
3821 
    result.write(oprot)
3822 
    oprot.writeMessageEnd()
3823 
    oprot.trans.flush()
3824 
 
772 rajveer 3825 
  def process_mergeBrowseHistory(self, seqid, iprot, oprot):
3826 
    args = mergeBrowseHistory_args()
3827 
    args.read(iprot)
3828 
    iprot.readMessageEnd()
3829 
    result = mergeBrowseHistory_result()
3830 
    self._handler.mergeBrowseHistory(args.fromUserId, args.toUserId)
3831 
    oprot.writeMessageBegin("mergeBrowseHistory", TMessageType.REPLY, seqid)
3832 
    result.write(oprot)
3833 
    oprot.writeMessageEnd()
3834 
    oprot.trans.flush()
559 chandransh 3835 
 
1596 ankur.sing 3836 
  def process_getUserCount(self, seqid, iprot, oprot):
3837 
    args = getUserCount_args()
3838 
    args.read(iprot)
3839 
    iprot.readMessageEnd()
3840 
    result = getUserCount_result()
3841 
    result.success = self._handler.getUserCount(args.userType)
3842 
    oprot.writeMessageBegin("getUserCount", TMessageType.REPLY, seqid)
3843 
    result.write(oprot)
3844 
    oprot.writeMessageEnd()
3845 
    oprot.trans.flush()
772 rajveer 3846 
 
1673 ankur.sing 3847 
  def process_getAllUsers(self, seqid, iprot, oprot):
3848 
    args = getAllUsers_args()
3849 
    args.read(iprot)
3850 
    iprot.readMessageEnd()
3851 
    result = getAllUsers_result()
1891 ankur.sing 3852 
    result.success = self._handler.getAllUsers(args.userType, args.startDate, args.endDate)
1673 ankur.sing 3853 
    oprot.writeMessageBegin("getAllUsers", TMessageType.REPLY, seqid)
3854 
    result.write(oprot)
3855 
    oprot.writeMessageEnd()
3856 
    oprot.trans.flush()
1596 ankur.sing 3857 
 
2642 varun.gupt 3858 
  def process_putUserNote(self, seqid, iprot, oprot):
3859 
    args = putUserNote_args()
3860 
    args.read(iprot)
3861 
    iprot.readMessageEnd()
3862 
    result = putUserNote_result()
2717 varun.gupt 3863 
    self._handler.putUserNote(args.user_id, args.entity_id, args.slide, args.note)
2642 varun.gupt 3864 
    oprot.writeMessageBegin("putUserNote", TMessageType.REPLY, seqid)
3865 
    result.write(oprot)
3866 
    oprot.writeMessageEnd()
3867 
    oprot.trans.flush()
1673 ankur.sing 3868 
 
2642 varun.gupt 3869 
  def process_getUserNotes(self, seqid, iprot, oprot):
3870 
    args = getUserNotes_args()
3871 
    args.read(iprot)
3872 
    iprot.readMessageEnd()
3873 
    result = getUserNotes_result()
3874 
    result.success = self._handler.getUserNotes(args.user_id, args.entity_id)
3875 
    oprot.writeMessageBegin("getUserNotes", TMessageType.REPLY, seqid)
3876 
    result.write(oprot)
3877 
    oprot.writeMessageEnd()
3878 
    oprot.trans.flush()
3879 
 
3880 
 
94 ashish 3881 
# HELPER FUNCTIONS AND STRUCTURES
3882 
 
765 rajveer 3883 
class closeSession_args:
3884 
 
3885 
  thrift_spec = (
3886 
  )
3887 
 
3888 
  def read(self, iprot):
3889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3891 
      return
3892 
    iprot.readStructBegin()
3893 
    while True:
3894 
      (fname, ftype, fid) = iprot.readFieldBegin()
3895 
      if ftype == TType.STOP:
3896 
        break
3897 
      else:
3898 
        iprot.skip(ftype)
3899 
      iprot.readFieldEnd()
3900 
    iprot.readStructEnd()
3901 
 
3902 
  def write(self, oprot):
3903 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3904 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3905 
      return
3906 
    oprot.writeStructBegin('closeSession_args')
3907 
    oprot.writeFieldStop()
3908 
    oprot.writeStructEnd()
3909 
 
3910 
  def __repr__(self):
3911 
    L = ['%s=%r' % (key, value)
3912 
      for key, value in self.__dict__.iteritems()]
3913 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3914 
 
3915 
  def __eq__(self, other):
3916 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3917 
 
3918 
  def __ne__(self, other):
3919 
    return not (self == other)
3920 
 
3921 
class closeSession_result:
3922 
 
3923 
  thrift_spec = (
3924 
  )
3925 
 
3926 
  def read(self, iprot):
3927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3929 
      return
3930 
    iprot.readStructBegin()
3931 
    while True:
3932 
      (fname, ftype, fid) = iprot.readFieldBegin()
3933 
      if ftype == TType.STOP:
3934 
        break
3935 
      else:
3936 
        iprot.skip(ftype)
3937 
      iprot.readFieldEnd()
3938 
    iprot.readStructEnd()
3939 
 
3940 
  def write(self, oprot):
3941 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3942 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3943 
      return
3944 
    oprot.writeStructBegin('closeSession_result')
3945 
    oprot.writeFieldStop()
3946 
    oprot.writeStructEnd()
3947 
 
3948 
  def __repr__(self):
3949 
    L = ['%s=%r' % (key, value)
3950 
      for key, value in self.__dict__.iteritems()]
3951 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
3952 
 
3953 
  def __eq__(self, other):
3954 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
3955 
 
3956 
  def __ne__(self, other):
3957 
    return not (self == other)
3958 
 
559 chandransh 3959 
class createAnonymousUser_args:
94 ashish 3960 
  """
3961 
  Attributes:
559 chandransh 3962 
   - jsessionId
94 ashish 3963 
  """
3964 
 
3965 
  thrift_spec = (
3966 
    None, # 0
559 chandransh 3967 
    (1, TType.STRING, 'jsessionId', None, None, ), # 1
94 ashish 3968 
  )
3969 
 
559 chandransh 3970 
  def __init__(self, jsessionId=None,):
3971 
    self.jsessionId = jsessionId
94 ashish 3972 
 
3973 
  def read(self, iprot):
3974 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
3975 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
3976 
      return
3977 
    iprot.readStructBegin()
3978 
    while True:
3979 
      (fname, ftype, fid) = iprot.readFieldBegin()
3980 
      if ftype == TType.STOP:
3981 
        break
3982 
      if fid == 1:
559 chandransh 3983 
        if ftype == TType.STRING:
3984 
          self.jsessionId = iprot.readString();
94 ashish 3985 
        else:
3986 
          iprot.skip(ftype)
3987 
      else:
3988 
        iprot.skip(ftype)
3989 
      iprot.readFieldEnd()
3990 
    iprot.readStructEnd()
3991 
 
3992 
  def write(self, oprot):
3993 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
3994 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
3995 
      return
559 chandransh 3996 
    oprot.writeStructBegin('createAnonymousUser_args')
3997 
    if self.jsessionId != None:
3998 
      oprot.writeFieldBegin('jsessionId', TType.STRING, 1)
3999 
      oprot.writeString(self.jsessionId)
94 ashish 4000 
      oprot.writeFieldEnd()
4001 
    oprot.writeFieldStop()
4002 
    oprot.writeStructEnd()
4003 
 
4004 
  def __repr__(self):
4005 
    L = ['%s=%r' % (key, value)
4006 
      for key, value in self.__dict__.iteritems()]
4007 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4008 
 
4009 
  def __eq__(self, other):
4010 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4011 
 
4012 
  def __ne__(self, other):
4013 
    return not (self == other)
4014 
 
559 chandransh 4015 
class createAnonymousUser_result:
94 ashish 4016 
  """
4017 
  Attributes:
4018 
   - success
559 chandransh 4019 
   - ucex
94 ashish 4020 
  """
4021 
 
4022 
  thrift_spec = (
559 chandransh 4023 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4024 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4025 
  )
4026 
 
559 chandransh 4027 
  def __init__(self, success=None, ucex=None,):
94 ashish 4028 
    self.success = success
559 chandransh 4029 
    self.ucex = ucex
94 ashish 4030 
 
4031 
  def read(self, iprot):
4032 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4033 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4034 
      return
4035 
    iprot.readStructBegin()
4036 
    while True:
4037 
      (fname, ftype, fid) = iprot.readFieldBegin()
4038 
      if ftype == TType.STOP:
4039 
        break
4040 
      if fid == 0:
4041 
        if ftype == TType.STRUCT:
559 chandransh 4042 
          self.success = User()
94 ashish 4043 
          self.success.read(iprot)
4044 
        else:
4045 
          iprot.skip(ftype)
4046 
      elif fid == 1:
4047 
        if ftype == TType.STRUCT:
559 chandransh 4048 
          self.ucex = UserContextException()
4049 
          self.ucex.read(iprot)
94 ashish 4050 
        else:
4051 
          iprot.skip(ftype)
4052 
      else:
4053 
        iprot.skip(ftype)
4054 
      iprot.readFieldEnd()
4055 
    iprot.readStructEnd()
4056 
 
4057 
  def write(self, oprot):
4058 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4059 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4060 
      return
559 chandransh 4061 
    oprot.writeStructBegin('createAnonymousUser_result')
94 ashish 4062 
    if self.success != None:
4063 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4064 
      self.success.write(oprot)
4065 
      oprot.writeFieldEnd()
559 chandransh 4066 
    if self.ucex != None:
4067 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4068 
      self.ucex.write(oprot)
94 ashish 4069 
      oprot.writeFieldEnd()
4070 
    oprot.writeFieldStop()
4071 
    oprot.writeStructEnd()
4072 
 
4073 
  def __repr__(self):
4074 
    L = ['%s=%r' % (key, value)
4075 
      for key, value in self.__dict__.iteritems()]
4076 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4077 
 
4078 
  def __eq__(self, other):
4079 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4080 
 
4081 
  def __ne__(self, other):
4082 
    return not (self == other)
4083 
 
559 chandransh 4084 
class getUserById_args:
94 ashish 4085 
  """
4086 
  Attributes:
4087 
   - userId
4088 
  """
4089 
 
4090 
  thrift_spec = (
4091 
    None, # 0
4092 
    (1, TType.I64, 'userId', None, None, ), # 1
4093 
  )
4094 
 
559 chandransh 4095 
  def __init__(self, userId=None,):
94 ashish 4096 
    self.userId = userId
4097 
 
4098 
  def read(self, iprot):
4099 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4100 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4101 
      return
4102 
    iprot.readStructBegin()
4103 
    while True:
4104 
      (fname, ftype, fid) = iprot.readFieldBegin()
4105 
      if ftype == TType.STOP:
4106 
        break
4107 
      if fid == 1:
4108 
        if ftype == TType.I64:
4109 
          self.userId = iprot.readI64();
4110 
        else:
4111 
          iprot.skip(ftype)
4112 
      else:
4113 
        iprot.skip(ftype)
4114 
      iprot.readFieldEnd()
4115 
    iprot.readStructEnd()
4116 
 
4117 
  def write(self, oprot):
4118 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4119 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4120 
      return
559 chandransh 4121 
    oprot.writeStructBegin('getUserById_args')
94 ashish 4122 
    if self.userId != None:
4123 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4124 
      oprot.writeI64(self.userId)
4125 
      oprot.writeFieldEnd()
4126 
    oprot.writeFieldStop()
4127 
    oprot.writeStructEnd()
4128 
 
4129 
  def __repr__(self):
4130 
    L = ['%s=%r' % (key, value)
4131 
      for key, value in self.__dict__.iteritems()]
4132 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4133 
 
4134 
  def __eq__(self, other):
4135 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4136 
 
4137 
  def __ne__(self, other):
4138 
    return not (self == other)
4139 
 
559 chandransh 4140 
class getUserById_result:
94 ashish 4141 
  """
4142 
  Attributes:
4143 
   - success
559 chandransh 4144 
   - ucex
94 ashish 4145 
  """
4146 
 
4147 
  thrift_spec = (
559 chandransh 4148 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4149 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4150 
  )
4151 
 
559 chandransh 4152 
  def __init__(self, success=None, ucex=None,):
94 ashish 4153 
    self.success = success
559 chandransh 4154 
    self.ucex = ucex
94 ashish 4155 
 
4156 
  def read(self, iprot):
4157 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4158 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4159 
      return
4160 
    iprot.readStructBegin()
4161 
    while True:
4162 
      (fname, ftype, fid) = iprot.readFieldBegin()
4163 
      if ftype == TType.STOP:
4164 
        break
4165 
      if fid == 0:
4166 
        if ftype == TType.STRUCT:
559 chandransh 4167 
          self.success = User()
94 ashish 4168 
          self.success.read(iprot)
4169 
        else:
4170 
          iprot.skip(ftype)
4171 
      elif fid == 1:
4172 
        if ftype == TType.STRUCT:
559 chandransh 4173 
          self.ucex = UserContextException()
4174 
          self.ucex.read(iprot)
94 ashish 4175 
        else:
4176 
          iprot.skip(ftype)
4177 
      else:
4178 
        iprot.skip(ftype)
4179 
      iprot.readFieldEnd()
4180 
    iprot.readStructEnd()
4181 
 
4182 
  def write(self, oprot):
4183 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4184 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4185 
      return
559 chandransh 4186 
    oprot.writeStructBegin('getUserById_result')
94 ashish 4187 
    if self.success != None:
4188 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4189 
      self.success.write(oprot)
4190 
      oprot.writeFieldEnd()
559 chandransh 4191 
    if self.ucex != None:
4192 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4193 
      self.ucex.write(oprot)
94 ashish 4194 
      oprot.writeFieldEnd()
4195 
    oprot.writeFieldStop()
4196 
    oprot.writeStructEnd()
4197 
 
4198 
  def __repr__(self):
4199 
    L = ['%s=%r' % (key, value)
4200 
      for key, value in self.__dict__.iteritems()]
4201 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4202 
 
4203 
  def __eq__(self, other):
4204 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4205 
 
4206 
  def __ne__(self, other):
4207 
    return not (self == other)
4208 
 
1491 vikas 4209 
class getUserByEmail_args:
4210 
  """
4211 
  Attributes:
4212 
   - email
4213 
  """
4214 
 
4215 
  thrift_spec = (
4216 
    None, # 0
4217 
    (1, TType.STRING, 'email', None, None, ), # 1
4218 
  )
4219 
 
4220 
  def __init__(self, email=None,):
4221 
    self.email = email
4222 
 
4223 
  def read(self, iprot):
4224 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4225 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4226 
      return
4227 
    iprot.readStructBegin()
4228 
    while True:
4229 
      (fname, ftype, fid) = iprot.readFieldBegin()
4230 
      if ftype == TType.STOP:
4231 
        break
4232 
      if fid == 1:
4233 
        if ftype == TType.STRING:
4234 
          self.email = iprot.readString();
4235 
        else:
4236 
          iprot.skip(ftype)
4237 
      else:
4238 
        iprot.skip(ftype)
4239 
      iprot.readFieldEnd()
4240 
    iprot.readStructEnd()
4241 
 
4242 
  def write(self, oprot):
4243 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4244 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4245 
      return
4246 
    oprot.writeStructBegin('getUserByEmail_args')
4247 
    if self.email != None:
4248 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4249 
      oprot.writeString(self.email)
4250 
      oprot.writeFieldEnd()
4251 
    oprot.writeFieldStop()
4252 
    oprot.writeStructEnd()
4253 
 
4254 
  def __repr__(self):
4255 
    L = ['%s=%r' % (key, value)
4256 
      for key, value in self.__dict__.iteritems()]
4257 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4258 
 
4259 
  def __eq__(self, other):
4260 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4261 
 
4262 
  def __ne__(self, other):
4263 
    return not (self == other)
4264 
 
4265 
class getUserByEmail_result:
4266 
  """
4267 
  Attributes:
4268 
   - success
4269 
   - ucex
4270 
  """
4271 
 
4272 
  thrift_spec = (
4273 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4274 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
4275 
  )
4276 
 
4277 
  def __init__(self, success=None, ucex=None,):
4278 
    self.success = success
4279 
    self.ucex = ucex
4280 
 
4281 
  def read(self, iprot):
4282 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4283 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4284 
      return
4285 
    iprot.readStructBegin()
4286 
    while True:
4287 
      (fname, ftype, fid) = iprot.readFieldBegin()
4288 
      if ftype == TType.STOP:
4289 
        break
4290 
      if fid == 0:
4291 
        if ftype == TType.STRUCT:
4292 
          self.success = User()
4293 
          self.success.read(iprot)
4294 
        else:
4295 
          iprot.skip(ftype)
4296 
      elif fid == 1:
4297 
        if ftype == TType.STRUCT:
4298 
          self.ucex = UserContextException()
4299 
          self.ucex.read(iprot)
4300 
        else:
4301 
          iprot.skip(ftype)
4302 
      else:
4303 
        iprot.skip(ftype)
4304 
      iprot.readFieldEnd()
4305 
    iprot.readStructEnd()
4306 
 
4307 
  def write(self, oprot):
4308 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4309 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4310 
      return
4311 
    oprot.writeStructBegin('getUserByEmail_result')
4312 
    if self.success != None:
4313 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4314 
      self.success.write(oprot)
4315 
      oprot.writeFieldEnd()
4316 
    if self.ucex != None:
4317 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4318 
      self.ucex.write(oprot)
4319 
      oprot.writeFieldEnd()
4320 
    oprot.writeFieldStop()
4321 
    oprot.writeStructEnd()
4322 
 
4323 
  def __repr__(self):
4324 
    L = ['%s=%r' % (key, value)
4325 
      for key, value in self.__dict__.iteritems()]
4326 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4327 
 
4328 
  def __eq__(self, other):
4329 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4330 
 
4331 
  def __ne__(self, other):
4332 
    return not (self == other)
4333 
 
559 chandransh 4334 
class createUser_args:
94 ashish 4335 
  """
4336 
  Attributes:
559 chandransh 4337 
   - user
94 ashish 4338 
  """
4339 
 
4340 
  thrift_spec = (
4341 
    None, # 0
559 chandransh 4342 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4343 
  )
4344 
 
559 chandransh 4345 
  def __init__(self, user=None,):
4346 
    self.user = user
94 ashish 4347 
 
4348 
  def read(self, iprot):
4349 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4350 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4351 
      return
4352 
    iprot.readStructBegin()
4353 
    while True:
4354 
      (fname, ftype, fid) = iprot.readFieldBegin()
4355 
      if ftype == TType.STOP:
4356 
        break
4357 
      if fid == 1:
559 chandransh 4358 
        if ftype == TType.STRUCT:
4359 
          self.user = User()
4360 
          self.user.read(iprot)
94 ashish 4361 
        else:
4362 
          iprot.skip(ftype)
4363 
      else:
4364 
        iprot.skip(ftype)
4365 
      iprot.readFieldEnd()
4366 
    iprot.readStructEnd()
4367 
 
4368 
  def write(self, oprot):
4369 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4370 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4371 
      return
559 chandransh 4372 
    oprot.writeStructBegin('createUser_args')
4373 
    if self.user != None:
4374 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4375 
      self.user.write(oprot)
94 ashish 4376 
      oprot.writeFieldEnd()
4377 
    oprot.writeFieldStop()
4378 
    oprot.writeStructEnd()
4379 
 
4380 
  def __repr__(self):
4381 
    L = ['%s=%r' % (key, value)
4382 
      for key, value in self.__dict__.iteritems()]
4383 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4384 
 
4385 
  def __eq__(self, other):
4386 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4387 
 
4388 
  def __ne__(self, other):
4389 
    return not (self == other)
4390 
 
559 chandransh 4391 
class createUser_result:
94 ashish 4392 
  """
4393 
  Attributes:
4394 
   - success
559 chandransh 4395 
   - ucex
94 ashish 4396 
  """
4397 
 
4398 
  thrift_spec = (
559 chandransh 4399 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4400 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4401 
  )
4402 
 
559 chandransh 4403 
  def __init__(self, success=None, ucex=None,):
94 ashish 4404 
    self.success = success
559 chandransh 4405 
    self.ucex = ucex
94 ashish 4406 
 
4407 
  def read(self, iprot):
4408 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4409 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4410 
      return
4411 
    iprot.readStructBegin()
4412 
    while True:
4413 
      (fname, ftype, fid) = iprot.readFieldBegin()
4414 
      if ftype == TType.STOP:
4415 
        break
4416 
      if fid == 0:
4417 
        if ftype == TType.STRUCT:
559 chandransh 4418 
          self.success = User()
94 ashish 4419 
          self.success.read(iprot)
4420 
        else:
4421 
          iprot.skip(ftype)
4422 
      elif fid == 1:
4423 
        if ftype == TType.STRUCT:
559 chandransh 4424 
          self.ucex = UserContextException()
4425 
          self.ucex.read(iprot)
94 ashish 4426 
        else:
4427 
          iprot.skip(ftype)
4428 
      else:
4429 
        iprot.skip(ftype)
4430 
      iprot.readFieldEnd()
4431 
    iprot.readStructEnd()
4432 
 
4433 
  def write(self, oprot):
4434 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4435 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4436 
      return
559 chandransh 4437 
    oprot.writeStructBegin('createUser_result')
94 ashish 4438 
    if self.success != None:
4439 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4440 
      self.success.write(oprot)
4441 
      oprot.writeFieldEnd()
559 chandransh 4442 
    if self.ucex != None:
4443 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4444 
      self.ucex.write(oprot)
94 ashish 4445 
      oprot.writeFieldEnd()
4446 
    oprot.writeFieldStop()
4447 
    oprot.writeStructEnd()
4448 
 
4449 
  def __repr__(self):
4450 
    L = ['%s=%r' % (key, value)
4451 
      for key, value in self.__dict__.iteritems()]
4452 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4453 
 
4454 
  def __eq__(self, other):
4455 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4456 
 
4457 
  def __ne__(self, other):
4458 
    return not (self == other)
4459 
 
559 chandransh 4460 
class updateUser_args:
94 ashish 4461 
  """
4462 
  Attributes:
559 chandransh 4463 
   - user
94 ashish 4464 
  """
4465 
 
4466 
  thrift_spec = (
4467 
    None, # 0
559 chandransh 4468 
    (1, TType.STRUCT, 'user', (User, User.thrift_spec), None, ), # 1
94 ashish 4469 
  )
4470 
 
559 chandransh 4471 
  def __init__(self, user=None,):
4472 
    self.user = user
94 ashish 4473 
 
4474 
  def read(self, iprot):
4475 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4476 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4477 
      return
4478 
    iprot.readStructBegin()
4479 
    while True:
4480 
      (fname, ftype, fid) = iprot.readFieldBegin()
4481 
      if ftype == TType.STOP:
4482 
        break
4483 
      if fid == 1:
559 chandransh 4484 
        if ftype == TType.STRUCT:
4485 
          self.user = User()
4486 
          self.user.read(iprot)
94 ashish 4487 
        else:
4488 
          iprot.skip(ftype)
4489 
      else:
4490 
        iprot.skip(ftype)
4491 
      iprot.readFieldEnd()
4492 
    iprot.readStructEnd()
4493 
 
4494 
  def write(self, oprot):
4495 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4496 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4497 
      return
559 chandransh 4498 
    oprot.writeStructBegin('updateUser_args')
4499 
    if self.user != None:
4500 
      oprot.writeFieldBegin('user', TType.STRUCT, 1)
4501 
      self.user.write(oprot)
94 ashish 4502 
      oprot.writeFieldEnd()
4503 
    oprot.writeFieldStop()
4504 
    oprot.writeStructEnd()
4505 
 
4506 
  def __repr__(self):
4507 
    L = ['%s=%r' % (key, value)
4508 
      for key, value in self.__dict__.iteritems()]
4509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4510 
 
4511 
  def __eq__(self, other):
4512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4513 
 
4514 
  def __ne__(self, other):
4515 
    return not (self == other)
4516 
 
559 chandransh 4517 
class updateUser_result:
94 ashish 4518 
  """
4519 
  Attributes:
4520 
   - success
559 chandransh 4521 
   - ucex
94 ashish 4522 
  """
4523 
 
4524 
  thrift_spec = (
559 chandransh 4525 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4526 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4527 
  )
4528 
 
559 chandransh 4529 
  def __init__(self, success=None, ucex=None,):
94 ashish 4530 
    self.success = success
559 chandransh 4531 
    self.ucex = ucex
94 ashish 4532 
 
4533 
  def read(self, iprot):
4534 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4535 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4536 
      return
4537 
    iprot.readStructBegin()
4538 
    while True:
4539 
      (fname, ftype, fid) = iprot.readFieldBegin()
4540 
      if ftype == TType.STOP:
4541 
        break
4542 
      if fid == 0:
4543 
        if ftype == TType.STRUCT:
559 chandransh 4544 
          self.success = User()
94 ashish 4545 
          self.success.read(iprot)
4546 
        else:
4547 
          iprot.skip(ftype)
4548 
      elif fid == 1:
4549 
        if ftype == TType.STRUCT:
559 chandransh 4550 
          self.ucex = UserContextException()
4551 
          self.ucex.read(iprot)
94 ashish 4552 
        else:
4553 
          iprot.skip(ftype)
4554 
      else:
4555 
        iprot.skip(ftype)
4556 
      iprot.readFieldEnd()
4557 
    iprot.readStructEnd()
4558 
 
4559 
  def write(self, oprot):
4560 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4561 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4562 
      return
559 chandransh 4563 
    oprot.writeStructBegin('updateUser_result')
94 ashish 4564 
    if self.success != None:
4565 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4566 
      self.success.write(oprot)
4567 
      oprot.writeFieldEnd()
559 chandransh 4568 
    if self.ucex != None:
4569 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4570 
      self.ucex.write(oprot)
94 ashish 4571 
      oprot.writeFieldEnd()
4572 
    oprot.writeFieldStop()
4573 
    oprot.writeStructEnd()
4574 
 
4575 
  def __repr__(self):
4576 
    L = ['%s=%r' % (key, value)
4577 
      for key, value in self.__dict__.iteritems()]
4578 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4579 
 
4580 
  def __eq__(self, other):
4581 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4582 
 
4583 
  def __ne__(self, other):
4584 
    return not (self == other)
4585 
 
559 chandransh 4586 
class deleteUser_args:
94 ashish 4587 
  """
4588 
  Attributes:
4589 
   - userId
4590 
  """
4591 
 
4592 
  thrift_spec = (
4593 
    None, # 0
4594 
    (1, TType.I64, 'userId', None, None, ), # 1
4595 
  )
4596 
 
559 chandransh 4597 
  def __init__(self, userId=None,):
94 ashish 4598 
    self.userId = userId
4599 
 
4600 
  def read(self, iprot):
4601 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4602 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4603 
      return
4604 
    iprot.readStructBegin()
4605 
    while True:
4606 
      (fname, ftype, fid) = iprot.readFieldBegin()
4607 
      if ftype == TType.STOP:
4608 
        break
4609 
      if fid == 1:
4610 
        if ftype == TType.I64:
4611 
          self.userId = iprot.readI64();
4612 
        else:
4613 
          iprot.skip(ftype)
4614 
      else:
4615 
        iprot.skip(ftype)
4616 
      iprot.readFieldEnd()
4617 
    iprot.readStructEnd()
4618 
 
4619 
  def write(self, oprot):
4620 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4621 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4622 
      return
559 chandransh 4623 
    oprot.writeStructBegin('deleteUser_args')
94 ashish 4624 
    if self.userId != None:
4625 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4626 
      oprot.writeI64(self.userId)
4627 
      oprot.writeFieldEnd()
4628 
    oprot.writeFieldStop()
4629 
    oprot.writeStructEnd()
4630 
 
4631 
  def __repr__(self):
4632 
    L = ['%s=%r' % (key, value)
4633 
      for key, value in self.__dict__.iteritems()]
4634 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4635 
 
4636 
  def __eq__(self, other):
4637 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4638 
 
4639 
  def __ne__(self, other):
4640 
    return not (self == other)
4641 
 
559 chandransh 4642 
class deleteUser_result:
94 ashish 4643 
  """
4644 
  Attributes:
4645 
   - success
559 chandransh 4646 
   - ucex
94 ashish 4647 
  """
4648 
 
4649 
  thrift_spec = (
559 chandransh 4650 
    (0, TType.BOOL, 'success', None, None, ), # 0
4651 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4652 
  )
4653 
 
559 chandransh 4654 
  def __init__(self, success=None, ucex=None,):
94 ashish 4655 
    self.success = success
559 chandransh 4656 
    self.ucex = ucex
94 ashish 4657 
 
4658 
  def read(self, iprot):
4659 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4660 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4661 
      return
4662 
    iprot.readStructBegin()
4663 
    while True:
4664 
      (fname, ftype, fid) = iprot.readFieldBegin()
4665 
      if ftype == TType.STOP:
4666 
        break
4667 
      if fid == 0:
559 chandransh 4668 
        if ftype == TType.BOOL:
4669 
          self.success = iprot.readBool();
94 ashish 4670 
        else:
4671 
          iprot.skip(ftype)
4672 
      elif fid == 1:
4673 
        if ftype == TType.STRUCT:
559 chandransh 4674 
          self.ucex = UserContextException()
4675 
          self.ucex.read(iprot)
94 ashish 4676 
        else:
4677 
          iprot.skip(ftype)
4678 
      else:
4679 
        iprot.skip(ftype)
4680 
      iprot.readFieldEnd()
4681 
    iprot.readStructEnd()
4682 
 
4683 
  def write(self, oprot):
4684 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4685 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4686 
      return
559 chandransh 4687 
    oprot.writeStructBegin('deleteUser_result')
94 ashish 4688 
    if self.success != None:
559 chandransh 4689 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
4690 
      oprot.writeBool(self.success)
94 ashish 4691 
      oprot.writeFieldEnd()
559 chandransh 4692 
    if self.ucex != None:
4693 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4694 
      self.ucex.write(oprot)
94 ashish 4695 
      oprot.writeFieldEnd()
4696 
    oprot.writeFieldStop()
4697 
    oprot.writeStructEnd()
4698 
 
4699 
  def __repr__(self):
4700 
    L = ['%s=%r' % (key, value)
4701 
      for key, value in self.__dict__.iteritems()]
4702 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4703 
 
4704 
  def __eq__(self, other):
4705 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4706 
 
4707 
  def __ne__(self, other):
4708 
    return not (self == other)
4709 
 
559 chandransh 4710 
class getUserState_args:
94 ashish 4711 
  """
4712 
  Attributes:
4713 
   - userId
4714 
  """
4715 
 
4716 
  thrift_spec = (
4717 
    None, # 0
4718 
    (1, TType.I64, 'userId', None, None, ), # 1
4719 
  )
4720 
 
559 chandransh 4721 
  def __init__(self, userId=None,):
94 ashish 4722 
    self.userId = userId
4723 
 
4724 
  def read(self, iprot):
4725 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4726 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4727 
      return
4728 
    iprot.readStructBegin()
4729 
    while True:
4730 
      (fname, ftype, fid) = iprot.readFieldBegin()
4731 
      if ftype == TType.STOP:
4732 
        break
4733 
      if fid == 1:
4734 
        if ftype == TType.I64:
4735 
          self.userId = iprot.readI64();
4736 
        else:
4737 
          iprot.skip(ftype)
4738 
      else:
4739 
        iprot.skip(ftype)
4740 
      iprot.readFieldEnd()
4741 
    iprot.readStructEnd()
4742 
 
4743 
  def write(self, oprot):
4744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4746 
      return
559 chandransh 4747 
    oprot.writeStructBegin('getUserState_args')
94 ashish 4748 
    if self.userId != None:
4749 
      oprot.writeFieldBegin('userId', TType.I64, 1)
4750 
      oprot.writeI64(self.userId)
4751 
      oprot.writeFieldEnd()
4752 
    oprot.writeFieldStop()
4753 
    oprot.writeStructEnd()
4754 
 
4755 
  def __repr__(self):
4756 
    L = ['%s=%r' % (key, value)
4757 
      for key, value in self.__dict__.iteritems()]
4758 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4759 
 
4760 
  def __eq__(self, other):
4761 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4762 
 
4763 
  def __ne__(self, other):
4764 
    return not (self == other)
4765 
 
559 chandransh 4766 
class getUserState_result:
94 ashish 4767 
  """
4768 
  Attributes:
4769 
   - success
559 chandransh 4770 
   - ucex
94 ashish 4771 
  """
4772 
 
4773 
  thrift_spec = (
559 chandransh 4774 
    (0, TType.STRUCT, 'success', (UserState, UserState.thrift_spec), None, ), # 0
4775 
    (1, TType.STRUCT, 'ucex', (UserContextException, UserContextException.thrift_spec), None, ), # 1
94 ashish 4776 
  )
4777 
 
559 chandransh 4778 
  def __init__(self, success=None, ucex=None,):
94 ashish 4779 
    self.success = success
559 chandransh 4780 
    self.ucex = ucex
94 ashish 4781 
 
4782 
  def read(self, iprot):
4783 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4784 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4785 
      return
4786 
    iprot.readStructBegin()
4787 
    while True:
4788 
      (fname, ftype, fid) = iprot.readFieldBegin()
4789 
      if ftype == TType.STOP:
4790 
        break
4791 
      if fid == 0:
4792 
        if ftype == TType.STRUCT:
559 chandransh 4793 
          self.success = UserState()
94 ashish 4794 
          self.success.read(iprot)
4795 
        else:
4796 
          iprot.skip(ftype)
4797 
      elif fid == 1:
4798 
        if ftype == TType.STRUCT:
559 chandransh 4799 
          self.ucex = UserContextException()
4800 
          self.ucex.read(iprot)
94 ashish 4801 
        else:
4802 
          iprot.skip(ftype)
4803 
      else:
4804 
        iprot.skip(ftype)
4805 
      iprot.readFieldEnd()
4806 
    iprot.readStructEnd()
4807 
 
4808 
  def write(self, oprot):
4809 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4810 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4811 
      return
559 chandransh 4812 
    oprot.writeStructBegin('getUserState_result')
94 ashish 4813 
    if self.success != None:
4814 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4815 
      self.success.write(oprot)
4816 
      oprot.writeFieldEnd()
559 chandransh 4817 
    if self.ucex != None:
4818 
      oprot.writeFieldBegin('ucex', TType.STRUCT, 1)
4819 
      self.ucex.write(oprot)
94 ashish 4820 
      oprot.writeFieldEnd()
4821 
    oprot.writeFieldStop()
4822 
    oprot.writeStructEnd()
4823 
 
4824 
  def __repr__(self):
4825 
    L = ['%s=%r' % (key, value)
4826 
      for key, value in self.__dict__.iteritems()]
4827 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4828 
 
4829 
  def __eq__(self, other):
4830 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4831 
 
4832 
  def __ne__(self, other):
4833 
    return not (self == other)
4834 
 
559 chandransh 4835 
class authenticateUser_args:
94 ashish 4836 
  """
4837 
  Attributes:
4838 
   - email
4839 
   - password
4840 
  """
4841 
 
4842 
  thrift_spec = (
4843 
    None, # 0
4844 
    (1, TType.STRING, 'email', None, None, ), # 1
4845 
    (2, TType.STRING, 'password', None, None, ), # 2
4846 
  )
4847 
 
4848 
  def __init__(self, email=None, password=None,):
4849 
    self.email = email
4850 
    self.password = password
4851 
 
4852 
  def read(self, iprot):
4853 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4854 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4855 
      return
4856 
    iprot.readStructBegin()
4857 
    while True:
4858 
      (fname, ftype, fid) = iprot.readFieldBegin()
4859 
      if ftype == TType.STOP:
4860 
        break
4861 
      if fid == 1:
4862 
        if ftype == TType.STRING:
4863 
          self.email = iprot.readString();
4864 
        else:
4865 
          iprot.skip(ftype)
4866 
      elif fid == 2:
4867 
        if ftype == TType.STRING:
4868 
          self.password = iprot.readString();
4869 
        else:
4870 
          iprot.skip(ftype)
4871 
      else:
4872 
        iprot.skip(ftype)
4873 
      iprot.readFieldEnd()
4874 
    iprot.readStructEnd()
4875 
 
4876 
  def write(self, oprot):
4877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4879 
      return
559 chandransh 4880 
    oprot.writeStructBegin('authenticateUser_args')
94 ashish 4881 
    if self.email != None:
4882 
      oprot.writeFieldBegin('email', TType.STRING, 1)
4883 
      oprot.writeString(self.email)
4884 
      oprot.writeFieldEnd()
4885 
    if self.password != None:
4886 
      oprot.writeFieldBegin('password', TType.STRING, 2)
4887 
      oprot.writeString(self.password)
4888 
      oprot.writeFieldEnd()
4889 
    oprot.writeFieldStop()
4890 
    oprot.writeStructEnd()
4891 
 
4892 
  def __repr__(self):
4893 
    L = ['%s=%r' % (key, value)
4894 
      for key, value in self.__dict__.iteritems()]
4895 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4896 
 
4897 
  def __eq__(self, other):
4898 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4899 
 
4900 
  def __ne__(self, other):
4901 
    return not (self == other)
4902 
 
559 chandransh 4903 
class authenticateUser_result:
94 ashish 4904 
  """
4905 
  Attributes:
4906 
   - success
559 chandransh 4907 
   - auex
94 ashish 4908 
  """
4909 
 
4910 
  thrift_spec = (
559 chandransh 4911 
    (0, TType.STRUCT, 'success', (User, User.thrift_spec), None, ), # 0
4912 
    (1, TType.STRUCT, 'auex', (AuthenticationException, AuthenticationException.thrift_spec), None, ), # 1
94 ashish 4913 
  )
4914 
 
559 chandransh 4915 
  def __init__(self, success=None, auex=None,):
94 ashish 4916 
    self.success = success
559 chandransh 4917 
    self.auex = auex
94 ashish 4918 
 
4919 
  def read(self, iprot):
4920 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4921 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4922 
      return
4923 
    iprot.readStructBegin()
4924 
    while True:
4925 
      (fname, ftype, fid) = iprot.readFieldBegin()
4926 
      if ftype == TType.STOP:
4927 
        break
4928 
      if fid == 0:
4929 
        if ftype == TType.STRUCT:
559 chandransh 4930 
          self.success = User()
94 ashish 4931 
          self.success.read(iprot)
4932 
        else:
4933 
          iprot.skip(ftype)
4934 
      elif fid == 1:
4935 
        if ftype == TType.STRUCT:
559 chandransh 4936 
          self.auex = AuthenticationException()
4937 
          self.auex.read(iprot)
94 ashish 4938 
        else:
4939 
          iprot.skip(ftype)
4940 
      else:
4941 
        iprot.skip(ftype)
4942 
      iprot.readFieldEnd()
4943 
    iprot.readStructEnd()
4944 
 
4945 
  def write(self, oprot):
4946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
4947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
4948 
      return
559 chandransh 4949 
    oprot.writeStructBegin('authenticateUser_result')
94 ashish 4950 
    if self.success != None:
4951 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
4952 
      self.success.write(oprot)
4953 
      oprot.writeFieldEnd()
559 chandransh 4954 
    if self.auex != None:
4955 
      oprot.writeFieldBegin('auex', TType.STRUCT, 1)
4956 
      self.auex.write(oprot)
94 ashish 4957 
      oprot.writeFieldEnd()
4958 
    oprot.writeFieldStop()
4959 
    oprot.writeStructEnd()
4960 
 
4961 
  def __repr__(self):
4962 
    L = ['%s=%r' % (key, value)
4963 
      for key, value in self.__dict__.iteritems()]
4964 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
4965 
 
4966 
  def __eq__(self, other):
4967 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
4968 
 
4969 
  def __ne__(self, other):
4970 
    return not (self == other)
4971 
 
559 chandransh 4972 
class userExists_args:
122 ashish 4973 
  """
4974 
  Attributes:
559 chandransh 4975 
   - email
122 ashish 4976 
  """
4977 
 
4978 
  thrift_spec = (
4979 
    None, # 0
559 chandransh 4980 
    (1, TType.STRING, 'email', None, None, ), # 1
122 ashish 4981 
  )
4982 
 
559 chandransh 4983 
  def __init__(self, email=None,):
4984 
    self.email = email
122 ashish 4985 
 
4986 
  def read(self, iprot):
4987 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
4988 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
4989 
      return
4990 
    iprot.readStructBegin()
4991 
    while True:
4992 
      (fname, ftype, fid) = iprot.readFieldBegin()
4993 
      if ftype == TType.STOP:
4994 
        break
4995 
      if fid == 1:
4996 
        if ftype == TType.STRING:
559 chandransh 4997 
          self.email = iprot.readString();
122 ashish 4998 
        else:
4999 
          iprot.skip(ftype)
559 chandransh 5000 
      else:
5001 
        iprot.skip(ftype)
5002 
      iprot.readFieldEnd()
5003 
    iprot.readStructEnd()
5004 
 
5005 
  def write(self, oprot):
5006 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5007 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5008 
      return
5009 
    oprot.writeStructBegin('userExists_args')
5010 
    if self.email != None:
5011 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5012 
      oprot.writeString(self.email)
5013 
      oprot.writeFieldEnd()
5014 
    oprot.writeFieldStop()
5015 
    oprot.writeStructEnd()
5016 
 
5017 
  def __repr__(self):
5018 
    L = ['%s=%r' % (key, value)
5019 
      for key, value in self.__dict__.iteritems()]
5020 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5021 
 
5022 
  def __eq__(self, other):
5023 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5024 
 
5025 
  def __ne__(self, other):
5026 
    return not (self == other)
5027 
 
5028 
class userExists_result:
5029 
  """
5030 
  Attributes:
5031 
   - success
5032 
   - ucx
5033 
  """
5034 
 
5035 
  thrift_spec = (
5036 
    (0, TType.BOOL, 'success', None, None, ), # 0
5037 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5038 
  )
5039 
 
5040 
  def __init__(self, success=None, ucx=None,):
5041 
    self.success = success
5042 
    self.ucx = ucx
5043 
 
5044 
  def read(self, iprot):
5045 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5046 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5047 
      return
5048 
    iprot.readStructBegin()
5049 
    while True:
5050 
      (fname, ftype, fid) = iprot.readFieldBegin()
5051 
      if ftype == TType.STOP:
5052 
        break
5053 
      if fid == 0:
5054 
        if ftype == TType.BOOL:
5055 
          self.success = iprot.readBool();
5056 
        else:
5057 
          iprot.skip(ftype)
5058 
      elif fid == 1:
5059 
        if ftype == TType.STRUCT:
5060 
          self.ucx = UserContextException()
5061 
          self.ucx.read(iprot)
5062 
        else:
5063 
          iprot.skip(ftype)
5064 
      else:
5065 
        iprot.skip(ftype)
5066 
      iprot.readFieldEnd()
5067 
    iprot.readStructEnd()
5068 
 
5069 
  def write(self, oprot):
5070 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5071 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5072 
      return
5073 
    oprot.writeStructBegin('userExists_result')
5074 
    if self.success != None:
5075 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5076 
      oprot.writeBool(self.success)
5077 
      oprot.writeFieldEnd()
5078 
    if self.ucx != None:
5079 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5080 
      self.ucx.write(oprot)
5081 
      oprot.writeFieldEnd()
5082 
    oprot.writeFieldStop()
5083 
    oprot.writeStructEnd()
5084 
 
5085 
  def __repr__(self):
5086 
    L = ['%s=%r' % (key, value)
5087 
      for key, value in self.__dict__.iteritems()]
5088 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5089 
 
5090 
  def __eq__(self, other):
5091 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5092 
 
5093 
  def __ne__(self, other):
5094 
    return not (self == other)
5095 
 
5096 
class addAddressForUser_args:
5097 
  """
5098 
  Attributes:
5099 
   - userId
5100 
   - address
5101 
   - setDefault
5102 
  """
5103 
 
5104 
  thrift_spec = (
5105 
    None, # 0
5106 
    (1, TType.I64, 'userId', None, None, ), # 1
5107 
    (2, TType.STRUCT, 'address', (Address, Address.thrift_spec), None, ), # 2
567 rajveer 5108 
    (3, TType.BOOL, 'setDefault', None, None, ), # 3
559 chandransh 5109 
  )
5110 
 
567 rajveer 5111 
  def __init__(self, userId=None, address=None, setDefault=None,):
559 chandransh 5112 
    self.userId = userId
5113 
    self.address = address
5114 
    self.setDefault = setDefault
5115 
 
5116 
  def read(self, iprot):
5117 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5118 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5119 
      return
5120 
    iprot.readStructBegin()
5121 
    while True:
5122 
      (fname, ftype, fid) = iprot.readFieldBegin()
5123 
      if ftype == TType.STOP:
5124 
        break
5125 
      if fid == 1:
5126 
        if ftype == TType.I64:
5127 
          self.userId = iprot.readI64();
5128 
        else:
5129 
          iprot.skip(ftype)
122 ashish 5130 
      elif fid == 2:
559 chandransh 5131 
        if ftype == TType.STRUCT:
5132 
          self.address = Address()
5133 
          self.address.read(iprot)
122 ashish 5134 
        else:
5135 
          iprot.skip(ftype)
5136 
      elif fid == 3:
5137 
        if ftype == TType.BOOL:
559 chandransh 5138 
          self.setDefault = iprot.readBool();
122 ashish 5139 
        else:
5140 
          iprot.skip(ftype)
5141 
      else:
5142 
        iprot.skip(ftype)
5143 
      iprot.readFieldEnd()
5144 
    iprot.readStructEnd()
5145 
 
5146 
  def write(self, oprot):
5147 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5148 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5149 
      return
559 chandransh 5150 
    oprot.writeStructBegin('addAddressForUser_args')
5151 
    if self.userId != None:
5152 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5153 
      oprot.writeI64(self.userId)
122 ashish 5154 
      oprot.writeFieldEnd()
559 chandransh 5155 
    if self.address != None:
5156 
      oprot.writeFieldBegin('address', TType.STRUCT, 2)
5157 
      self.address.write(oprot)
122 ashish 5158 
      oprot.writeFieldEnd()
559 chandransh 5159 
    if self.setDefault != None:
567 rajveer 5160 
      oprot.writeFieldBegin('setDefault', TType.BOOL, 3)
559 chandransh 5161 
      oprot.writeBool(self.setDefault)
5162 
      oprot.writeFieldEnd()
122 ashish 5163 
    oprot.writeFieldStop()
5164 
    oprot.writeStructEnd()
5165 
 
5166 
  def __repr__(self):
5167 
    L = ['%s=%r' % (key, value)
5168 
      for key, value in self.__dict__.iteritems()]
5169 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5170 
 
5171 
  def __eq__(self, other):
5172 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5173 
 
5174 
  def __ne__(self, other):
5175 
    return not (self == other)
5176 
 
559 chandransh 5177 
class addAddressForUser_result:
122 ashish 5178 
  """
5179 
  Attributes:
5180 
   - success
559 chandransh 5181 
   - ucx
122 ashish 5182 
  """
5183 
 
5184 
  thrift_spec = (
567 rajveer 5185 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 5186 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
122 ashish 5187 
  )
5188 
 
559 chandransh 5189 
  def __init__(self, success=None, ucx=None,):
122 ashish 5190 
    self.success = success
559 chandransh 5191 
    self.ucx = ucx
122 ashish 5192 
 
5193 
  def read(self, iprot):
5194 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5195 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5196 
      return
5197 
    iprot.readStructBegin()
5198 
    while True:
5199 
      (fname, ftype, fid) = iprot.readFieldBegin()
5200 
      if ftype == TType.STOP:
5201 
        break
5202 
      if fid == 0:
567 rajveer 5203 
        if ftype == TType.I64:
5204 
          self.success = iprot.readI64();
122 ashish 5205 
        else:
5206 
          iprot.skip(ftype)
5207 
      elif fid == 1:
5208 
        if ftype == TType.STRUCT:
559 chandransh 5209 
          self.ucx = UserContextException()
5210 
          self.ucx.read(iprot)
122 ashish 5211 
        else:
5212 
          iprot.skip(ftype)
5213 
      else:
5214 
        iprot.skip(ftype)
5215 
      iprot.readFieldEnd()
5216 
    iprot.readStructEnd()
5217 
 
5218 
  def write(self, oprot):
5219 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5220 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5221 
      return
559 chandransh 5222 
    oprot.writeStructBegin('addAddressForUser_result')
122 ashish 5223 
    if self.success != None:
567 rajveer 5224 
      oprot.writeFieldBegin('success', TType.I64, 0)
5225 
      oprot.writeI64(self.success)
122 ashish 5226 
      oprot.writeFieldEnd()
559 chandransh 5227 
    if self.ucx != None:
5228 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5229 
      self.ucx.write(oprot)
122 ashish 5230 
      oprot.writeFieldEnd()
5231 
    oprot.writeFieldStop()
5232 
    oprot.writeStructEnd()
5233 
 
5234 
  def __repr__(self):
5235 
    L = ['%s=%r' % (key, value)
5236 
      for key, value in self.__dict__.iteritems()]
5237 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5238 
 
5239 
  def __eq__(self, other):
5240 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5241 
 
5242 
  def __ne__(self, other):
5243 
    return not (self == other)
5244 
 
559 chandransh 5245 
class removeAddressForUser_args:
94 ashish 5246 
  """
5247 
  Attributes:
559 chandransh 5248 
   - userid
5249 
   - addressId
94 ashish 5250 
  """
5251 
 
5252 
  thrift_spec = (
5253 
    None, # 0
559 chandransh 5254 
    (1, TType.I64, 'userid', None, None, ), # 1
5255 
    (2, TType.I64, 'addressId', None, None, ), # 2
94 ashish 5256 
  )
5257 
 
559 chandransh 5258 
  def __init__(self, userid=None, addressId=None,):
5259 
    self.userid = userid
5260 
    self.addressId = addressId
94 ashish 5261 
 
5262 
  def read(self, iprot):
5263 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5264 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5265 
      return
5266 
    iprot.readStructBegin()
5267 
    while True:
5268 
      (fname, ftype, fid) = iprot.readFieldBegin()
5269 
      if ftype == TType.STOP:
5270 
        break
5271 
      if fid == 1:
559 chandransh 5272 
        if ftype == TType.I64:
5273 
          self.userid = iprot.readI64();
94 ashish 5274 
        else:
5275 
          iprot.skip(ftype)
559 chandransh 5276 
      elif fid == 2:
5277 
        if ftype == TType.I64:
5278 
          self.addressId = iprot.readI64();
5279 
        else:
5280 
          iprot.skip(ftype)
94 ashish 5281 
      else:
5282 
        iprot.skip(ftype)
5283 
      iprot.readFieldEnd()
5284 
    iprot.readStructEnd()
5285 
 
5286 
  def write(self, oprot):
5287 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5288 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5289 
      return
559 chandransh 5290 
    oprot.writeStructBegin('removeAddressForUser_args')
5291 
    if self.userid != None:
5292 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5293 
      oprot.writeI64(self.userid)
94 ashish 5294 
      oprot.writeFieldEnd()
559 chandransh 5295 
    if self.addressId != None:
5296 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5297 
      oprot.writeI64(self.addressId)
5298 
      oprot.writeFieldEnd()
94 ashish 5299 
    oprot.writeFieldStop()
5300 
    oprot.writeStructEnd()
5301 
 
5302 
  def __repr__(self):
5303 
    L = ['%s=%r' % (key, value)
5304 
      for key, value in self.__dict__.iteritems()]
5305 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5306 
 
5307 
  def __eq__(self, other):
5308 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5309 
 
5310 
  def __ne__(self, other):
5311 
    return not (self == other)
5312 
 
559 chandransh 5313 
class removeAddressForUser_result:
94 ashish 5314 
  """
5315 
  Attributes:
5316 
   - success
5317 
   - ucx
5318 
  """
5319 
 
5320 
  thrift_spec = (
5321 
    (0, TType.BOOL, 'success', None, None, ), # 0
5322 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5323 
  )
5324 
 
5325 
  def __init__(self, success=None, ucx=None,):
5326 
    self.success = success
5327 
    self.ucx = ucx
5328 
 
5329 
  def read(self, iprot):
5330 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5331 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5332 
      return
5333 
    iprot.readStructBegin()
5334 
    while True:
5335 
      (fname, ftype, fid) = iprot.readFieldBegin()
5336 
      if ftype == TType.STOP:
5337 
        break
5338 
      if fid == 0:
5339 
        if ftype == TType.BOOL:
5340 
          self.success = iprot.readBool();
5341 
        else:
5342 
          iprot.skip(ftype)
5343 
      elif fid == 1:
5344 
        if ftype == TType.STRUCT:
5345 
          self.ucx = UserContextException()
5346 
          self.ucx.read(iprot)
5347 
        else:
5348 
          iprot.skip(ftype)
5349 
      else:
5350 
        iprot.skip(ftype)
5351 
      iprot.readFieldEnd()
5352 
    iprot.readStructEnd()
5353 
 
5354 
  def write(self, oprot):
5355 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5356 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5357 
      return
559 chandransh 5358 
    oprot.writeStructBegin('removeAddressForUser_result')
94 ashish 5359 
    if self.success != None:
5360 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5361 
      oprot.writeBool(self.success)
5362 
      oprot.writeFieldEnd()
5363 
    if self.ucx != None:
5364 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5365 
      self.ucx.write(oprot)
5366 
      oprot.writeFieldEnd()
5367 
    oprot.writeFieldStop()
5368 
    oprot.writeStructEnd()
5369 
 
5370 
  def __repr__(self):
5371 
    L = ['%s=%r' % (key, value)
5372 
      for key, value in self.__dict__.iteritems()]
5373 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5374 
 
5375 
  def __eq__(self, other):
5376 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5377 
 
5378 
  def __ne__(self, other):
5379 
    return not (self == other)
5380 
 
559 chandransh 5381 
class setUserAsLoggedIn_args:
94 ashish 5382 
  """
5383 
  Attributes:
559 chandransh 5384 
   - userId
94 ashish 5385 
   - timestamp
5386 
  """
5387 
 
5388 
  thrift_spec = (
5389 
    None, # 0
559 chandransh 5390 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 5391 
    (2, TType.I64, 'timestamp', None, None, ), # 2
5392 
  )
5393 
 
559 chandransh 5394 
  def __init__(self, userId=None, timestamp=None,):
5395 
    self.userId = userId
94 ashish 5396 
    self.timestamp = timestamp
5397 
 
5398 
  def read(self, iprot):
5399 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5400 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5401 
      return
5402 
    iprot.readStructBegin()
5403 
    while True:
5404 
      (fname, ftype, fid) = iprot.readFieldBegin()
5405 
      if ftype == TType.STOP:
5406 
        break
5407 
      if fid == 1:
559 chandransh 5408 
        if ftype == TType.I64:
5409 
          self.userId = iprot.readI64();
94 ashish 5410 
        else:
5411 
          iprot.skip(ftype)
5412 
      elif fid == 2:
5413 
        if ftype == TType.I64:
5414 
          self.timestamp = iprot.readI64();
5415 
        else:
5416 
          iprot.skip(ftype)
5417 
      else:
5418 
        iprot.skip(ftype)
5419 
      iprot.readFieldEnd()
5420 
    iprot.readStructEnd()
5421 
 
5422 
  def write(self, oprot):
5423 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5424 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5425 
      return
559 chandransh 5426 
    oprot.writeStructBegin('setUserAsLoggedIn_args')
5427 
    if self.userId != None:
5428 
      oprot.writeFieldBegin('userId', TType.I64, 1)
5429 
      oprot.writeI64(self.userId)
94 ashish 5430 
      oprot.writeFieldEnd()
5431 
    if self.timestamp != None:
5432 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
5433 
      oprot.writeI64(self.timestamp)
5434 
      oprot.writeFieldEnd()
5435 
    oprot.writeFieldStop()
5436 
    oprot.writeStructEnd()
5437 
 
5438 
  def __repr__(self):
5439 
    L = ['%s=%r' % (key, value)
5440 
      for key, value in self.__dict__.iteritems()]
5441 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5442 
 
5443 
  def __eq__(self, other):
5444 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5445 
 
5446 
  def __ne__(self, other):
5447 
    return not (self == other)
5448 
 
559 chandransh 5449 
class setUserAsLoggedIn_result:
94 ashish 5450 
  """
5451 
  Attributes:
5452 
   - success
5453 
   - ucx
5454 
  """
5455 
 
5456 
  thrift_spec = (
5457 
    (0, TType.BOOL, 'success', None, None, ), # 0
5458 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5459 
  )
5460 
 
5461 
  def __init__(self, success=None, ucx=None,):
5462 
    self.success = success
5463 
    self.ucx = ucx
5464 
 
5465 
  def read(self, iprot):
5466 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5467 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5468 
      return
5469 
    iprot.readStructBegin()
5470 
    while True:
5471 
      (fname, ftype, fid) = iprot.readFieldBegin()
5472 
      if ftype == TType.STOP:
5473 
        break
5474 
      if fid == 0:
5475 
        if ftype == TType.BOOL:
5476 
          self.success = iprot.readBool();
5477 
        else:
5478 
          iprot.skip(ftype)
5479 
      elif fid == 1:
5480 
        if ftype == TType.STRUCT:
5481 
          self.ucx = UserContextException()
5482 
          self.ucx.read(iprot)
5483 
        else:
5484 
          iprot.skip(ftype)
5485 
      else:
5486 
        iprot.skip(ftype)
5487 
      iprot.readFieldEnd()
5488 
    iprot.readStructEnd()
5489 
 
5490 
  def write(self, oprot):
5491 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5492 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5493 
      return
559 chandransh 5494 
    oprot.writeStructBegin('setUserAsLoggedIn_result')
94 ashish 5495 
    if self.success != None:
5496 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5497 
      oprot.writeBool(self.success)
5498 
      oprot.writeFieldEnd()
5499 
    if self.ucx != None:
5500 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5501 
      self.ucx.write(oprot)
5502 
      oprot.writeFieldEnd()
5503 
    oprot.writeFieldStop()
5504 
    oprot.writeStructEnd()
5505 
 
5506 
  def __repr__(self):
5507 
    L = ['%s=%r' % (key, value)
5508 
      for key, value in self.__dict__.iteritems()]
5509 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5510 
 
5511 
  def __eq__(self, other):
5512 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5513 
 
5514 
  def __ne__(self, other):
5515 
    return not (self == other)
5516 
 
559 chandransh 5517 
class setUserAsLoggedOut_args:
94 ashish 5518 
  """
5519 
  Attributes:
5520 
   - userid
5521 
   - timestamp
5522 
  """
5523 
 
5524 
  thrift_spec = (
5525 
    None, # 0
559 chandransh 5526 
    (1, TType.I64, 'userid', None, None, ), # 1
5527 
    (2, TType.I64, 'timestamp', None, None, ), # 2
94 ashish 5528 
  )
5529 
 
559 chandransh 5530 
  def __init__(self, userid=None, timestamp=None,):
94 ashish 5531 
    self.userid = userid
5532 
    self.timestamp = timestamp
5533 
 
5534 
  def read(self, iprot):
5535 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5536 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5537 
      return
5538 
    iprot.readStructBegin()
5539 
    while True:
5540 
      (fname, ftype, fid) = iprot.readFieldBegin()
5541 
      if ftype == TType.STOP:
5542 
        break
5543 
      if fid == 1:
5544 
        if ftype == TType.I64:
5545 
          self.userid = iprot.readI64();
5546 
        else:
5547 
          iprot.skip(ftype)
559 chandransh 5548 
      elif fid == 2:
94 ashish 5549 
        if ftype == TType.I64:
5550 
          self.timestamp = iprot.readI64();
5551 
        else:
5552 
          iprot.skip(ftype)
5553 
      else:
5554 
        iprot.skip(ftype)
5555 
      iprot.readFieldEnd()
5556 
    iprot.readStructEnd()
5557 
 
5558 
  def write(self, oprot):
5559 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5560 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5561 
      return
559 chandransh 5562 
    oprot.writeStructBegin('setUserAsLoggedOut_args')
94 ashish 5563 
    if self.userid != None:
559 chandransh 5564 
      oprot.writeFieldBegin('userid', TType.I64, 1)
94 ashish 5565 
      oprot.writeI64(self.userid)
5566 
      oprot.writeFieldEnd()
5567 
    if self.timestamp != None:
559 chandransh 5568 
      oprot.writeFieldBegin('timestamp', TType.I64, 2)
94 ashish 5569 
      oprot.writeI64(self.timestamp)
5570 
      oprot.writeFieldEnd()
5571 
    oprot.writeFieldStop()
5572 
    oprot.writeStructEnd()
5573 
 
5574 
  def __repr__(self):
5575 
    L = ['%s=%r' % (key, value)
5576 
      for key, value in self.__dict__.iteritems()]
5577 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5578 
 
5579 
  def __eq__(self, other):
5580 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5581 
 
5582 
  def __ne__(self, other):
5583 
    return not (self == other)
5584 
 
559 chandransh 5585 
class setUserAsLoggedOut_result:
94 ashish 5586 
  """
5587 
  Attributes:
5588 
   - success
5589 
   - ucx
5590 
  """
5591 
 
5592 
  thrift_spec = (
5593 
    (0, TType.BOOL, 'success', None, None, ), # 0
5594 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5595 
  )
5596 
 
5597 
  def __init__(self, success=None, ucx=None,):
5598 
    self.success = success
5599 
    self.ucx = ucx
5600 
 
5601 
  def read(self, iprot):
5602 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5603 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5604 
      return
5605 
    iprot.readStructBegin()
5606 
    while True:
5607 
      (fname, ftype, fid) = iprot.readFieldBegin()
5608 
      if ftype == TType.STOP:
5609 
        break
5610 
      if fid == 0:
5611 
        if ftype == TType.BOOL:
5612 
          self.success = iprot.readBool();
5613 
        else:
5614 
          iprot.skip(ftype)
5615 
      elif fid == 1:
5616 
        if ftype == TType.STRUCT:
5617 
          self.ucx = UserContextException()
5618 
          self.ucx.read(iprot)
5619 
        else:
5620 
          iprot.skip(ftype)
5621 
      else:
5622 
        iprot.skip(ftype)
5623 
      iprot.readFieldEnd()
5624 
    iprot.readStructEnd()
5625 
 
5626 
  def write(self, oprot):
5627 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5628 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5629 
      return
559 chandransh 5630 
    oprot.writeStructBegin('setUserAsLoggedOut_result')
94 ashish 5631 
    if self.success != None:
5632 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5633 
      oprot.writeBool(self.success)
5634 
      oprot.writeFieldEnd()
5635 
    if self.ucx != None:
5636 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5637 
      self.ucx.write(oprot)
5638 
      oprot.writeFieldEnd()
5639 
    oprot.writeFieldStop()
5640 
    oprot.writeStructEnd()
5641 
 
5642 
  def __repr__(self):
5643 
    L = ['%s=%r' % (key, value)
5644 
      for key, value in self.__dict__.iteritems()]
5645 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5646 
 
5647 
  def __eq__(self, other):
5648 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5649 
 
5650 
  def __ne__(self, other):
5651 
    return not (self == other)
5652 
 
559 chandransh 5653 
class setDefaultAddress_args:
94 ashish 5654 
  """
5655 
  Attributes:
5656 
   - userid
5657 
   - addressId
5658 
  """
5659 
 
5660 
  thrift_spec = (
5661 
    None, # 0
5662 
    (1, TType.I64, 'userid', None, None, ), # 1
5663 
    (2, TType.I64, 'addressId', None, None, ), # 2
5664 
  )
5665 
 
5666 
  def __init__(self, userid=None, addressId=None,):
5667 
    self.userid = userid
5668 
    self.addressId = addressId
5669 
 
5670 
  def read(self, iprot):
5671 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5672 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5673 
      return
5674 
    iprot.readStructBegin()
5675 
    while True:
5676 
      (fname, ftype, fid) = iprot.readFieldBegin()
5677 
      if ftype == TType.STOP:
5678 
        break
5679 
      if fid == 1:
5680 
        if ftype == TType.I64:
5681 
          self.userid = iprot.readI64();
5682 
        else:
5683 
          iprot.skip(ftype)
5684 
      elif fid == 2:
5685 
        if ftype == TType.I64:
5686 
          self.addressId = iprot.readI64();
5687 
        else:
5688 
          iprot.skip(ftype)
5689 
      else:
5690 
        iprot.skip(ftype)
5691 
      iprot.readFieldEnd()
5692 
    iprot.readStructEnd()
5693 
 
5694 
  def write(self, oprot):
5695 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5696 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5697 
      return
559 chandransh 5698 
    oprot.writeStructBegin('setDefaultAddress_args')
94 ashish 5699 
    if self.userid != None:
5700 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5701 
      oprot.writeI64(self.userid)
5702 
      oprot.writeFieldEnd()
5703 
    if self.addressId != None:
5704 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
5705 
      oprot.writeI64(self.addressId)
5706 
      oprot.writeFieldEnd()
5707 
    oprot.writeFieldStop()
5708 
    oprot.writeStructEnd()
5709 
 
5710 
  def __repr__(self):
5711 
    L = ['%s=%r' % (key, value)
5712 
      for key, value in self.__dict__.iteritems()]
5713 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5714 
 
5715 
  def __eq__(self, other):
5716 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5717 
 
5718 
  def __ne__(self, other):
5719 
    return not (self == other)
5720 
 
559 chandransh 5721 
class setDefaultAddress_result:
94 ashish 5722 
  """
5723 
  Attributes:
5724 
   - success
5725 
   - ucx
5726 
  """
5727 
 
5728 
  thrift_spec = (
5729 
    (0, TType.BOOL, 'success', None, None, ), # 0
5730 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5731 
  )
5732 
 
5733 
  def __init__(self, success=None, ucx=None,):
5734 
    self.success = success
5735 
    self.ucx = ucx
5736 
 
5737 
  def read(self, iprot):
5738 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5739 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5740 
      return
5741 
    iprot.readStructBegin()
5742 
    while True:
5743 
      (fname, ftype, fid) = iprot.readFieldBegin()
5744 
      if ftype == TType.STOP:
5745 
        break
5746 
      if fid == 0:
5747 
        if ftype == TType.BOOL:
5748 
          self.success = iprot.readBool();
5749 
        else:
5750 
          iprot.skip(ftype)
5751 
      elif fid == 1:
5752 
        if ftype == TType.STRUCT:
5753 
          self.ucx = UserContextException()
5754 
          self.ucx.read(iprot)
5755 
        else:
5756 
          iprot.skip(ftype)
5757 
      else:
5758 
        iprot.skip(ftype)
5759 
      iprot.readFieldEnd()
5760 
    iprot.readStructEnd()
5761 
 
5762 
  def write(self, oprot):
5763 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5764 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5765 
      return
559 chandransh 5766 
    oprot.writeStructBegin('setDefaultAddress_result')
94 ashish 5767 
    if self.success != None:
5768 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5769 
      oprot.writeBool(self.success)
5770 
      oprot.writeFieldEnd()
5771 
    if self.ucx != None:
5772 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5773 
      self.ucx.write(oprot)
5774 
      oprot.writeFieldEnd()
5775 
    oprot.writeFieldStop()
5776 
    oprot.writeStructEnd()
5777 
 
5778 
  def __repr__(self):
5779 
    L = ['%s=%r' % (key, value)
5780 
      for key, value in self.__dict__.iteritems()]
5781 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5782 
 
5783 
  def __eq__(self, other):
5784 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5785 
 
5786 
  def __ne__(self, other):
5787 
    return not (self == other)
5788 
 
559 chandransh 5789 
class updatePassword_args:
94 ashish 5790 
  """
5791 
  Attributes:
559 chandransh 5792 
   - userid
594 rajveer 5793 
   - oldPassword
5794 
   - newPassword
94 ashish 5795 
  """
5796 
 
5797 
  thrift_spec = (
5798 
    None, # 0
559 chandransh 5799 
    (1, TType.I64, 'userid', None, None, ), # 1
594 rajveer 5800 
    (2, TType.STRING, 'oldPassword', None, None, ), # 2
5801 
    (3, TType.STRING, 'newPassword', None, None, ), # 3
94 ashish 5802 
  )
5803 
 
594 rajveer 5804 
  def __init__(self, userid=None, oldPassword=None, newPassword=None,):
559 chandransh 5805 
    self.userid = userid
594 rajveer 5806 
    self.oldPassword = oldPassword
5807 
    self.newPassword = newPassword
94 ashish 5808 
 
5809 
  def read(self, iprot):
5810 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5811 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5812 
      return
5813 
    iprot.readStructBegin()
5814 
    while True:
5815 
      (fname, ftype, fid) = iprot.readFieldBegin()
5816 
      if ftype == TType.STOP:
5817 
        break
5818 
      if fid == 1:
5819 
        if ftype == TType.I64:
559 chandransh 5820 
          self.userid = iprot.readI64();
94 ashish 5821 
        else:
5822 
          iprot.skip(ftype)
5823 
      elif fid == 2:
559 chandransh 5824 
        if ftype == TType.STRING:
594 rajveer 5825 
          self.oldPassword = iprot.readString();
94 ashish 5826 
        else:
5827 
          iprot.skip(ftype)
594 rajveer 5828 
      elif fid == 3:
5829 
        if ftype == TType.STRING:
5830 
          self.newPassword = iprot.readString();
5831 
        else:
5832 
          iprot.skip(ftype)
94 ashish 5833 
      else:
5834 
        iprot.skip(ftype)
5835 
      iprot.readFieldEnd()
5836 
    iprot.readStructEnd()
5837 
 
5838 
  def write(self, oprot):
5839 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5840 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5841 
      return
559 chandransh 5842 
    oprot.writeStructBegin('updatePassword_args')
5843 
    if self.userid != None:
5844 
      oprot.writeFieldBegin('userid', TType.I64, 1)
5845 
      oprot.writeI64(self.userid)
94 ashish 5846 
      oprot.writeFieldEnd()
594 rajveer 5847 
    if self.oldPassword != None:
5848 
      oprot.writeFieldBegin('oldPassword', TType.STRING, 2)
5849 
      oprot.writeString(self.oldPassword)
94 ashish 5850 
      oprot.writeFieldEnd()
594 rajveer 5851 
    if self.newPassword != None:
5852 
      oprot.writeFieldBegin('newPassword', TType.STRING, 3)
5853 
      oprot.writeString(self.newPassword)
5854 
      oprot.writeFieldEnd()
94 ashish 5855 
    oprot.writeFieldStop()
5856 
    oprot.writeStructEnd()
5857 
 
5858 
  def __repr__(self):
5859 
    L = ['%s=%r' % (key, value)
5860 
      for key, value in self.__dict__.iteritems()]
5861 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5862 
 
5863 
  def __eq__(self, other):
5864 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5865 
 
5866 
  def __ne__(self, other):
5867 
    return not (self == other)
5868 
 
559 chandransh 5869 
class updatePassword_result:
94 ashish 5870 
  """
5871 
  Attributes:
5872 
   - success
5873 
   - ucx
5874 
  """
5875 
 
5876 
  thrift_spec = (
5877 
    (0, TType.BOOL, 'success', None, None, ), # 0
5878 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
5879 
  )
5880 
 
5881 
  def __init__(self, success=None, ucx=None,):
5882 
    self.success = success
5883 
    self.ucx = ucx
5884 
 
5885 
  def read(self, iprot):
5886 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5887 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5888 
      return
5889 
    iprot.readStructBegin()
5890 
    while True:
5891 
      (fname, ftype, fid) = iprot.readFieldBegin()
5892 
      if ftype == TType.STOP:
5893 
        break
5894 
      if fid == 0:
5895 
        if ftype == TType.BOOL:
5896 
          self.success = iprot.readBool();
5897 
        else:
5898 
          iprot.skip(ftype)
5899 
      elif fid == 1:
5900 
        if ftype == TType.STRUCT:
5901 
          self.ucx = UserContextException()
5902 
          self.ucx.read(iprot)
5903 
        else:
5904 
          iprot.skip(ftype)
5905 
      else:
5906 
        iprot.skip(ftype)
5907 
      iprot.readFieldEnd()
5908 
    iprot.readStructEnd()
5909 
 
5910 
  def write(self, oprot):
5911 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5912 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5913 
      return
559 chandransh 5914 
    oprot.writeStructBegin('updatePassword_result')
94 ashish 5915 
    if self.success != None:
5916 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
5917 
      oprot.writeBool(self.success)
5918 
      oprot.writeFieldEnd()
5919 
    if self.ucx != None:
5920 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
5921 
      self.ucx.write(oprot)
5922 
      oprot.writeFieldEnd()
5923 
    oprot.writeFieldStop()
5924 
    oprot.writeStructEnd()
5925 
 
5926 
  def __repr__(self):
5927 
    L = ['%s=%r' % (key, value)
5928 
      for key, value in self.__dict__.iteritems()]
5929 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5930 
 
5931 
  def __eq__(self, other):
5932 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
5933 
 
5934 
  def __ne__(self, other):
5935 
    return not (self == other)
5936 
 
581 rajveer 5937 
class forgotPassword_args:
5938 
  """
5939 
  Attributes:
5940 
   - email
884 rajveer 5941 
   - newPassword
581 rajveer 5942 
  """
5943 
 
5944 
  thrift_spec = (
5945 
    None, # 0
5946 
    (1, TType.STRING, 'email', None, None, ), # 1
884 rajveer 5947 
    (2, TType.STRING, 'newPassword', None, None, ), # 2
581 rajveer 5948 
  )
5949 
 
884 rajveer 5950 
  def __init__(self, email=None, newPassword=None,):
581 rajveer 5951 
    self.email = email
884 rajveer 5952 
    self.newPassword = newPassword
581 rajveer 5953 
 
5954 
  def read(self, iprot):
5955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
5956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
5957 
      return
5958 
    iprot.readStructBegin()
5959 
    while True:
5960 
      (fname, ftype, fid) = iprot.readFieldBegin()
5961 
      if ftype == TType.STOP:
5962 
        break
5963 
      if fid == 1:
5964 
        if ftype == TType.STRING:
5965 
          self.email = iprot.readString();
5966 
        else:
5967 
          iprot.skip(ftype)
884 rajveer 5968 
      elif fid == 2:
5969 
        if ftype == TType.STRING:
5970 
          self.newPassword = iprot.readString();
5971 
        else:
5972 
          iprot.skip(ftype)
581 rajveer 5973 
      else:
5974 
        iprot.skip(ftype)
5975 
      iprot.readFieldEnd()
5976 
    iprot.readStructEnd()
5977 
 
5978 
  def write(self, oprot):
5979 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
5980 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
5981 
      return
5982 
    oprot.writeStructBegin('forgotPassword_args')
5983 
    if self.email != None:
5984 
      oprot.writeFieldBegin('email', TType.STRING, 1)
5985 
      oprot.writeString(self.email)
5986 
      oprot.writeFieldEnd()
884 rajveer 5987 
    if self.newPassword != None:
5988 
      oprot.writeFieldBegin('newPassword', TType.STRING, 2)
5989 
      oprot.writeString(self.newPassword)
5990 
      oprot.writeFieldEnd()
581 rajveer 5991 
    oprot.writeFieldStop()
5992 
    oprot.writeStructEnd()
5993 
 
5994 
  def __repr__(self):
5995 
    L = ['%s=%r' % (key, value)
5996 
      for key, value in self.__dict__.iteritems()]
5997 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
5998 
 
5999 
  def __eq__(self, other):
6000 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6001 
 
6002 
  def __ne__(self, other):
6003 
    return not (self == other)
6004 
 
6005 
class forgotPassword_result:
6006 
  """
6007 
  Attributes:
6008 
   - success
6009 
   - ucx
6010 
  """
6011 
 
6012 
  thrift_spec = (
6013 
    (0, TType.BOOL, 'success', None, None, ), # 0
6014 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6015 
  )
6016 
 
6017 
  def __init__(self, success=None, ucx=None,):
6018 
    self.success = success
6019 
    self.ucx = ucx
6020 
 
6021 
  def read(self, iprot):
6022 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6023 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6024 
      return
6025 
    iprot.readStructBegin()
6026 
    while True:
6027 
      (fname, ftype, fid) = iprot.readFieldBegin()
6028 
      if ftype == TType.STOP:
6029 
        break
6030 
      if fid == 0:
6031 
        if ftype == TType.BOOL:
6032 
          self.success = iprot.readBool();
6033 
        else:
6034 
          iprot.skip(ftype)
6035 
      elif fid == 1:
6036 
        if ftype == TType.STRUCT:
6037 
          self.ucx = UserContextException()
6038 
          self.ucx.read(iprot)
6039 
        else:
6040 
          iprot.skip(ftype)
6041 
      else:
6042 
        iprot.skip(ftype)
6043 
      iprot.readFieldEnd()
6044 
    iprot.readStructEnd()
6045 
 
6046 
  def write(self, oprot):
6047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6049 
      return
6050 
    oprot.writeStructBegin('forgotPassword_result')
6051 
    if self.success != None:
6052 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6053 
      oprot.writeBool(self.success)
6054 
      oprot.writeFieldEnd()
6055 
    if self.ucx != None:
6056 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6057 
      self.ucx.write(oprot)
6058 
      oprot.writeFieldEnd()
6059 
    oprot.writeFieldStop()
6060 
    oprot.writeStructEnd()
6061 
 
6062 
  def __repr__(self):
6063 
    L = ['%s=%r' % (key, value)
6064 
      for key, value in self.__dict__.iteritems()]
6065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6066 
 
6067 
  def __eq__(self, other):
6068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6069 
 
6070 
  def __ne__(self, other):
6071 
    return not (self == other)
6072 
 
594 rajveer 6073 
class getAllAddressesForUser_args:
6074 
  """
6075 
  Attributes:
6076 
   - userId
6077 
  """
6078 
 
6079 
  thrift_spec = (
6080 
    None, # 0
6081 
    (1, TType.I64, 'userId', None, None, ), # 1
6082 
  )
6083 
 
6084 
  def __init__(self, userId=None,):
6085 
    self.userId = userId
6086 
 
6087 
  def read(self, iprot):
6088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6090 
      return
6091 
    iprot.readStructBegin()
6092 
    while True:
6093 
      (fname, ftype, fid) = iprot.readFieldBegin()
6094 
      if ftype == TType.STOP:
6095 
        break
6096 
      if fid == 1:
6097 
        if ftype == TType.I64:
6098 
          self.userId = iprot.readI64();
6099 
        else:
6100 
          iprot.skip(ftype)
6101 
      else:
6102 
        iprot.skip(ftype)
6103 
      iprot.readFieldEnd()
6104 
    iprot.readStructEnd()
6105 
 
6106 
  def write(self, oprot):
6107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6109 
      return
6110 
    oprot.writeStructBegin('getAllAddressesForUser_args')
6111 
    if self.userId != None:
6112 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6113 
      oprot.writeI64(self.userId)
6114 
      oprot.writeFieldEnd()
6115 
    oprot.writeFieldStop()
6116 
    oprot.writeStructEnd()
6117 
 
6118 
  def __repr__(self):
6119 
    L = ['%s=%r' % (key, value)
6120 
      for key, value in self.__dict__.iteritems()]
6121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6122 
 
6123 
  def __eq__(self, other):
6124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6125 
 
6126 
  def __ne__(self, other):
6127 
    return not (self == other)
6128 
 
6129 
class getAllAddressesForUser_result:
6130 
  """
6131 
  Attributes:
6132 
   - success
6133 
   - ucx
6134 
  """
6135 
 
6136 
  thrift_spec = (
6137 
    (0, TType.LIST, 'success', (TType.STRUCT,(Address, Address.thrift_spec)), None, ), # 0
6138 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6139 
  )
6140 
 
6141 
  def __init__(self, success=None, ucx=None,):
6142 
    self.success = success
6143 
    self.ucx = ucx
6144 
 
6145 
  def read(self, iprot):
6146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6148 
      return
6149 
    iprot.readStructBegin()
6150 
    while True:
6151 
      (fname, ftype, fid) = iprot.readFieldBegin()
6152 
      if ftype == TType.STOP:
6153 
        break
6154 
      if fid == 0:
6155 
        if ftype == TType.LIST:
6156 
          self.success = []
1976 varun.gupt 6157 
          (_etype38, _size35) = iprot.readListBegin()
6158 
          for _i39 in xrange(_size35):
6159 
            _elem40 = Address()
6160 
            _elem40.read(iprot)
6161 
            self.success.append(_elem40)
594 rajveer 6162 
          iprot.readListEnd()
6163 
        else:
6164 
          iprot.skip(ftype)
6165 
      elif fid == 1:
6166 
        if ftype == TType.STRUCT:
6167 
          self.ucx = UserContextException()
6168 
          self.ucx.read(iprot)
6169 
        else:
6170 
          iprot.skip(ftype)
6171 
      else:
6172 
        iprot.skip(ftype)
6173 
      iprot.readFieldEnd()
6174 
    iprot.readStructEnd()
6175 
 
6176 
  def write(self, oprot):
6177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6179 
      return
6180 
    oprot.writeStructBegin('getAllAddressesForUser_result')
6181 
    if self.success != None:
6182 
      oprot.writeFieldBegin('success', TType.LIST, 0)
6183 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 6184 
      for iter41 in self.success:
6185 
        iter41.write(oprot)
594 rajveer 6186 
      oprot.writeListEnd()
6187 
      oprot.writeFieldEnd()
6188 
    if self.ucx != None:
6189 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6190 
      self.ucx.write(oprot)
6191 
      oprot.writeFieldEnd()
6192 
    oprot.writeFieldStop()
6193 
    oprot.writeStructEnd()
6194 
 
6195 
  def __repr__(self):
6196 
    L = ['%s=%r' % (key, value)
6197 
      for key, value in self.__dict__.iteritems()]
6198 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6199 
 
6200 
  def __eq__(self, other):
6201 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6202 
 
6203 
  def __ne__(self, other):
6204 
    return not (self == other)
6205 
 
1894 vikas 6206 
class getAddressById_args:
6207 
  """
6208 
  Attributes:
6209 
   - addressId
6210 
  """
6211 
 
6212 
  thrift_spec = (
6213 
    None, # 0
6214 
    (1, TType.I64, 'addressId', None, None, ), # 1
6215 
  )
6216 
 
6217 
  def __init__(self, addressId=None,):
6218 
    self.addressId = addressId
6219 
 
6220 
  def read(self, iprot):
6221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6223 
      return
6224 
    iprot.readStructBegin()
6225 
    while True:
6226 
      (fname, ftype, fid) = iprot.readFieldBegin()
6227 
      if ftype == TType.STOP:
6228 
        break
6229 
      if fid == 1:
6230 
        if ftype == TType.I64:
6231 
          self.addressId = iprot.readI64();
6232 
        else:
6233 
          iprot.skip(ftype)
6234 
      else:
6235 
        iprot.skip(ftype)
6236 
      iprot.readFieldEnd()
6237 
    iprot.readStructEnd()
6238 
 
6239 
  def write(self, oprot):
6240 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6241 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6242 
      return
6243 
    oprot.writeStructBegin('getAddressById_args')
6244 
    if self.addressId != None:
6245 
      oprot.writeFieldBegin('addressId', TType.I64, 1)
6246 
      oprot.writeI64(self.addressId)
6247 
      oprot.writeFieldEnd()
6248 
    oprot.writeFieldStop()
6249 
    oprot.writeStructEnd()
6250 
 
6251 
  def __repr__(self):
6252 
    L = ['%s=%r' % (key, value)
6253 
      for key, value in self.__dict__.iteritems()]
6254 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6255 
 
6256 
  def __eq__(self, other):
6257 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6258 
 
6259 
  def __ne__(self, other):
6260 
    return not (self == other)
6261 
 
6262 
class getAddressById_result:
6263 
  """
6264 
  Attributes:
6265 
   - success
6266 
   - ucx
6267 
  """
6268 
 
6269 
  thrift_spec = (
6270 
    (0, TType.STRUCT, 'success', (Address, Address.thrift_spec), None, ), # 0
6271 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6272 
  )
6273 
 
6274 
  def __init__(self, success=None, ucx=None,):
6275 
    self.success = success
6276 
    self.ucx = ucx
6277 
 
6278 
  def read(self, iprot):
6279 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6280 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6281 
      return
6282 
    iprot.readStructBegin()
6283 
    while True:
6284 
      (fname, ftype, fid) = iprot.readFieldBegin()
6285 
      if ftype == TType.STOP:
6286 
        break
6287 
      if fid == 0:
6288 
        if ftype == TType.STRUCT:
6289 
          self.success = Address()
6290 
          self.success.read(iprot)
6291 
        else:
6292 
          iprot.skip(ftype)
6293 
      elif fid == 1:
6294 
        if ftype == TType.STRUCT:
6295 
          self.ucx = UserContextException()
6296 
          self.ucx.read(iprot)
6297 
        else:
6298 
          iprot.skip(ftype)
6299 
      else:
6300 
        iprot.skip(ftype)
6301 
      iprot.readFieldEnd()
6302 
    iprot.readStructEnd()
6303 
 
6304 
  def write(self, oprot):
6305 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6306 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6307 
      return
6308 
    oprot.writeStructBegin('getAddressById_result')
6309 
    if self.success != None:
6310 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6311 
      self.success.write(oprot)
6312 
      oprot.writeFieldEnd()
6313 
    if self.ucx != None:
6314 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6315 
      self.ucx.write(oprot)
6316 
      oprot.writeFieldEnd()
6317 
    oprot.writeFieldStop()
6318 
    oprot.writeStructEnd()
6319 
 
6320 
  def __repr__(self):
6321 
    L = ['%s=%r' % (key, value)
6322 
      for key, value in self.__dict__.iteritems()]
6323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6324 
 
6325 
  def __eq__(self, other):
6326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6327 
 
6328 
  def __ne__(self, other):
6329 
    return not (self == other)
6330 
 
594 rajveer 6331 
class getDefaultAddressId_args:
6332 
  """
6333 
  Attributes:
6334 
   - userId
6335 
  """
6336 
 
6337 
  thrift_spec = (
6338 
    None, # 0
6339 
    (1, TType.I64, 'userId', None, None, ), # 1
6340 
  )
6341 
 
6342 
  def __init__(self, userId=None,):
6343 
    self.userId = userId
6344 
 
6345 
  def read(self, iprot):
6346 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6347 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6348 
      return
6349 
    iprot.readStructBegin()
6350 
    while True:
6351 
      (fname, ftype, fid) = iprot.readFieldBegin()
6352 
      if ftype == TType.STOP:
6353 
        break
6354 
      if fid == 1:
6355 
        if ftype == TType.I64:
6356 
          self.userId = iprot.readI64();
6357 
        else:
6358 
          iprot.skip(ftype)
6359 
      else:
6360 
        iprot.skip(ftype)
6361 
      iprot.readFieldEnd()
6362 
    iprot.readStructEnd()
6363 
 
6364 
  def write(self, oprot):
6365 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6366 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6367 
      return
6368 
    oprot.writeStructBegin('getDefaultAddressId_args')
6369 
    if self.userId != None:
6370 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6371 
      oprot.writeI64(self.userId)
6372 
      oprot.writeFieldEnd()
6373 
    oprot.writeFieldStop()
6374 
    oprot.writeStructEnd()
6375 
 
6376 
  def __repr__(self):
6377 
    L = ['%s=%r' % (key, value)
6378 
      for key, value in self.__dict__.iteritems()]
6379 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6380 
 
6381 
  def __eq__(self, other):
6382 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6383 
 
6384 
  def __ne__(self, other):
6385 
    return not (self == other)
6386 
 
6387 
class getDefaultAddressId_result:
6388 
  """
6389 
  Attributes:
6390 
   - success
6391 
   - ucx
6392 
  """
6393 
 
6394 
  thrift_spec = (
6395 
    (0, TType.I64, 'success', None, None, ), # 0
6396 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6397 
  )
6398 
 
6399 
  def __init__(self, success=None, ucx=None,):
6400 
    self.success = success
6401 
    self.ucx = ucx
6402 
 
6403 
  def read(self, iprot):
6404 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6405 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6406 
      return
6407 
    iprot.readStructBegin()
6408 
    while True:
6409 
      (fname, ftype, fid) = iprot.readFieldBegin()
6410 
      if ftype == TType.STOP:
6411 
        break
6412 
      if fid == 0:
6413 
        if ftype == TType.I64:
6414 
          self.success = iprot.readI64();
6415 
        else:
6416 
          iprot.skip(ftype)
6417 
      elif fid == 1:
6418 
        if ftype == TType.STRUCT:
6419 
          self.ucx = UserContextException()
6420 
          self.ucx.read(iprot)
6421 
        else:
6422 
          iprot.skip(ftype)
6423 
      else:
6424 
        iprot.skip(ftype)
6425 
      iprot.readFieldEnd()
6426 
    iprot.readStructEnd()
6427 
 
6428 
  def write(self, oprot):
6429 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6430 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6431 
      return
6432 
    oprot.writeStructBegin('getDefaultAddressId_result')
6433 
    if self.success != None:
6434 
      oprot.writeFieldBegin('success', TType.I64, 0)
6435 
      oprot.writeI64(self.success)
6436 
      oprot.writeFieldEnd()
6437 
    if self.ucx != None:
6438 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6439 
      self.ucx.write(oprot)
6440 
      oprot.writeFieldEnd()
6441 
    oprot.writeFieldStop()
6442 
    oprot.writeStructEnd()
6443 
 
6444 
  def __repr__(self):
6445 
    L = ['%s=%r' % (key, value)
6446 
      for key, value in self.__dict__.iteritems()]
6447 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6448 
 
6449 
  def __eq__(self, other):
6450 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6451 
 
6452 
  def __ne__(self, other):
6453 
    return not (self == other)
6454 
 
785 rajveer 6455 
class getDefaultPincode_args:
6456 
  """
6457 
  Attributes:
6458 
   - userId
6459 
  """
6460 
 
6461 
  thrift_spec = (
6462 
    None, # 0
6463 
    (1, TType.I64, 'userId', None, None, ), # 1
6464 
  )
6465 
 
6466 
  def __init__(self, userId=None,):
6467 
    self.userId = userId
6468 
 
6469 
  def read(self, iprot):
6470 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6471 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6472 
      return
6473 
    iprot.readStructBegin()
6474 
    while True:
6475 
      (fname, ftype, fid) = iprot.readFieldBegin()
6476 
      if ftype == TType.STOP:
6477 
        break
6478 
      if fid == 1:
6479 
        if ftype == TType.I64:
6480 
          self.userId = iprot.readI64();
6481 
        else:
6482 
          iprot.skip(ftype)
6483 
      else:
6484 
        iprot.skip(ftype)
6485 
      iprot.readFieldEnd()
6486 
    iprot.readStructEnd()
6487 
 
6488 
  def write(self, oprot):
6489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6491 
      return
6492 
    oprot.writeStructBegin('getDefaultPincode_args')
6493 
    if self.userId != None:
6494 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6495 
      oprot.writeI64(self.userId)
6496 
      oprot.writeFieldEnd()
6497 
    oprot.writeFieldStop()
6498 
    oprot.writeStructEnd()
6499 
 
6500 
  def __repr__(self):
6501 
    L = ['%s=%r' % (key, value)
6502 
      for key, value in self.__dict__.iteritems()]
6503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6504 
 
6505 
  def __eq__(self, other):
6506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6507 
 
6508 
  def __ne__(self, other):
6509 
    return not (self == other)
6510 
 
6511 
class getDefaultPincode_result:
6512 
  """
6513 
  Attributes:
6514 
   - success
6515 
   - ucx
6516 
  """
6517 
 
6518 
  thrift_spec = (
6519 
    (0, TType.STRING, 'success', None, None, ), # 0
6520 
    (1, TType.STRUCT, 'ucx', (UserContextException, UserContextException.thrift_spec), None, ), # 1
6521 
  )
6522 
 
6523 
  def __init__(self, success=None, ucx=None,):
6524 
    self.success = success
6525 
    self.ucx = ucx
6526 
 
6527 
  def read(self, iprot):
6528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6530 
      return
6531 
    iprot.readStructBegin()
6532 
    while True:
6533 
      (fname, ftype, fid) = iprot.readFieldBegin()
6534 
      if ftype == TType.STOP:
6535 
        break
6536 
      if fid == 0:
6537 
        if ftype == TType.STRING:
6538 
          self.success = iprot.readString();
6539 
        else:
6540 
          iprot.skip(ftype)
6541 
      elif fid == 1:
6542 
        if ftype == TType.STRUCT:
6543 
          self.ucx = UserContextException()
6544 
          self.ucx.read(iprot)
6545 
        else:
6546 
          iprot.skip(ftype)
6547 
      else:
6548 
        iprot.skip(ftype)
6549 
      iprot.readFieldEnd()
6550 
    iprot.readStructEnd()
6551 
 
6552 
  def write(self, oprot):
6553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6555 
      return
6556 
    oprot.writeStructBegin('getDefaultPincode_result')
6557 
    if self.success != None:
6558 
      oprot.writeFieldBegin('success', TType.STRING, 0)
6559 
      oprot.writeString(self.success)
6560 
      oprot.writeFieldEnd()
6561 
    if self.ucx != None:
6562 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6563 
      self.ucx.write(oprot)
6564 
      oprot.writeFieldEnd()
6565 
    oprot.writeFieldStop()
6566 
    oprot.writeStructEnd()
6567 
 
6568 
  def __repr__(self):
6569 
    L = ['%s=%r' % (key, value)
6570 
      for key, value in self.__dict__.iteritems()]
6571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6572 
 
6573 
  def __eq__(self, other):
6574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6575 
 
6576 
  def __ne__(self, other):
6577 
    return not (self == other)
6578 
 
1274 varun.gupt 6579 
class saveUserCommunication_args:
6580 
  """
6581 
  Attributes:
6582 
   - userId
6583 
   - replyTo
6584 
   - communicationType
6585 
   - orderId
6586 
   - airwaybillNo
6587 
   - productName
6588 
   - subject
6589 
   - message
6590 
  """
6591 
 
6592 
  thrift_spec = (
6593 
    None, # 0
6594 
    (1, TType.I64, 'userId', None, None, ), # 1
6595 
    (2, TType.STRING, 'replyTo', None, None, ), # 2
6596 
    (3, TType.I64, 'communicationType', None, None, ), # 3
6597 
    (4, TType.I64, 'orderId', None, None, ), # 4
6598 
    (5, TType.STRING, 'airwaybillNo', None, None, ), # 5
6599 
    (6, TType.STRING, 'productName', None, None, ), # 6
6600 
    (7, TType.STRING, 'subject', None, None, ), # 7
6601 
    (8, TType.STRING, 'message', None, None, ), # 8
6602 
  )
6603 
 
6604 
  def __init__(self, userId=None, replyTo=None, communicationType=None, orderId=None, airwaybillNo=None, productName=None, subject=None, message=None,):
6605 
    self.userId = userId
6606 
    self.replyTo = replyTo
6607 
    self.communicationType = communicationType
6608 
    self.orderId = orderId
6609 
    self.airwaybillNo = airwaybillNo
6610 
    self.productName = productName
6611 
    self.subject = subject
6612 
    self.message = message
6613 
 
6614 
  def read(self, iprot):
6615 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6616 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6617 
      return
6618 
    iprot.readStructBegin()
6619 
    while True:
6620 
      (fname, ftype, fid) = iprot.readFieldBegin()
6621 
      if ftype == TType.STOP:
6622 
        break
6623 
      if fid == 1:
6624 
        if ftype == TType.I64:
6625 
          self.userId = iprot.readI64();
6626 
        else:
6627 
          iprot.skip(ftype)
6628 
      elif fid == 2:
6629 
        if ftype == TType.STRING:
6630 
          self.replyTo = iprot.readString();
6631 
        else:
6632 
          iprot.skip(ftype)
6633 
      elif fid == 3:
6634 
        if ftype == TType.I64:
6635 
          self.communicationType = iprot.readI64();
6636 
        else:
6637 
          iprot.skip(ftype)
6638 
      elif fid == 4:
6639 
        if ftype == TType.I64:
6640 
          self.orderId = iprot.readI64();
6641 
        else:
6642 
          iprot.skip(ftype)
6643 
      elif fid == 5:
6644 
        if ftype == TType.STRING:
6645 
          self.airwaybillNo = iprot.readString();
6646 
        else:
6647 
          iprot.skip(ftype)
6648 
      elif fid == 6:
6649 
        if ftype == TType.STRING:
6650 
          self.productName = iprot.readString();
6651 
        else:
6652 
          iprot.skip(ftype)
6653 
      elif fid == 7:
6654 
        if ftype == TType.STRING:
6655 
          self.subject = iprot.readString();
6656 
        else:
6657 
          iprot.skip(ftype)
6658 
      elif fid == 8:
6659 
        if ftype == TType.STRING:
6660 
          self.message = iprot.readString();
6661 
        else:
6662 
          iprot.skip(ftype)
6663 
      else:
6664 
        iprot.skip(ftype)
6665 
      iprot.readFieldEnd()
6666 
    iprot.readStructEnd()
6667 
 
6668 
  def write(self, oprot):
6669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6671 
      return
6672 
    oprot.writeStructBegin('saveUserCommunication_args')
6673 
    if self.userId != None:
6674 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6675 
      oprot.writeI64(self.userId)
6676 
      oprot.writeFieldEnd()
6677 
    if self.replyTo != None:
6678 
      oprot.writeFieldBegin('replyTo', TType.STRING, 2)
6679 
      oprot.writeString(self.replyTo)
6680 
      oprot.writeFieldEnd()
6681 
    if self.communicationType != None:
6682 
      oprot.writeFieldBegin('communicationType', TType.I64, 3)
6683 
      oprot.writeI64(self.communicationType)
6684 
      oprot.writeFieldEnd()
6685 
    if self.orderId != None:
6686 
      oprot.writeFieldBegin('orderId', TType.I64, 4)
6687 
      oprot.writeI64(self.orderId)
6688 
      oprot.writeFieldEnd()
6689 
    if self.airwaybillNo != None:
6690 
      oprot.writeFieldBegin('airwaybillNo', TType.STRING, 5)
6691 
      oprot.writeString(self.airwaybillNo)
6692 
      oprot.writeFieldEnd()
6693 
    if self.productName != None:
6694 
      oprot.writeFieldBegin('productName', TType.STRING, 6)
6695 
      oprot.writeString(self.productName)
6696 
      oprot.writeFieldEnd()
6697 
    if self.subject != None:
6698 
      oprot.writeFieldBegin('subject', TType.STRING, 7)
6699 
      oprot.writeString(self.subject)
6700 
      oprot.writeFieldEnd()
6701 
    if self.message != None:
6702 
      oprot.writeFieldBegin('message', TType.STRING, 8)
6703 
      oprot.writeString(self.message)
6704 
      oprot.writeFieldEnd()
6705 
    oprot.writeFieldStop()
6706 
    oprot.writeStructEnd()
6707 
 
6708 
  def __repr__(self):
6709 
    L = ['%s=%r' % (key, value)
6710 
      for key, value in self.__dict__.iteritems()]
6711 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6712 
 
6713 
  def __eq__(self, other):
6714 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6715 
 
6716 
  def __ne__(self, other):
6717 
    return not (self == other)
6718 
 
6719 
class saveUserCommunication_result:
6720 
  """
6721 
  Attributes:
6722 
   - success
6723 
   - ucx
6724 
  """
6725 
 
6726 
  thrift_spec = (
6727 
    (0, TType.BOOL, 'success', None, None, ), # 0
6728 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6729 
  )
6730 
 
6731 
  def __init__(self, success=None, ucx=None,):
6732 
    self.success = success
6733 
    self.ucx = ucx
6734 
 
6735 
  def read(self, iprot):
6736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6738 
      return
6739 
    iprot.readStructBegin()
6740 
    while True:
6741 
      (fname, ftype, fid) = iprot.readFieldBegin()
6742 
      if ftype == TType.STOP:
6743 
        break
6744 
      if fid == 0:
6745 
        if ftype == TType.BOOL:
6746 
          self.success = iprot.readBool();
6747 
        else:
6748 
          iprot.skip(ftype)
6749 
      elif fid == 1:
6750 
        if ftype == TType.STRUCT:
6751 
          self.ucx = UserCommunicationException()
6752 
          self.ucx.read(iprot)
6753 
        else:
6754 
          iprot.skip(ftype)
6755 
      else:
6756 
        iprot.skip(ftype)
6757 
      iprot.readFieldEnd()
6758 
    iprot.readStructEnd()
6759 
 
6760 
  def write(self, oprot):
6761 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6762 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6763 
      return
6764 
    oprot.writeStructBegin('saveUserCommunication_result')
6765 
    if self.success != None:
6766 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
6767 
      oprot.writeBool(self.success)
6768 
      oprot.writeFieldEnd()
6769 
    if self.ucx != None:
6770 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6771 
      self.ucx.write(oprot)
6772 
      oprot.writeFieldEnd()
6773 
    oprot.writeFieldStop()
6774 
    oprot.writeStructEnd()
6775 
 
6776 
  def __repr__(self):
6777 
    L = ['%s=%r' % (key, value)
6778 
      for key, value in self.__dict__.iteritems()]
6779 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6780 
 
6781 
  def __eq__(self, other):
6782 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6783 
 
6784 
  def __ne__(self, other):
6785 
    return not (self == other)
6786 
 
1590 varun.gupt 6787 
class getUserCommunicationById_args:
6788 
  """
6789 
  Attributes:
6790 
   - id
6791 
  """
6792 
 
6793 
  thrift_spec = (
6794 
    None, # 0
6795 
    (1, TType.I64, 'id', None, None, ), # 1
6796 
  )
6797 
 
6798 
  def __init__(self, id=None,):
6799 
    self.id = id
6800 
 
6801 
  def read(self, iprot):
6802 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6803 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6804 
      return
6805 
    iprot.readStructBegin()
6806 
    while True:
6807 
      (fname, ftype, fid) = iprot.readFieldBegin()
6808 
      if ftype == TType.STOP:
6809 
        break
6810 
      if fid == 1:
6811 
        if ftype == TType.I64:
6812 
          self.id = iprot.readI64();
6813 
        else:
6814 
          iprot.skip(ftype)
6815 
      else:
6816 
        iprot.skip(ftype)
6817 
      iprot.readFieldEnd()
6818 
    iprot.readStructEnd()
6819 
 
6820 
  def write(self, oprot):
6821 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6822 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6823 
      return
6824 
    oprot.writeStructBegin('getUserCommunicationById_args')
6825 
    if self.id != None:
6826 
      oprot.writeFieldBegin('id', TType.I64, 1)
6827 
      oprot.writeI64(self.id)
6828 
      oprot.writeFieldEnd()
6829 
    oprot.writeFieldStop()
6830 
    oprot.writeStructEnd()
6831 
 
6832 
  def __repr__(self):
6833 
    L = ['%s=%r' % (key, value)
6834 
      for key, value in self.__dict__.iteritems()]
6835 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6836 
 
6837 
  def __eq__(self, other):
6838 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6839 
 
6840 
  def __ne__(self, other):
6841 
    return not (self == other)
6842 
 
6843 
class getUserCommunicationById_result:
6844 
  """
6845 
  Attributes:
6846 
   - success
6847 
   - ucx
6848 
  """
6849 
 
6850 
  thrift_spec = (
6851 
    (0, TType.STRUCT, 'success', (UserCommunication, UserCommunication.thrift_spec), None, ), # 0
6852 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6853 
  )
6854 
 
6855 
  def __init__(self, success=None, ucx=None,):
6856 
    self.success = success
6857 
    self.ucx = ucx
6858 
 
6859 
  def read(self, iprot):
6860 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6861 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6862 
      return
6863 
    iprot.readStructBegin()
6864 
    while True:
6865 
      (fname, ftype, fid) = iprot.readFieldBegin()
6866 
      if ftype == TType.STOP:
6867 
        break
6868 
      if fid == 0:
6869 
        if ftype == TType.STRUCT:
6870 
          self.success = UserCommunication()
6871 
          self.success.read(iprot)
6872 
        else:
6873 
          iprot.skip(ftype)
6874 
      elif fid == 1:
6875 
        if ftype == TType.STRUCT:
6876 
          self.ucx = UserCommunicationException()
6877 
          self.ucx.read(iprot)
6878 
        else:
6879 
          iprot.skip(ftype)
6880 
      else:
6881 
        iprot.skip(ftype)
6882 
      iprot.readFieldEnd()
6883 
    iprot.readStructEnd()
6884 
 
6885 
  def write(self, oprot):
6886 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6887 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6888 
      return
6889 
    oprot.writeStructBegin('getUserCommunicationById_result')
6890 
    if self.success != None:
6891 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
6892 
      self.success.write(oprot)
6893 
      oprot.writeFieldEnd()
6894 
    if self.ucx != None:
6895 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
6896 
      self.ucx.write(oprot)
6897 
      oprot.writeFieldEnd()
6898 
    oprot.writeFieldStop()
6899 
    oprot.writeStructEnd()
6900 
 
6901 
  def __repr__(self):
6902 
    L = ['%s=%r' % (key, value)
6903 
      for key, value in self.__dict__.iteritems()]
6904 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6905 
 
6906 
  def __eq__(self, other):
6907 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6908 
 
6909 
  def __ne__(self, other):
6910 
    return not (self == other)
6911 
 
6912 
class getUserCommunicationByUser_args:
6913 
  """
6914 
  Attributes:
6915 
   - userId
6916 
  """
6917 
 
6918 
  thrift_spec = (
6919 
    None, # 0
6920 
    (1, TType.I64, 'userId', None, None, ), # 1
6921 
  )
6922 
 
6923 
  def __init__(self, userId=None,):
6924 
    self.userId = userId
6925 
 
6926 
  def read(self, iprot):
6927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6929 
      return
6930 
    iprot.readStructBegin()
6931 
    while True:
6932 
      (fname, ftype, fid) = iprot.readFieldBegin()
6933 
      if ftype == TType.STOP:
6934 
        break
6935 
      if fid == 1:
6936 
        if ftype == TType.I64:
6937 
          self.userId = iprot.readI64();
6938 
        else:
6939 
          iprot.skip(ftype)
6940 
      else:
6941 
        iprot.skip(ftype)
6942 
      iprot.readFieldEnd()
6943 
    iprot.readStructEnd()
6944 
 
6945 
  def write(self, oprot):
6946 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
6947 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
6948 
      return
6949 
    oprot.writeStructBegin('getUserCommunicationByUser_args')
6950 
    if self.userId != None:
6951 
      oprot.writeFieldBegin('userId', TType.I64, 1)
6952 
      oprot.writeI64(self.userId)
6953 
      oprot.writeFieldEnd()
6954 
    oprot.writeFieldStop()
6955 
    oprot.writeStructEnd()
6956 
 
6957 
  def __repr__(self):
6958 
    L = ['%s=%r' % (key, value)
6959 
      for key, value in self.__dict__.iteritems()]
6960 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
6961 
 
6962 
  def __eq__(self, other):
6963 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
6964 
 
6965 
  def __ne__(self, other):
6966 
    return not (self == other)
6967 
 
6968 
class getUserCommunicationByUser_result:
6969 
  """
6970 
  Attributes:
6971 
   - success
6972 
   - ucx
6973 
  """
6974 
 
6975 
  thrift_spec = (
6976 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
6977 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
6978 
  )
6979 
 
6980 
  def __init__(self, success=None, ucx=None,):
6981 
    self.success = success
6982 
    self.ucx = ucx
6983 
 
6984 
  def read(self, iprot):
6985 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
6986 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
6987 
      return
6988 
    iprot.readStructBegin()
6989 
    while True:
6990 
      (fname, ftype, fid) = iprot.readFieldBegin()
6991 
      if ftype == TType.STOP:
6992 
        break
6993 
      if fid == 0:
6994 
        if ftype == TType.LIST:
6995 
          self.success = []
1976 varun.gupt 6996 
          (_etype45, _size42) = iprot.readListBegin()
6997 
          for _i46 in xrange(_size42):
6998 
            _elem47 = UserCommunication()
6999 
            _elem47.read(iprot)
7000 
            self.success.append(_elem47)
1590 varun.gupt 7001 
          iprot.readListEnd()
7002 
        else:
7003 
          iprot.skip(ftype)
7004 
      elif fid == 1:
7005 
        if ftype == TType.STRUCT:
7006 
          self.ucx = UserCommunicationException()
7007 
          self.ucx.read(iprot)
7008 
        else:
7009 
          iprot.skip(ftype)
7010 
      else:
7011 
        iprot.skip(ftype)
7012 
      iprot.readFieldEnd()
7013 
    iprot.readStructEnd()
7014 
 
7015 
  def write(self, oprot):
7016 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7017 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7018 
      return
7019 
    oprot.writeStructBegin('getUserCommunicationByUser_result')
7020 
    if self.success != None:
7021 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7022 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 7023 
      for iter48 in self.success:
7024 
        iter48.write(oprot)
1590 varun.gupt 7025 
      oprot.writeListEnd()
7026 
      oprot.writeFieldEnd()
7027 
    if self.ucx != None:
7028 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7029 
      self.ucx.write(oprot)
7030 
      oprot.writeFieldEnd()
7031 
    oprot.writeFieldStop()
7032 
    oprot.writeStructEnd()
7033 
 
7034 
  def __repr__(self):
7035 
    L = ['%s=%r' % (key, value)
7036 
      for key, value in self.__dict__.iteritems()]
7037 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7038 
 
7039 
  def __eq__(self, other):
7040 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7041 
 
7042 
  def __ne__(self, other):
7043 
    return not (self == other)
7044 
 
7045 
class getAllUserCommunications_args:
7046 
 
7047 
  thrift_spec = (
7048 
  )
7049 
 
7050 
  def read(self, iprot):
7051 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7052 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7053 
      return
7054 
    iprot.readStructBegin()
7055 
    while True:
7056 
      (fname, ftype, fid) = iprot.readFieldBegin()
7057 
      if ftype == TType.STOP:
7058 
        break
7059 
      else:
7060 
        iprot.skip(ftype)
7061 
      iprot.readFieldEnd()
7062 
    iprot.readStructEnd()
7063 
 
7064 
  def write(self, oprot):
7065 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7066 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7067 
      return
7068 
    oprot.writeStructBegin('getAllUserCommunications_args')
7069 
    oprot.writeFieldStop()
7070 
    oprot.writeStructEnd()
7071 
 
7072 
  def __repr__(self):
7073 
    L = ['%s=%r' % (key, value)
7074 
      for key, value in self.__dict__.iteritems()]
7075 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7076 
 
7077 
  def __eq__(self, other):
7078 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7079 
 
7080 
  def __ne__(self, other):
7081 
    return not (self == other)
7082 
 
7083 
class getAllUserCommunications_result:
7084 
  """
7085 
  Attributes:
7086 
   - success
7087 
   - ucx
7088 
  """
7089 
 
7090 
  thrift_spec = (
7091 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserCommunication, UserCommunication.thrift_spec)), None, ), # 0
7092 
    (1, TType.STRUCT, 'ucx', (UserCommunicationException, UserCommunicationException.thrift_spec), None, ), # 1
7093 
  )
7094 
 
7095 
  def __init__(self, success=None, ucx=None,):
7096 
    self.success = success
7097 
    self.ucx = ucx
7098 
 
7099 
  def read(self, iprot):
7100 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7101 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7102 
      return
7103 
    iprot.readStructBegin()
7104 
    while True:
7105 
      (fname, ftype, fid) = iprot.readFieldBegin()
7106 
      if ftype == TType.STOP:
7107 
        break
7108 
      if fid == 0:
7109 
        if ftype == TType.LIST:
7110 
          self.success = []
1976 varun.gupt 7111 
          (_etype52, _size49) = iprot.readListBegin()
7112 
          for _i53 in xrange(_size49):
7113 
            _elem54 = UserCommunication()
7114 
            _elem54.read(iprot)
7115 
            self.success.append(_elem54)
1590 varun.gupt 7116 
          iprot.readListEnd()
7117 
        else:
7118 
          iprot.skip(ftype)
7119 
      elif fid == 1:
7120 
        if ftype == TType.STRUCT:
7121 
          self.ucx = UserCommunicationException()
7122 
          self.ucx.read(iprot)
7123 
        else:
7124 
          iprot.skip(ftype)
7125 
      else:
7126 
        iprot.skip(ftype)
7127 
      iprot.readFieldEnd()
7128 
    iprot.readStructEnd()
7129 
 
7130 
  def write(self, oprot):
7131 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7132 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7133 
      return
7134 
    oprot.writeStructBegin('getAllUserCommunications_result')
7135 
    if self.success != None:
7136 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7137 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 7138 
      for iter55 in self.success:
7139 
        iter55.write(oprot)
1590 varun.gupt 7140 
      oprot.writeListEnd()
7141 
      oprot.writeFieldEnd()
7142 
    if self.ucx != None:
7143 
      oprot.writeFieldBegin('ucx', TType.STRUCT, 1)
7144 
      self.ucx.write(oprot)
7145 
      oprot.writeFieldEnd()
7146 
    oprot.writeFieldStop()
7147 
    oprot.writeStructEnd()
7148 
 
7149 
  def __repr__(self):
7150 
    L = ['%s=%r' % (key, value)
7151 
      for key, value in self.__dict__.iteritems()]
7152 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7153 
 
7154 
  def __eq__(self, other):
7155 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7156 
 
7157 
  def __ne__(self, other):
7158 
    return not (self == other)
7159 
 
1845 vikas 7160 
class createMasterAffiliate_args:
7161 
  """
7162 
  Attributes:
7163 
   - name
1859 vikas 7164 
   - addedOn
1845 vikas 7165 
  """
7166 
 
7167 
  thrift_spec = (
7168 
    None, # 0
7169 
    (1, TType.STRING, 'name', None, None, ), # 1
1859 vikas 7170 
    (2, TType.I64, 'addedOn', None, None, ), # 2
1845 vikas 7171 
  )
7172 
 
1859 vikas 7173 
  def __init__(self, name=None, addedOn=None,):
1845 vikas 7174 
    self.name = name
1859 vikas 7175 
    self.addedOn = addedOn
1845 vikas 7176 
 
7177 
  def read(self, iprot):
7178 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7179 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7180 
      return
7181 
    iprot.readStructBegin()
7182 
    while True:
7183 
      (fname, ftype, fid) = iprot.readFieldBegin()
7184 
      if ftype == TType.STOP:
7185 
        break
7186 
      if fid == 1:
7187 
        if ftype == TType.STRING:
7188 
          self.name = iprot.readString();
7189 
        else:
7190 
          iprot.skip(ftype)
1859 vikas 7191 
      elif fid == 2:
7192 
        if ftype == TType.I64:
7193 
          self.addedOn = iprot.readI64();
7194 
        else:
7195 
          iprot.skip(ftype)
1845 vikas 7196 
      else:
7197 
        iprot.skip(ftype)
7198 
      iprot.readFieldEnd()
7199 
    iprot.readStructEnd()
7200 
 
7201 
  def write(self, oprot):
7202 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7203 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7204 
      return
7205 
    oprot.writeStructBegin('createMasterAffiliate_args')
7206 
    if self.name != None:
7207 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7208 
      oprot.writeString(self.name)
7209 
      oprot.writeFieldEnd()
1859 vikas 7210 
    if self.addedOn != None:
7211 
      oprot.writeFieldBegin('addedOn', TType.I64, 2)
7212 
      oprot.writeI64(self.addedOn)
7213 
      oprot.writeFieldEnd()
1845 vikas 7214 
    oprot.writeFieldStop()
7215 
    oprot.writeStructEnd()
7216 
 
7217 
  def __repr__(self):
7218 
    L = ['%s=%r' % (key, value)
7219 
      for key, value in self.__dict__.iteritems()]
7220 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7221 
 
7222 
  def __eq__(self, other):
7223 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7224 
 
7225 
  def __ne__(self, other):
7226 
    return not (self == other)
7227 
 
7228 
class createMasterAffiliate_result:
7229 
  """
7230 
  Attributes:
7231 
   - success
7232 
   - utx
7233 
  """
7234 
 
7235 
  thrift_spec = (
7236 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7237 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7238 
  )
7239 
 
7240 
  def __init__(self, success=None, utx=None,):
7241 
    self.success = success
7242 
    self.utx = utx
7243 
 
7244 
  def read(self, iprot):
7245 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7246 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7247 
      return
7248 
    iprot.readStructBegin()
7249 
    while True:
7250 
      (fname, ftype, fid) = iprot.readFieldBegin()
7251 
      if ftype == TType.STOP:
7252 
        break
7253 
      if fid == 0:
7254 
        if ftype == TType.STRUCT:
7255 
          self.success = MasterAffiliate()
7256 
          self.success.read(iprot)
7257 
        else:
7258 
          iprot.skip(ftype)
7259 
      elif fid == 1:
7260 
        if ftype == TType.STRUCT:
1996 vikas 7261 
          self.utx = UserAffiliateException()
1845 vikas 7262 
          self.utx.read(iprot)
7263 
        else:
7264 
          iprot.skip(ftype)
7265 
      else:
7266 
        iprot.skip(ftype)
7267 
      iprot.readFieldEnd()
7268 
    iprot.readStructEnd()
7269 
 
7270 
  def write(self, oprot):
7271 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7272 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7273 
      return
7274 
    oprot.writeStructBegin('createMasterAffiliate_result')
7275 
    if self.success != None:
7276 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7277 
      self.success.write(oprot)
7278 
      oprot.writeFieldEnd()
7279 
    if self.utx != None:
7280 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7281 
      self.utx.write(oprot)
7282 
      oprot.writeFieldEnd()
7283 
    oprot.writeFieldStop()
7284 
    oprot.writeStructEnd()
7285 
 
7286 
  def __repr__(self):
7287 
    L = ['%s=%r' % (key, value)
7288 
      for key, value in self.__dict__.iteritems()]
7289 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7290 
 
7291 
  def __eq__(self, other):
7292 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7293 
 
7294 
  def __ne__(self, other):
7295 
    return not (self == other)
7296 
 
1899 vikas 7297 
class getAllMasterAffiliates_args:
7298 
 
7299 
  thrift_spec = (
7300 
  )
7301 
 
7302 
  def read(self, iprot):
7303 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7304 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7305 
      return
7306 
    iprot.readStructBegin()
7307 
    while True:
7308 
      (fname, ftype, fid) = iprot.readFieldBegin()
7309 
      if ftype == TType.STOP:
7310 
        break
7311 
      else:
7312 
        iprot.skip(ftype)
7313 
      iprot.readFieldEnd()
7314 
    iprot.readStructEnd()
7315 
 
7316 
  def write(self, oprot):
7317 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7318 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7319 
      return
7320 
    oprot.writeStructBegin('getAllMasterAffiliates_args')
7321 
    oprot.writeFieldStop()
7322 
    oprot.writeStructEnd()
7323 
 
7324 
  def __repr__(self):
7325 
    L = ['%s=%r' % (key, value)
7326 
      for key, value in self.__dict__.iteritems()]
7327 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7328 
 
7329 
  def __eq__(self, other):
7330 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7331 
 
7332 
  def __ne__(self, other):
7333 
    return not (self == other)
7334 
 
7335 
class getAllMasterAffiliates_result:
7336 
  """
7337 
  Attributes:
7338 
   - success
7339 
   - utx
7340 
  """
7341 
 
7342 
  thrift_spec = (
7343 
    (0, TType.LIST, 'success', (TType.STRUCT,(MasterAffiliate, MasterAffiliate.thrift_spec)), None, ), # 0
1996 vikas 7344 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1899 vikas 7345 
  )
7346 
 
7347 
  def __init__(self, success=None, utx=None,):
7348 
    self.success = success
7349 
    self.utx = utx
7350 
 
7351 
  def read(self, iprot):
7352 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7353 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7354 
      return
7355 
    iprot.readStructBegin()
7356 
    while True:
7357 
      (fname, ftype, fid) = iprot.readFieldBegin()
7358 
      if ftype == TType.STOP:
7359 
        break
7360 
      if fid == 0:
7361 
        if ftype == TType.LIST:
7362 
          self.success = []
1976 varun.gupt 7363 
          (_etype59, _size56) = iprot.readListBegin()
7364 
          for _i60 in xrange(_size56):
7365 
            _elem61 = MasterAffiliate()
7366 
            _elem61.read(iprot)
7367 
            self.success.append(_elem61)
1899 vikas 7368 
          iprot.readListEnd()
7369 
        else:
7370 
          iprot.skip(ftype)
7371 
      elif fid == 1:
7372 
        if ftype == TType.STRUCT:
1996 vikas 7373 
          self.utx = UserAffiliateException()
1899 vikas 7374 
          self.utx.read(iprot)
7375 
        else:
7376 
          iprot.skip(ftype)
7377 
      else:
7378 
        iprot.skip(ftype)
7379 
      iprot.readFieldEnd()
7380 
    iprot.readStructEnd()
7381 
 
7382 
  def write(self, oprot):
7383 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7384 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7385 
      return
7386 
    oprot.writeStructBegin('getAllMasterAffiliates_result')
7387 
    if self.success != None:
7388 
      oprot.writeFieldBegin('success', TType.LIST, 0)
7389 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1976 varun.gupt 7390 
      for iter62 in self.success:
7391 
        iter62.write(oprot)
1899 vikas 7392 
      oprot.writeListEnd()
7393 
      oprot.writeFieldEnd()
7394 
    if self.utx != None:
7395 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7396 
      self.utx.write(oprot)
7397 
      oprot.writeFieldEnd()
7398 
    oprot.writeFieldStop()
7399 
    oprot.writeStructEnd()
7400 
 
7401 
  def __repr__(self):
7402 
    L = ['%s=%r' % (key, value)
7403 
      for key, value in self.__dict__.iteritems()]
7404 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7405 
 
7406 
  def __eq__(self, other):
7407 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7408 
 
7409 
  def __ne__(self, other):
7410 
    return not (self == other)
7411 
 
1845 vikas 7412 
class getMasterAffiliateById_args:
7413 
  """
7414 
  Attributes:
7415 
   - id
7416 
  """
7417 
 
7418 
  thrift_spec = (
7419 
    None, # 0
7420 
    (1, TType.I64, 'id', None, None, ), # 1
7421 
  )
7422 
 
7423 
  def __init__(self, id=None,):
7424 
    self.id = id
7425 
 
7426 
  def read(self, iprot):
7427 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7428 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7429 
      return
7430 
    iprot.readStructBegin()
7431 
    while True:
7432 
      (fname, ftype, fid) = iprot.readFieldBegin()
7433 
      if ftype == TType.STOP:
7434 
        break
7435 
      if fid == 1:
7436 
        if ftype == TType.I64:
7437 
          self.id = iprot.readI64();
7438 
        else:
7439 
          iprot.skip(ftype)
7440 
      else:
7441 
        iprot.skip(ftype)
7442 
      iprot.readFieldEnd()
7443 
    iprot.readStructEnd()
7444 
 
7445 
  def write(self, oprot):
7446 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7447 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7448 
      return
7449 
    oprot.writeStructBegin('getMasterAffiliateById_args')
7450 
    if self.id != None:
7451 
      oprot.writeFieldBegin('id', TType.I64, 1)
7452 
      oprot.writeI64(self.id)
7453 
      oprot.writeFieldEnd()
7454 
    oprot.writeFieldStop()
7455 
    oprot.writeStructEnd()
7456 
 
7457 
  def __repr__(self):
7458 
    L = ['%s=%r' % (key, value)
7459 
      for key, value in self.__dict__.iteritems()]
7460 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7461 
 
7462 
  def __eq__(self, other):
7463 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7464 
 
7465 
  def __ne__(self, other):
7466 
    return not (self == other)
7467 
 
7468 
class getMasterAffiliateById_result:
7469 
  """
7470 
  Attributes:
7471 
   - success
7472 
   - utx
7473 
  """
7474 
 
7475 
  thrift_spec = (
7476 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7477 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7478 
  )
7479 
 
7480 
  def __init__(self, success=None, utx=None,):
7481 
    self.success = success
7482 
    self.utx = utx
7483 
 
7484 
  def read(self, iprot):
7485 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7486 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7487 
      return
7488 
    iprot.readStructBegin()
7489 
    while True:
7490 
      (fname, ftype, fid) = iprot.readFieldBegin()
7491 
      if ftype == TType.STOP:
7492 
        break
7493 
      if fid == 0:
7494 
        if ftype == TType.STRUCT:
7495 
          self.success = MasterAffiliate()
7496 
          self.success.read(iprot)
7497 
        else:
7498 
          iprot.skip(ftype)
7499 
      elif fid == 1:
7500 
        if ftype == TType.STRUCT:
1996 vikas 7501 
          self.utx = UserAffiliateException()
1845 vikas 7502 
          self.utx.read(iprot)
7503 
        else:
7504 
          iprot.skip(ftype)
7505 
      else:
7506 
        iprot.skip(ftype)
7507 
      iprot.readFieldEnd()
7508 
    iprot.readStructEnd()
7509 
 
7510 
  def write(self, oprot):
7511 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7512 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7513 
      return
7514 
    oprot.writeStructBegin('getMasterAffiliateById_result')
7515 
    if self.success != None:
7516 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7517 
      self.success.write(oprot)
7518 
      oprot.writeFieldEnd()
7519 
    if self.utx != None:
7520 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7521 
      self.utx.write(oprot)
7522 
      oprot.writeFieldEnd()
7523 
    oprot.writeFieldStop()
7524 
    oprot.writeStructEnd()
7525 
 
7526 
  def __repr__(self):
7527 
    L = ['%s=%r' % (key, value)
7528 
      for key, value in self.__dict__.iteritems()]
7529 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7530 
 
7531 
  def __eq__(self, other):
7532 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7533 
 
7534 
  def __ne__(self, other):
7535 
    return not (self == other)
7536 
 
7537 
class getMasterAffiliateByName_args:
7538 
  """
7539 
  Attributes:
7540 
   - name
7541 
  """
7542 
 
7543 
  thrift_spec = (
7544 
    None, # 0
7545 
    (1, TType.STRING, 'name', None, None, ), # 1
7546 
  )
7547 
 
7548 
  def __init__(self, name=None,):
7549 
    self.name = name
7550 
 
7551 
  def read(self, iprot):
7552 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7553 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7554 
      return
7555 
    iprot.readStructBegin()
7556 
    while True:
7557 
      (fname, ftype, fid) = iprot.readFieldBegin()
7558 
      if ftype == TType.STOP:
7559 
        break
7560 
      if fid == 1:
7561 
        if ftype == TType.STRING:
7562 
          self.name = iprot.readString();
7563 
        else:
7564 
          iprot.skip(ftype)
7565 
      else:
7566 
        iprot.skip(ftype)
7567 
      iprot.readFieldEnd()
7568 
    iprot.readStructEnd()
7569 
 
7570 
  def write(self, oprot):
7571 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7572 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7573 
      return
7574 
    oprot.writeStructBegin('getMasterAffiliateByName_args')
7575 
    if self.name != None:
7576 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7577 
      oprot.writeString(self.name)
7578 
      oprot.writeFieldEnd()
7579 
    oprot.writeFieldStop()
7580 
    oprot.writeStructEnd()
7581 
 
7582 
  def __repr__(self):
7583 
    L = ['%s=%r' % (key, value)
7584 
      for key, value in self.__dict__.iteritems()]
7585 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7586 
 
7587 
  def __eq__(self, other):
7588 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7589 
 
7590 
  def __ne__(self, other):
7591 
    return not (self == other)
7592 
 
7593 
class getMasterAffiliateByName_result:
7594 
  """
7595 
  Attributes:
7596 
   - success
7597 
   - utx
7598 
  """
7599 
 
7600 
  thrift_spec = (
7601 
    (0, TType.STRUCT, 'success', (MasterAffiliate, MasterAffiliate.thrift_spec), None, ), # 0
1996 vikas 7602 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7603 
  )
7604 
 
7605 
  def __init__(self, success=None, utx=None,):
7606 
    self.success = success
7607 
    self.utx = utx
7608 
 
7609 
  def read(self, iprot):
7610 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7611 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7612 
      return
7613 
    iprot.readStructBegin()
7614 
    while True:
7615 
      (fname, ftype, fid) = iprot.readFieldBegin()
7616 
      if ftype == TType.STOP:
7617 
        break
7618 
      if fid == 0:
7619 
        if ftype == TType.STRUCT:
7620 
          self.success = MasterAffiliate()
7621 
          self.success.read(iprot)
7622 
        else:
7623 
          iprot.skip(ftype)
7624 
      elif fid == 1:
7625 
        if ftype == TType.STRUCT:
1996 vikas 7626 
          self.utx = UserAffiliateException()
1845 vikas 7627 
          self.utx.read(iprot)
7628 
        else:
7629 
          iprot.skip(ftype)
7630 
      else:
7631 
        iprot.skip(ftype)
7632 
      iprot.readFieldEnd()
7633 
    iprot.readStructEnd()
7634 
 
7635 
  def write(self, oprot):
7636 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7637 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7638 
      return
7639 
    oprot.writeStructBegin('getMasterAffiliateByName_result')
7640 
    if self.success != None:
7641 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7642 
      self.success.write(oprot)
7643 
      oprot.writeFieldEnd()
7644 
    if self.utx != None:
7645 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7646 
      self.utx.write(oprot)
7647 
      oprot.writeFieldEnd()
7648 
    oprot.writeFieldStop()
7649 
    oprot.writeStructEnd()
7650 
 
7651 
  def __repr__(self):
7652 
    L = ['%s=%r' % (key, value)
7653 
      for key, value in self.__dict__.iteritems()]
7654 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7655 
 
7656 
  def __eq__(self, other):
7657 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7658 
 
7659 
  def __ne__(self, other):
7660 
    return not (self == other)
7661 
 
7662 
class createAffiliate_args:
7663 
  """
7664 
  Attributes:
7665 
   - name
7666 
   - url
7667 
   - masterAffiliateId
1859 vikas 7668 
   - addedOn
1845 vikas 7669 
  """
7670 
 
7671 
  thrift_spec = (
7672 
    None, # 0
7673 
    (1, TType.STRING, 'name', None, None, ), # 1
7674 
    (2, TType.STRING, 'url', None, None, ), # 2
7675 
    (3, TType.I64, 'masterAffiliateId', None, None, ), # 3
1859 vikas 7676 
    (4, TType.I64, 'addedOn', None, None, ), # 4
1845 vikas 7677 
  )
7678 
 
1859 vikas 7679 
  def __init__(self, name=None, url=None, masterAffiliateId=None, addedOn=None,):
1845 vikas 7680 
    self.name = name
7681 
    self.url = url
7682 
    self.masterAffiliateId = masterAffiliateId
1859 vikas 7683 
    self.addedOn = addedOn
1845 vikas 7684 
 
7685 
  def read(self, iprot):
7686 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7687 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7688 
      return
7689 
    iprot.readStructBegin()
7690 
    while True:
7691 
      (fname, ftype, fid) = iprot.readFieldBegin()
7692 
      if ftype == TType.STOP:
7693 
        break
7694 
      if fid == 1:
7695 
        if ftype == TType.STRING:
7696 
          self.name = iprot.readString();
7697 
        else:
7698 
          iprot.skip(ftype)
7699 
      elif fid == 2:
7700 
        if ftype == TType.STRING:
7701 
          self.url = iprot.readString();
7702 
        else:
7703 
          iprot.skip(ftype)
7704 
      elif fid == 3:
7705 
        if ftype == TType.I64:
7706 
          self.masterAffiliateId = iprot.readI64();
7707 
        else:
7708 
          iprot.skip(ftype)
1859 vikas 7709 
      elif fid == 4:
7710 
        if ftype == TType.I64:
7711 
          self.addedOn = iprot.readI64();
7712 
        else:
7713 
          iprot.skip(ftype)
1845 vikas 7714 
      else:
7715 
        iprot.skip(ftype)
7716 
      iprot.readFieldEnd()
7717 
    iprot.readStructEnd()
7718 
 
7719 
  def write(self, oprot):
7720 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7721 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7722 
      return
7723 
    oprot.writeStructBegin('createAffiliate_args')
7724 
    if self.name != None:
7725 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7726 
      oprot.writeString(self.name)
7727 
      oprot.writeFieldEnd()
7728 
    if self.url != None:
7729 
      oprot.writeFieldBegin('url', TType.STRING, 2)
7730 
      oprot.writeString(self.url)
7731 
      oprot.writeFieldEnd()
7732 
    if self.masterAffiliateId != None:
7733 
      oprot.writeFieldBegin('masterAffiliateId', TType.I64, 3)
7734 
      oprot.writeI64(self.masterAffiliateId)
7735 
      oprot.writeFieldEnd()
1859 vikas 7736 
    if self.addedOn != None:
7737 
      oprot.writeFieldBegin('addedOn', TType.I64, 4)
7738 
      oprot.writeI64(self.addedOn)
7739 
      oprot.writeFieldEnd()
1845 vikas 7740 
    oprot.writeFieldStop()
7741 
    oprot.writeStructEnd()
7742 
 
7743 
  def __repr__(self):
7744 
    L = ['%s=%r' % (key, value)
7745 
      for key, value in self.__dict__.iteritems()]
7746 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7747 
 
7748 
  def __eq__(self, other):
7749 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7750 
 
7751 
  def __ne__(self, other):
7752 
    return not (self == other)
7753 
 
7754 
class createAffiliate_result:
7755 
  """
7756 
  Attributes:
7757 
   - success
7758 
   - utx
7759 
  """
7760 
 
7761 
  thrift_spec = (
7762 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 7763 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7764 
  )
7765 
 
7766 
  def __init__(self, success=None, utx=None,):
7767 
    self.success = success
7768 
    self.utx = utx
7769 
 
7770 
  def read(self, iprot):
7771 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7772 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7773 
      return
7774 
    iprot.readStructBegin()
7775 
    while True:
7776 
      (fname, ftype, fid) = iprot.readFieldBegin()
7777 
      if ftype == TType.STOP:
7778 
        break
7779 
      if fid == 0:
7780 
        if ftype == TType.STRUCT:
7781 
          self.success = Affiliate()
7782 
          self.success.read(iprot)
7783 
        else:
7784 
          iprot.skip(ftype)
7785 
      elif fid == 1:
7786 
        if ftype == TType.STRUCT:
1996 vikas 7787 
          self.utx = UserAffiliateException()
1845 vikas 7788 
          self.utx.read(iprot)
7789 
        else:
7790 
          iprot.skip(ftype)
7791 
      else:
7792 
        iprot.skip(ftype)
7793 
      iprot.readFieldEnd()
7794 
    iprot.readStructEnd()
7795 
 
7796 
  def write(self, oprot):
7797 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7798 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7799 
      return
7800 
    oprot.writeStructBegin('createAffiliate_result')
7801 
    if self.success != None:
7802 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7803 
      self.success.write(oprot)
7804 
      oprot.writeFieldEnd()
7805 
    if self.utx != None:
7806 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7807 
      self.utx.write(oprot)
7808 
      oprot.writeFieldEnd()
7809 
    oprot.writeFieldStop()
7810 
    oprot.writeStructEnd()
7811 
 
7812 
  def __repr__(self):
7813 
    L = ['%s=%r' % (key, value)
7814 
      for key, value in self.__dict__.iteritems()]
7815 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7816 
 
7817 
  def __eq__(self, other):
7818 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7819 
 
7820 
  def __ne__(self, other):
7821 
    return not (self == other)
7822 
 
7823 
class getAffiliateById_args:
7824 
  """
7825 
  Attributes:
7826 
   - id
7827 
  """
7828 
 
7829 
  thrift_spec = (
7830 
    None, # 0
7831 
    (1, TType.I64, 'id', None, None, ), # 1
7832 
  )
7833 
 
7834 
  def __init__(self, id=None,):
7835 
    self.id = id
7836 
 
7837 
  def read(self, iprot):
7838 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7839 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7840 
      return
7841 
    iprot.readStructBegin()
7842 
    while True:
7843 
      (fname, ftype, fid) = iprot.readFieldBegin()
7844 
      if ftype == TType.STOP:
7845 
        break
7846 
      if fid == 1:
7847 
        if ftype == TType.I64:
7848 
          self.id = iprot.readI64();
7849 
        else:
7850 
          iprot.skip(ftype)
7851 
      else:
7852 
        iprot.skip(ftype)
7853 
      iprot.readFieldEnd()
7854 
    iprot.readStructEnd()
7855 
 
7856 
  def write(self, oprot):
7857 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7858 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7859 
      return
7860 
    oprot.writeStructBegin('getAffiliateById_args')
7861 
    if self.id != None:
7862 
      oprot.writeFieldBegin('id', TType.I64, 1)
7863 
      oprot.writeI64(self.id)
7864 
      oprot.writeFieldEnd()
7865 
    oprot.writeFieldStop()
7866 
    oprot.writeStructEnd()
7867 
 
7868 
  def __repr__(self):
7869 
    L = ['%s=%r' % (key, value)
7870 
      for key, value in self.__dict__.iteritems()]
7871 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7872 
 
7873 
  def __eq__(self, other):
7874 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7875 
 
7876 
  def __ne__(self, other):
7877 
    return not (self == other)
7878 
 
7879 
class getAffiliateById_result:
7880 
  """
7881 
  Attributes:
7882 
   - success
7883 
   - utx
7884 
  """
7885 
 
7886 
  thrift_spec = (
7887 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 7888 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 7889 
  )
7890 
 
7891 
  def __init__(self, success=None, utx=None,):
7892 
    self.success = success
7893 
    self.utx = utx
7894 
 
7895 
  def read(self, iprot):
7896 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7897 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7898 
      return
7899 
    iprot.readStructBegin()
7900 
    while True:
7901 
      (fname, ftype, fid) = iprot.readFieldBegin()
7902 
      if ftype == TType.STOP:
7903 
        break
7904 
      if fid == 0:
7905 
        if ftype == TType.STRUCT:
7906 
          self.success = Affiliate()
7907 
          self.success.read(iprot)
7908 
        else:
7909 
          iprot.skip(ftype)
7910 
      elif fid == 1:
7911 
        if ftype == TType.STRUCT:
1996 vikas 7912 
          self.utx = UserAffiliateException()
1845 vikas 7913 
          self.utx.read(iprot)
7914 
        else:
7915 
          iprot.skip(ftype)
7916 
      else:
7917 
        iprot.skip(ftype)
7918 
      iprot.readFieldEnd()
7919 
    iprot.readStructEnd()
7920 
 
7921 
  def write(self, oprot):
7922 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7923 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7924 
      return
7925 
    oprot.writeStructBegin('getAffiliateById_result')
7926 
    if self.success != None:
7927 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
7928 
      self.success.write(oprot)
7929 
      oprot.writeFieldEnd()
7930 
    if self.utx != None:
7931 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
7932 
      self.utx.write(oprot)
7933 
      oprot.writeFieldEnd()
7934 
    oprot.writeFieldStop()
7935 
    oprot.writeStructEnd()
7936 
 
7937 
  def __repr__(self):
7938 
    L = ['%s=%r' % (key, value)
7939 
      for key, value in self.__dict__.iteritems()]
7940 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7941 
 
7942 
  def __eq__(self, other):
7943 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
7944 
 
7945 
  def __ne__(self, other):
7946 
    return not (self == other)
7947 
 
7948 
class getAffiliateByName_args:
7949 
  """
7950 
  Attributes:
7951 
   - name
7952 
  """
7953 
 
7954 
  thrift_spec = (
7955 
    None, # 0
7956 
    (1, TType.STRING, 'name', None, None, ), # 1
7957 
  )
7958 
 
7959 
  def __init__(self, name=None,):
7960 
    self.name = name
7961 
 
7962 
  def read(self, iprot):
7963 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
7964 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
7965 
      return
7966 
    iprot.readStructBegin()
7967 
    while True:
7968 
      (fname, ftype, fid) = iprot.readFieldBegin()
7969 
      if ftype == TType.STOP:
7970 
        break
7971 
      if fid == 1:
7972 
        if ftype == TType.STRING:
7973 
          self.name = iprot.readString();
7974 
        else:
7975 
          iprot.skip(ftype)
7976 
      else:
7977 
        iprot.skip(ftype)
7978 
      iprot.readFieldEnd()
7979 
    iprot.readStructEnd()
7980 
 
7981 
  def write(self, oprot):
7982 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
7983 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
7984 
      return
7985 
    oprot.writeStructBegin('getAffiliateByName_args')
7986 
    if self.name != None:
7987 
      oprot.writeFieldBegin('name', TType.STRING, 1)
7988 
      oprot.writeString(self.name)
7989 
      oprot.writeFieldEnd()
7990 
    oprot.writeFieldStop()
7991 
    oprot.writeStructEnd()
7992 
 
7993 
  def __repr__(self):
7994 
    L = ['%s=%r' % (key, value)
7995 
      for key, value in self.__dict__.iteritems()]
7996 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
7997 
 
7998 
  def __eq__(self, other):
7999 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8000 
 
8001 
  def __ne__(self, other):
8002 
    return not (self == other)
8003 
 
8004 
class getAffiliateByName_result:
8005 
  """
8006 
  Attributes:
8007 
   - success
8008 
   - utx
8009 
  """
8010 
 
8011 
  thrift_spec = (
8012 
    (0, TType.STRUCT, 'success', (Affiliate, Affiliate.thrift_spec), None, ), # 0
1996 vikas 8013 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8014 
  )
8015 
 
8016 
  def __init__(self, success=None, utx=None,):
8017 
    self.success = success
8018 
    self.utx = utx
8019 
 
8020 
  def read(self, iprot):
8021 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8022 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8023 
      return
8024 
    iprot.readStructBegin()
8025 
    while True:
8026 
      (fname, ftype, fid) = iprot.readFieldBegin()
8027 
      if ftype == TType.STOP:
8028 
        break
8029 
      if fid == 0:
8030 
        if ftype == TType.STRUCT:
8031 
          self.success = Affiliate()
8032 
          self.success.read(iprot)
8033 
        else:
8034 
          iprot.skip(ftype)
8035 
      elif fid == 1:
8036 
        if ftype == TType.STRUCT:
1996 vikas 8037 
          self.utx = UserAffiliateException()
1845 vikas 8038 
          self.utx.read(iprot)
8039 
        else:
8040 
          iprot.skip(ftype)
8041 
      else:
8042 
        iprot.skip(ftype)
8043 
      iprot.readFieldEnd()
8044 
    iprot.readStructEnd()
8045 
 
8046 
  def write(self, oprot):
8047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8049 
      return
8050 
    oprot.writeStructBegin('getAffiliateByName_result')
8051 
    if self.success != None:
8052 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8053 
      self.success.write(oprot)
8054 
      oprot.writeFieldEnd()
8055 
    if self.utx != None:
8056 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8057 
      self.utx.write(oprot)
8058 
      oprot.writeFieldEnd()
8059 
    oprot.writeFieldStop()
8060 
    oprot.writeStructEnd()
8061 
 
8062 
  def __repr__(self):
8063 
    L = ['%s=%r' % (key, value)
8064 
      for key, value in self.__dict__.iteritems()]
8065 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8066 
 
8067 
  def __eq__(self, other):
8068 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8069 
 
8070 
  def __ne__(self, other):
8071 
    return not (self == other)
8072 
 
1996 vikas 8073 
class getTrackerById_args:
1845 vikas 8074 
  """
8075 
  Attributes:
8076 
   - id
8077 
  """
8078 
 
8079 
  thrift_spec = (
8080 
    None, # 0
8081 
    (1, TType.I64, 'id', None, None, ), # 1
8082 
  )
8083 
 
8084 
  def __init__(self, id=None,):
8085 
    self.id = id
8086 
 
8087 
  def read(self, iprot):
8088 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8089 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8090 
      return
8091 
    iprot.readStructBegin()
8092 
    while True:
8093 
      (fname, ftype, fid) = iprot.readFieldBegin()
8094 
      if ftype == TType.STOP:
8095 
        break
8096 
      if fid == 1:
8097 
        if ftype == TType.I64:
8098 
          self.id = iprot.readI64();
8099 
        else:
8100 
          iprot.skip(ftype)
8101 
      else:
8102 
        iprot.skip(ftype)
8103 
      iprot.readFieldEnd()
8104 
    iprot.readStructEnd()
8105 
 
8106 
  def write(self, oprot):
8107 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8108 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8109 
      return
1996 vikas 8110 
    oprot.writeStructBegin('getTrackerById_args')
1845 vikas 8111 
    if self.id != None:
8112 
      oprot.writeFieldBegin('id', TType.I64, 1)
8113 
      oprot.writeI64(self.id)
8114 
      oprot.writeFieldEnd()
8115 
    oprot.writeFieldStop()
8116 
    oprot.writeStructEnd()
8117 
 
8118 
  def __repr__(self):
8119 
    L = ['%s=%r' % (key, value)
8120 
      for key, value in self.__dict__.iteritems()]
8121 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8122 
 
8123 
  def __eq__(self, other):
8124 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8125 
 
8126 
  def __ne__(self, other):
8127 
    return not (self == other)
8128 
 
8129 
class getTrackerById_result:
8130 
  """
8131 
  Attributes:
8132 
   - success
8133 
   - utx
8134 
  """
8135 
 
8136 
  thrift_spec = (
8137 
    (0, TType.STRUCT, 'success', (Tracker, Tracker.thrift_spec), None, ), # 0
1996 vikas 8138 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8139 
  )
8140 
 
8141 
  def __init__(self, success=None, utx=None,):
8142 
    self.success = success
8143 
    self.utx = utx
8144 
 
8145 
  def read(self, iprot):
8146 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8147 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8148 
      return
8149 
    iprot.readStructBegin()
8150 
    while True:
8151 
      (fname, ftype, fid) = iprot.readFieldBegin()
8152 
      if ftype == TType.STOP:
8153 
        break
8154 
      if fid == 0:
8155 
        if ftype == TType.STRUCT:
8156 
          self.success = Tracker()
8157 
          self.success.read(iprot)
8158 
        else:
8159 
          iprot.skip(ftype)
8160 
      elif fid == 1:
8161 
        if ftype == TType.STRUCT:
1996 vikas 8162 
          self.utx = UserAffiliateException()
1845 vikas 8163 
          self.utx.read(iprot)
8164 
        else:
8165 
          iprot.skip(ftype)
8166 
      else:
8167 
        iprot.skip(ftype)
8168 
      iprot.readFieldEnd()
8169 
    iprot.readStructEnd()
8170 
 
8171 
  def write(self, oprot):
8172 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8173 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8174 
      return
8175 
    oprot.writeStructBegin('getTrackerById_result')
8176 
    if self.success != None:
8177 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8178 
      self.success.write(oprot)
8179 
      oprot.writeFieldEnd()
8180 
    if self.utx != None:
8181 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8182 
      self.utx.write(oprot)
8183 
      oprot.writeFieldEnd()
8184 
    oprot.writeFieldStop()
8185 
    oprot.writeStructEnd()
8186 
 
8187 
  def __repr__(self):
8188 
    L = ['%s=%r' % (key, value)
8189 
      for key, value in self.__dict__.iteritems()]
8190 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8191 
 
8192 
  def __eq__(self, other):
8193 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8194 
 
8195 
  def __ne__(self, other):
8196 
    return not (self == other)
8197 
 
1996 vikas 8198 
class getAffiliatesByMasterAffiliate_args:
1845 vikas 8199 
  """
8200 
  Attributes:
1996 vikas 8201 
   - id
1845 vikas 8202 
  """
8203 
 
8204 
  thrift_spec = (
8205 
    None, # 0
1996 vikas 8206 
    (1, TType.I64, 'id', None, None, ), # 1
1845 vikas 8207 
  )
8208 
 
1996 vikas 8209 
  def __init__(self, id=None,):
8210 
    self.id = id
1845 vikas 8211 
 
8212 
  def read(self, iprot):
8213 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8214 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8215 
      return
8216 
    iprot.readStructBegin()
8217 
    while True:
8218 
      (fname, ftype, fid) = iprot.readFieldBegin()
8219 
      if ftype == TType.STOP:
8220 
        break
8221 
      if fid == 1:
8222 
        if ftype == TType.I64:
1996 vikas 8223 
          self.id = iprot.readI64();
1845 vikas 8224 
        else:
8225 
          iprot.skip(ftype)
8226 
      else:
8227 
        iprot.skip(ftype)
8228 
      iprot.readFieldEnd()
8229 
    iprot.readStructEnd()
8230 
 
8231 
  def write(self, oprot):
8232 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8233 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8234 
      return
1996 vikas 8235 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_args')
8236 
    if self.id != None:
8237 
      oprot.writeFieldBegin('id', TType.I64, 1)
8238 
      oprot.writeI64(self.id)
1845 vikas 8239 
      oprot.writeFieldEnd()
8240 
    oprot.writeFieldStop()
8241 
    oprot.writeStructEnd()
8242 
 
8243 
  def __repr__(self):
8244 
    L = ['%s=%r' % (key, value)
8245 
      for key, value in self.__dict__.iteritems()]
8246 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8247 
 
8248 
  def __eq__(self, other):
8249 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8250 
 
8251 
  def __ne__(self, other):
8252 
    return not (self == other)
8253 
 
1996 vikas 8254 
class getAffiliatesByMasterAffiliate_result:
1845 vikas 8255 
  """
8256 
  Attributes:
8257 
   - success
8258 
   - utx
8259 
  """
8260 
 
8261 
  thrift_spec = (
1996 vikas 8262 
    (0, TType.LIST, 'success', (TType.STRUCT,(Affiliate, Affiliate.thrift_spec)), None, ), # 0
8263 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8264 
  )
8265 
 
8266 
  def __init__(self, success=None, utx=None,):
8267 
    self.success = success
8268 
    self.utx = utx
8269 
 
8270 
  def read(self, iprot):
8271 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8272 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8273 
      return
8274 
    iprot.readStructBegin()
8275 
    while True:
8276 
      (fname, ftype, fid) = iprot.readFieldBegin()
8277 
      if ftype == TType.STOP:
8278 
        break
8279 
      if fid == 0:
8280 
        if ftype == TType.LIST:
8281 
          self.success = []
1996 vikas 8282 
          (_etype66, _size63) = iprot.readListBegin()
8283 
          for _i67 in xrange(_size63):
8284 
            _elem68 = Affiliate()
8285 
            _elem68.read(iprot)
8286 
            self.success.append(_elem68)
1845 vikas 8287 
          iprot.readListEnd()
8288 
        else:
8289 
          iprot.skip(ftype)
8290 
      elif fid == 1:
8291 
        if ftype == TType.STRUCT:
1996 vikas 8292 
          self.utx = UserAffiliateException()
1845 vikas 8293 
          self.utx.read(iprot)
8294 
        else:
8295 
          iprot.skip(ftype)
8296 
      else:
8297 
        iprot.skip(ftype)
8298 
      iprot.readFieldEnd()
8299 
    iprot.readStructEnd()
8300 
 
8301 
  def write(self, oprot):
8302 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8303 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8304 
      return
1996 vikas 8305 
    oprot.writeStructBegin('getAffiliatesByMasterAffiliate_result')
1845 vikas 8306 
    if self.success != None:
8307 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8308 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 8309 
      for iter69 in self.success:
8310 
        iter69.write(oprot)
1845 vikas 8311 
      oprot.writeListEnd()
8312 
      oprot.writeFieldEnd()
8313 
    if self.utx != None:
8314 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8315 
      self.utx.write(oprot)
8316 
      oprot.writeFieldEnd()
8317 
    oprot.writeFieldStop()
8318 
    oprot.writeStructEnd()
8319 
 
8320 
  def __repr__(self):
8321 
    L = ['%s=%r' % (key, value)
8322 
      for key, value in self.__dict__.iteritems()]
8323 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8324 
 
8325 
  def __eq__(self, other):
8326 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8327 
 
8328 
  def __ne__(self, other):
8329 
    return not (self == other)
8330 
 
8331 
class addTrackLog_args:
8332 
  """
8333 
  Attributes:
1996 vikas 8334 
   - affiliateId
1845 vikas 8335 
   - userId
8336 
   - event
8337 
   - url
8338 
   - data
1859 vikas 8339 
   - addedOn
1845 vikas 8340 
  """
8341 
 
8342 
  thrift_spec = (
8343 
    None, # 0
1996 vikas 8344 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 8345 
    (2, TType.I64, 'userId', None, None, ), # 2
8346 
    (3, TType.STRING, 'event', None, None, ), # 3
8347 
    (4, TType.STRING, 'url', None, None, ), # 4
8348 
    (5, TType.STRING, 'data', None, None, ), # 5
1859 vikas 8349 
    (6, TType.I64, 'addedOn', None, None, ), # 6
1845 vikas 8350 
  )
8351 
 
1996 vikas 8352 
  def __init__(self, affiliateId=None, userId=None, event=None, url=None, data=None, addedOn=None,):
8353 
    self.affiliateId = affiliateId
1845 vikas 8354 
    self.userId = userId
8355 
    self.event = event
8356 
    self.url = url
8357 
    self.data = data
1859 vikas 8358 
    self.addedOn = addedOn
1845 vikas 8359 
 
8360 
  def read(self, iprot):
8361 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8362 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8363 
      return
8364 
    iprot.readStructBegin()
8365 
    while True:
8366 
      (fname, ftype, fid) = iprot.readFieldBegin()
8367 
      if ftype == TType.STOP:
8368 
        break
8369 
      if fid == 1:
8370 
        if ftype == TType.I64:
1996 vikas 8371 
          self.affiliateId = iprot.readI64();
1845 vikas 8372 
        else:
8373 
          iprot.skip(ftype)
8374 
      elif fid == 2:
8375 
        if ftype == TType.I64:
8376 
          self.userId = iprot.readI64();
8377 
        else:
8378 
          iprot.skip(ftype)
8379 
      elif fid == 3:
8380 
        if ftype == TType.STRING:
8381 
          self.event = iprot.readString();
8382 
        else:
8383 
          iprot.skip(ftype)
8384 
      elif fid == 4:
8385 
        if ftype == TType.STRING:
8386 
          self.url = iprot.readString();
8387 
        else:
8388 
          iprot.skip(ftype)
8389 
      elif fid == 5:
8390 
        if ftype == TType.STRING:
8391 
          self.data = iprot.readString();
8392 
        else:
8393 
          iprot.skip(ftype)
1859 vikas 8394 
      elif fid == 6:
8395 
        if ftype == TType.I64:
8396 
          self.addedOn = iprot.readI64();
8397 
        else:
8398 
          iprot.skip(ftype)
1845 vikas 8399 
      else:
8400 
        iprot.skip(ftype)
8401 
      iprot.readFieldEnd()
8402 
    iprot.readStructEnd()
8403 
 
8404 
  def write(self, oprot):
8405 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8406 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8407 
      return
8408 
    oprot.writeStructBegin('addTrackLog_args')
1996 vikas 8409 
    if self.affiliateId != None:
8410 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
8411 
      oprot.writeI64(self.affiliateId)
1845 vikas 8412 
      oprot.writeFieldEnd()
8413 
    if self.userId != None:
8414 
      oprot.writeFieldBegin('userId', TType.I64, 2)
8415 
      oprot.writeI64(self.userId)
8416 
      oprot.writeFieldEnd()
8417 
    if self.event != None:
8418 
      oprot.writeFieldBegin('event', TType.STRING, 3)
8419 
      oprot.writeString(self.event)
8420 
      oprot.writeFieldEnd()
8421 
    if self.url != None:
8422 
      oprot.writeFieldBegin('url', TType.STRING, 4)
8423 
      oprot.writeString(self.url)
8424 
      oprot.writeFieldEnd()
8425 
    if self.data != None:
8426 
      oprot.writeFieldBegin('data', TType.STRING, 5)
8427 
      oprot.writeString(self.data)
8428 
      oprot.writeFieldEnd()
1859 vikas 8429 
    if self.addedOn != None:
8430 
      oprot.writeFieldBegin('addedOn', TType.I64, 6)
8431 
      oprot.writeI64(self.addedOn)
8432 
      oprot.writeFieldEnd()
1845 vikas 8433 
    oprot.writeFieldStop()
8434 
    oprot.writeStructEnd()
8435 
 
8436 
  def __repr__(self):
8437 
    L = ['%s=%r' % (key, value)
8438 
      for key, value in self.__dict__.iteritems()]
8439 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8440 
 
8441 
  def __eq__(self, other):
8442 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8443 
 
8444 
  def __ne__(self, other):
8445 
    return not (self == other)
8446 
 
8447 
class addTrackLog_result:
8448 
  """
8449 
  Attributes:
8450 
   - success
8451 
   - utx
8452 
  """
8453 
 
8454 
  thrift_spec = (
8455 
    (0, TType.I64, 'success', None, None, ), # 0
1996 vikas 8456 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8457 
  )
8458 
 
8459 
  def __init__(self, success=None, utx=None,):
8460 
    self.success = success
8461 
    self.utx = utx
8462 
 
8463 
  def read(self, iprot):
8464 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8465 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8466 
      return
8467 
    iprot.readStructBegin()
8468 
    while True:
8469 
      (fname, ftype, fid) = iprot.readFieldBegin()
8470 
      if ftype == TType.STOP:
8471 
        break
8472 
      if fid == 0:
8473 
        if ftype == TType.I64:
8474 
          self.success = iprot.readI64();
8475 
        else:
8476 
          iprot.skip(ftype)
8477 
      elif fid == 1:
8478 
        if ftype == TType.STRUCT:
1996 vikas 8479 
          self.utx = UserAffiliateException()
1845 vikas 8480 
          self.utx.read(iprot)
8481 
        else:
8482 
          iprot.skip(ftype)
8483 
      else:
8484 
        iprot.skip(ftype)
8485 
      iprot.readFieldEnd()
8486 
    iprot.readStructEnd()
8487 
 
8488 
  def write(self, oprot):
8489 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8490 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8491 
      return
8492 
    oprot.writeStructBegin('addTrackLog_result')
8493 
    if self.success != None:
8494 
      oprot.writeFieldBegin('success', TType.I64, 0)
8495 
      oprot.writeI64(self.success)
8496 
      oprot.writeFieldEnd()
8497 
    if self.utx != None:
8498 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8499 
      self.utx.write(oprot)
8500 
      oprot.writeFieldEnd()
8501 
    oprot.writeFieldStop()
8502 
    oprot.writeStructEnd()
8503 
 
8504 
  def __repr__(self):
8505 
    L = ['%s=%r' % (key, value)
8506 
      for key, value in self.__dict__.iteritems()]
8507 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8508 
 
8509 
  def __eq__(self, other):
8510 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8511 
 
8512 
  def __ne__(self, other):
8513 
    return not (self == other)
8514 
 
8515 
class getTrackLogById_args:
8516 
  """
8517 
  Attributes:
8518 
   - id
8519 
  """
8520 
 
8521 
  thrift_spec = (
8522 
    None, # 0
8523 
    (1, TType.I64, 'id', None, None, ), # 1
8524 
  )
8525 
 
8526 
  def __init__(self, id=None,):
8527 
    self.id = id
8528 
 
8529 
  def read(self, iprot):
8530 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8531 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8532 
      return
8533 
    iprot.readStructBegin()
8534 
    while True:
8535 
      (fname, ftype, fid) = iprot.readFieldBegin()
8536 
      if ftype == TType.STOP:
8537 
        break
8538 
      if fid == 1:
8539 
        if ftype == TType.I64:
8540 
          self.id = iprot.readI64();
8541 
        else:
8542 
          iprot.skip(ftype)
8543 
      else:
8544 
        iprot.skip(ftype)
8545 
      iprot.readFieldEnd()
8546 
    iprot.readStructEnd()
8547 
 
8548 
  def write(self, oprot):
8549 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8550 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8551 
      return
8552 
    oprot.writeStructBegin('getTrackLogById_args')
8553 
    if self.id != None:
8554 
      oprot.writeFieldBegin('id', TType.I64, 1)
8555 
      oprot.writeI64(self.id)
8556 
      oprot.writeFieldEnd()
8557 
    oprot.writeFieldStop()
8558 
    oprot.writeStructEnd()
8559 
 
8560 
  def __repr__(self):
8561 
    L = ['%s=%r' % (key, value)
8562 
      for key, value in self.__dict__.iteritems()]
8563 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8564 
 
8565 
  def __eq__(self, other):
8566 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8567 
 
8568 
  def __ne__(self, other):
8569 
    return not (self == other)
8570 
 
8571 
class getTrackLogById_result:
8572 
  """
8573 
  Attributes:
8574 
   - success
8575 
   - utx
8576 
  """
8577 
 
8578 
  thrift_spec = (
8579 
    (0, TType.STRUCT, 'success', (TrackLog, TrackLog.thrift_spec), None, ), # 0
1996 vikas 8580 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8581 
  )
8582 
 
8583 
  def __init__(self, success=None, utx=None,):
8584 
    self.success = success
8585 
    self.utx = utx
8586 
 
8587 
  def read(self, iprot):
8588 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8589 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8590 
      return
8591 
    iprot.readStructBegin()
8592 
    while True:
8593 
      (fname, ftype, fid) = iprot.readFieldBegin()
8594 
      if ftype == TType.STOP:
8595 
        break
8596 
      if fid == 0:
8597 
        if ftype == TType.STRUCT:
8598 
          self.success = TrackLog()
8599 
          self.success.read(iprot)
8600 
        else:
8601 
          iprot.skip(ftype)
8602 
      elif fid == 1:
8603 
        if ftype == TType.STRUCT:
1996 vikas 8604 
          self.utx = UserAffiliateException()
1845 vikas 8605 
          self.utx.read(iprot)
8606 
        else:
8607 
          iprot.skip(ftype)
8608 
      else:
8609 
        iprot.skip(ftype)
8610 
      iprot.readFieldEnd()
8611 
    iprot.readStructEnd()
8612 
 
8613 
  def write(self, oprot):
8614 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8615 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8616 
      return
8617 
    oprot.writeStructBegin('getTrackLogById_result')
8618 
    if self.success != None:
8619 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
8620 
      self.success.write(oprot)
8621 
      oprot.writeFieldEnd()
8622 
    if self.utx != None:
8623 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8624 
      self.utx.write(oprot)
8625 
      oprot.writeFieldEnd()
8626 
    oprot.writeFieldStop()
8627 
    oprot.writeStructEnd()
8628 
 
8629 
  def __repr__(self):
8630 
    L = ['%s=%r' % (key, value)
8631 
      for key, value in self.__dict__.iteritems()]
8632 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8633 
 
8634 
  def __eq__(self, other):
8635 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8636 
 
8637 
  def __ne__(self, other):
8638 
    return not (self == other)
8639 
 
1996 vikas 8640 
class getTrackLogsByAffiliate_args:
1845 vikas 8641 
  """
8642 
  Attributes:
1996 vikas 8643 
   - affiliateId
1845 vikas 8644 
  """
8645 
 
8646 
  thrift_spec = (
8647 
    None, # 0
1996 vikas 8648 
    (1, TType.I64, 'affiliateId', None, None, ), # 1
1845 vikas 8649 
  )
8650 
 
1996 vikas 8651 
  def __init__(self, affiliateId=None,):
8652 
    self.affiliateId = affiliateId
1845 vikas 8653 
 
8654 
  def read(self, iprot):
8655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8657 
      return
8658 
    iprot.readStructBegin()
8659 
    while True:
8660 
      (fname, ftype, fid) = iprot.readFieldBegin()
8661 
      if ftype == TType.STOP:
8662 
        break
8663 
      if fid == 1:
8664 
        if ftype == TType.I64:
1996 vikas 8665 
          self.affiliateId = iprot.readI64();
1845 vikas 8666 
        else:
8667 
          iprot.skip(ftype)
8668 
      else:
8669 
        iprot.skip(ftype)
8670 
      iprot.readFieldEnd()
8671 
    iprot.readStructEnd()
8672 
 
8673 
  def write(self, oprot):
8674 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8675 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8676 
      return
1996 vikas 8677 
    oprot.writeStructBegin('getTrackLogsByAffiliate_args')
8678 
    if self.affiliateId != None:
8679 
      oprot.writeFieldBegin('affiliateId', TType.I64, 1)
8680 
      oprot.writeI64(self.affiliateId)
1845 vikas 8681 
      oprot.writeFieldEnd()
8682 
    oprot.writeFieldStop()
8683 
    oprot.writeStructEnd()
8684 
 
8685 
  def __repr__(self):
8686 
    L = ['%s=%r' % (key, value)
8687 
      for key, value in self.__dict__.iteritems()]
8688 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8689 
 
8690 
  def __eq__(self, other):
8691 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8692 
 
8693 
  def __ne__(self, other):
8694 
    return not (self == other)
8695 
 
1996 vikas 8696 
class getTrackLogsByAffiliate_result:
1845 vikas 8697 
  """
8698 
  Attributes:
8699 
   - success
8700 
   - utx
8701 
  """
8702 
 
8703 
  thrift_spec = (
8704 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 8705 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8706 
  )
8707 
 
8708 
  def __init__(self, success=None, utx=None,):
8709 
    self.success = success
8710 
    self.utx = utx
8711 
 
8712 
  def read(self, iprot):
8713 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8714 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8715 
      return
8716 
    iprot.readStructBegin()
8717 
    while True:
8718 
      (fname, ftype, fid) = iprot.readFieldBegin()
8719 
      if ftype == TType.STOP:
8720 
        break
8721 
      if fid == 0:
8722 
        if ftype == TType.LIST:
8723 
          self.success = []
1996 vikas 8724 
          (_etype73, _size70) = iprot.readListBegin()
8725 
          for _i74 in xrange(_size70):
8726 
            _elem75 = TrackLog()
8727 
            _elem75.read(iprot)
8728 
            self.success.append(_elem75)
1845 vikas 8729 
          iprot.readListEnd()
8730 
        else:
8731 
          iprot.skip(ftype)
8732 
      elif fid == 1:
8733 
        if ftype == TType.STRUCT:
1996 vikas 8734 
          self.utx = UserAffiliateException()
1845 vikas 8735 
          self.utx.read(iprot)
8736 
        else:
8737 
          iprot.skip(ftype)
8738 
      else:
8739 
        iprot.skip(ftype)
8740 
      iprot.readFieldEnd()
8741 
    iprot.readStructEnd()
8742 
 
8743 
  def write(self, oprot):
8744 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8745 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8746 
      return
1996 vikas 8747 
    oprot.writeStructBegin('getTrackLogsByAffiliate_result')
1845 vikas 8748 
    if self.success != None:
8749 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8750 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 8751 
      for iter76 in self.success:
8752 
        iter76.write(oprot)
1845 vikas 8753 
      oprot.writeListEnd()
8754 
      oprot.writeFieldEnd()
8755 
    if self.utx != None:
8756 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8757 
      self.utx.write(oprot)
8758 
      oprot.writeFieldEnd()
8759 
    oprot.writeFieldStop()
8760 
    oprot.writeStructEnd()
8761 
 
8762 
  def __repr__(self):
8763 
    L = ['%s=%r' % (key, value)
8764 
      for key, value in self.__dict__.iteritems()]
8765 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8766 
 
8767 
  def __eq__(self, other):
8768 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8769 
 
8770 
  def __ne__(self, other):
8771 
    return not (self == other)
8772 
 
8773 
class getTrackLogsByUser_args:
8774 
  """
8775 
  Attributes:
8776 
   - userId
8777 
  """
8778 
 
8779 
  thrift_spec = (
8780 
    None, # 0
8781 
    (1, TType.I64, 'userId', None, None, ), # 1
8782 
  )
8783 
 
8784 
  def __init__(self, userId=None,):
8785 
    self.userId = userId
8786 
 
8787 
  def read(self, iprot):
8788 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8789 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8790 
      return
8791 
    iprot.readStructBegin()
8792 
    while True:
8793 
      (fname, ftype, fid) = iprot.readFieldBegin()
8794 
      if ftype == TType.STOP:
8795 
        break
8796 
      if fid == 1:
8797 
        if ftype == TType.I64:
8798 
          self.userId = iprot.readI64();
8799 
        else:
8800 
          iprot.skip(ftype)
8801 
      else:
8802 
        iprot.skip(ftype)
8803 
      iprot.readFieldEnd()
8804 
    iprot.readStructEnd()
8805 
 
8806 
  def write(self, oprot):
8807 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8808 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8809 
      return
8810 
    oprot.writeStructBegin('getTrackLogsByUser_args')
8811 
    if self.userId != None:
8812 
      oprot.writeFieldBegin('userId', TType.I64, 1)
8813 
      oprot.writeI64(self.userId)
8814 
      oprot.writeFieldEnd()
8815 
    oprot.writeFieldStop()
8816 
    oprot.writeStructEnd()
8817 
 
8818 
  def __repr__(self):
8819 
    L = ['%s=%r' % (key, value)
8820 
      for key, value in self.__dict__.iteritems()]
8821 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8822 
 
8823 
  def __eq__(self, other):
8824 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8825 
 
8826 
  def __ne__(self, other):
8827 
    return not (self == other)
8828 
 
8829 
class getTrackLogsByUser_result:
8830 
  """
8831 
  Attributes:
8832 
   - success
8833 
   - utx
8834 
  """
8835 
 
8836 
  thrift_spec = (
8837 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 8838 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8839 
  )
8840 
 
8841 
  def __init__(self, success=None, utx=None,):
8842 
    self.success = success
8843 
    self.utx = utx
8844 
 
8845 
  def read(self, iprot):
8846 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8847 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8848 
      return
8849 
    iprot.readStructBegin()
8850 
    while True:
8851 
      (fname, ftype, fid) = iprot.readFieldBegin()
8852 
      if ftype == TType.STOP:
8853 
        break
8854 
      if fid == 0:
8855 
        if ftype == TType.LIST:
8856 
          self.success = []
1996 vikas 8857 
          (_etype80, _size77) = iprot.readListBegin()
8858 
          for _i81 in xrange(_size77):
8859 
            _elem82 = TrackLog()
8860 
            _elem82.read(iprot)
8861 
            self.success.append(_elem82)
1845 vikas 8862 
          iprot.readListEnd()
8863 
        else:
8864 
          iprot.skip(ftype)
8865 
      elif fid == 1:
8866 
        if ftype == TType.STRUCT:
1996 vikas 8867 
          self.utx = UserAffiliateException()
1845 vikas 8868 
          self.utx.read(iprot)
8869 
        else:
8870 
          iprot.skip(ftype)
8871 
      else:
8872 
        iprot.skip(ftype)
8873 
      iprot.readFieldEnd()
8874 
    iprot.readStructEnd()
8875 
 
8876 
  def write(self, oprot):
8877 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8878 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8879 
      return
8880 
    oprot.writeStructBegin('getTrackLogsByUser_result')
8881 
    if self.success != None:
8882 
      oprot.writeFieldBegin('success', TType.LIST, 0)
8883 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 8884 
      for iter83 in self.success:
8885 
        iter83.write(oprot)
1845 vikas 8886 
      oprot.writeListEnd()
8887 
      oprot.writeFieldEnd()
8888 
    if self.utx != None:
8889 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
8890 
      self.utx.write(oprot)
8891 
      oprot.writeFieldEnd()
8892 
    oprot.writeFieldStop()
8893 
    oprot.writeStructEnd()
8894 
 
8895 
  def __repr__(self):
8896 
    L = ['%s=%r' % (key, value)
8897 
      for key, value in self.__dict__.iteritems()]
8898 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8899 
 
8900 
  def __eq__(self, other):
8901 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8902 
 
8903 
  def __ne__(self, other):
8904 
    return not (self == other)
8905 
 
8906 
class getTrackLogs_args:
8907 
  """
8908 
  Attributes:
8909 
   - userId
8910 
   - event
8911 
   - url
8912 
  """
8913 
 
8914 
  thrift_spec = (
8915 
    None, # 0
1996 vikas 8916 
    (1, TType.I64, 'userId', None, None, ), # 1
8917 
    (2, TType.STRING, 'event', None, None, ), # 2
8918 
    (3, TType.STRING, 'url', None, None, ), # 3
1845 vikas 8919 
  )
8920 
 
1996 vikas 8921 
  def __init__(self, userId=None, event=None, url=None,):
1845 vikas 8922 
    self.userId = userId
8923 
    self.event = event
8924 
    self.url = url
8925 
 
8926 
  def read(self, iprot):
8927 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
8928 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
8929 
      return
8930 
    iprot.readStructBegin()
8931 
    while True:
8932 
      (fname, ftype, fid) = iprot.readFieldBegin()
8933 
      if ftype == TType.STOP:
8934 
        break
8935 
      if fid == 1:
8936 
        if ftype == TType.I64:
1996 vikas 8937 
          self.userId = iprot.readI64();
1845 vikas 8938 
        else:
8939 
          iprot.skip(ftype)
8940 
      elif fid == 2:
8941 
        if ftype == TType.STRING:
8942 
          self.event = iprot.readString();
8943 
        else:
8944 
          iprot.skip(ftype)
1996 vikas 8945 
      elif fid == 3:
1845 vikas 8946 
        if ftype == TType.STRING:
8947 
          self.url = iprot.readString();
8948 
        else:
8949 
          iprot.skip(ftype)
8950 
      else:
8951 
        iprot.skip(ftype)
8952 
      iprot.readFieldEnd()
8953 
    iprot.readStructEnd()
8954 
 
8955 
  def write(self, oprot):
8956 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
8957 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
8958 
      return
8959 
    oprot.writeStructBegin('getTrackLogs_args')
8960 
    if self.userId != None:
1996 vikas 8961 
      oprot.writeFieldBegin('userId', TType.I64, 1)
1845 vikas 8962 
      oprot.writeI64(self.userId)
8963 
      oprot.writeFieldEnd()
8964 
    if self.event != None:
1996 vikas 8965 
      oprot.writeFieldBegin('event', TType.STRING, 2)
1845 vikas 8966 
      oprot.writeString(self.event)
8967 
      oprot.writeFieldEnd()
8968 
    if self.url != None:
1996 vikas 8969 
      oprot.writeFieldBegin('url', TType.STRING, 3)
1845 vikas 8970 
      oprot.writeString(self.url)
8971 
      oprot.writeFieldEnd()
8972 
    oprot.writeFieldStop()
8973 
    oprot.writeStructEnd()
8974 
 
8975 
  def __repr__(self):
8976 
    L = ['%s=%r' % (key, value)
8977 
      for key, value in self.__dict__.iteritems()]
8978 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
8979 
 
8980 
  def __eq__(self, other):
8981 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
8982 
 
8983 
  def __ne__(self, other):
8984 
    return not (self == other)
8985 
 
8986 
class getTrackLogs_result:
8987 
  """
8988 
  Attributes:
8989 
   - success
8990 
   - utx
8991 
  """
8992 
 
8993 
  thrift_spec = (
8994 
    (0, TType.LIST, 'success', (TType.STRUCT,(TrackLog, TrackLog.thrift_spec)), None, ), # 0
1996 vikas 8995 
    (1, TType.STRUCT, 'utx', (UserAffiliateException, UserAffiliateException.thrift_spec), None, ), # 1
1845 vikas 8996 
  )
8997 
 
8998 
  def __init__(self, success=None, utx=None,):
8999 
    self.success = success
9000 
    self.utx = utx
9001 
 
9002 
  def read(self, iprot):
9003 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9004 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9005 
      return
9006 
    iprot.readStructBegin()
9007 
    while True:
9008 
      (fname, ftype, fid) = iprot.readFieldBegin()
9009 
      if ftype == TType.STOP:
9010 
        break
9011 
      if fid == 0:
9012 
        if ftype == TType.LIST:
9013 
          self.success = []
1996 vikas 9014 
          (_etype87, _size84) = iprot.readListBegin()
9015 
          for _i88 in xrange(_size84):
9016 
            _elem89 = TrackLog()
9017 
            _elem89.read(iprot)
9018 
            self.success.append(_elem89)
1845 vikas 9019 
          iprot.readListEnd()
9020 
        else:
9021 
          iprot.skip(ftype)
9022 
      elif fid == 1:
9023 
        if ftype == TType.STRUCT:
1996 vikas 9024 
          self.utx = UserAffiliateException()
1845 vikas 9025 
          self.utx.read(iprot)
9026 
        else:
9027 
          iprot.skip(ftype)
9028 
      else:
9029 
        iprot.skip(ftype)
9030 
      iprot.readFieldEnd()
9031 
    iprot.readStructEnd()
9032 
 
9033 
  def write(self, oprot):
9034 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9035 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9036 
      return
9037 
    oprot.writeStructBegin('getTrackLogs_result')
9038 
    if self.success != None:
9039 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9040 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 9041 
      for iter90 in self.success:
9042 
        iter90.write(oprot)
1845 vikas 9043 
      oprot.writeListEnd()
9044 
      oprot.writeFieldEnd()
9045 
    if self.utx != None:
9046 
      oprot.writeFieldBegin('utx', TType.STRUCT, 1)
9047 
      self.utx.write(oprot)
9048 
      oprot.writeFieldEnd()
9049 
    oprot.writeFieldStop()
9050 
    oprot.writeStructEnd()
9051 
 
9052 
  def __repr__(self):
9053 
    L = ['%s=%r' % (key, value)
9054 
      for key, value in self.__dict__.iteritems()]
9055 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9056 
 
9057 
  def __eq__(self, other):
9058 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9059 
 
9060 
  def __ne__(self, other):
9061 
    return not (self == other)
9062 
 
559 chandransh 9063 
class createCart_args:
94 ashish 9064 
  """
9065 
  Attributes:
559 chandransh 9066 
   - userId
94 ashish 9067 
  """
9068 
 
9069 
  thrift_spec = (
9070 
    None, # 0
559 chandransh 9071 
    (1, TType.I64, 'userId', None, None, ), # 1
94 ashish 9072 
  )
9073 
 
559 chandransh 9074 
  def __init__(self, userId=None,):
9075 
    self.userId = userId
94 ashish 9076 
 
9077 
  def read(self, iprot):
9078 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9079 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9080 
      return
9081 
    iprot.readStructBegin()
9082 
    while True:
9083 
      (fname, ftype, fid) = iprot.readFieldBegin()
9084 
      if ftype == TType.STOP:
9085 
        break
9086 
      if fid == 1:
9087 
        if ftype == TType.I64:
559 chandransh 9088 
          self.userId = iprot.readI64();
94 ashish 9089 
        else:
9090 
          iprot.skip(ftype)
559 chandransh 9091 
      else:
9092 
        iprot.skip(ftype)
9093 
      iprot.readFieldEnd()
9094 
    iprot.readStructEnd()
9095 
 
9096 
  def write(self, oprot):
9097 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9098 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9099 
      return
9100 
    oprot.writeStructBegin('createCart_args')
9101 
    if self.userId != None:
9102 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9103 
      oprot.writeI64(self.userId)
9104 
      oprot.writeFieldEnd()
9105 
    oprot.writeFieldStop()
9106 
    oprot.writeStructEnd()
9107 
 
9108 
  def __repr__(self):
9109 
    L = ['%s=%r' % (key, value)
9110 
      for key, value in self.__dict__.iteritems()]
9111 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9112 
 
9113 
  def __eq__(self, other):
9114 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9115 
 
9116 
  def __ne__(self, other):
9117 
    return not (self == other)
9118 
 
9119 
class createCart_result:
9120 
  """
9121 
  Attributes:
9122 
   - success
9123 
   - scx
9124 
  """
9125 
 
9126 
  thrift_spec = (
9127 
    (0, TType.I64, 'success', None, None, ), # 0
9128 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9129 
  )
9130 
 
9131 
  def __init__(self, success=None, scx=None,):
9132 
    self.success = success
9133 
    self.scx = scx
9134 
 
9135 
  def read(self, iprot):
9136 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9137 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9138 
      return
9139 
    iprot.readStructBegin()
9140 
    while True:
9141 
      (fname, ftype, fid) = iprot.readFieldBegin()
9142 
      if ftype == TType.STOP:
9143 
        break
9144 
      if fid == 0:
94 ashish 9145 
        if ftype == TType.I64:
559 chandransh 9146 
          self.success = iprot.readI64();
94 ashish 9147 
        else:
9148 
          iprot.skip(ftype)
559 chandransh 9149 
      elif fid == 1:
9150 
        if ftype == TType.STRUCT:
9151 
          self.scx = ShoppingCartException()
9152 
          self.scx.read(iprot)
9153 
        else:
9154 
          iprot.skip(ftype)
94 ashish 9155 
      else:
9156 
        iprot.skip(ftype)
9157 
      iprot.readFieldEnd()
9158 
    iprot.readStructEnd()
9159 
 
9160 
  def write(self, oprot):
9161 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9162 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9163 
      return
559 chandransh 9164 
    oprot.writeStructBegin('createCart_result')
9165 
    if self.success != None:
9166 
      oprot.writeFieldBegin('success', TType.I64, 0)
9167 
      oprot.writeI64(self.success)
94 ashish 9168 
      oprot.writeFieldEnd()
559 chandransh 9169 
    if self.scx != None:
9170 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9171 
      self.scx.write(oprot)
94 ashish 9172 
      oprot.writeFieldEnd()
9173 
    oprot.writeFieldStop()
9174 
    oprot.writeStructEnd()
9175 
 
9176 
  def __repr__(self):
9177 
    L = ['%s=%r' % (key, value)
9178 
      for key, value in self.__dict__.iteritems()]
9179 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9180 
 
9181 
  def __eq__(self, other):
9182 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9183 
 
9184 
  def __ne__(self, other):
9185 
    return not (self == other)
9186 
 
559 chandransh 9187 
class getCurrentCart_args:
94 ashish 9188 
  """
9189 
  Attributes:
559 chandransh 9190 
   - userId
9191 
  """
9192 
 
9193 
  thrift_spec = (
9194 
    None, # 0
9195 
    (1, TType.I64, 'userId', None, None, ), # 1
9196 
  )
9197 
 
9198 
  def __init__(self, userId=None,):
9199 
    self.userId = userId
9200 
 
9201 
  def read(self, iprot):
9202 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9203 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9204 
      return
9205 
    iprot.readStructBegin()
9206 
    while True:
9207 
      (fname, ftype, fid) = iprot.readFieldBegin()
9208 
      if ftype == TType.STOP:
9209 
        break
9210 
      if fid == 1:
9211 
        if ftype == TType.I64:
9212 
          self.userId = iprot.readI64();
9213 
        else:
9214 
          iprot.skip(ftype)
9215 
      else:
9216 
        iprot.skip(ftype)
9217 
      iprot.readFieldEnd()
9218 
    iprot.readStructEnd()
9219 
 
9220 
  def write(self, oprot):
9221 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9222 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9223 
      return
9224 
    oprot.writeStructBegin('getCurrentCart_args')
9225 
    if self.userId != None:
9226 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9227 
      oprot.writeI64(self.userId)
9228 
      oprot.writeFieldEnd()
9229 
    oprot.writeFieldStop()
9230 
    oprot.writeStructEnd()
9231 
 
9232 
  def __repr__(self):
9233 
    L = ['%s=%r' % (key, value)
9234 
      for key, value in self.__dict__.iteritems()]
9235 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9236 
 
9237 
  def __eq__(self, other):
9238 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9239 
 
9240 
  def __ne__(self, other):
9241 
    return not (self == other)
9242 
 
9243 
class getCurrentCart_result:
9244 
  """
9245 
  Attributes:
94 ashish 9246 
   - success
559 chandransh 9247 
   - scx
94 ashish 9248 
  """
9249 
 
9250 
  thrift_spec = (
559 chandransh 9251 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9252 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9253 
  )
9254 
 
559 chandransh 9255 
  def __init__(self, success=None, scx=None,):
94 ashish 9256 
    self.success = success
559 chandransh 9257 
    self.scx = scx
94 ashish 9258 
 
9259 
  def read(self, iprot):
9260 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9261 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9262 
      return
9263 
    iprot.readStructBegin()
9264 
    while True:
9265 
      (fname, ftype, fid) = iprot.readFieldBegin()
9266 
      if ftype == TType.STOP:
9267 
        break
9268 
      if fid == 0:
559 chandransh 9269 
        if ftype == TType.STRUCT:
9270 
          self.success = Cart()
9271 
          self.success.read(iprot)
94 ashish 9272 
        else:
9273 
          iprot.skip(ftype)
9274 
      elif fid == 1:
9275 
        if ftype == TType.STRUCT:
559 chandransh 9276 
          self.scx = ShoppingCartException()
9277 
          self.scx.read(iprot)
94 ashish 9278 
        else:
9279 
          iprot.skip(ftype)
9280 
      else:
9281 
        iprot.skip(ftype)
9282 
      iprot.readFieldEnd()
9283 
    iprot.readStructEnd()
9284 
 
9285 
  def write(self, oprot):
9286 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9287 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9288 
      return
559 chandransh 9289 
    oprot.writeStructBegin('getCurrentCart_result')
94 ashish 9290 
    if self.success != None:
559 chandransh 9291 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9292 
      self.success.write(oprot)
94 ashish 9293 
      oprot.writeFieldEnd()
559 chandransh 9294 
    if self.scx != None:
9295 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9296 
      self.scx.write(oprot)
94 ashish 9297 
      oprot.writeFieldEnd()
9298 
    oprot.writeFieldStop()
9299 
    oprot.writeStructEnd()
9300 
 
9301 
  def __repr__(self):
9302 
    L = ['%s=%r' % (key, value)
9303 
      for key, value in self.__dict__.iteritems()]
9304 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9305 
 
9306 
  def __eq__(self, other):
9307 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9308 
 
9309 
  def __ne__(self, other):
9310 
    return not (self == other)
9311 
 
559 chandransh 9312 
class getCart_args:
504 rajveer 9313 
  """
9314 
  Attributes:
559 chandransh 9315 
   - cartId
504 rajveer 9316 
  """
9317 
 
9318 
  thrift_spec = (
9319 
    None, # 0
559 chandransh 9320 
    (1, TType.I64, 'cartId', None, None, ), # 1
504 rajveer 9321 
  )
9322 
 
559 chandransh 9323 
  def __init__(self, cartId=None,):
9324 
    self.cartId = cartId
504 rajveer 9325 
 
9326 
  def read(self, iprot):
9327 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9328 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9329 
      return
9330 
    iprot.readStructBegin()
9331 
    while True:
9332 
      (fname, ftype, fid) = iprot.readFieldBegin()
9333 
      if ftype == TType.STOP:
9334 
        break
9335 
      if fid == 1:
9336 
        if ftype == TType.I64:
559 chandransh 9337 
          self.cartId = iprot.readI64();
504 rajveer 9338 
        else:
9339 
          iprot.skip(ftype)
9340 
      else:
9341 
        iprot.skip(ftype)
9342 
      iprot.readFieldEnd()
9343 
    iprot.readStructEnd()
9344 
 
9345 
  def write(self, oprot):
9346 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9347 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9348 
      return
559 chandransh 9349 
    oprot.writeStructBegin('getCart_args')
9350 
    if self.cartId != None:
9351 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9352 
      oprot.writeI64(self.cartId)
504 rajveer 9353 
      oprot.writeFieldEnd()
9354 
    oprot.writeFieldStop()
9355 
    oprot.writeStructEnd()
9356 
 
9357 
  def __repr__(self):
9358 
    L = ['%s=%r' % (key, value)
9359 
      for key, value in self.__dict__.iteritems()]
9360 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9361 
 
9362 
  def __eq__(self, other):
9363 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9364 
 
9365 
  def __ne__(self, other):
9366 
    return not (self == other)
9367 
 
559 chandransh 9368 
class getCart_result:
504 rajveer 9369 
  """
9370 
  Attributes:
9371 
   - success
559 chandransh 9372 
   - scx
504 rajveer 9373 
  """
9374 
 
9375 
  thrift_spec = (
559 chandransh 9376 
    (0, TType.STRUCT, 'success', (Cart, Cart.thrift_spec), None, ), # 0
9377 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
504 rajveer 9378 
  )
9379 
 
559 chandransh 9380 
  def __init__(self, success=None, scx=None,):
504 rajveer 9381 
    self.success = success
559 chandransh 9382 
    self.scx = scx
504 rajveer 9383 
 
9384 
  def read(self, iprot):
9385 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9386 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9387 
      return
9388 
    iprot.readStructBegin()
9389 
    while True:
9390 
      (fname, ftype, fid) = iprot.readFieldBegin()
9391 
      if ftype == TType.STOP:
9392 
        break
9393 
      if fid == 0:
559 chandransh 9394 
        if ftype == TType.STRUCT:
9395 
          self.success = Cart()
9396 
          self.success.read(iprot)
504 rajveer 9397 
        else:
9398 
          iprot.skip(ftype)
9399 
      elif fid == 1:
9400 
        if ftype == TType.STRUCT:
559 chandransh 9401 
          self.scx = ShoppingCartException()
9402 
          self.scx.read(iprot)
504 rajveer 9403 
        else:
9404 
          iprot.skip(ftype)
9405 
      else:
9406 
        iprot.skip(ftype)
9407 
      iprot.readFieldEnd()
9408 
    iprot.readStructEnd()
9409 
 
9410 
  def write(self, oprot):
9411 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9412 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9413 
      return
559 chandransh 9414 
    oprot.writeStructBegin('getCart_result')
504 rajveer 9415 
    if self.success != None:
559 chandransh 9416 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
9417 
      self.success.write(oprot)
504 rajveer 9418 
      oprot.writeFieldEnd()
559 chandransh 9419 
    if self.scx != None:
9420 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9421 
      self.scx.write(oprot)
504 rajveer 9422 
      oprot.writeFieldEnd()
9423 
    oprot.writeFieldStop()
9424 
    oprot.writeStructEnd()
9425 
 
9426 
  def __repr__(self):
9427 
    L = ['%s=%r' % (key, value)
9428 
      for key, value in self.__dict__.iteritems()]
9429 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9430 
 
9431 
  def __eq__(self, other):
9432 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9433 
 
9434 
  def __ne__(self, other):
9435 
    return not (self == other)
9436 
 
559 chandransh 9437 
class getCartsForUser_args:
94 ashish 9438 
  """
9439 
  Attributes:
559 chandransh 9440 
   - userId
9441 
   - status
94 ashish 9442 
  """
9443 
 
9444 
  thrift_spec = (
9445 
    None, # 0
559 chandransh 9446 
    (1, TType.I64, 'userId', None, None, ), # 1
9447 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 9448 
  )
9449 
 
559 chandransh 9450 
  def __init__(self, userId=None, status=None,):
9451 
    self.userId = userId
9452 
    self.status = status
94 ashish 9453 
 
9454 
  def read(self, iprot):
9455 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9456 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9457 
      return
9458 
    iprot.readStructBegin()
9459 
    while True:
9460 
      (fname, ftype, fid) = iprot.readFieldBegin()
9461 
      if ftype == TType.STOP:
9462 
        break
9463 
      if fid == 1:
9464 
        if ftype == TType.I64:
559 chandransh 9465 
          self.userId = iprot.readI64();
94 ashish 9466 
        else:
9467 
          iprot.skip(ftype)
9468 
      elif fid == 2:
559 chandransh 9469 
        if ftype == TType.I32:
9470 
          self.status = iprot.readI32();
94 ashish 9471 
        else:
9472 
          iprot.skip(ftype)
9473 
      else:
9474 
        iprot.skip(ftype)
9475 
      iprot.readFieldEnd()
9476 
    iprot.readStructEnd()
9477 
 
9478 
  def write(self, oprot):
9479 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9480 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9481 
      return
559 chandransh 9482 
    oprot.writeStructBegin('getCartsForUser_args')
9483 
    if self.userId != None:
9484 
      oprot.writeFieldBegin('userId', TType.I64, 1)
9485 
      oprot.writeI64(self.userId)
94 ashish 9486 
      oprot.writeFieldEnd()
559 chandransh 9487 
    if self.status != None:
9488 
      oprot.writeFieldBegin('status', TType.I32, 2)
9489 
      oprot.writeI32(self.status)
94 ashish 9490 
      oprot.writeFieldEnd()
9491 
    oprot.writeFieldStop()
9492 
    oprot.writeStructEnd()
9493 
 
9494 
  def __repr__(self):
9495 
    L = ['%s=%r' % (key, value)
9496 
      for key, value in self.__dict__.iteritems()]
9497 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9498 
 
9499 
  def __eq__(self, other):
9500 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9501 
 
9502 
  def __ne__(self, other):
9503 
    return not (self == other)
9504 
 
559 chandransh 9505 
class getCartsForUser_result:
94 ashish 9506 
  """
9507 
  Attributes:
9508 
   - success
559 chandransh 9509 
   - scx
94 ashish 9510 
  """
9511 
 
9512 
  thrift_spec = (
559 chandransh 9513 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9514 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9515 
  )
9516 
 
559 chandransh 9517 
  def __init__(self, success=None, scx=None,):
94 ashish 9518 
    self.success = success
559 chandransh 9519 
    self.scx = scx
94 ashish 9520 
 
9521 
  def read(self, iprot):
9522 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9523 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9524 
      return
9525 
    iprot.readStructBegin()
9526 
    while True:
9527 
      (fname, ftype, fid) = iprot.readFieldBegin()
9528 
      if ftype == TType.STOP:
9529 
        break
9530 
      if fid == 0:
559 chandransh 9531 
        if ftype == TType.LIST:
9532 
          self.success = []
1996 vikas 9533 
          (_etype94, _size91) = iprot.readListBegin()
9534 
          for _i95 in xrange(_size91):
9535 
            _elem96 = Cart()
9536 
            _elem96.read(iprot)
9537 
            self.success.append(_elem96)
559 chandransh 9538 
          iprot.readListEnd()
94 ashish 9539 
        else:
9540 
          iprot.skip(ftype)
9541 
      elif fid == 1:
9542 
        if ftype == TType.STRUCT:
559 chandransh 9543 
          self.scx = ShoppingCartException()
9544 
          self.scx.read(iprot)
94 ashish 9545 
        else:
9546 
          iprot.skip(ftype)
9547 
      else:
9548 
        iprot.skip(ftype)
9549 
      iprot.readFieldEnd()
9550 
    iprot.readStructEnd()
9551 
 
9552 
  def write(self, oprot):
9553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9555 
      return
559 chandransh 9556 
    oprot.writeStructBegin('getCartsForUser_result')
94 ashish 9557 
    if self.success != None:
559 chandransh 9558 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9559 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 9560 
      for iter97 in self.success:
9561 
        iter97.write(oprot)
559 chandransh 9562 
      oprot.writeListEnd()
94 ashish 9563 
      oprot.writeFieldEnd()
559 chandransh 9564 
    if self.scx != None:
9565 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9566 
      self.scx.write(oprot)
94 ashish 9567 
      oprot.writeFieldEnd()
9568 
    oprot.writeFieldStop()
9569 
    oprot.writeStructEnd()
9570 
 
9571 
  def __repr__(self):
9572 
    L = ['%s=%r' % (key, value)
9573 
      for key, value in self.__dict__.iteritems()]
9574 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9575 
 
9576 
  def __eq__(self, other):
9577 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9578 
 
9579 
  def __ne__(self, other):
9580 
    return not (self == other)
9581 
 
559 chandransh 9582 
class getCartsByStatus_args:
94 ashish 9583 
  """
9584 
  Attributes:
559 chandransh 9585 
   - status
94 ashish 9586 
  """
9587 
 
9588 
  thrift_spec = (
9589 
    None, # 0
559 chandransh 9590 
    (1, TType.I32, 'status', None, None, ), # 1
94 ashish 9591 
  )
9592 
 
559 chandransh 9593 
  def __init__(self, status=None,):
9594 
    self.status = status
94 ashish 9595 
 
9596 
  def read(self, iprot):
9597 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9598 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9599 
      return
9600 
    iprot.readStructBegin()
9601 
    while True:
9602 
      (fname, ftype, fid) = iprot.readFieldBegin()
9603 
      if ftype == TType.STOP:
9604 
        break
9605 
      if fid == 1:
559 chandransh 9606 
        if ftype == TType.I32:
9607 
          self.status = iprot.readI32();
9608 
        else:
9609 
          iprot.skip(ftype)
9610 
      else:
9611 
        iprot.skip(ftype)
9612 
      iprot.readFieldEnd()
9613 
    iprot.readStructEnd()
9614 
 
9615 
  def write(self, oprot):
9616 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9617 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9618 
      return
9619 
    oprot.writeStructBegin('getCartsByStatus_args')
9620 
    if self.status != None:
9621 
      oprot.writeFieldBegin('status', TType.I32, 1)
9622 
      oprot.writeI32(self.status)
9623 
      oprot.writeFieldEnd()
9624 
    oprot.writeFieldStop()
9625 
    oprot.writeStructEnd()
9626 
 
9627 
  def __repr__(self):
9628 
    L = ['%s=%r' % (key, value)
9629 
      for key, value in self.__dict__.iteritems()]
9630 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9631 
 
9632 
  def __eq__(self, other):
9633 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9634 
 
9635 
  def __ne__(self, other):
9636 
    return not (self == other)
9637 
 
9638 
class getCartsByStatus_result:
9639 
  """
9640 
  Attributes:
9641 
   - success
9642 
   - scx
9643 
  """
9644 
 
9645 
  thrift_spec = (
9646 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9647 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9648 
  )
9649 
 
9650 
  def __init__(self, success=None, scx=None,):
9651 
    self.success = success
9652 
    self.scx = scx
9653 
 
9654 
  def read(self, iprot):
9655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9657 
      return
9658 
    iprot.readStructBegin()
9659 
    while True:
9660 
      (fname, ftype, fid) = iprot.readFieldBegin()
9661 
      if ftype == TType.STOP:
9662 
        break
9663 
      if fid == 0:
9664 
        if ftype == TType.LIST:
9665 
          self.success = []
1996 vikas 9666 
          (_etype101, _size98) = iprot.readListBegin()
9667 
          for _i102 in xrange(_size98):
9668 
            _elem103 = Cart()
9669 
            _elem103.read(iprot)
9670 
            self.success.append(_elem103)
559 chandransh 9671 
          iprot.readListEnd()
9672 
        else:
9673 
          iprot.skip(ftype)
9674 
      elif fid == 1:
9675 
        if ftype == TType.STRUCT:
9676 
          self.scx = ShoppingCartException()
9677 
          self.scx.read(iprot)
9678 
        else:
9679 
          iprot.skip(ftype)
9680 
      else:
9681 
        iprot.skip(ftype)
9682 
      iprot.readFieldEnd()
9683 
    iprot.readStructEnd()
9684 
 
9685 
  def write(self, oprot):
9686 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9687 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9688 
      return
9689 
    oprot.writeStructBegin('getCartsByStatus_result')
9690 
    if self.success != None:
9691 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9692 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 9693 
      for iter104 in self.success:
9694 
        iter104.write(oprot)
559 chandransh 9695 
      oprot.writeListEnd()
9696 
      oprot.writeFieldEnd()
9697 
    if self.scx != None:
9698 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9699 
      self.scx.write(oprot)
9700 
      oprot.writeFieldEnd()
9701 
    oprot.writeFieldStop()
9702 
    oprot.writeStructEnd()
9703 
 
9704 
  def __repr__(self):
9705 
    L = ['%s=%r' % (key, value)
9706 
      for key, value in self.__dict__.iteritems()]
9707 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9708 
 
9709 
  def __eq__(self, other):
9710 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9711 
 
9712 
  def __ne__(self, other):
9713 
    return not (self == other)
9714 
 
9715 
class getCartsByTime_args:
9716 
  """
9717 
  Attributes:
9718 
   - from_time
9719 
   - to_time
9720 
   - status
9721 
  """
9722 
 
9723 
  thrift_spec = (
9724 
    None, # 0
9725 
    (1, TType.I64, 'from_time', None, None, ), # 1
9726 
    (2, TType.I64, 'to_time', None, None, ), # 2
9727 
    (3, TType.I32, 'status', None, None, ), # 3
9728 
  )
9729 
 
9730 
  def __init__(self, from_time=None, to_time=None, status=None,):
9731 
    self.from_time = from_time
9732 
    self.to_time = to_time
9733 
    self.status = status
9734 
 
9735 
  def read(self, iprot):
9736 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9737 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9738 
      return
9739 
    iprot.readStructBegin()
9740 
    while True:
9741 
      (fname, ftype, fid) = iprot.readFieldBegin()
9742 
      if ftype == TType.STOP:
9743 
        break
9744 
      if fid == 1:
94 ashish 9745 
        if ftype == TType.I64:
559 chandransh 9746 
          self.from_time = iprot.readI64();
94 ashish 9747 
        else:
9748 
          iprot.skip(ftype)
122 ashish 9749 
      elif fid == 2:
559 chandransh 9750 
        if ftype == TType.I64:
9751 
          self.to_time = iprot.readI64();
122 ashish 9752 
        else:
9753 
          iprot.skip(ftype)
559 chandransh 9754 
      elif fid == 3:
9755 
        if ftype == TType.I32:
9756 
          self.status = iprot.readI32();
9757 
        else:
9758 
          iprot.skip(ftype)
94 ashish 9759 
      else:
9760 
        iprot.skip(ftype)
9761 
      iprot.readFieldEnd()
9762 
    iprot.readStructEnd()
9763 
 
9764 
  def write(self, oprot):
9765 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9766 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9767 
      return
559 chandransh 9768 
    oprot.writeStructBegin('getCartsByTime_args')
9769 
    if self.from_time != None:
9770 
      oprot.writeFieldBegin('from_time', TType.I64, 1)
9771 
      oprot.writeI64(self.from_time)
94 ashish 9772 
      oprot.writeFieldEnd()
559 chandransh 9773 
    if self.to_time != None:
9774 
      oprot.writeFieldBegin('to_time', TType.I64, 2)
9775 
      oprot.writeI64(self.to_time)
122 ashish 9776 
      oprot.writeFieldEnd()
559 chandransh 9777 
    if self.status != None:
9778 
      oprot.writeFieldBegin('status', TType.I32, 3)
9779 
      oprot.writeI32(self.status)
9780 
      oprot.writeFieldEnd()
94 ashish 9781 
    oprot.writeFieldStop()
9782 
    oprot.writeStructEnd()
9783 
 
9784 
  def __repr__(self):
9785 
    L = ['%s=%r' % (key, value)
9786 
      for key, value in self.__dict__.iteritems()]
9787 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9788 
 
9789 
  def __eq__(self, other):
9790 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9791 
 
9792 
  def __ne__(self, other):
9793 
    return not (self == other)
9794 
 
559 chandransh 9795 
class getCartsByTime_result:
94 ashish 9796 
  """
9797 
  Attributes:
9798 
   - success
559 chandransh 9799 
   - scx
94 ashish 9800 
  """
9801 
 
9802 
  thrift_spec = (
559 chandransh 9803 
    (0, TType.LIST, 'success', (TType.STRUCT,(Cart, Cart.thrift_spec)), None, ), # 0
9804 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 9805 
  )
9806 
 
559 chandransh 9807 
  def __init__(self, success=None, scx=None,):
94 ashish 9808 
    self.success = success
559 chandransh 9809 
    self.scx = scx
94 ashish 9810 
 
9811 
  def read(self, iprot):
9812 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9813 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9814 
      return
9815 
    iprot.readStructBegin()
9816 
    while True:
9817 
      (fname, ftype, fid) = iprot.readFieldBegin()
9818 
      if ftype == TType.STOP:
9819 
        break
9820 
      if fid == 0:
559 chandransh 9821 
        if ftype == TType.LIST:
9822 
          self.success = []
1996 vikas 9823 
          (_etype108, _size105) = iprot.readListBegin()
9824 
          for _i109 in xrange(_size105):
9825 
            _elem110 = Cart()
9826 
            _elem110.read(iprot)
9827 
            self.success.append(_elem110)
559 chandransh 9828 
          iprot.readListEnd()
94 ashish 9829 
        else:
9830 
          iprot.skip(ftype)
9831 
      elif fid == 1:
9832 
        if ftype == TType.STRUCT:
559 chandransh 9833 
          self.scx = ShoppingCartException()
9834 
          self.scx.read(iprot)
94 ashish 9835 
        else:
9836 
          iprot.skip(ftype)
9837 
      else:
9838 
        iprot.skip(ftype)
9839 
      iprot.readFieldEnd()
9840 
    iprot.readStructEnd()
9841 
 
9842 
  def write(self, oprot):
9843 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9844 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9845 
      return
559 chandransh 9846 
    oprot.writeStructBegin('getCartsByTime_result')
94 ashish 9847 
    if self.success != None:
559 chandransh 9848 
      oprot.writeFieldBegin('success', TType.LIST, 0)
9849 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 9850 
      for iter111 in self.success:
9851 
        iter111.write(oprot)
559 chandransh 9852 
      oprot.writeListEnd()
94 ashish 9853 
      oprot.writeFieldEnd()
559 chandransh 9854 
    if self.scx != None:
9855 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9856 
      self.scx.write(oprot)
94 ashish 9857 
      oprot.writeFieldEnd()
9858 
    oprot.writeFieldStop()
9859 
    oprot.writeStructEnd()
9860 
 
9861 
  def __repr__(self):
9862 
    L = ['%s=%r' % (key, value)
9863 
      for key, value in self.__dict__.iteritems()]
9864 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9865 
 
9866 
  def __eq__(self, other):
9867 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9868 
 
9869 
  def __ne__(self, other):
9870 
    return not (self == other)
9871 
 
559 chandransh 9872 
class changeCartStatus_args:
94 ashish 9873 
  """
9874 
  Attributes:
559 chandransh 9875 
   - cartId
9876 
   - status
94 ashish 9877 
  """
9878 
 
9879 
  thrift_spec = (
9880 
    None, # 0
559 chandransh 9881 
    (1, TType.I64, 'cartId', None, None, ), # 1
9882 
    (2, TType.I32, 'status', None, None, ), # 2
94 ashish 9883 
  )
9884 
 
559 chandransh 9885 
  def __init__(self, cartId=None, status=None,):
9886 
    self.cartId = cartId
9887 
    self.status = status
94 ashish 9888 
 
9889 
  def read(self, iprot):
9890 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9891 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9892 
      return
9893 
    iprot.readStructBegin()
9894 
    while True:
9895 
      (fname, ftype, fid) = iprot.readFieldBegin()
9896 
      if ftype == TType.STOP:
9897 
        break
9898 
      if fid == 1:
9899 
        if ftype == TType.I64:
559 chandransh 9900 
          self.cartId = iprot.readI64();
94 ashish 9901 
        else:
9902 
          iprot.skip(ftype)
559 chandransh 9903 
      elif fid == 2:
9904 
        if ftype == TType.I32:
9905 
          self.status = iprot.readI32();
9906 
        else:
9907 
          iprot.skip(ftype)
94 ashish 9908 
      else:
9909 
        iprot.skip(ftype)
9910 
      iprot.readFieldEnd()
9911 
    iprot.readStructEnd()
9912 
 
9913 
  def write(self, oprot):
9914 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9915 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9916 
      return
559 chandransh 9917 
    oprot.writeStructBegin('changeCartStatus_args')
9918 
    if self.cartId != None:
9919 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
9920 
      oprot.writeI64(self.cartId)
94 ashish 9921 
      oprot.writeFieldEnd()
559 chandransh 9922 
    if self.status != None:
9923 
      oprot.writeFieldBegin('status', TType.I32, 2)
9924 
      oprot.writeI32(self.status)
9925 
      oprot.writeFieldEnd()
94 ashish 9926 
    oprot.writeFieldStop()
9927 
    oprot.writeStructEnd()
9928 
 
9929 
  def __repr__(self):
9930 
    L = ['%s=%r' % (key, value)
9931 
      for key, value in self.__dict__.iteritems()]
9932 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9933 
 
9934 
  def __eq__(self, other):
9935 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9936 
 
9937 
  def __ne__(self, other):
9938 
    return not (self == other)
9939 
 
559 chandransh 9940 
class changeCartStatus_result:
94 ashish 9941 
  """
9942 
  Attributes:
559 chandransh 9943 
   - scx
9944 
  """
9945 
 
9946 
  thrift_spec = (
9947 
    None, # 0
9948 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
9949 
  )
9950 
 
9951 
  def __init__(self, scx=None,):
9952 
    self.scx = scx
9953 
 
9954 
  def read(self, iprot):
9955 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
9956 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
9957 
      return
9958 
    iprot.readStructBegin()
9959 
    while True:
9960 
      (fname, ftype, fid) = iprot.readFieldBegin()
9961 
      if ftype == TType.STOP:
9962 
        break
9963 
      if fid == 1:
9964 
        if ftype == TType.STRUCT:
9965 
          self.scx = ShoppingCartException()
9966 
          self.scx.read(iprot)
9967 
        else:
9968 
          iprot.skip(ftype)
9969 
      else:
9970 
        iprot.skip(ftype)
9971 
      iprot.readFieldEnd()
9972 
    iprot.readStructEnd()
9973 
 
9974 
  def write(self, oprot):
9975 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
9976 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
9977 
      return
9978 
    oprot.writeStructBegin('changeCartStatus_result')
9979 
    if self.scx != None:
9980 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
9981 
      self.scx.write(oprot)
9982 
      oprot.writeFieldEnd()
9983 
    oprot.writeFieldStop()
9984 
    oprot.writeStructEnd()
9985 
 
9986 
  def __repr__(self):
9987 
    L = ['%s=%r' % (key, value)
9988 
      for key, value in self.__dict__.iteritems()]
9989 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
9990 
 
9991 
  def __eq__(self, other):
9992 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
9993 
 
9994 
  def __ne__(self, other):
9995 
    return not (self == other)
9996 
 
9997 
class addItemToCart_args:
9998 
  """
9999 
  Attributes:
10000 
   - cartId
10001 
   - itemId
10002 
   - quantity
10003 
  """
10004 
 
10005 
  thrift_spec = (
10006 
    None, # 0
10007 
    (1, TType.I64, 'cartId', None, None, ), # 1
10008 
    (2, TType.I64, 'itemId', None, None, ), # 2
10009 
    (3, TType.I64, 'quantity', None, None, ), # 3
10010 
  )
10011 
 
10012 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
10013 
    self.cartId = cartId
10014 
    self.itemId = itemId
10015 
    self.quantity = quantity
10016 
 
10017 
  def read(self, iprot):
10018 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10019 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10020 
      return
10021 
    iprot.readStructBegin()
10022 
    while True:
10023 
      (fname, ftype, fid) = iprot.readFieldBegin()
10024 
      if ftype == TType.STOP:
10025 
        break
10026 
      if fid == 1:
10027 
        if ftype == TType.I64:
10028 
          self.cartId = iprot.readI64();
10029 
        else:
10030 
          iprot.skip(ftype)
10031 
      elif fid == 2:
10032 
        if ftype == TType.I64:
10033 
          self.itemId = iprot.readI64();
10034 
        else:
10035 
          iprot.skip(ftype)
10036 
      elif fid == 3:
10037 
        if ftype == TType.I64:
10038 
          self.quantity = iprot.readI64();
10039 
        else:
10040 
          iprot.skip(ftype)
10041 
      else:
10042 
        iprot.skip(ftype)
10043 
      iprot.readFieldEnd()
10044 
    iprot.readStructEnd()
10045 
 
10046 
  def write(self, oprot):
10047 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10048 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10049 
      return
10050 
    oprot.writeStructBegin('addItemToCart_args')
10051 
    if self.cartId != None:
10052 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10053 
      oprot.writeI64(self.cartId)
10054 
      oprot.writeFieldEnd()
10055 
    if self.itemId != None:
10056 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10057 
      oprot.writeI64(self.itemId)
10058 
      oprot.writeFieldEnd()
10059 
    if self.quantity != None:
10060 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10061 
      oprot.writeI64(self.quantity)
10062 
      oprot.writeFieldEnd()
10063 
    oprot.writeFieldStop()
10064 
    oprot.writeStructEnd()
10065 
 
10066 
  def __repr__(self):
10067 
    L = ['%s=%r' % (key, value)
10068 
      for key, value in self.__dict__.iteritems()]
10069 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10070 
 
10071 
  def __eq__(self, other):
10072 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10073 
 
10074 
  def __ne__(self, other):
10075 
    return not (self == other)
10076 
 
10077 
class addItemToCart_result:
10078 
  """
10079 
  Attributes:
2035 rajveer 10080 
   - success
559 chandransh 10081 
   - scx
10082 
  """
10083 
 
10084 
  thrift_spec = (
2035 rajveer 10085 
    (0, TType.STRING, 'success', None, None, ), # 0
559 chandransh 10086 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10087 
  )
10088 
 
2035 rajveer 10089 
  def __init__(self, success=None, scx=None,):
10090 
    self.success = success
559 chandransh 10091 
    self.scx = scx
10092 
 
10093 
  def read(self, iprot):
10094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10096 
      return
10097 
    iprot.readStructBegin()
10098 
    while True:
10099 
      (fname, ftype, fid) = iprot.readFieldBegin()
10100 
      if ftype == TType.STOP:
10101 
        break
2035 rajveer 10102 
      if fid == 0:
10103 
        if ftype == TType.STRING:
10104 
          self.success = iprot.readString();
10105 
        else:
10106 
          iprot.skip(ftype)
10107 
      elif fid == 1:
559 chandransh 10108 
        if ftype == TType.STRUCT:
10109 
          self.scx = ShoppingCartException()
10110 
          self.scx.read(iprot)
10111 
        else:
10112 
          iprot.skip(ftype)
10113 
      else:
10114 
        iprot.skip(ftype)
10115 
      iprot.readFieldEnd()
10116 
    iprot.readStructEnd()
10117 
 
10118 
  def write(self, oprot):
10119 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10120 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10121 
      return
10122 
    oprot.writeStructBegin('addItemToCart_result')
2035 rajveer 10123 
    if self.success != None:
10124 
      oprot.writeFieldBegin('success', TType.STRING, 0)
10125 
      oprot.writeString(self.success)
10126 
      oprot.writeFieldEnd()
559 chandransh 10127 
    if self.scx != None:
10128 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10129 
      self.scx.write(oprot)
10130 
      oprot.writeFieldEnd()
10131 
    oprot.writeFieldStop()
10132 
    oprot.writeStructEnd()
10133 
 
10134 
  def __repr__(self):
10135 
    L = ['%s=%r' % (key, value)
10136 
      for key, value in self.__dict__.iteritems()]
10137 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10138 
 
10139 
  def __eq__(self, other):
10140 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10141 
 
10142 
  def __ne__(self, other):
10143 
    return not (self == other)
10144 
 
10145 
class deleteItemFromCart_args:
10146 
  """
10147 
  Attributes:
10148 
   - cartId
10149 
   - itemId
10150 
  """
10151 
 
10152 
  thrift_spec = (
10153 
    None, # 0
10154 
    (1, TType.I64, 'cartId', None, None, ), # 1
10155 
    (2, TType.I64, 'itemId', None, None, ), # 2
10156 
  )
10157 
 
10158 
  def __init__(self, cartId=None, itemId=None,):
10159 
    self.cartId = cartId
10160 
    self.itemId = itemId
10161 
 
10162 
  def read(self, iprot):
10163 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10164 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10165 
      return
10166 
    iprot.readStructBegin()
10167 
    while True:
10168 
      (fname, ftype, fid) = iprot.readFieldBegin()
10169 
      if ftype == TType.STOP:
10170 
        break
10171 
      if fid == 1:
10172 
        if ftype == TType.I64:
10173 
          self.cartId = iprot.readI64();
10174 
        else:
10175 
          iprot.skip(ftype)
10176 
      elif fid == 2:
10177 
        if ftype == TType.I64:
10178 
          self.itemId = iprot.readI64();
10179 
        else:
10180 
          iprot.skip(ftype)
10181 
      else:
10182 
        iprot.skip(ftype)
10183 
      iprot.readFieldEnd()
10184 
    iprot.readStructEnd()
10185 
 
10186 
  def write(self, oprot):
10187 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10188 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10189 
      return
10190 
    oprot.writeStructBegin('deleteItemFromCart_args')
10191 
    if self.cartId != None:
10192 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10193 
      oprot.writeI64(self.cartId)
10194 
      oprot.writeFieldEnd()
10195 
    if self.itemId != None:
10196 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10197 
      oprot.writeI64(self.itemId)
10198 
      oprot.writeFieldEnd()
10199 
    oprot.writeFieldStop()
10200 
    oprot.writeStructEnd()
10201 
 
10202 
  def __repr__(self):
10203 
    L = ['%s=%r' % (key, value)
10204 
      for key, value in self.__dict__.iteritems()]
10205 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10206 
 
10207 
  def __eq__(self, other):
10208 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10209 
 
10210 
  def __ne__(self, other):
10211 
    return not (self == other)
10212 
 
10213 
class deleteItemFromCart_result:
10214 
  """
10215 
  Attributes:
10216 
   - scx
10217 
  """
10218 
 
10219 
  thrift_spec = (
10220 
    None, # 0
10221 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10222 
  )
10223 
 
10224 
  def __init__(self, scx=None,):
10225 
    self.scx = scx
10226 
 
10227 
  def read(self, iprot):
10228 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10229 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10230 
      return
10231 
    iprot.readStructBegin()
10232 
    while True:
10233 
      (fname, ftype, fid) = iprot.readFieldBegin()
10234 
      if ftype == TType.STOP:
10235 
        break
10236 
      if fid == 1:
10237 
        if ftype == TType.STRUCT:
10238 
          self.scx = ShoppingCartException()
10239 
          self.scx.read(iprot)
10240 
        else:
10241 
          iprot.skip(ftype)
10242 
      else:
10243 
        iprot.skip(ftype)
10244 
      iprot.readFieldEnd()
10245 
    iprot.readStructEnd()
10246 
 
10247 
  def write(self, oprot):
10248 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10249 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10250 
      return
10251 
    oprot.writeStructBegin('deleteItemFromCart_result')
10252 
    if self.scx != None:
10253 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10254 
      self.scx.write(oprot)
10255 
      oprot.writeFieldEnd()
10256 
    oprot.writeFieldStop()
10257 
    oprot.writeStructEnd()
10258 
 
10259 
  def __repr__(self):
10260 
    L = ['%s=%r' % (key, value)
10261 
      for key, value in self.__dict__.iteritems()]
10262 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10263 
 
10264 
  def __eq__(self, other):
10265 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10266 
 
10267 
  def __ne__(self, other):
10268 
    return not (self == other)
10269 
 
10270 
class changeQuantity_args:
10271 
  """
10272 
  Attributes:
10273 
   - cartId
10274 
   - itemId
10275 
   - quantity
10276 
  """
10277 
 
10278 
  thrift_spec = (
10279 
    None, # 0
10280 
    (1, TType.I64, 'cartId', None, None, ), # 1
10281 
    (2, TType.I64, 'itemId', None, None, ), # 2
10282 
    (3, TType.I64, 'quantity', None, None, ), # 3
10283 
  )
10284 
 
10285 
  def __init__(self, cartId=None, itemId=None, quantity=None,):
10286 
    self.cartId = cartId
10287 
    self.itemId = itemId
10288 
    self.quantity = quantity
10289 
 
10290 
  def read(self, iprot):
10291 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10292 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10293 
      return
10294 
    iprot.readStructBegin()
10295 
    while True:
10296 
      (fname, ftype, fid) = iprot.readFieldBegin()
10297 
      if ftype == TType.STOP:
10298 
        break
10299 
      if fid == 1:
10300 
        if ftype == TType.I64:
10301 
          self.cartId = iprot.readI64();
10302 
        else:
10303 
          iprot.skip(ftype)
10304 
      elif fid == 2:
10305 
        if ftype == TType.I64:
10306 
          self.itemId = iprot.readI64();
10307 
        else:
10308 
          iprot.skip(ftype)
10309 
      elif fid == 3:
10310 
        if ftype == TType.I64:
10311 
          self.quantity = iprot.readI64();
10312 
        else:
10313 
          iprot.skip(ftype)
10314 
      else:
10315 
        iprot.skip(ftype)
10316 
      iprot.readFieldEnd()
10317 
    iprot.readStructEnd()
10318 
 
10319 
  def write(self, oprot):
10320 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10321 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10322 
      return
10323 
    oprot.writeStructBegin('changeQuantity_args')
10324 
    if self.cartId != None:
10325 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10326 
      oprot.writeI64(self.cartId)
10327 
      oprot.writeFieldEnd()
10328 
    if self.itemId != None:
10329 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10330 
      oprot.writeI64(self.itemId)
10331 
      oprot.writeFieldEnd()
10332 
    if self.quantity != None:
10333 
      oprot.writeFieldBegin('quantity', TType.I64, 3)
10334 
      oprot.writeI64(self.quantity)
10335 
      oprot.writeFieldEnd()
10336 
    oprot.writeFieldStop()
10337 
    oprot.writeStructEnd()
10338 
 
10339 
  def __repr__(self):
10340 
    L = ['%s=%r' % (key, value)
10341 
      for key, value in self.__dict__.iteritems()]
10342 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10343 
 
10344 
  def __eq__(self, other):
10345 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10346 
 
10347 
  def __ne__(self, other):
10348 
    return not (self == other)
10349 
 
10350 
class changeQuantity_result:
10351 
  """
10352 
  Attributes:
10353 
   - scx
10354 
  """
10355 
 
10356 
  thrift_spec = (
10357 
    None, # 0
10358 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10359 
  )
10360 
 
10361 
  def __init__(self, scx=None,):
10362 
    self.scx = scx
10363 
 
10364 
  def read(self, iprot):
10365 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10366 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10367 
      return
10368 
    iprot.readStructBegin()
10369 
    while True:
10370 
      (fname, ftype, fid) = iprot.readFieldBegin()
10371 
      if ftype == TType.STOP:
10372 
        break
10373 
      if fid == 1:
10374 
        if ftype == TType.STRUCT:
10375 
          self.scx = ShoppingCartException()
10376 
          self.scx.read(iprot)
10377 
        else:
10378 
          iprot.skip(ftype)
10379 
      else:
10380 
        iprot.skip(ftype)
10381 
      iprot.readFieldEnd()
10382 
    iprot.readStructEnd()
10383 
 
10384 
  def write(self, oprot):
10385 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10386 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10387 
      return
10388 
    oprot.writeStructBegin('changeQuantity_result')
10389 
    if self.scx != None:
10390 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10391 
      self.scx.write(oprot)
10392 
      oprot.writeFieldEnd()
10393 
    oprot.writeFieldStop()
10394 
    oprot.writeStructEnd()
10395 
 
10396 
  def __repr__(self):
10397 
    L = ['%s=%r' % (key, value)
10398 
      for key, value in self.__dict__.iteritems()]
10399 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10400 
 
10401 
  def __eq__(self, other):
10402 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10403 
 
10404 
  def __ne__(self, other):
10405 
    return not (self == other)
10406 
 
10407 
class changeItemStatus_args:
10408 
  """
10409 
  Attributes:
10410 
   - cartId
10411 
   - itemId
10412 
   - status
10413 
  """
10414 
 
10415 
  thrift_spec = (
10416 
    None, # 0
10417 
    (1, TType.I64, 'cartId', None, None, ), # 1
10418 
    (2, TType.I64, 'itemId', None, None, ), # 2
10419 
    (3, TType.I32, 'status', None, None, ), # 3
10420 
  )
10421 
 
10422 
  def __init__(self, cartId=None, itemId=None, status=None,):
10423 
    self.cartId = cartId
10424 
    self.itemId = itemId
10425 
    self.status = status
10426 
 
10427 
  def read(self, iprot):
10428 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10429 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10430 
      return
10431 
    iprot.readStructBegin()
10432 
    while True:
10433 
      (fname, ftype, fid) = iprot.readFieldBegin()
10434 
      if ftype == TType.STOP:
10435 
        break
10436 
      if fid == 1:
10437 
        if ftype == TType.I64:
10438 
          self.cartId = iprot.readI64();
10439 
        else:
10440 
          iprot.skip(ftype)
10441 
      elif fid == 2:
10442 
        if ftype == TType.I64:
10443 
          self.itemId = iprot.readI64();
10444 
        else:
10445 
          iprot.skip(ftype)
10446 
      elif fid == 3:
10447 
        if ftype == TType.I32:
10448 
          self.status = iprot.readI32();
10449 
        else:
10450 
          iprot.skip(ftype)
10451 
      else:
10452 
        iprot.skip(ftype)
10453 
      iprot.readFieldEnd()
10454 
    iprot.readStructEnd()
10455 
 
10456 
  def write(self, oprot):
10457 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10458 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10459 
      return
10460 
    oprot.writeStructBegin('changeItemStatus_args')
10461 
    if self.cartId != None:
10462 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10463 
      oprot.writeI64(self.cartId)
10464 
      oprot.writeFieldEnd()
10465 
    if self.itemId != None:
10466 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
10467 
      oprot.writeI64(self.itemId)
10468 
      oprot.writeFieldEnd()
10469 
    if self.status != None:
10470 
      oprot.writeFieldBegin('status', TType.I32, 3)
10471 
      oprot.writeI32(self.status)
10472 
      oprot.writeFieldEnd()
10473 
    oprot.writeFieldStop()
10474 
    oprot.writeStructEnd()
10475 
 
10476 
  def __repr__(self):
10477 
    L = ['%s=%r' % (key, value)
10478 
      for key, value in self.__dict__.iteritems()]
10479 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10480 
 
10481 
  def __eq__(self, other):
10482 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10483 
 
10484 
  def __ne__(self, other):
10485 
    return not (self == other)
10486 
 
10487 
class changeItemStatus_result:
10488 
  """
10489 
  Attributes:
10490 
   - scx
10491 
  """
10492 
 
10493 
  thrift_spec = (
10494 
    None, # 0
10495 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10496 
  )
10497 
 
10498 
  def __init__(self, scx=None,):
10499 
    self.scx = scx
10500 
 
10501 
  def read(self, iprot):
10502 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10503 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10504 
      return
10505 
    iprot.readStructBegin()
10506 
    while True:
10507 
      (fname, ftype, fid) = iprot.readFieldBegin()
10508 
      if ftype == TType.STOP:
10509 
        break
10510 
      if fid == 1:
10511 
        if ftype == TType.STRUCT:
10512 
          self.scx = ShoppingCartException()
10513 
          self.scx.read(iprot)
10514 
        else:
10515 
          iprot.skip(ftype)
10516 
      else:
10517 
        iprot.skip(ftype)
10518 
      iprot.readFieldEnd()
10519 
    iprot.readStructEnd()
10520 
 
10521 
  def write(self, oprot):
10522 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10523 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10524 
      return
10525 
    oprot.writeStructBegin('changeItemStatus_result')
10526 
    if self.scx != None:
10527 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10528 
      self.scx.write(oprot)
10529 
      oprot.writeFieldEnd()
10530 
    oprot.writeFieldStop()
10531 
    oprot.writeStructEnd()
10532 
 
10533 
  def __repr__(self):
10534 
    L = ['%s=%r' % (key, value)
10535 
      for key, value in self.__dict__.iteritems()]
10536 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10537 
 
10538 
  def __eq__(self, other):
10539 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10540 
 
10541 
  def __ne__(self, other):
10542 
    return not (self == other)
10543 
 
10544 
class addAddressToCart_args:
10545 
  """
10546 
  Attributes:
10547 
   - cartId
10548 
   - addressId
10549 
  """
10550 
 
10551 
  thrift_spec = (
10552 
    None, # 0
10553 
    (1, TType.I64, 'cartId', None, None, ), # 1
10554 
    (2, TType.I64, 'addressId', None, None, ), # 2
10555 
  )
10556 
 
10557 
  def __init__(self, cartId=None, addressId=None,):
10558 
    self.cartId = cartId
10559 
    self.addressId = addressId
10560 
 
10561 
  def read(self, iprot):
10562 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10563 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10564 
      return
10565 
    iprot.readStructBegin()
10566 
    while True:
10567 
      (fname, ftype, fid) = iprot.readFieldBegin()
10568 
      if ftype == TType.STOP:
10569 
        break
10570 
      if fid == 1:
10571 
        if ftype == TType.I64:
10572 
          self.cartId = iprot.readI64();
10573 
        else:
10574 
          iprot.skip(ftype)
10575 
      elif fid == 2:
10576 
        if ftype == TType.I64:
10577 
          self.addressId = iprot.readI64();
10578 
        else:
10579 
          iprot.skip(ftype)
10580 
      else:
10581 
        iprot.skip(ftype)
10582 
      iprot.readFieldEnd()
10583 
    iprot.readStructEnd()
10584 
 
10585 
  def write(self, oprot):
10586 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10587 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10588 
      return
10589 
    oprot.writeStructBegin('addAddressToCart_args')
10590 
    if self.cartId != None:
10591 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10592 
      oprot.writeI64(self.cartId)
10593 
      oprot.writeFieldEnd()
10594 
    if self.addressId != None:
10595 
      oprot.writeFieldBegin('addressId', TType.I64, 2)
10596 
      oprot.writeI64(self.addressId)
10597 
      oprot.writeFieldEnd()
10598 
    oprot.writeFieldStop()
10599 
    oprot.writeStructEnd()
10600 
 
10601 
  def __repr__(self):
10602 
    L = ['%s=%r' % (key, value)
10603 
      for key, value in self.__dict__.iteritems()]
10604 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10605 
 
10606 
  def __eq__(self, other):
10607 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10608 
 
10609 
  def __ne__(self, other):
10610 
    return not (self == other)
10611 
 
10612 
class addAddressToCart_result:
575 chandransh 10613 
  """
10614 
  Attributes:
10615 
   - scx
10616 
  """
559 chandransh 10617 
 
10618 
  thrift_spec = (
575 chandransh 10619 
    None, # 0
10620 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 10621 
  )
10622 
 
575 chandransh 10623 
  def __init__(self, scx=None,):
10624 
    self.scx = scx
10625 
 
559 chandransh 10626 
  def read(self, iprot):
10627 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10628 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10629 
      return
10630 
    iprot.readStructBegin()
10631 
    while True:
10632 
      (fname, ftype, fid) = iprot.readFieldBegin()
10633 
      if ftype == TType.STOP:
10634 
        break
575 chandransh 10635 
      if fid == 1:
10636 
        if ftype == TType.STRUCT:
10637 
          self.scx = ShoppingCartException()
10638 
          self.scx.read(iprot)
10639 
        else:
10640 
          iprot.skip(ftype)
559 chandransh 10641 
      else:
10642 
        iprot.skip(ftype)
10643 
      iprot.readFieldEnd()
10644 
    iprot.readStructEnd()
10645 
 
10646 
  def write(self, oprot):
10647 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10648 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10649 
      return
10650 
    oprot.writeStructBegin('addAddressToCart_result')
575 chandransh 10651 
    if self.scx != None:
10652 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10653 
      self.scx.write(oprot)
10654 
      oprot.writeFieldEnd()
559 chandransh 10655 
    oprot.writeFieldStop()
10656 
    oprot.writeStructEnd()
10657 
 
10658 
  def __repr__(self):
10659 
    L = ['%s=%r' % (key, value)
10660 
      for key, value in self.__dict__.iteritems()]
10661 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10662 
 
10663 
  def __eq__(self, other):
10664 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10665 
 
10666 
  def __ne__(self, other):
10667 
    return not (self == other)
10668 
 
1976 varun.gupt 10669 
class applyCouponToCart_args:
10670 
  """
10671 
  Attributes:
10672 
   - cartId
10673 
   - couponCode
10674 
   - totalPrice
10675 
   - discountedPrice
10676 
  """
10677 
 
10678 
  thrift_spec = (
10679 
    None, # 0
10680 
    (1, TType.I64, 'cartId', None, None, ), # 1
10681 
    (2, TType.STRING, 'couponCode', None, None, ), # 2
10682 
    (3, TType.DOUBLE, 'totalPrice', None, None, ), # 3
10683 
    (4, TType.DOUBLE, 'discountedPrice', None, None, ), # 4
10684 
  )
10685 
 
10686 
  def __init__(self, cartId=None, couponCode=None, totalPrice=None, discountedPrice=None,):
10687 
    self.cartId = cartId
10688 
    self.couponCode = couponCode
10689 
    self.totalPrice = totalPrice
10690 
    self.discountedPrice = discountedPrice
10691 
 
10692 
  def read(self, iprot):
10693 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10694 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10695 
      return
10696 
    iprot.readStructBegin()
10697 
    while True:
10698 
      (fname, ftype, fid) = iprot.readFieldBegin()
10699 
      if ftype == TType.STOP:
10700 
        break
10701 
      if fid == 1:
10702 
        if ftype == TType.I64:
10703 
          self.cartId = iprot.readI64();
10704 
        else:
10705 
          iprot.skip(ftype)
10706 
      elif fid == 2:
10707 
        if ftype == TType.STRING:
10708 
          self.couponCode = iprot.readString();
10709 
        else:
10710 
          iprot.skip(ftype)
10711 
      elif fid == 3:
10712 
        if ftype == TType.DOUBLE:
10713 
          self.totalPrice = iprot.readDouble();
10714 
        else:
10715 
          iprot.skip(ftype)
10716 
      elif fid == 4:
10717 
        if ftype == TType.DOUBLE:
10718 
          self.discountedPrice = iprot.readDouble();
10719 
        else:
10720 
          iprot.skip(ftype)
10721 
      else:
10722 
        iprot.skip(ftype)
10723 
      iprot.readFieldEnd()
10724 
    iprot.readStructEnd()
10725 
 
10726 
  def write(self, oprot):
10727 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10728 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10729 
      return
10730 
    oprot.writeStructBegin('applyCouponToCart_args')
10731 
    if self.cartId != None:
10732 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10733 
      oprot.writeI64(self.cartId)
10734 
      oprot.writeFieldEnd()
10735 
    if self.couponCode != None:
10736 
      oprot.writeFieldBegin('couponCode', TType.STRING, 2)
10737 
      oprot.writeString(self.couponCode)
10738 
      oprot.writeFieldEnd()
10739 
    if self.totalPrice != None:
10740 
      oprot.writeFieldBegin('totalPrice', TType.DOUBLE, 3)
10741 
      oprot.writeDouble(self.totalPrice)
10742 
      oprot.writeFieldEnd()
10743 
    if self.discountedPrice != None:
10744 
      oprot.writeFieldBegin('discountedPrice', TType.DOUBLE, 4)
10745 
      oprot.writeDouble(self.discountedPrice)
10746 
      oprot.writeFieldEnd()
10747 
    oprot.writeFieldStop()
10748 
    oprot.writeStructEnd()
10749 
 
10750 
  def __repr__(self):
10751 
    L = ['%s=%r' % (key, value)
10752 
      for key, value in self.__dict__.iteritems()]
10753 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10754 
 
10755 
  def __eq__(self, other):
10756 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10757 
 
10758 
  def __ne__(self, other):
10759 
    return not (self == other)
10760 
 
10761 
class applyCouponToCart_result:
10762 
  """
10763 
  Attributes:
10764 
   - scx
10765 
  """
10766 
 
10767 
  thrift_spec = (
10768 
    None, # 0
10769 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10770 
  )
10771 
 
10772 
  def __init__(self, scx=None,):
10773 
    self.scx = scx
10774 
 
10775 
  def read(self, iprot):
10776 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10777 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10778 
      return
10779 
    iprot.readStructBegin()
10780 
    while True:
10781 
      (fname, ftype, fid) = iprot.readFieldBegin()
10782 
      if ftype == TType.STOP:
10783 
        break
10784 
      if fid == 1:
10785 
        if ftype == TType.STRUCT:
10786 
          self.scx = ShoppingCartException()
10787 
          self.scx.read(iprot)
10788 
        else:
10789 
          iprot.skip(ftype)
10790 
      else:
10791 
        iprot.skip(ftype)
10792 
      iprot.readFieldEnd()
10793 
    iprot.readStructEnd()
10794 
 
10795 
  def write(self, oprot):
10796 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10797 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10798 
      return
10799 
    oprot.writeStructBegin('applyCouponToCart_result')
10800 
    if self.scx != None:
10801 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10802 
      self.scx.write(oprot)
10803 
      oprot.writeFieldEnd()
10804 
    oprot.writeFieldStop()
10805 
    oprot.writeStructEnd()
10806 
 
10807 
  def __repr__(self):
10808 
    L = ['%s=%r' % (key, value)
10809 
      for key, value in self.__dict__.iteritems()]
10810 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10811 
 
10812 
  def __eq__(self, other):
10813 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10814 
 
10815 
  def __ne__(self, other):
10816 
    return not (self == other)
10817 
 
10818 
class removeCoupon_args:
10819 
  """
10820 
  Attributes:
10821 
   - cartId
10822 
  """
10823 
 
10824 
  thrift_spec = (
10825 
    None, # 0
10826 
    (1, TType.I64, 'cartId', None, None, ), # 1
10827 
  )
10828 
 
10829 
  def __init__(self, cartId=None,):
10830 
    self.cartId = cartId
10831 
 
10832 
  def read(self, iprot):
10833 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10834 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10835 
      return
10836 
    iprot.readStructBegin()
10837 
    while True:
10838 
      (fname, ftype, fid) = iprot.readFieldBegin()
10839 
      if ftype == TType.STOP:
10840 
        break
10841 
      if fid == 1:
10842 
        if ftype == TType.I64:
10843 
          self.cartId = iprot.readI64();
10844 
        else:
10845 
          iprot.skip(ftype)
10846 
      else:
10847 
        iprot.skip(ftype)
10848 
      iprot.readFieldEnd()
10849 
    iprot.readStructEnd()
10850 
 
10851 
  def write(self, oprot):
10852 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10853 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10854 
      return
10855 
    oprot.writeStructBegin('removeCoupon_args')
10856 
    if self.cartId != None:
10857 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10858 
      oprot.writeI64(self.cartId)
10859 
      oprot.writeFieldEnd()
10860 
    oprot.writeFieldStop()
10861 
    oprot.writeStructEnd()
10862 
 
10863 
  def __repr__(self):
10864 
    L = ['%s=%r' % (key, value)
10865 
      for key, value in self.__dict__.iteritems()]
10866 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10867 
 
10868 
  def __eq__(self, other):
10869 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10870 
 
10871 
  def __ne__(self, other):
10872 
    return not (self == other)
10873 
 
10874 
class removeCoupon_result:
10875 
  """
10876 
  Attributes:
10877 
   - scx
10878 
  """
10879 
 
10880 
  thrift_spec = (
10881 
    None, # 0
10882 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
10883 
  )
10884 
 
10885 
  def __init__(self, scx=None,):
10886 
    self.scx = scx
10887 
 
10888 
  def read(self, iprot):
10889 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10890 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10891 
      return
10892 
    iprot.readStructBegin()
10893 
    while True:
10894 
      (fname, ftype, fid) = iprot.readFieldBegin()
10895 
      if ftype == TType.STOP:
10896 
        break
10897 
      if fid == 1:
10898 
        if ftype == TType.STRUCT:
10899 
          self.scx = ShoppingCartException()
10900 
          self.scx.read(iprot)
10901 
        else:
10902 
          iprot.skip(ftype)
10903 
      else:
10904 
        iprot.skip(ftype)
10905 
      iprot.readFieldEnd()
10906 
    iprot.readStructEnd()
10907 
 
10908 
  def write(self, oprot):
10909 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10910 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10911 
      return
10912 
    oprot.writeStructBegin('removeCoupon_result')
10913 
    if self.scx != None:
10914 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
10915 
      self.scx.write(oprot)
10916 
      oprot.writeFieldEnd()
10917 
    oprot.writeFieldStop()
10918 
    oprot.writeStructEnd()
10919 
 
10920 
  def __repr__(self):
10921 
    L = ['%s=%r' % (key, value)
10922 
      for key, value in self.__dict__.iteritems()]
10923 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
10924 
 
10925 
  def __eq__(self, other):
10926 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
10927 
 
10928 
  def __ne__(self, other):
10929 
    return not (self == other)
10930 
 
690 chandransh 10931 
class createOrders_args:
559 chandransh 10932 
  """
10933 
  Attributes:
10934 
   - cartId
2815 vikas 10935 
   - sessionSource
10936 
   - sessionStartTime
559 chandransh 10937 
  """
10938 
 
10939 
  thrift_spec = (
10940 
    None, # 0
10941 
    (1, TType.I64, 'cartId', None, None, ), # 1
2815 vikas 10942 
    (2, TType.STRING, 'sessionSource', None, None, ), # 2
10943 
    (3, TType.I64, 'sessionStartTime', None, None, ), # 3
559 chandransh 10944 
  )
10945 
 
2815 vikas 10946 
  def __init__(self, cartId=None, sessionSource=None, sessionStartTime=None,):
559 chandransh 10947 
    self.cartId = cartId
2815 vikas 10948 
    self.sessionSource = sessionSource
10949 
    self.sessionStartTime = sessionStartTime
559 chandransh 10950 
 
10951 
  def read(self, iprot):
10952 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
10953 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
10954 
      return
10955 
    iprot.readStructBegin()
10956 
    while True:
10957 
      (fname, ftype, fid) = iprot.readFieldBegin()
10958 
      if ftype == TType.STOP:
10959 
        break
10960 
      if fid == 1:
10961 
        if ftype == TType.I64:
10962 
          self.cartId = iprot.readI64();
10963 
        else:
10964 
          iprot.skip(ftype)
2815 vikas 10965 
      elif fid == 2:
10966 
        if ftype == TType.STRING:
10967 
          self.sessionSource = iprot.readString();
10968 
        else:
10969 
          iprot.skip(ftype)
10970 
      elif fid == 3:
10971 
        if ftype == TType.I64:
10972 
          self.sessionStartTime = iprot.readI64();
10973 
        else:
10974 
          iprot.skip(ftype)
559 chandransh 10975 
      else:
10976 
        iprot.skip(ftype)
10977 
      iprot.readFieldEnd()
10978 
    iprot.readStructEnd()
10979 
 
10980 
  def write(self, oprot):
10981 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
10982 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
10983 
      return
690 chandransh 10984 
    oprot.writeStructBegin('createOrders_args')
559 chandransh 10985 
    if self.cartId != None:
10986 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
10987 
      oprot.writeI64(self.cartId)
10988 
      oprot.writeFieldEnd()
2815 vikas 10989 
    if self.sessionSource != None:
10990 
      oprot.writeFieldBegin('sessionSource', TType.STRING, 2)
10991 
      oprot.writeString(self.sessionSource)
10992 
      oprot.writeFieldEnd()
10993 
    if self.sessionStartTime != None:
10994 
      oprot.writeFieldBegin('sessionStartTime', TType.I64, 3)
10995 
      oprot.writeI64(self.sessionStartTime)
10996 
      oprot.writeFieldEnd()
559 chandransh 10997 
    oprot.writeFieldStop()
10998 
    oprot.writeStructEnd()
10999 
 
11000 
  def __repr__(self):
11001 
    L = ['%s=%r' % (key, value)
11002 
      for key, value in self.__dict__.iteritems()]
11003 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11004 
 
11005 
  def __eq__(self, other):
11006 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11007 
 
11008 
  def __ne__(self, other):
11009 
    return not (self == other)
11010 
 
690 chandransh 11011 
class createOrders_result:
559 chandransh 11012 
  """
11013 
  Attributes:
94 ashish 11014 
   - success
559 chandransh 11015 
   - scx
94 ashish 11016 
  """
11017 
 
11018 
  thrift_spec = (
575 chandransh 11019 
    (0, TType.I64, 'success', None, None, ), # 0
559 chandransh 11020 
    (1, TType.STRUCT, 'scx', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11021 
  )
11022 
 
559 chandransh 11023 
  def __init__(self, success=None, scx=None,):
94 ashish 11024 
    self.success = success
559 chandransh 11025 
    self.scx = scx
94 ashish 11026 
 
11027 
  def read(self, iprot):
11028 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11029 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11030 
      return
11031 
    iprot.readStructBegin()
11032 
    while True:
11033 
      (fname, ftype, fid) = iprot.readFieldBegin()
11034 
      if ftype == TType.STOP:
11035 
        break
11036 
      if fid == 0:
575 chandransh 11037 
        if ftype == TType.I64:
11038 
          self.success = iprot.readI64();
94 ashish 11039 
        else:
11040 
          iprot.skip(ftype)
11041 
      elif fid == 1:
11042 
        if ftype == TType.STRUCT:
559 chandransh 11043 
          self.scx = ShoppingCartException()
11044 
          self.scx.read(iprot)
94 ashish 11045 
        else:
11046 
          iprot.skip(ftype)
11047 
      else:
11048 
        iprot.skip(ftype)
11049 
      iprot.readFieldEnd()
11050 
    iprot.readStructEnd()
11051 
 
11052 
  def write(self, oprot):
11053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11055 
      return
690 chandransh 11056 
    oprot.writeStructBegin('createOrders_result')
94 ashish 11057 
    if self.success != None:
575 chandransh 11058 
      oprot.writeFieldBegin('success', TType.I64, 0)
11059 
      oprot.writeI64(self.success)
94 ashish 11060 
      oprot.writeFieldEnd()
559 chandransh 11061 
    if self.scx != None:
11062 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11063 
      self.scx.write(oprot)
94 ashish 11064 
      oprot.writeFieldEnd()
11065 
    oprot.writeFieldStop()
11066 
    oprot.writeStructEnd()
11067 
 
11068 
  def __repr__(self):
11069 
    L = ['%s=%r' % (key, value)
11070 
      for key, value in self.__dict__.iteritems()]
11071 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11072 
 
11073 
  def __eq__(self, other):
11074 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11075 
 
11076 
  def __ne__(self, other):
11077 
    return not (self == other)
11078 
 
559 chandransh 11079 
class validateCart_args:
94 ashish 11080 
  """
11081 
  Attributes:
559 chandransh 11082 
   - cartId
94 ashish 11083 
  """
11084 
 
11085 
  thrift_spec = (
11086 
    None, # 0
559 chandransh 11087 
    (1, TType.I64, 'cartId', None, None, ), # 1
94 ashish 11088 
  )
11089 
 
559 chandransh 11090 
  def __init__(self, cartId=None,):
11091 
    self.cartId = cartId
94 ashish 11092 
 
11093 
  def read(self, iprot):
11094 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11095 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11096 
      return
11097 
    iprot.readStructBegin()
11098 
    while True:
11099 
      (fname, ftype, fid) = iprot.readFieldBegin()
11100 
      if ftype == TType.STOP:
11101 
        break
11102 
      if fid == 1:
11103 
        if ftype == TType.I64:
559 chandransh 11104 
          self.cartId = iprot.readI64();
94 ashish 11105 
        else:
11106 
          iprot.skip(ftype)
11107 
      else:
11108 
        iprot.skip(ftype)
11109 
      iprot.readFieldEnd()
11110 
    iprot.readStructEnd()
11111 
 
11112 
  def write(self, oprot):
11113 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11114 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11115 
      return
559 chandransh 11116 
    oprot.writeStructBegin('validateCart_args')
11117 
    if self.cartId != None:
11118 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11119 
      oprot.writeI64(self.cartId)
94 ashish 11120 
      oprot.writeFieldEnd()
11121 
    oprot.writeFieldStop()
11122 
    oprot.writeStructEnd()
11123 
 
11124 
  def __repr__(self):
11125 
    L = ['%s=%r' % (key, value)
11126 
      for key, value in self.__dict__.iteritems()]
11127 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11128 
 
11129 
  def __eq__(self, other):
11130 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11131 
 
11132 
  def __ne__(self, other):
11133 
    return not (self == other)
11134 
 
559 chandransh 11135 
class validateCart_result:
94 ashish 11136 
  """
11137 
  Attributes:
11138 
   - success
575 chandransh 11139 
   - scex
94 ashish 11140 
  """
11141 
 
11142 
  thrift_spec = (
1466 ankur.sing 11143 
    (0, TType.STRING, 'success', None, None, ), # 0
575 chandransh 11144 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
94 ashish 11145 
  )
11146 
 
575 chandransh 11147 
  def __init__(self, success=None, scex=None,):
94 ashish 11148 
    self.success = success
575 chandransh 11149 
    self.scex = scex
94 ashish 11150 
 
11151 
  def read(self, iprot):
11152 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11153 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11154 
      return
11155 
    iprot.readStructBegin()
11156 
    while True:
11157 
      (fname, ftype, fid) = iprot.readFieldBegin()
11158 
      if ftype == TType.STOP:
11159 
        break
11160 
      if fid == 0:
1466 ankur.sing 11161 
        if ftype == TType.STRING:
11162 
          self.success = iprot.readString();
94 ashish 11163 
        else:
11164 
          iprot.skip(ftype)
575 chandransh 11165 
      elif fid == 1:
11166 
        if ftype == TType.STRUCT:
11167 
          self.scex = ShoppingCartException()
11168 
          self.scex.read(iprot)
11169 
        else:
11170 
          iprot.skip(ftype)
94 ashish 11171 
      else:
11172 
        iprot.skip(ftype)
11173 
      iprot.readFieldEnd()
11174 
    iprot.readStructEnd()
11175 
 
11176 
  def write(self, oprot):
11177 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11178 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11179 
      return
559 chandransh 11180 
    oprot.writeStructBegin('validateCart_result')
94 ashish 11181 
    if self.success != None:
1466 ankur.sing 11182 
      oprot.writeFieldBegin('success', TType.STRING, 0)
11183 
      oprot.writeString(self.success)
94 ashish 11184 
      oprot.writeFieldEnd()
575 chandransh 11185 
    if self.scex != None:
11186 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11187 
      self.scex.write(oprot)
11188 
      oprot.writeFieldEnd()
559 chandransh 11189 
    oprot.writeFieldStop()
11190 
    oprot.writeStructEnd()
11191 
 
11192 
  def __repr__(self):
11193 
    L = ['%s=%r' % (key, value)
11194 
      for key, value in self.__dict__.iteritems()]
11195 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11196 
 
11197 
  def __eq__(self, other):
11198 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11199 
 
11200 
  def __ne__(self, other):
11201 
    return not (self == other)
11202 
 
690 chandransh 11203 
class mergeCart_args:
575 chandransh 11204 
  """
11205 
  Attributes:
690 chandransh 11206 
   - fromCartId
11207 
   - toCartId
11208 
  """
11209 
 
11210 
  thrift_spec = (
11211 
    None, # 0
11212 
    (1, TType.I64, 'fromCartId', None, None, ), # 1
11213 
    (2, TType.I64, 'toCartId', None, None, ), # 2
11214 
  )
11215 
 
11216 
  def __init__(self, fromCartId=None, toCartId=None,):
11217 
    self.fromCartId = fromCartId
11218 
    self.toCartId = toCartId
11219 
 
11220 
  def read(self, iprot):
11221 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11222 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11223 
      return
11224 
    iprot.readStructBegin()
11225 
    while True:
11226 
      (fname, ftype, fid) = iprot.readFieldBegin()
11227 
      if ftype == TType.STOP:
11228 
        break
11229 
      if fid == 1:
11230 
        if ftype == TType.I64:
11231 
          self.fromCartId = iprot.readI64();
11232 
        else:
11233 
          iprot.skip(ftype)
11234 
      elif fid == 2:
11235 
        if ftype == TType.I64:
11236 
          self.toCartId = iprot.readI64();
11237 
        else:
11238 
          iprot.skip(ftype)
11239 
      else:
11240 
        iprot.skip(ftype)
11241 
      iprot.readFieldEnd()
11242 
    iprot.readStructEnd()
11243 
 
11244 
  def write(self, oprot):
11245 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11246 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11247 
      return
11248 
    oprot.writeStructBegin('mergeCart_args')
11249 
    if self.fromCartId != None:
11250 
      oprot.writeFieldBegin('fromCartId', TType.I64, 1)
11251 
      oprot.writeI64(self.fromCartId)
11252 
      oprot.writeFieldEnd()
11253 
    if self.toCartId != None:
11254 
      oprot.writeFieldBegin('toCartId', TType.I64, 2)
11255 
      oprot.writeI64(self.toCartId)
11256 
      oprot.writeFieldEnd()
11257 
    oprot.writeFieldStop()
11258 
    oprot.writeStructEnd()
11259 
 
11260 
  def __repr__(self):
11261 
    L = ['%s=%r' % (key, value)
11262 
      for key, value in self.__dict__.iteritems()]
11263 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11264 
 
11265 
  def __eq__(self, other):
11266 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11267 
 
11268 
  def __ne__(self, other):
11269 
    return not (self == other)
11270 
 
11271 
class mergeCart_result:
11272 
 
11273 
  thrift_spec = (
11274 
  )
11275 
 
11276 
  def read(self, iprot):
11277 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11278 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11279 
      return
11280 
    iprot.readStructBegin()
11281 
    while True:
11282 
      (fname, ftype, fid) = iprot.readFieldBegin()
11283 
      if ftype == TType.STOP:
11284 
        break
11285 
      else:
11286 
        iprot.skip(ftype)
11287 
      iprot.readFieldEnd()
11288 
    iprot.readStructEnd()
11289 
 
11290 
  def write(self, oprot):
11291 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11292 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11293 
      return
11294 
    oprot.writeStructBegin('mergeCart_result')
11295 
    oprot.writeFieldStop()
11296 
    oprot.writeStructEnd()
11297 
 
11298 
  def __repr__(self):
11299 
    L = ['%s=%r' % (key, value)
11300 
      for key, value in self.__dict__.iteritems()]
11301 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11302 
 
11303 
  def __eq__(self, other):
11304 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11305 
 
11306 
  def __ne__(self, other):
11307 
    return not (self == other)
11308 
 
11309 
class checkOut_args:
11310 
  """
11311 
  Attributes:
575 chandransh 11312 
   - cartId
11313 
  """
11314 
 
11315 
  thrift_spec = (
11316 
    None, # 0
11317 
    (1, TType.I64, 'cartId', None, None, ), # 1
11318 
  )
11319 
 
11320 
  def __init__(self, cartId=None,):
11321 
    self.cartId = cartId
11322 
 
11323 
  def read(self, iprot):
11324 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11325 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11326 
      return
11327 
    iprot.readStructBegin()
11328 
    while True:
11329 
      (fname, ftype, fid) = iprot.readFieldBegin()
11330 
      if ftype == TType.STOP:
11331 
        break
11332 
      if fid == 1:
11333 
        if ftype == TType.I64:
11334 
          self.cartId = iprot.readI64();
11335 
        else:
11336 
          iprot.skip(ftype)
11337 
      else:
11338 
        iprot.skip(ftype)
11339 
      iprot.readFieldEnd()
11340 
    iprot.readStructEnd()
11341 
 
11342 
  def write(self, oprot):
11343 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11344 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11345 
      return
690 chandransh 11346 
    oprot.writeStructBegin('checkOut_args')
575 chandransh 11347 
    if self.cartId != None:
11348 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11349 
      oprot.writeI64(self.cartId)
11350 
      oprot.writeFieldEnd()
11351 
    oprot.writeFieldStop()
11352 
    oprot.writeStructEnd()
11353 
 
11354 
  def __repr__(self):
11355 
    L = ['%s=%r' % (key, value)
11356 
      for key, value in self.__dict__.iteritems()]
11357 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11358 
 
11359 
  def __eq__(self, other):
11360 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11361 
 
11362 
  def __ne__(self, other):
11363 
    return not (self == other)
11364 
 
690 chandransh 11365 
class checkOut_result:
575 chandransh 11366 
  """
11367 
  Attributes:
11368 
   - success
11369 
   - scex
11370 
  """
11371 
 
11372 
  thrift_spec = (
11373 
    (0, TType.BOOL, 'success', None, None, ), # 0
11374 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
11375 
  )
11376 
 
11377 
  def __init__(self, success=None, scex=None,):
11378 
    self.success = success
11379 
    self.scex = scex
11380 
 
11381 
  def read(self, iprot):
11382 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11383 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11384 
      return
11385 
    iprot.readStructBegin()
11386 
    while True:
11387 
      (fname, ftype, fid) = iprot.readFieldBegin()
11388 
      if ftype == TType.STOP:
11389 
        break
11390 
      if fid == 0:
11391 
        if ftype == TType.BOOL:
11392 
          self.success = iprot.readBool();
11393 
        else:
11394 
          iprot.skip(ftype)
11395 
      elif fid == 1:
11396 
        if ftype == TType.STRUCT:
11397 
          self.scex = ShoppingCartException()
11398 
          self.scex.read(iprot)
11399 
        else:
11400 
          iprot.skip(ftype)
11401 
      else:
11402 
        iprot.skip(ftype)
11403 
      iprot.readFieldEnd()
11404 
    iprot.readStructEnd()
11405 
 
11406 
  def write(self, oprot):
11407 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11408 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11409 
      return
690 chandransh 11410 
    oprot.writeStructBegin('checkOut_result')
575 chandransh 11411 
    if self.success != None:
11412 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11413 
      oprot.writeBool(self.success)
11414 
      oprot.writeFieldEnd()
11415 
    if self.scex != None:
11416 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11417 
      self.scex.write(oprot)
11418 
      oprot.writeFieldEnd()
11419 
    oprot.writeFieldStop()
11420 
    oprot.writeStructEnd()
11421 
 
11422 
  def __repr__(self):
11423 
    L = ['%s=%r' % (key, value)
11424 
      for key, value in self.__dict__.iteritems()]
11425 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11426 
 
11427 
  def __eq__(self, other):
11428 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11429 
 
11430 
  def __ne__(self, other):
11431 
    return not (self == other)
11432 
 
690 chandransh 11433 
class resetCart_args:
559 chandransh 11434 
  """
11435 
  Attributes:
690 chandransh 11436 
   - cartId
11437 
   - items
559 chandransh 11438 
  """
11439 
 
11440 
  thrift_spec = (
11441 
    None, # 0
690 chandransh 11442 
    (1, TType.I64, 'cartId', None, None, ), # 1
707 rajveer 11443 
    (2, TType.MAP, 'items', (TType.I64,None,TType.DOUBLE,None), None, ), # 2
559 chandransh 11444 
  )
11445 
 
690 chandransh 11446 
  def __init__(self, cartId=None, items=None,):
11447 
    self.cartId = cartId
11448 
    self.items = items
559 chandransh 11449 
 
11450 
  def read(self, iprot):
11451 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11452 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11453 
      return
11454 
    iprot.readStructBegin()
11455 
    while True:
11456 
      (fname, ftype, fid) = iprot.readFieldBegin()
11457 
      if ftype == TType.STOP:
11458 
        break
11459 
      if fid == 1:
11460 
        if ftype == TType.I64:
690 chandransh 11461 
          self.cartId = iprot.readI64();
559 chandransh 11462 
        else:
11463 
          iprot.skip(ftype)
11464 
      elif fid == 2:
690 chandransh 11465 
        if ftype == TType.MAP:
11466 
          self.items = {}
1996 vikas 11467 
          (_ktype113, _vtype114, _size112 ) = iprot.readMapBegin()
11468 
          for _i116 in xrange(_size112):
11469 
            _key117 = iprot.readI64();
11470 
            _val118 = iprot.readDouble();
11471 
            self.items[_key117] = _val118
690 chandransh 11472 
          iprot.readMapEnd()
559 chandransh 11473 
        else:
11474 
          iprot.skip(ftype)
11475 
      else:
11476 
        iprot.skip(ftype)
11477 
      iprot.readFieldEnd()
11478 
    iprot.readStructEnd()
11479 
 
11480 
  def write(self, oprot):
11481 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11482 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11483 
      return
690 chandransh 11484 
    oprot.writeStructBegin('resetCart_args')
11485 
    if self.cartId != None:
11486 
      oprot.writeFieldBegin('cartId', TType.I64, 1)
11487 
      oprot.writeI64(self.cartId)
94 ashish 11488 
      oprot.writeFieldEnd()
690 chandransh 11489 
    if self.items != None:
11490 
      oprot.writeFieldBegin('items', TType.MAP, 2)
707 rajveer 11491 
      oprot.writeMapBegin(TType.I64, TType.DOUBLE, len(self.items))
1996 vikas 11492 
      for kiter119,viter120 in self.items.items():
11493 
        oprot.writeI64(kiter119)
11494 
        oprot.writeDouble(viter120)
690 chandransh 11495 
      oprot.writeMapEnd()
559 chandransh 11496 
      oprot.writeFieldEnd()
94 ashish 11497 
    oprot.writeFieldStop()
11498 
    oprot.writeStructEnd()
11499 
 
11500 
  def __repr__(self):
11501 
    L = ['%s=%r' % (key, value)
11502 
      for key, value in self.__dict__.iteritems()]
11503 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11504 
 
11505 
  def __eq__(self, other):
11506 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11507 
 
11508 
  def __ne__(self, other):
11509 
    return not (self == other)
11510 
 
690 chandransh 11511 
class resetCart_result:
11512 
  """
11513 
  Attributes:
11514 
   - success
11515 
   - scex
11516 
  """
559 chandransh 11517 
 
11518 
  thrift_spec = (
690 chandransh 11519 
    (0, TType.BOOL, 'success', None, None, ), # 0
11520 
    (1, TType.STRUCT, 'scex', (ShoppingCartException, ShoppingCartException.thrift_spec), None, ), # 1
559 chandransh 11521 
  )
11522 
 
690 chandransh 11523 
  def __init__(self, success=None, scex=None,):
11524 
    self.success = success
11525 
    self.scex = scex
11526 
 
559 chandransh 11527 
  def read(self, iprot):
11528 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11529 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11530 
      return
11531 
    iprot.readStructBegin()
11532 
    while True:
11533 
      (fname, ftype, fid) = iprot.readFieldBegin()
11534 
      if ftype == TType.STOP:
11535 
        break
690 chandransh 11536 
      if fid == 0:
11537 
        if ftype == TType.BOOL:
11538 
          self.success = iprot.readBool();
11539 
        else:
11540 
          iprot.skip(ftype)
11541 
      elif fid == 1:
11542 
        if ftype == TType.STRUCT:
11543 
          self.scex = ShoppingCartException()
11544 
          self.scex.read(iprot)
11545 
        else:
11546 
          iprot.skip(ftype)
559 chandransh 11547 
      else:
11548 
        iprot.skip(ftype)
11549 
      iprot.readFieldEnd()
11550 
    iprot.readStructEnd()
11551 
 
11552 
  def write(self, oprot):
11553 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11554 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11555 
      return
690 chandransh 11556 
    oprot.writeStructBegin('resetCart_result')
11557 
    if self.success != None:
11558 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11559 
      oprot.writeBool(self.success)
11560 
      oprot.writeFieldEnd()
11561 
    if self.scex != None:
11562 
      oprot.writeFieldBegin('scex', TType.STRUCT, 1)
11563 
      self.scex.write(oprot)
11564 
      oprot.writeFieldEnd()
559 chandransh 11565 
    oprot.writeFieldStop()
11566 
    oprot.writeStructEnd()
11567 
 
11568 
  def __repr__(self):
11569 
    L = ['%s=%r' % (key, value)
11570 
      for key, value in self.__dict__.iteritems()]
11571 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11572 
 
11573 
  def __eq__(self, other):
11574 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11575 
 
11576 
  def __ne__(self, other):
11577 
    return not (self == other)
11578 
 
772 rajveer 11579 
class getMyResearch_args:
94 ashish 11580 
  """
11581 
  Attributes:
559 chandransh 11582 
   - userId
11583 
  """
11584 
 
11585 
  thrift_spec = (
11586 
    None, # 0
772 rajveer 11587 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 11588 
  )
11589 
 
772 rajveer 11590 
  def __init__(self, userId=None,):
559 chandransh 11591 
    self.userId = userId
11592 
 
11593 
  def read(self, iprot):
11594 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11595 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11596 
      return
11597 
    iprot.readStructBegin()
11598 
    while True:
11599 
      (fname, ftype, fid) = iprot.readFieldBegin()
11600 
      if ftype == TType.STOP:
11601 
        break
11602 
      if fid == 1:
11603 
        if ftype == TType.I64:
11604 
          self.userId = iprot.readI64();
11605 
        else:
11606 
          iprot.skip(ftype)
11607 
      else:
11608 
        iprot.skip(ftype)
11609 
      iprot.readFieldEnd()
11610 
    iprot.readStructEnd()
11611 
 
11612 
  def write(self, oprot):
11613 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11614 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11615 
      return
772 rajveer 11616 
    oprot.writeStructBegin('getMyResearch_args')
559 chandransh 11617 
    if self.userId != None:
772 rajveer 11618 
      oprot.writeFieldBegin('userId', TType.I64, 1)
559 chandransh 11619 
      oprot.writeI64(self.userId)
11620 
      oprot.writeFieldEnd()
11621 
    oprot.writeFieldStop()
11622 
    oprot.writeStructEnd()
11623 
 
11624 
  def __repr__(self):
11625 
    L = ['%s=%r' % (key, value)
11626 
      for key, value in self.__dict__.iteritems()]
11627 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11628 
 
11629 
  def __eq__(self, other):
11630 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11631 
 
11632 
  def __ne__(self, other):
11633 
    return not (self == other)
11634 
 
11635 
class getMyResearch_result:
94 ashish 11636 
  """
11637 
  Attributes:
11638 
   - success
559 chandransh 11639 
   - scx
94 ashish 11640 
  """
11641 
 
11642 
  thrift_spec = (
559 chandransh 11643 
    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
11644 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
94 ashish 11645 
  )
11646 
 
559 chandransh 11647 
  def __init__(self, success=None, scx=None,):
94 ashish 11648 
    self.success = success
559 chandransh 11649 
    self.scx = scx
94 ashish 11650 
 
11651 
  def read(self, iprot):
11652 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11653 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11654 
      return
11655 
    iprot.readStructBegin()
11656 
    while True:
11657 
      (fname, ftype, fid) = iprot.readFieldBegin()
11658 
      if ftype == TType.STOP:
11659 
        break
11660 
      if fid == 0:
559 chandransh 11661 
        if ftype == TType.STRUCT:
11662 
          self.success = Widget()
11663 
          self.success.read(iprot)
94 ashish 11664 
        else:
11665 
          iprot.skip(ftype)
11666 
      elif fid == 1:
11667 
        if ftype == TType.STRUCT:
559 chandransh 11668 
          self.scx = WidgetException()
11669 
          self.scx.read(iprot)
94 ashish 11670 
        else:
11671 
          iprot.skip(ftype)
11672 
      else:
11673 
        iprot.skip(ftype)
11674 
      iprot.readFieldEnd()
11675 
    iprot.readStructEnd()
11676 
 
11677 
  def write(self, oprot):
11678 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11679 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11680 
      return
559 chandransh 11681 
    oprot.writeStructBegin('getMyResearch_result')
94 ashish 11682 
    if self.success != None:
559 chandransh 11683 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
11684 
      self.success.write(oprot)
94 ashish 11685 
      oprot.writeFieldEnd()
559 chandransh 11686 
    if self.scx != None:
11687 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11688 
      self.scx.write(oprot)
94 ashish 11689 
      oprot.writeFieldEnd()
11690 
    oprot.writeFieldStop()
11691 
    oprot.writeStructEnd()
11692 
 
11693 
  def __repr__(self):
11694 
    L = ['%s=%r' % (key, value)
11695 
      for key, value in self.__dict__.iteritems()]
11696 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11697 
 
11698 
  def __eq__(self, other):
11699 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11700 
 
11701 
  def __ne__(self, other):
11702 
    return not (self == other)
11703 
 
559 chandransh 11704 
class updateMyResearch_args:
94 ashish 11705 
  """
11706 
  Attributes:
772 rajveer 11707 
   - userId
11708 
   - itemId
94 ashish 11709 
  """
11710 
 
11711 
  thrift_spec = (
11712 
    None, # 0
772 rajveer 11713 
    (1, TType.I64, 'userId', None, None, ), # 1
11714 
    (2, TType.I64, 'itemId', None, None, ), # 2
94 ashish 11715 
  )
11716 
 
772 rajveer 11717 
  def __init__(self, userId=None, itemId=None,):
11718 
    self.userId = userId
11719 
    self.itemId = itemId
94 ashish 11720 
 
11721 
  def read(self, iprot):
11722 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11723 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11724 
      return
11725 
    iprot.readStructBegin()
11726 
    while True:
11727 
      (fname, ftype, fid) = iprot.readFieldBegin()
11728 
      if ftype == TType.STOP:
11729 
        break
11730 
      if fid == 1:
11731 
        if ftype == TType.I64:
772 rajveer 11732 
          self.userId = iprot.readI64();
94 ashish 11733 
        else:
11734 
          iprot.skip(ftype)
11735 
      elif fid == 2:
559 chandransh 11736 
        if ftype == TType.I64:
772 rajveer 11737 
          self.itemId = iprot.readI64();
94 ashish 11738 
        else:
11739 
          iprot.skip(ftype)
11740 
      else:
11741 
        iprot.skip(ftype)
11742 
      iprot.readFieldEnd()
11743 
    iprot.readStructEnd()
11744 
 
11745 
  def write(self, oprot):
11746 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11747 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11748 
      return
559 chandransh 11749 
    oprot.writeStructBegin('updateMyResearch_args')
772 rajveer 11750 
    if self.userId != None:
11751 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11752 
      oprot.writeI64(self.userId)
94 ashish 11753 
      oprot.writeFieldEnd()
772 rajveer 11754 
    if self.itemId != None:
11755 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11756 
      oprot.writeI64(self.itemId)
94 ashish 11757 
      oprot.writeFieldEnd()
11758 
    oprot.writeFieldStop()
11759 
    oprot.writeStructEnd()
11760 
 
11761 
  def __repr__(self):
11762 
    L = ['%s=%r' % (key, value)
11763 
      for key, value in self.__dict__.iteritems()]
11764 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11765 
 
11766 
  def __eq__(self, other):
11767 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11768 
 
11769 
  def __ne__(self, other):
11770 
    return not (self == other)
11771 
 
559 chandransh 11772 
class updateMyResearch_result:
94 ashish 11773 
  """
11774 
  Attributes:
11775 
   - success
559 chandransh 11776 
   - scx
94 ashish 11777 
  """
11778 
 
11779 
  thrift_spec = (
11780 
    (0, TType.BOOL, 'success', None, None, ), # 0
559 chandransh 11781 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
94 ashish 11782 
  )
11783 
 
559 chandransh 11784 
  def __init__(self, success=None, scx=None,):
94 ashish 11785 
    self.success = success
559 chandransh 11786 
    self.scx = scx
94 ashish 11787 
 
11788 
  def read(self, iprot):
11789 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11790 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11791 
      return
11792 
    iprot.readStructBegin()
11793 
    while True:
11794 
      (fname, ftype, fid) = iprot.readFieldBegin()
11795 
      if ftype == TType.STOP:
11796 
        break
11797 
      if fid == 0:
11798 
        if ftype == TType.BOOL:
11799 
          self.success = iprot.readBool();
11800 
        else:
11801 
          iprot.skip(ftype)
11802 
      elif fid == 1:
11803 
        if ftype == TType.STRUCT:
559 chandransh 11804 
          self.scx = WidgetException()
11805 
          self.scx.read(iprot)
94 ashish 11806 
        else:
11807 
          iprot.skip(ftype)
11808 
      else:
11809 
        iprot.skip(ftype)
11810 
      iprot.readFieldEnd()
11811 
    iprot.readStructEnd()
11812 
 
11813 
  def write(self, oprot):
11814 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11815 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11816 
      return
559 chandransh 11817 
    oprot.writeStructBegin('updateMyResearch_result')
94 ashish 11818 
    if self.success != None:
11819 
      oprot.writeFieldBegin('success', TType.BOOL, 0)
11820 
      oprot.writeBool(self.success)
11821 
      oprot.writeFieldEnd()
559 chandransh 11822 
    if self.scx != None:
11823 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11824 
      self.scx.write(oprot)
94 ashish 11825 
      oprot.writeFieldEnd()
11826 
    oprot.writeFieldStop()
11827 
    oprot.writeStructEnd()
11828 
 
11829 
  def __repr__(self):
11830 
    L = ['%s=%r' % (key, value)
11831 
      for key, value in self.__dict__.iteritems()]
11832 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11833 
 
11834 
  def __eq__(self, other):
11835 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11836 
 
11837 
  def __ne__(self, other):
11838 
    return not (self == other)
11839 
 
559 chandransh 11840 
class deleteItemFromMyResearch_args:
130 ashish 11841 
  """
11842 
  Attributes:
772 rajveer 11843 
   - userId
11844 
   - itemId
130 ashish 11845 
  """
94 ashish 11846 
 
130 ashish 11847 
  thrift_spec = (
11848 
    None, # 0
772 rajveer 11849 
    (1, TType.I64, 'userId', None, None, ), # 1
11850 
    (2, TType.I64, 'itemId', None, None, ), # 2
130 ashish 11851 
  )
11852 
 
772 rajveer 11853 
  def __init__(self, userId=None, itemId=None,):
11854 
    self.userId = userId
11855 
    self.itemId = itemId
130 ashish 11856 
 
11857 
  def read(self, iprot):
11858 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11859 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11860 
      return
11861 
    iprot.readStructBegin()
11862 
    while True:
11863 
      (fname, ftype, fid) = iprot.readFieldBegin()
11864 
      if ftype == TType.STOP:
11865 
        break
11866 
      if fid == 1:
11867 
        if ftype == TType.I64:
772 rajveer 11868 
          self.userId = iprot.readI64();
130 ashish 11869 
        else:
11870 
          iprot.skip(ftype)
559 chandransh 11871 
      elif fid == 2:
11872 
        if ftype == TType.I64:
772 rajveer 11873 
          self.itemId = iprot.readI64();
559 chandransh 11874 
        else:
11875 
          iprot.skip(ftype)
130 ashish 11876 
      else:
11877 
        iprot.skip(ftype)
11878 
      iprot.readFieldEnd()
11879 
    iprot.readStructEnd()
11880 
 
11881 
  def write(self, oprot):
11882 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11883 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11884 
      return
559 chandransh 11885 
    oprot.writeStructBegin('deleteItemFromMyResearch_args')
772 rajveer 11886 
    if self.userId != None:
11887 
      oprot.writeFieldBegin('userId', TType.I64, 1)
11888 
      oprot.writeI64(self.userId)
130 ashish 11889 
      oprot.writeFieldEnd()
772 rajveer 11890 
    if self.itemId != None:
11891 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
11892 
      oprot.writeI64(self.itemId)
559 chandransh 11893 
      oprot.writeFieldEnd()
130 ashish 11894 
    oprot.writeFieldStop()
11895 
    oprot.writeStructEnd()
11896 
 
11897 
  def __repr__(self):
11898 
    L = ['%s=%r' % (key, value)
11899 
      for key, value in self.__dict__.iteritems()]
11900 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11901 
 
11902 
  def __eq__(self, other):
11903 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11904 
 
11905 
  def __ne__(self, other):
11906 
    return not (self == other)
11907 
 
559 chandransh 11908 
class deleteItemFromMyResearch_result:
130 ashish 11909 
  """
11910 
  Attributes:
559 chandransh 11911 
   - scx
11912 
  """
11913 
 
11914 
  thrift_spec = (
11915 
    None, # 0
11916 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
11917 
  )
11918 
 
11919 
  def __init__(self, scx=None,):
11920 
    self.scx = scx
11921 
 
11922 
  def read(self, iprot):
11923 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11924 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11925 
      return
11926 
    iprot.readStructBegin()
11927 
    while True:
11928 
      (fname, ftype, fid) = iprot.readFieldBegin()
11929 
      if ftype == TType.STOP:
11930 
        break
11931 
      if fid == 1:
11932 
        if ftype == TType.STRUCT:
11933 
          self.scx = WidgetException()
11934 
          self.scx.read(iprot)
11935 
        else:
11936 
          iprot.skip(ftype)
11937 
      else:
11938 
        iprot.skip(ftype)
11939 
      iprot.readFieldEnd()
11940 
    iprot.readStructEnd()
11941 
 
11942 
  def write(self, oprot):
11943 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
11944 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
11945 
      return
11946 
    oprot.writeStructBegin('deleteItemFromMyResearch_result')
11947 
    if self.scx != None:
11948 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
11949 
      self.scx.write(oprot)
11950 
      oprot.writeFieldEnd()
11951 
    oprot.writeFieldStop()
11952 
    oprot.writeStructEnd()
11953 
 
11954 
  def __repr__(self):
11955 
    L = ['%s=%r' % (key, value)
11956 
      for key, value in self.__dict__.iteritems()]
11957 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
11958 
 
11959 
  def __eq__(self, other):
11960 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
11961 
 
11962 
  def __ne__(self, other):
11963 
    return not (self == other)
11964 
 
772 rajveer 11965 
class updateBrowseHistory_args:
559 chandransh 11966 
  """
11967 
  Attributes:
772 rajveer 11968 
   - userId
11969 
   - itemId
559 chandransh 11970 
  """
11971 
 
11972 
  thrift_spec = (
11973 
    None, # 0
772 rajveer 11974 
    (1, TType.I64, 'userId', None, None, ), # 1
11975 
    (2, TType.I64, 'itemId', None, None, ), # 2
559 chandransh 11976 
  )
11977 
 
772 rajveer 11978 
  def __init__(self, userId=None, itemId=None,):
11979 
    self.userId = userId
11980 
    self.itemId = itemId
559 chandransh 11981 
 
11982 
  def read(self, iprot):
11983 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
11984 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
11985 
      return
11986 
    iprot.readStructBegin()
11987 
    while True:
11988 
      (fname, ftype, fid) = iprot.readFieldBegin()
11989 
      if ftype == TType.STOP:
11990 
        break
11991 
      if fid == 1:
11992 
        if ftype == TType.I64:
772 rajveer 11993 
          self.userId = iprot.readI64();
559 chandransh 11994 
        else:
11995 
          iprot.skip(ftype)
11996 
      elif fid == 2:
11997 
        if ftype == TType.I64:
772 rajveer 11998 
          self.itemId = iprot.readI64();
559 chandransh 11999 
        else:
12000 
          iprot.skip(ftype)
12001 
      else:
12002 
        iprot.skip(ftype)
12003 
      iprot.readFieldEnd()
12004 
    iprot.readStructEnd()
12005 
 
12006 
  def write(self, oprot):
12007 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12008 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12009 
      return
772 rajveer 12010 
    oprot.writeStructBegin('updateBrowseHistory_args')
12011 
    if self.userId != None:
12012 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12013 
      oprot.writeI64(self.userId)
559 chandransh 12014 
      oprot.writeFieldEnd()
772 rajveer 12015 
    if self.itemId != None:
12016 
      oprot.writeFieldBegin('itemId', TType.I64, 2)
12017 
      oprot.writeI64(self.itemId)
559 chandransh 12018 
      oprot.writeFieldEnd()
12019 
    oprot.writeFieldStop()
12020 
    oprot.writeStructEnd()
12021 
 
12022 
  def __repr__(self):
12023 
    L = ['%s=%r' % (key, value)
12024 
      for key, value in self.__dict__.iteritems()]
12025 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12026 
 
12027 
  def __eq__(self, other):
12028 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12029 
 
12030 
  def __ne__(self, other):
12031 
    return not (self == other)
12032 
 
772 rajveer 12033 
class updateBrowseHistory_result:
559 chandransh 12034 
 
12035 
  thrift_spec = (
12036 
  )
12037 
 
12038 
  def read(self, iprot):
12039 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12040 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12041 
      return
12042 
    iprot.readStructBegin()
12043 
    while True:
12044 
      (fname, ftype, fid) = iprot.readFieldBegin()
12045 
      if ftype == TType.STOP:
12046 
        break
12047 
      else:
12048 
        iprot.skip(ftype)
12049 
      iprot.readFieldEnd()
12050 
    iprot.readStructEnd()
12051 
 
12052 
  def write(self, oprot):
12053 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12054 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12055 
      return
772 rajveer 12056 
    oprot.writeStructBegin('updateBrowseHistory_result')
559 chandransh 12057 
    oprot.writeFieldStop()
12058 
    oprot.writeStructEnd()
12059 
 
12060 
  def __repr__(self):
12061 
    L = ['%s=%r' % (key, value)
12062 
      for key, value in self.__dict__.iteritems()]
12063 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12064 
 
12065 
  def __eq__(self, other):
12066 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12067 
 
12068 
  def __ne__(self, other):
12069 
    return not (self == other)
12070 
 
772 rajveer 12071 
class getBrowseHistory_args:
559 chandransh 12072 
  """
12073 
  Attributes:
772 rajveer 12074 
   - userId
559 chandransh 12075 
  """
12076 
 
12077 
  thrift_spec = (
12078 
    None, # 0
772 rajveer 12079 
    (1, TType.I64, 'userId', None, None, ), # 1
559 chandransh 12080 
  )
12081 
 
772 rajveer 12082 
  def __init__(self, userId=None,):
12083 
    self.userId = userId
559 chandransh 12084 
 
12085 
  def read(self, iprot):
12086 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12087 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12088 
      return
12089 
    iprot.readStructBegin()
12090 
    while True:
12091 
      (fname, ftype, fid) = iprot.readFieldBegin()
12092 
      if ftype == TType.STOP:
12093 
        break
12094 
      if fid == 1:
12095 
        if ftype == TType.I64:
772 rajveer 12096 
          self.userId = iprot.readI64();
559 chandransh 12097 
        else:
12098 
          iprot.skip(ftype)
12099 
      else:
12100 
        iprot.skip(ftype)
12101 
      iprot.readFieldEnd()
12102 
    iprot.readStructEnd()
12103 
 
12104 
  def write(self, oprot):
12105 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12106 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12107 
      return
772 rajveer 12108 
    oprot.writeStructBegin('getBrowseHistory_args')
12109 
    if self.userId != None:
12110 
      oprot.writeFieldBegin('userId', TType.I64, 1)
12111 
      oprot.writeI64(self.userId)
559 chandransh 12112 
      oprot.writeFieldEnd()
12113 
    oprot.writeFieldStop()
12114 
    oprot.writeStructEnd()
12115 
 
12116 
  def __repr__(self):
12117 
    L = ['%s=%r' % (key, value)
12118 
      for key, value in self.__dict__.iteritems()]
12119 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12120 
 
12121 
  def __eq__(self, other):
12122 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12123 
 
12124 
  def __ne__(self, other):
12125 
    return not (self == other)
12126 
 
772 rajveer 12127 
class getBrowseHistory_result:
559 chandransh 12128 
  """
12129 
  Attributes:
130 ashish 12130 
   - success
559 chandransh 12131 
   - scx
130 ashish 12132 
  """
12133 
 
12134 
  thrift_spec = (
772 rajveer 12135 
    (0, TType.STRUCT, 'success', (Widget, Widget.thrift_spec), None, ), # 0
559 chandransh 12136 
    (1, TType.STRUCT, 'scx', (WidgetException, WidgetException.thrift_spec), None, ), # 1
130 ashish 12137 
  )
12138 
 
559 chandransh 12139 
  def __init__(self, success=None, scx=None,):
130 ashish 12140 
    self.success = success
559 chandransh 12141 
    self.scx = scx
130 ashish 12142 
 
12143 
  def read(self, iprot):
12144 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12145 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12146 
      return
12147 
    iprot.readStructBegin()
12148 
    while True:
12149 
      (fname, ftype, fid) = iprot.readFieldBegin()
12150 
      if ftype == TType.STOP:
12151 
        break
12152 
      if fid == 0:
559 chandransh 12153 
        if ftype == TType.STRUCT:
772 rajveer 12154 
          self.success = Widget()
559 chandransh 12155 
          self.success.read(iprot)
130 ashish 12156 
        else:
12157 
          iprot.skip(ftype)
12158 
      elif fid == 1:
12159 
        if ftype == TType.STRUCT:
559 chandransh 12160 
          self.scx = WidgetException()
12161 
          self.scx.read(iprot)
130 ashish 12162 
        else:
12163 
          iprot.skip(ftype)
12164 
      else:
12165 
        iprot.skip(ftype)
12166 
      iprot.readFieldEnd()
12167 
    iprot.readStructEnd()
12168 
 
12169 
  def write(self, oprot):
12170 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12171 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12172 
      return
772 rajveer 12173 
    oprot.writeStructBegin('getBrowseHistory_result')
130 ashish 12174 
    if self.success != None:
559 chandransh 12175 
      oprot.writeFieldBegin('success', TType.STRUCT, 0)
12176 
      self.success.write(oprot)
130 ashish 12177 
      oprot.writeFieldEnd()
559 chandransh 12178 
    if self.scx != None:
12179 
      oprot.writeFieldBegin('scx', TType.STRUCT, 1)
12180 
      self.scx.write(oprot)
130 ashish 12181 
      oprot.writeFieldEnd()
12182 
    oprot.writeFieldStop()
12183 
    oprot.writeStructEnd()
12184 
 
12185 
  def __repr__(self):
12186 
    L = ['%s=%r' % (key, value)
12187 
      for key, value in self.__dict__.iteritems()]
12188 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12189 
 
12190 
  def __eq__(self, other):
12191 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12192 
 
12193 
  def __ne__(self, other):
12194 
    return not (self == other)
12195 
 
772 rajveer 12196 
class mergeBrowseHistory_args:
130 ashish 12197 
  """
12198 
  Attributes:
772 rajveer 12199 
   - fromUserId
12200 
   - toUserId
130 ashish 12201 
  """
12202 
 
12203 
  thrift_spec = (
12204 
    None, # 0
772 rajveer 12205 
    (1, TType.I64, 'fromUserId', None, None, ), # 1
12206 
    (2, TType.I64, 'toUserId', None, None, ), # 2
130 ashish 12207 
  )
12208 
 
772 rajveer 12209 
  def __init__(self, fromUserId=None, toUserId=None,):
12210 
    self.fromUserId = fromUserId
12211 
    self.toUserId = toUserId
130 ashish 12212 
 
12213 
  def read(self, iprot):
12214 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12215 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12216 
      return
12217 
    iprot.readStructBegin()
12218 
    while True:
12219 
      (fname, ftype, fid) = iprot.readFieldBegin()
12220 
      if ftype == TType.STOP:
12221 
        break
12222 
      if fid == 1:
559 chandransh 12223 
        if ftype == TType.I64:
772 rajveer 12224 
          self.fromUserId = iprot.readI64();
130 ashish 12225 
        else:
12226 
          iprot.skip(ftype)
12227 
      elif fid == 2:
559 chandransh 12228 
        if ftype == TType.I64:
772 rajveer 12229 
          self.toUserId = iprot.readI64();
559 chandransh 12230 
        else:
12231 
          iprot.skip(ftype)
130 ashish 12232 
      else:
12233 
        iprot.skip(ftype)
12234 
      iprot.readFieldEnd()
12235 
    iprot.readStructEnd()
12236 
 
12237 
  def write(self, oprot):
12238 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12239 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12240 
      return
772 rajveer 12241 
    oprot.writeStructBegin('mergeBrowseHistory_args')
12242 
    if self.fromUserId != None:
12243 
      oprot.writeFieldBegin('fromUserId', TType.I64, 1)
12244 
      oprot.writeI64(self.fromUserId)
130 ashish 12245 
      oprot.writeFieldEnd()
772 rajveer 12246 
    if self.toUserId != None:
12247 
      oprot.writeFieldBegin('toUserId', TType.I64, 2)
12248 
      oprot.writeI64(self.toUserId)
130 ashish 12249 
      oprot.writeFieldEnd()
12250 
    oprot.writeFieldStop()
12251 
    oprot.writeStructEnd()
12252 
 
12253 
  def __repr__(self):
12254 
    L = ['%s=%r' % (key, value)
12255 
      for key, value in self.__dict__.iteritems()]
12256 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12257 
 
12258 
  def __eq__(self, other):
12259 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12260 
 
12261 
  def __ne__(self, other):
12262 
    return not (self == other)
12263 
 
772 rajveer 12264 
class mergeBrowseHistory_result:
559 chandransh 12265 
 
12266 
  thrift_spec = (
12267 
  )
12268 
 
12269 
  def read(self, iprot):
12270 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12271 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12272 
      return
12273 
    iprot.readStructBegin()
12274 
    while True:
12275 
      (fname, ftype, fid) = iprot.readFieldBegin()
12276 
      if ftype == TType.STOP:
12277 
        break
12278 
      else:
12279 
        iprot.skip(ftype)
12280 
      iprot.readFieldEnd()
12281 
    iprot.readStructEnd()
12282 
 
12283 
  def write(self, oprot):
12284 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12285 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12286 
      return
772 rajveer 12287 
    oprot.writeStructBegin('mergeBrowseHistory_result')
559 chandransh 12288 
    oprot.writeFieldStop()
12289 
    oprot.writeStructEnd()
12290 
 
12291 
  def __repr__(self):
12292 
    L = ['%s=%r' % (key, value)
12293 
      for key, value in self.__dict__.iteritems()]
12294 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12295 
 
12296 
  def __eq__(self, other):
12297 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12298 
 
12299 
  def __ne__(self, other):
12300 
    return not (self == other)
12301 
 
1596 ankur.sing 12302 
class getUserCount_args:
12303 
  """
12304 
  Attributes:
12305 
   - userType
12306 
  """
559 chandransh 12307 
 
1596 ankur.sing 12308 
  thrift_spec = (
12309 
    None, # 0
12310 
    (1, TType.I32, 'userType', None, None, ), # 1
12311 
  )
12312 
 
12313 
  def __init__(self, userType=None,):
12314 
    self.userType = userType
12315 
 
12316 
  def read(self, iprot):
12317 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12318 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12319 
      return
12320 
    iprot.readStructBegin()
12321 
    while True:
12322 
      (fname, ftype, fid) = iprot.readFieldBegin()
12323 
      if ftype == TType.STOP:
12324 
        break
12325 
      if fid == 1:
12326 
        if ftype == TType.I32:
12327 
          self.userType = iprot.readI32();
12328 
        else:
12329 
          iprot.skip(ftype)
12330 
      else:
12331 
        iprot.skip(ftype)
12332 
      iprot.readFieldEnd()
12333 
    iprot.readStructEnd()
12334 
 
12335 
  def write(self, oprot):
12336 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12337 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12338 
      return
12339 
    oprot.writeStructBegin('getUserCount_args')
12340 
    if self.userType != None:
12341 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12342 
      oprot.writeI32(self.userType)
12343 
      oprot.writeFieldEnd()
12344 
    oprot.writeFieldStop()
12345 
    oprot.writeStructEnd()
12346 
 
12347 
  def __repr__(self):
12348 
    L = ['%s=%r' % (key, value)
12349 
      for key, value in self.__dict__.iteritems()]
12350 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12351 
 
12352 
  def __eq__(self, other):
12353 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12354 
 
12355 
  def __ne__(self, other):
12356 
    return not (self == other)
12357 
 
12358 
class getUserCount_result:
12359 
  """
12360 
  Attributes:
12361 
   - success
12362 
  """
12363 
 
12364 
  thrift_spec = (
12365 
    (0, TType.I64, 'success', None, None, ), # 0
12366 
  )
12367 
 
12368 
  def __init__(self, success=None,):
12369 
    self.success = success
12370 
 
12371 
  def read(self, iprot):
12372 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12373 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12374 
      return
12375 
    iprot.readStructBegin()
12376 
    while True:
12377 
      (fname, ftype, fid) = iprot.readFieldBegin()
12378 
      if ftype == TType.STOP:
12379 
        break
12380 
      if fid == 0:
12381 
        if ftype == TType.I64:
12382 
          self.success = iprot.readI64();
12383 
        else:
12384 
          iprot.skip(ftype)
12385 
      else:
12386 
        iprot.skip(ftype)
12387 
      iprot.readFieldEnd()
12388 
    iprot.readStructEnd()
12389 
 
12390 
  def write(self, oprot):
12391 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12392 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12393 
      return
12394 
    oprot.writeStructBegin('getUserCount_result')
12395 
    if self.success != None:
12396 
      oprot.writeFieldBegin('success', TType.I64, 0)
12397 
      oprot.writeI64(self.success)
12398 
      oprot.writeFieldEnd()
12399 
    oprot.writeFieldStop()
12400 
    oprot.writeStructEnd()
12401 
 
12402 
  def __repr__(self):
12403 
    L = ['%s=%r' % (key, value)
12404 
      for key, value in self.__dict__.iteritems()]
12405 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12406 
 
12407 
  def __eq__(self, other):
12408 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12409 
 
12410 
  def __ne__(self, other):
12411 
    return not (self == other)
12412 
 
1673 ankur.sing 12413 
class getAllUsers_args:
12414 
  """
12415 
  Attributes:
12416 
   - userType
1891 ankur.sing 12417 
   - startDate
12418 
   - endDate
1673 ankur.sing 12419 
  """
1596 ankur.sing 12420 
 
1673 ankur.sing 12421 
  thrift_spec = (
12422 
    None, # 0
12423 
    (1, TType.I32, 'userType', None, None, ), # 1
1891 ankur.sing 12424 
    (2, TType.I64, 'startDate', None, None, ), # 2
12425 
    (3, TType.I64, 'endDate', None, None, ), # 3
1673 ankur.sing 12426 
  )
12427 
 
1891 ankur.sing 12428 
  def __init__(self, userType=None, startDate=None, endDate=None,):
1673 ankur.sing 12429 
    self.userType = userType
1891 ankur.sing 12430 
    self.startDate = startDate
12431 
    self.endDate = endDate
1673 ankur.sing 12432 
 
12433 
  def read(self, iprot):
12434 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12435 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12436 
      return
12437 
    iprot.readStructBegin()
12438 
    while True:
12439 
      (fname, ftype, fid) = iprot.readFieldBegin()
12440 
      if ftype == TType.STOP:
12441 
        break
12442 
      if fid == 1:
12443 
        if ftype == TType.I32:
12444 
          self.userType = iprot.readI32();
12445 
        else:
12446 
          iprot.skip(ftype)
1891 ankur.sing 12447 
      elif fid == 2:
12448 
        if ftype == TType.I64:
12449 
          self.startDate = iprot.readI64();
12450 
        else:
12451 
          iprot.skip(ftype)
12452 
      elif fid == 3:
12453 
        if ftype == TType.I64:
12454 
          self.endDate = iprot.readI64();
12455 
        else:
12456 
          iprot.skip(ftype)
1673 ankur.sing 12457 
      else:
12458 
        iprot.skip(ftype)
12459 
      iprot.readFieldEnd()
12460 
    iprot.readStructEnd()
12461 
 
12462 
  def write(self, oprot):
12463 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12464 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12465 
      return
12466 
    oprot.writeStructBegin('getAllUsers_args')
12467 
    if self.userType != None:
12468 
      oprot.writeFieldBegin('userType', TType.I32, 1)
12469 
      oprot.writeI32(self.userType)
12470 
      oprot.writeFieldEnd()
1891 ankur.sing 12471 
    if self.startDate != None:
12472 
      oprot.writeFieldBegin('startDate', TType.I64, 2)
12473 
      oprot.writeI64(self.startDate)
12474 
      oprot.writeFieldEnd()
12475 
    if self.endDate != None:
12476 
      oprot.writeFieldBegin('endDate', TType.I64, 3)
12477 
      oprot.writeI64(self.endDate)
12478 
      oprot.writeFieldEnd()
1673 ankur.sing 12479 
    oprot.writeFieldStop()
12480 
    oprot.writeStructEnd()
12481 
 
12482 
  def __repr__(self):
12483 
    L = ['%s=%r' % (key, value)
12484 
      for key, value in self.__dict__.iteritems()]
12485 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12486 
 
12487 
  def __eq__(self, other):
12488 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12489 
 
12490 
  def __ne__(self, other):
12491 
    return not (self == other)
12492 
 
12493 
class getAllUsers_result:
12494 
  """
12495 
  Attributes:
12496 
   - success
12497 
  """
12498 
 
12499 
  thrift_spec = (
12500 
    (0, TType.LIST, 'success', (TType.STRUCT,(User, User.thrift_spec)), None, ), # 0
12501 
  )
12502 
 
12503 
  def __init__(self, success=None,):
12504 
    self.success = success
12505 
 
12506 
  def read(self, iprot):
12507 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12508 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12509 
      return
12510 
    iprot.readStructBegin()
12511 
    while True:
12512 
      (fname, ftype, fid) = iprot.readFieldBegin()
12513 
      if ftype == TType.STOP:
12514 
        break
12515 
      if fid == 0:
12516 
        if ftype == TType.LIST:
12517 
          self.success = []
1996 vikas 12518 
          (_etype124, _size121) = iprot.readListBegin()
12519 
          for _i125 in xrange(_size121):
12520 
            _elem126 = User()
12521 
            _elem126.read(iprot)
12522 
            self.success.append(_elem126)
1673 ankur.sing 12523 
          iprot.readListEnd()
12524 
        else:
12525 
          iprot.skip(ftype)
12526 
      else:
12527 
        iprot.skip(ftype)
12528 
      iprot.readFieldEnd()
12529 
    iprot.readStructEnd()
12530 
 
12531 
  def write(self, oprot):
12532 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12533 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12534 
      return
12535 
    oprot.writeStructBegin('getAllUsers_result')
12536 
    if self.success != None:
12537 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12538 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
1996 vikas 12539 
      for iter127 in self.success:
12540 
        iter127.write(oprot)
1673 ankur.sing 12541 
      oprot.writeListEnd()
12542 
      oprot.writeFieldEnd()
12543 
    oprot.writeFieldStop()
12544 
    oprot.writeStructEnd()
12545 
 
12546 
  def __repr__(self):
12547 
    L = ['%s=%r' % (key, value)
12548 
      for key, value in self.__dict__.iteritems()]
12549 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12550 
 
12551 
  def __eq__(self, other):
12552 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12553 
 
12554 
  def __ne__(self, other):
12555 
    return not (self == other)
12556 
 
2642 varun.gupt 12557 
class putUserNote_args:
12558 
  """
12559 
  Attributes:
12560 
   - user_id
12561 
   - entity_id
2717 varun.gupt 12562 
   - slide
2642 varun.gupt 12563 
   - note
12564 
  """
1673 ankur.sing 12565 
 
2642 varun.gupt 12566 
  thrift_spec = (
12567 
    None, # 0
12568 
    (1, TType.I64, 'user_id', None, None, ), # 1
12569 
    (2, TType.I64, 'entity_id', None, None, ), # 2
2717 varun.gupt 12570 
    (3, TType.STRING, 'slide', None, None, ), # 3
2642 varun.gupt 12571 
    (4, TType.STRING, 'note', None, None, ), # 4
12572 
  )
12573 
 
2717 varun.gupt 12574 
  def __init__(self, user_id=None, entity_id=None, slide=None, note=None,):
2642 varun.gupt 12575 
    self.user_id = user_id
12576 
    self.entity_id = entity_id
2717 varun.gupt 12577 
    self.slide = slide
2642 varun.gupt 12578 
    self.note = note
12579 
 
12580 
  def read(self, iprot):
12581 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12582 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12583 
      return
12584 
    iprot.readStructBegin()
12585 
    while True:
12586 
      (fname, ftype, fid) = iprot.readFieldBegin()
12587 
      if ftype == TType.STOP:
12588 
        break
12589 
      if fid == 1:
12590 
        if ftype == TType.I64:
12591 
          self.user_id = iprot.readI64();
12592 
        else:
12593 
          iprot.skip(ftype)
12594 
      elif fid == 2:
12595 
        if ftype == TType.I64:
12596 
          self.entity_id = iprot.readI64();
12597 
        else:
12598 
          iprot.skip(ftype)
12599 
      elif fid == 3:
2717 varun.gupt 12600 
        if ftype == TType.STRING:
12601 
          self.slide = iprot.readString();
2642 varun.gupt 12602 
        else:
12603 
          iprot.skip(ftype)
12604 
      elif fid == 4:
12605 
        if ftype == TType.STRING:
12606 
          self.note = iprot.readString();
12607 
        else:
12608 
          iprot.skip(ftype)
12609 
      else:
12610 
        iprot.skip(ftype)
12611 
      iprot.readFieldEnd()
12612 
    iprot.readStructEnd()
12613 
 
12614 
  def write(self, oprot):
12615 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12616 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12617 
      return
12618 
    oprot.writeStructBegin('putUserNote_args')
12619 
    if self.user_id != None:
12620 
      oprot.writeFieldBegin('user_id', TType.I64, 1)
12621 
      oprot.writeI64(self.user_id)
12622 
      oprot.writeFieldEnd()
12623 
    if self.entity_id != None:
12624 
      oprot.writeFieldBegin('entity_id', TType.I64, 2)
12625 
      oprot.writeI64(self.entity_id)
12626 
      oprot.writeFieldEnd()
2717 varun.gupt 12627 
    if self.slide != None:
12628 
      oprot.writeFieldBegin('slide', TType.STRING, 3)
12629 
      oprot.writeString(self.slide)
2642 varun.gupt 12630 
      oprot.writeFieldEnd()
12631 
    if self.note != None:
12632 
      oprot.writeFieldBegin('note', TType.STRING, 4)
12633 
      oprot.writeString(self.note)
12634 
      oprot.writeFieldEnd()
12635 
    oprot.writeFieldStop()
12636 
    oprot.writeStructEnd()
12637 
 
12638 
  def __repr__(self):
12639 
    L = ['%s=%r' % (key, value)
12640 
      for key, value in self.__dict__.iteritems()]
12641 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12642 
 
12643 
  def __eq__(self, other):
12644 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12645 
 
12646 
  def __ne__(self, other):
12647 
    return not (self == other)
12648 
 
12649 
class putUserNote_result:
12650 
 
12651 
  thrift_spec = (
12652 
  )
12653 
 
12654 
  def read(self, iprot):
12655 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12656 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12657 
      return
12658 
    iprot.readStructBegin()
12659 
    while True:
12660 
      (fname, ftype, fid) = iprot.readFieldBegin()
12661 
      if ftype == TType.STOP:
12662 
        break
12663 
      else:
12664 
        iprot.skip(ftype)
12665 
      iprot.readFieldEnd()
12666 
    iprot.readStructEnd()
12667 
 
12668 
  def write(self, oprot):
12669 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12670 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12671 
      return
12672 
    oprot.writeStructBegin('putUserNote_result')
12673 
    oprot.writeFieldStop()
12674 
    oprot.writeStructEnd()
12675 
 
12676 
  def __repr__(self):
12677 
    L = ['%s=%r' % (key, value)
12678 
      for key, value in self.__dict__.iteritems()]
12679 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12680 
 
12681 
  def __eq__(self, other):
12682 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12683 
 
12684 
  def __ne__(self, other):
12685 
    return not (self == other)
12686 
 
12687 
class getUserNotes_args:
12688 
  """
12689 
  Attributes:
12690 
   - user_id
12691 
   - entity_id
12692 
  """
12693 
 
12694 
  thrift_spec = (
12695 
    None, # 0
12696 
    (1, TType.I64, 'user_id', None, None, ), # 1
12697 
    (2, TType.I64, 'entity_id', None, None, ), # 2
12698 
  )
12699 
 
12700 
  def __init__(self, user_id=None, entity_id=None,):
12701 
    self.user_id = user_id
12702 
    self.entity_id = entity_id
12703 
 
12704 
  def read(self, iprot):
12705 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12706 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12707 
      return
12708 
    iprot.readStructBegin()
12709 
    while True:
12710 
      (fname, ftype, fid) = iprot.readFieldBegin()
12711 
      if ftype == TType.STOP:
12712 
        break
12713 
      if fid == 1:
12714 
        if ftype == TType.I64:
12715 
          self.user_id = iprot.readI64();
12716 
        else:
12717 
          iprot.skip(ftype)
12718 
      elif fid == 2:
12719 
        if ftype == TType.I64:
12720 
          self.entity_id = iprot.readI64();
12721 
        else:
12722 
          iprot.skip(ftype)
12723 
      else:
12724 
        iprot.skip(ftype)
12725 
      iprot.readFieldEnd()
12726 
    iprot.readStructEnd()
12727 
 
12728 
  def write(self, oprot):
12729 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12730 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12731 
      return
12732 
    oprot.writeStructBegin('getUserNotes_args')
12733 
    if self.user_id != None:
12734 
      oprot.writeFieldBegin('user_id', TType.I64, 1)
12735 
      oprot.writeI64(self.user_id)
12736 
      oprot.writeFieldEnd()
12737 
    if self.entity_id != None:
12738 
      oprot.writeFieldBegin('entity_id', TType.I64, 2)
12739 
      oprot.writeI64(self.entity_id)
12740 
      oprot.writeFieldEnd()
12741 
    oprot.writeFieldStop()
12742 
    oprot.writeStructEnd()
12743 
 
12744 
  def __repr__(self):
12745 
    L = ['%s=%r' % (key, value)
12746 
      for key, value in self.__dict__.iteritems()]
12747 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12748 
 
12749 
  def __eq__(self, other):
12750 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12751 
 
12752 
  def __ne__(self, other):
12753 
    return not (self == other)
12754 
 
12755 
class getUserNotes_result:
12756 
  """
12757 
  Attributes:
12758 
   - success
12759 
  """
12760 
 
12761 
  thrift_spec = (
12762 
    (0, TType.LIST, 'success', (TType.STRUCT,(UserNote, UserNote.thrift_spec)), None, ), # 0
12763 
  )
12764 
 
12765 
  def __init__(self, success=None,):
12766 
    self.success = success
12767 
 
12768 
  def read(self, iprot):
12769 
    if iprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and isinstance(iprot.trans, TTransport.CReadableTransport) and self.thrift_spec is not None and fastbinary is not None:
12770 
      fastbinary.decode_binary(self, iprot.trans, (self.__class__, self.thrift_spec))
12771 
      return
12772 
    iprot.readStructBegin()
12773 
    while True:
12774 
      (fname, ftype, fid) = iprot.readFieldBegin()
12775 
      if ftype == TType.STOP:
12776 
        break
12777 
      if fid == 0:
12778 
        if ftype == TType.LIST:
12779 
          self.success = []
12780 
          (_etype131, _size128) = iprot.readListBegin()
12781 
          for _i132 in xrange(_size128):
12782 
            _elem133 = UserNote()
12783 
            _elem133.read(iprot)
12784 
            self.success.append(_elem133)
12785 
          iprot.readListEnd()
12786 
        else:
12787 
          iprot.skip(ftype)
12788 
      else:
12789 
        iprot.skip(ftype)
12790 
      iprot.readFieldEnd()
12791 
    iprot.readStructEnd()
12792 
 
12793 
  def write(self, oprot):
12794 
    if oprot.__class__ == TBinaryProtocol.TBinaryProtocolAccelerated and self.thrift_spec is not None and fastbinary is not None:
12795 
      oprot.trans.write(fastbinary.encode_binary(self, (self.__class__, self.thrift_spec)))
12796 
      return
12797 
    oprot.writeStructBegin('getUserNotes_result')
12798 
    if self.success != None:
12799 
      oprot.writeFieldBegin('success', TType.LIST, 0)
12800 
      oprot.writeListBegin(TType.STRUCT, len(self.success))
12801 
      for iter134 in self.success:
12802 
        iter134.write(oprot)
12803 
      oprot.writeListEnd()
12804 
      oprot.writeFieldEnd()
12805 
    oprot.writeFieldStop()
12806 
    oprot.writeStructEnd()
12807 
 
12808 
  def __repr__(self):
12809 
    L = ['%s=%r' % (key, value)
12810 
      for key, value in self.__dict__.iteritems()]
12811 
    return '%s(%s)' % (self.__class__.__name__, ', '.join(L))
12812 
 
12813 
  def __eq__(self, other):
12814 
    return isinstance(other, self.__class__) and self.__dict__ == other.__dict__
12815 
 
12816 
  def __ne__(self, other):
12817 
    return not (self == other)
12818 
 
12819